const SkipFunc … type Marshalers … // NewMarshalers constructs a flattened list of marshal functions. // If multiple functions in the list are applicable for a value of a given type, // then those earlier in the list take precedence over those that come later. // If a function returns SkipFunc, then the next applicable function is called, // otherwise the default marshaling behavior is used. // // For example: // // m1 := NewMarshalers(f1, f2) // m2 := NewMarshalers(f0, m1, f3) // equivalent to m3 // m3 := NewMarshalers(f0, f1, f2, f3) // equivalent to m2 func NewMarshalers(ms ...*Marshalers) *Marshalers { … } type Unmarshalers … // NewUnmarshalers constructs a flattened list of unmarshal functions. // If multiple functions in the list are applicable for a value of a given type, // then those earlier in the list take precedence over those that come later. // If a function returns SkipFunc, then the next applicable function is called, // otherwise the default unmarshaling behavior is used. // // For example: // // u1 := NewUnmarshalers(f1, f2) // u2 := NewUnmarshalers(f0, u1, f3) // equivalent to u3 // u3 := NewUnmarshalers(f0, f1, f2, f3) // equivalent to u2 func NewUnmarshalers(us ...*Unmarshalers) *Unmarshalers { … } type typedMarshalers … type typedUnmarshalers … type typedArshalers … type typedMarshaler … type typedUnmarshaler … type typedArshaler … func newMarshalers(ms ...*Marshalers) *Marshalers { … } func newUnmarshalers(us ...*Unmarshalers) *Unmarshalers { … } func newTypedArshalers[Options, Coder any](as ...*typedArshalers[Options, Coder]) *typedArshalers[Options, Coder] { … } func (a *typedArshalers[Options, Coder]) lookup(fnc func(Options, *Coder, addressableValue) error, t reflect.Type) (func(Options, *Coder, addressableValue) error, bool) { … } // MarshalFuncV1 constructs a type-specific marshaler that // specifies how to marshal values of type T. // T can be any type except a named pointer. // The function is always provided with a non-nil pointer value // if T is an interface or pointer type. // // The function must marshal exactly one JSON value. // The value of T must not be retained outside the function call. // It may not return SkipFunc. func MarshalFuncV1[T any](fn func(T) ([]byte, error)) *Marshalers { … } // MarshalFuncV2 constructs a type-specific marshaler that // specifies how to marshal values of type T. // T can be any type except a named pointer. // The function is always provided with a non-nil pointer value // if T is an interface or pointer type. // // The function must marshal exactly one JSON value by calling write methods // on the provided encoder. It may return SkipFunc such that marshaling can // move on to the next marshal function. However, no mutable method calls may // be called on the encoder if SkipFunc is returned. // The pointer to Encoder and the value of T must not be retained // outside the function call. func MarshalFuncV2[T any](fn func(MarshalOptions, *Encoder, T) error) *Marshalers { … } // UnmarshalFuncV1 constructs a type-specific unmarshaler that // specifies how to unmarshal values of type T. // T must be an unnamed pointer or an interface type. // The function is always provided with a non-nil pointer value. // // The function must unmarshal exactly one JSON value. // The input []byte must not be mutated. // The input []byte and value T must not be retained outside the function call. // It may not return SkipFunc. func UnmarshalFuncV1[T any](fn func([]byte, T) error) *Unmarshalers { … } // UnmarshalFuncV2 constructs a type-specific unmarshaler that // specifies how to unmarshal values of type T. // T must be an unnamed pointer or an interface type. // The function is always provided with a non-nil pointer value. // // The function must unmarshal exactly one JSON value by calling read methods // on the provided decoder. It may return SkipFunc such that unmarshaling can // move on to the next unmarshal function. However, no mutable method calls may // be called on the decoder if SkipFunc is returned. // The pointer to Decoder and the value of T must not be retained // outside the function call. func UnmarshalFuncV2[T any](fn func(UnmarshalOptions, *Decoder, T) error) *Unmarshalers { … } // assertCastableTo asserts that "to" is a valid type to be casted to. // These are the Go types that type-specific arshalers may operate upon. // // Let AllTypes be the universal set of all possible Go types. // This function generally asserts that: // // len([from for from in AllTypes if castableTo(from, to)]) > 0 // // otherwise it panics. // // As a special-case if marshal is false, then we forbid any non-pointer or // non-interface type since it is almost always a bug trying to unmarshal // into something where the end-user caller did not pass in an addressable value // since they will not observe the mutations. func assertCastableTo(to reflect.Type, marshal bool) { … } // castableTo checks whether values of type "from" can be casted to type "to". // Nil pointer or interface "from" values are never considered castable. // // This function must be kept in sync with addressableValue.castTo. func castableTo(from, to reflect.Type) bool { … } // castTo casts va to the specified type. // If the type is an interface, then the underlying type will always // be a non-nil pointer to a concrete type. // // Requirement: castableTo(va.Type(), to) must hold. func (va addressableValue) castTo(to reflect.Type) reflect.Value { … } // castableToFromAny reports whether "to" can be casted to from any // of the dynamic types used to represent arbitrary JSON. func castableToFromAny(to reflect.Type) bool { … } func wrapSkipFunc(err error, what string) error { … }
Codebase Browser
kubernetes