kubernetes/vendor/gopkg.in/yaml.v2/decode.go

const documentNode …

const mappingNode …

const sequenceNode …

const scalarNode …

const aliasNode …

type node …

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 int) *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 mapItemType …

var durationType …

var defaultMapType …

var ifaceType …

var timeType …

var ptrTimeType …

func newDecoder(strict bool) *decoder { … }

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

func (d *decoder) callUnmarshaler(n *node, u Unmarshaler) (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) { … }

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) 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 (d *decoder) setMapIndex(n *node, out, k, v reflect.Value) { … }

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

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

func failWantMap() { … }

func (d *decoder) merge(n *node, out reflect.Value) { … }

func isMerge(n *node) bool { … }