go: cuelang.org/go/internal/third_party/yaml Index | Files

package yaml

import "cuelang.org/go/internal/third_party/yaml"

Package yaml implements YAML support for the Go language.

Source code and other details for the project are available at GitHub:

https://github.com/go-yaml/yaml

Index

Package Files

apic.go decode.go parserc.go readerc.go resolve.go scannerc.go yaml.go yamlh.go yamlprivateh.go

func Unmarshal Uses

func Unmarshal(filename string, in []byte) (expr ast.Expr, err error)

Unmarshal decodes the first document found within the in byte slice and assigns decoded values into the out value.

Maps and pointers (to a struct, string, int, etc) are accepted as out values. If an internal pointer within a struct is not initialized, the yaml package will initialize it if necessary for unmarshalling the provided data. The out parameter must not be nil.

The type of the decoded values should be compatible with the respective values in out. If one or more values cannot be decoded due to a type mismatches, decoding continues partially until the end of the YAML content, and a *yaml.TypeError is returned with details for all missed values.

Struct fields are only unmarshalled if they are exported (have an upper case first letter), and are unmarshalled using the field name lowercased as the default key. Custom keys may be defined via the "yaml" name in the field tag: the content preceding the first comma is used as the key, and the following comma-separated options are used to tweak the marshalling process (see Marshal). Conflicting names result in a runtime error.

For example:

type T struct {
    F int `yaml:"a,omitempty"`
    B int
}
var t T
yaml.Unmarshal([]byte("a: 1\nb: 2"), &t)

See the documentation of Marshal for the format of tags and a list of supported tag options.

type Decoder Uses

type Decoder struct {
    // contains filtered or unexported fields
}

A Decorder reads and decodes YAML values from an input stream.

func NewDecoder Uses

func NewDecoder(filename string, src interface{}) (*Decoder, error)

NewDecoder returns a new decoder that reads from r.

The decoder introduces its own buffering and may read data from r beyond the YAML values requested.

func (*Decoder) Decode Uses

func (dec *Decoder) Decode() (expr ast.Expr, err error)

Decode reads the next YAML-encoded value from its input and stores it in the value pointed to by v. It returns io.EOF if there are no more value in the stream.

See the documentation for Unmarshal for details about the conversion of YAML into a Go value.

type IsZeroer Uses

type IsZeroer interface {
    IsZero() bool
}

IsZeroer is used to check whether an object is zero to determine whether it should be omitted when marshaling with the omitempty flag. One notable implementation is time.Time.

type MapItem Uses

type MapItem struct {
    Key, Value interface{}
}

MapItem is an item in a MapSlice.

type MapSlice Uses

type MapSlice []MapItem

MapSlice encodes and decodes as a YAML map. The order of keys is preserved when encoding and decoding.

type Marshaler Uses

type Marshaler interface {
    MarshalYAML() (interface{}, error)
}

The Marshaler interface may be implemented by types to customize their behavior when being marshaled into a YAML document. The returned value is marshaled in place of the original value implementing Marshaler.

If an error is returned by MarshalYAML, the marshaling procedure stops and returns with the provided error.

type TypeError Uses

type TypeError struct {
    Errors []string
}

A TypeError is returned by Unmarshal when one or more fields in the YAML document cannot be properly decoded into the requested types. When this error is returned, the value is still unmarshaled partially.

func (*TypeError) Error Uses

func (e *TypeError) Error() string

type Unmarshaler Uses

type Unmarshaler interface {
    UnmarshalYAML(unmarshal func(interface{}) error) error
}

The Unmarshaler interface may be implemented by types to customize their behavior when being unmarshaled from a YAML document. The UnmarshalYAML method receives a function that may be called to unmarshal the original YAML value into a field or variable. It is safe to call the unmarshal function parameter more than once if necessary.

Package yaml imports 16 packages (graph) and is imported by 6 packages. Updated 2019-12-13. Refresh now. Tools for package owners.