kubernetes/vendor/sigs.k8s.io/yaml/goyaml.v3/decode.go

type parser …

func newParser(b []byte) *parser { … }

func newParserFromReader(r io.Reader) *parser { … }

func (p *parser) init() { … }

func (p *parser) destroy() { … }

// expect consumes an event from the event stream and
// checks that it's of the expected type.
func (p *parser) expect(e yaml_event_type_t) { … }

// peek peeks at the next event in the event stream,
// puts the results into p.event and returns the event type.
func (p *parser) peek() yaml_event_type_t { … }

func (p *parser) fail() { … }

func (p *parser) anchor(n *Node, anchor []byte) { … }

func (p *parser) parse() *Node { … }

func (p *parser) node(kind Kind, defaultTag, tag, value string) *Node { … }

func (p *parser) parseChild(parent *Node) *Node { … }

func (p *parser) document() *Node { … }

func (p *parser) alias() *Node { … }

func (p *parser) scalar() *Node { … }

func (p *parser) sequence() *Node { … }

func (p *parser) mapping() *Node { … }

type decoder …

var nodeType …

var durationType …

var stringMapType …

var generalMapType …

var ifaceType …

var timeType …

var ptrTimeType …

func newDecoder() *decoder { … }

func (d *decoder) terror(n *Node, tag string, out reflect.Value) { … }

func (d *decoder) callUnmarshaler(n *Node, u Unmarshaler) (good bool) { … }

func (d *decoder) callObsoleteUnmarshaler(n *Node, u obsoleteUnmarshaler) (good bool) { … }

// d.prepare initializes and dereferences pointers and calls UnmarshalYAML
// if a value is found to implement it.
// It returns the initialized and dereferenced out value, whether
// unmarshalling was already done by UnmarshalYAML, and if so whether
// its types unmarshalled appropriately.
//
// If n holds a null value, prepare returns before doing anything.
func (d *decoder) prepare(n *Node, out reflect.Value) (newout reflect.Value, unmarshaled, good bool) { … }

func (d *decoder) fieldByIndex(n *Node, v reflect.Value, index []int) (field reflect.Value) { … }

const alias_ratio_range_low …

const alias_ratio_range_high …

const alias_ratio_range …

func allowedAliasRatio(decodeCount int) float64 { … }

func (d *decoder) unmarshal(n *Node, out reflect.Value) (good bool) { … }

func (d *decoder) document(n *Node, out reflect.Value) (good bool) { … }

func (d *decoder) alias(n *Node, out reflect.Value) (good bool) { … }

var zeroValue …

func resetMap(out reflect.Value) { … }

func (d *decoder) null(out reflect.Value) bool { … }

func (d *decoder) scalar(n *Node, out reflect.Value) bool { … }

func settableValueOf(i interface{ … }

func (d *decoder) sequence(n *Node, out reflect.Value) (good bool) { … }

func (d *decoder) mapping(n *Node, out reflect.Value) (good bool) { … }

func isStringMap(n *Node) bool { … }

func (d *decoder) mappingStruct(n *Node, out reflect.Value) (good bool) { … }

func failWantMap() { … }

func (d *decoder) merge(parent *Node, merge *Node, out reflect.Value) { … }

func isMerge(n *Node) bool { … }