yson

func AttrsOf ¶

func AttrsOf(value any) map[string]any

AttrsOf is a helper function to work with ValueWithAttrs. If value is a pointer to ValueWithAttrs, returns attributes. Otherwise returns nil.

func InferAttrs ¶

func InferAttrs(v any) ([]string, error)

InferAttrs infers attribute names from struct.

Function returns attribute names of struct fields including exported fields of yson-untagged anonymous fields

func IsTrue ¶

func IsTrue(value any) bool

IsTrue is a helper function for compatibility with C++ ConvertTo<bool>().

It returns true, if value is bool(true) or string("true").

Early versions of YSON was missing separate wire type for bool. Instead, string "true" was used to specify true value. C++ code still accepts string value where bool is expected, for compatibility reasons.

func Marshal ¶

func Marshal(value any) ([]byte, error)

Marshal returns YSON encoding of value.

Marshal traverses value recursively.

If value implements Marshaler interface, Marshal calls its MarshalYSON method to produce YSON.

If value implements StreamMarshaler interface, Marshal calls its MarshalYSON method to produce YSON.

Otherwise, the following default encoding is used.

Boolean values are encoded as YSON booleans.

Floating point values are encoded as YSON float64.

Unsigned integer types uint8, uint16, uint32, uint64 and uint are encoded as unsigned YSON integers.

Signed integer types int8, int16, int32, int64 and int are encoded as signed YSON integers.

string and []byte values are encoded as YSON strings. Note that YSON strings are always binary.

Slice values are encoded as YSON lists (with exception of []byte).

Struct values are encoded as YSON maps by default. Encoding of each struct field can be customized by format string stored under the "yson" key in the field's tag.

// Field appears in YSON under key "my_field".
Field int `yson:"my_field"`

// Field appears as attribute with name "my_attr".
Field int `yson:"my_attr,attr"`

// Field encoding completely replaces encoding of the whole struct.
// Other fields annotated as ",attr" are encoded as attributes preceding the value.
// All other fields are ignored.
Field int `yson:",value"`

// Field is skipped if empty.
Field int `yson:",omitempty"'

// Field is ignored by this package
Field int `yson:"-"`

// Field appears in YSON under key "-"
Field int `yson:"-,"`

Map values are encoded as YSON maps. The map's key type must either be a string, implement encoding.TextMarshaler, or implement encoding.BinaryMarshaler. The map keys are sorted and used as YSON map keys by applying the following rules:

• keys of any string type are used directly
• encoding.TextMarshalers are marshaled
• encoding.BinaryMarshalers are marshaled

Pointer values are encoded as the value pointed to. A nil pointer encodes as the YSON entity value.

Values implementing encoding.TextMarshaler and encoding.BinaryMarshaler interface are encoded as YSON strings.

Interface values are encoded as the value contained in the interface. A nil interface value encodes as the YSON entity value.

func MarshalFormat ¶

func MarshalFormat(value any, format Format) ([]byte, error)

func MarshalOptions ¶

func MarshalOptions(value any, opts *EncoderOptions) ([]byte, error)

func MarshalTime ¶

func MarshalTime(t Time) (s string, err error)

MarshalTime encodes time to YT-specific time format.

Zero time is encoded into entity.

func MustInferAttrs ¶

func MustInferAttrs(v any) []string

MustInferAttrs is like InferAttrs but panics in case of an error.

package main

import (
	"fmt"
	"strings"

	"go.ytsaurus.tech/yt/go/yson"
)

type Inner struct {
	G bool `yson:"g,attr"`
}

type anonymous struct {
	F *int `yson:"f,attr"`
	*Inner
}

type Anonymous struct {
	F *int `yson:"f,attr"`
	*Inner
}

type MyStruct struct {
	Value  string  `yson:",value"`
	Attr   int64   `yson:"attr,attr"`
	NoName float64 `yson:",attr"`
	NoAttr string  `yson:"no_attr"`
	NoTag  string
	Inner  *Inner `yson:"inner,attr"`
	anonymous
	Anonymous `yson:"a,attr"`
}

var Attrs = yson.MustInferAttrs(&MyStruct{})

func main() {
	fmt.Println(strings.Join(Attrs, ","))

}

Output:

attr,NoName,inner,f,g,a

func RegisterInterfaceDecoder ¶

func RegisterInterfaceDecoder(iface any, decoder DecoderFn)

func SliceYPathAttrs ¶

func SliceYPathAttrs(ypath []byte) (n int, err error)

SliceYPathAttrs splits ypath into attributes and path.

SliceYPathAttrs does not validate that path is a correct ypath.

func SliceYPathString ¶

func SliceYPathString(ypath []byte, str *[]byte) (n int, err error)

func SliceYPathValue ¶

func SliceYPathValue(ypath []byte, value *any) (n int, err error)

SliceYPathValue decodes single YSON value from beginning of ypath.

Returned value might point into the buffer.

func Unmarshal ¶

func Unmarshal(data []byte, v any) error

Unmarshal parses YSON-encoded data and stores result in the value pointed by v. If v is nil or not a pointer, Unmarshal returns UnsupportedTypeError.

Unmarshal works similar to encoding/json package.

Mapping between YSON types and go objects is the same as in Marshal().

func UnmarshalOptions ¶

func UnmarshalOptions(data []byte, v any, opts *DecoderOptions) error

func Valid ¶

func Valid(data []byte) error

Valid checks that byte sequence is a valid YSON node.

func ValidListFragment ¶

func ValidListFragment(data []byte) error

ValidListFragment checks that byte sequence is a valid YSON list fragment.

func ValidMapFragment ¶

func ValidMapFragment(data []byte) error

ValidMapFragment checks that byte sequence is a valid YSON map fragment.

func ValueOf ¶

func ValueOf(value any) any

ValueOf is a helper function to work with ValueWithAttrs. If value is a pointer to ValueWithAttrs, returns inner value. Otherwise returns value directly.