oscript

func Compact ¶

func Compact(dst *bytes.Buffer, src []byte) error

Compact appends to dst the oscript-encoded src with insignificant space characters elided.

func Marshal ¶

func Marshal(v interface{}) ([]byte, error)

The encoding of each struct field can be customized by the format string stored under the "oscript" key in the struct field's tag. The format string gives the name of the field, possibly followed by a comma-separated list of options. The name may be empty in order to specify options without overriding the default field name.

The "omitempty" option specifies that the field should be omitted from the encoding if the field has an empty value, defined as false, 0, a nil pointer, a nil interface value, and any empty array, slice, map, or string.

As a special case, if the field tag is "-", the field is always omitted. Note that a field with name "-" can still be generated using the tag "-,".

Anonymous struct fields are usually marshaled as if their inner exported fields were fields in the outer struct, subject to the usual Go visibility rules amended as described in the next paragraph. An anonymous struct field with a name given in its Oscript tag is treated as having that name, rather than being anonymous. An anonymous struct field of interface type is treated the same as having that type as its name, rather than being anonymous.

The Go visibility rules for struct fields are amended for Oscript when deciding which field to marshal or unmarshal. If there are multiple fields at the same level, and that level is the least nested (and would therefore be the nesting level selected by the usual Go rules), the following extra rules apply:

1) Of those fields, if any are Oscript-tagged, only tagged fields are considered, even if there are multiple untagged fields that would otherwise conflict.

2) If there is exactly one field (tagged or not according to the first rule), that is selected.

3) Otherwise there are multiple fields, and all are ignored; no error occurs.

Map values encode as oscript objects: A<1,?,'key'=value>. The map's key type must either be a string, an integer type, or implement encoding.TextMarshaler.

• string keys are used directly
• encoding.TextMarshalers are marshaled
• integer keys are converted to strings

Pointer values encode as the value pointed to. A nil pointer encodes as the undefined Oscript value.

Interface values encode as the value contained in the interface. A nil interface value encodes as the undefined Oscript value.

Channel, complex, and function values cannot be encoded in oscript. Attempting to encode such a value causes Marshal to return an UnsupportedTypeError.

Oscript cannot represent cyclic data structures and Marshal does not handle them. Passing cyclic structures to Marshal will result in an infinite recursion.

package main

import (
	"fmt"
	"os"

	"github.com/itcomusic/ot/pkg/oscript"
)

func main() {
	type ColorGroup struct {
		ID     int
		Name   string
		Colors []string
	}
	group := ColorGroup{
		ID:     1,
		Name:   "Reds",
		Colors: []string{"Crimson", "Red", "Ruby", "Maroon"},
	}
	b, err := oscript.Marshal(group)
	if err != nil {
		fmt.Println("error:", err)
	}
	os.Stdout.Write(b)
}

Output:

A<1,?,'ID'=1,'Name'='Reds','Colors'={'Crimson','Red','Ruby','Maroon'}>

func Unmarshal ¶

func Unmarshal(data []byte, v interface{}) error

The oscript undefined value unmarshals into an interface, map, pointer, or slice by setting that Go value to nil. Because undefined is often used in oscript to mean `not present' unmarshaling a Oscript undefined into any other Go type has no effect on the value and produces no error.

When unmarshaling quoted strings, invalid UTF-8 or invalid UTF-16 surrogate pairs are not treated as an error. Instead, they are replaced by the Unicode replacement character U+FFFD.

package main

import (
	"fmt"

	"github.com/itcomusic/ot/pkg/oscript"
)

func main() {
	var oscriptBlob = []byte(`{
	A<1,?,'Name'= 'Platypus', 'Order'= 'Monotremata'>,
	A<1,?,'Name'= 'Quoll',    'Order'= 'Dasyuromorphia'>
}`)
	type Animal struct {
		Name  string
		Order string
	}

	var animals []Animal
	err := oscript.Unmarshal(oscriptBlob, &animals)

	if err != nil {
		fmt.Println("error:", err)
	}
	fmt.Printf("%+v", animals)
}

Output:

[{Name:Platypus Order:Monotremata} {Name:Quoll Order:Dasyuromorphia}]

func Valid ¶

func Valid(data []byte) bool

Valid reports whether data is a valid Oscript encoding.