Encoding, decoding, marshaling, unmarshaling, and verification of the DSON (Doge Serialized Object Notation)
MIT License
dson.go provides encoding, decoding, marshaling, unmarshaling, and verification of the DSON (Doge Serialized Object Notation) as defined here.
go get muzzammil.xyz/dsongo
DSON is built on two structures:
A collection of key/value pairs. In various languages, this is realized as an object, record, struct, dictionary, hash table, keyed list, or associative array.
An ordered list of values. In most languages, this is realized as an array, vector, list, or sequence.
A key is a string
in double quotes.
A value can be a string
in double quotes, or a number
, or yes
or no
or empty
, or an object
or an array
. These structures can be nested.
such
"foo" is "bar"
wow
is equivalent to this in JSON:
{
"foo": "bar"
}
A string is a sequence of zero or more Unicode characters, wrapped in double quotes, using backslash escapes.
A number is very much like a C or Java number, except it is presented in the dog-friendly octal base.
An object begins with such
and ends with wow
. Each key is followed by is and the key/value pairs are separated by ,
(comma) or .
(dot) or !
or ?
.
such
"foo" is "bar",
"number" is 42!
"alive" is yes
wow
is equivalent to this in JSON:
{
"foo": "bar",
"number": 34,
"alive": true
}
An array begins with so
and ends with many
. Values are separated by and
or also
.
such
"ID" is 1!
"Name" is "Reds".
"Colors" is so
"Crimson" and "Red" and "Ruby" also "Maroon"
many
wow
is equivalent to this in JSON:
{
"id": 1,
"Name": "Reds",
"Colors": ["Crimson", "Red", "Ruby", "Maroon"]
}
import (
"fmt"
"muzzammil.xyz/dsongo"
)
func main() {
d := dson.Encode(`{"foo":"bar"}`)
fmt.Println(d) // such "foo" is "bar" wow
}
func main() {
j := dson.Decode(`such "foo" is "bar" wow`)
fmt.Println(j) // {"foo":"bar"}
}
func main() {
if dson.Valid(`such "foo" is "bar" wow`) {
fmt.Println("Valid DSON")
} else {
fmt.Println("Invalid DSON")
}
}
func main() {
type ColorGroup struct {
ID int
Name string
Colors []string
}
RedGroup := ColorGroup{
ID: 1,
Name: "Reds",
Colors: []string{"Crimson", "Red", "Ruby", "Maroon"},
}
r, err := dson.Marshal(RedGroup)
if err == nil && dson.Valid(r) {
fmt.Println(r) // such "ID" is 1! "Name" is "Reds". "Colors" is so "Crimson" and "Red" and "Ruby" also "Maroon" many wow
}
}
func main() {
d := `so such "Name" is "Platypus" and "Order" is "Monotremata" wow and such "Name" is "Quoll" and "Order" is "Dasyuromorphia" wow many`
if !dson.Valid(d) {
fmt.Println("DSON is not valid")
return
}
type Animal struct {
Name string
Order string
}
var animals []Animal
err := dson.Unmarshal(d, &animals)
if err == nil {
fmt.Printf("%+v", animals) // [{Name:Platypus Order:Monotremata} {Name:Quoll Order:Dasyuromorphia}]
}
}