Documentation

Overview

    Defines conversions between generic types and structs to map query strings to struct objects.

    Package runtime is a generated protocol buffer package.
    
    It is generated from these files:
    	k8s.io/kubernetes/vendor/k8s.io/apimachinery/pkg/runtime/generated.proto
    
    It has these top-level messages:
    	RawExtension
    	TypeMeta
    	Unknown
    

    Index

    Constants

    View Source
    const (
    	// APIVersionInternal may be used if you are registering a type that should not
    	// be considered stable or serialized - it is a convention only and has no
    	// special behavior in this package.
    	APIVersionInternal = "__internal"
    )
    View Source
    const (
    	ContentTypeJSON string = "application/json"
    )

    Variables

    View Source
    var (
    	ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
    	ErrIntOverflowGenerated   = fmt.Errorf("proto: integer overflow")
    )
    View Source
    var DefaultFramer = defaultFramer{}

      DefaultFramer is valid for any stream that can read objects serially without any separation in the stream.

        DefaultStringConversions are helpers for converting []string and string to real values.

        Functions

        func CheckCodec

        func CheckCodec(c Codec, internalType Object, externalTypes ...schema.GroupVersionKind) error

          CheckCodec makes sure that the codec can encode objects like internalType, decode all of the external types listed, and also decode them into the given object. (Will modify internalObject.) (Assumes JSON serialization.) TODO: verify that the correct external version is chosen on encode...

          func Convert_Slice_string_To_bool

          func Convert_Slice_string_To_bool(input *[]string, out *bool, s conversion.Scope) error

            Conver_Slice_string_To_bool will convert a string parameter to boolean. Only the absence of a value, a value of "false", or a value of "0" resolve to false. Any other value (including empty string) resolves to true.

            func Convert_Slice_string_To_int

            func Convert_Slice_string_To_int(input *[]string, out *int, s conversion.Scope) error

            func Convert_Slice_string_To_int64

            func Convert_Slice_string_To_int64(input *[]string, out *int64, s conversion.Scope) error

            func Convert_Slice_string_To_string

            func Convert_Slice_string_To_string(input *[]string, out *string, s conversion.Scope) error

            func Convert_runtime_Object_To_runtime_RawExtension

            func Convert_runtime_Object_To_runtime_RawExtension(in *Object, out *RawExtension, s conversion.Scope) error

            func Convert_runtime_RawExtension_To_runtime_Object

            func Convert_runtime_RawExtension_To_runtime_Object(in *RawExtension, out *Object, s conversion.Scope) error

            func DecodeInto

            func DecodeInto(d Decoder, data []byte, into Object) error

              DecodeInto performs a Decode into the provided object.

              func DecodeList

              func DecodeList(objects []Object, decoders ...Decoder) []error

                DecodeList alters the list in place, attempting to decode any objects found in the list that have the Unknown type. Any errors that occur are returned after the entire list is processed. Decoders are tried in order.

                func DeepCopy_runtime_RawExtension

                func DeepCopy_runtime_RawExtension(in interface{}, out interface{}, c *conversion.Cloner) error

                func DeepCopy_runtime_TypeMeta

                func DeepCopy_runtime_TypeMeta(in interface{}, out interface{}, c *conversion.Cloner) error

                func DeepCopy_runtime_Unknown

                func DeepCopy_runtime_Unknown(in interface{}, out interface{}, c *conversion.Cloner) error

                func DefaultEmbeddedConversions

                func DefaultEmbeddedConversions() []interface{}

                func Encode

                func Encode(e Encoder, obj Object) ([]byte, error)

                  Encode is a convenience wrapper for encoding to a []byte from an Encoder

                  func EncodeList

                  func EncodeList(e Encoder, objects []Object) error

                    EncodeList ensures that each object in an array is converted to a Unknown{} in serialized form. TODO: accept a content type.

                    func EncodeOrDie

                    func EncodeOrDie(e Encoder, obj Object) string

                      EncodeOrDie is a version of Encode which will panic instead of returning an error. For tests.

                      func Field

                      func Field(v reflect.Value, fieldName string, dest interface{}) error

                        Field puts the value of fieldName, which must be a member of v, into dest, which must be a variable to which this field's value can be assigned.

                        func FieldPtr

                        func FieldPtr(v reflect.Value, fieldName string, dest interface{}) error

                          fieldPtr puts the address of fieldName, which must be a member of v, into dest, which must be an address of a variable to which this field's address can be assigned.

                          func GetGeneratedDeepCopyFuncs

                          func GetGeneratedDeepCopyFuncs() []conversion.GeneratedDeepCopyFunc

                            GetGeneratedDeepCopyFuncs returns the generated funcs, since we aren't registering them.

                            func IsMissingKind

                            func IsMissingKind(err error) bool

                              IsMissingKind returns true if the error indicates that the provided object is missing a 'Kind' field.

                              func IsMissingVersion

                              func IsMissingVersion(err error) bool

                              func IsNotRegisteredError

                              func IsNotRegisteredError(err error) bool

                                IsNotRegisteredError returns true if the error indicates the provided object or input data is not registered.

                                func JSONKeyMapper

                                func JSONKeyMapper(key string, sourceTag, destTag reflect.StructTag) (string, string)

                                  JSONKeyMapper uses the struct tags on a conversion to determine the key value for the other side. Use when mapping from a map[string]* to a struct or vice versa.

                                  func NewMissingKindErr

                                  func NewMissingKindErr(data string) error

                                  func NewMissingVersionErr

                                  func NewMissingVersionErr(data string) error

                                    IsMissingVersion returns true if the error indicates that the provided object is missing a 'Version' field.

                                    func NewNotRegisteredErr

                                    func NewNotRegisteredErr(gvk schema.GroupVersionKind, t reflect.Type) error

                                      NewNotRegisteredErr is exposed for testing.

                                      func SetField

                                      func SetField(src interface{}, v reflect.Value, fieldName string) error

                                        SetField puts the value of src, into fieldName, which must be a member of v. The value of src must be assignable to the field.

                                        func SetZeroValue

                                        func SetZeroValue(objPtr Object) error

                                          SetZeroValue would set the object of objPtr to zero value of its type.

                                          func VerifySwaggerDocsExist

                                          func VerifySwaggerDocsExist(kubeTypes []KubeTypes, w io.Writer) (int, error)

                                            VerifySwaggerDocsExist writes in a io.Writer a list of structs and fields that are missing of documentation.

                                            func WriteSwaggerDocFunc

                                            func WriteSwaggerDocFunc(kubeTypes []KubeTypes, w io.Writer) error

                                              WriteSwaggerDocFunc writes a declaration of a function as a string. This function is used in Swagger as a documentation source for structs and theirs fields

                                              Types

                                              type Codec

                                              type Codec Serializer

                                                Codec is a Serializer that deals with the details of versioning objects. It offers the same interface as Serializer, so this is a marker to consumers that care about the version of the objects they receive.

                                                func NewCodec

                                                func NewCodec(e Encoder, d Decoder) Codec

                                                  NewCodec creates a Codec from an Encoder and Decoder.

                                                  type Decoder

                                                  type Decoder interface {
                                                  	// Decode attempts to deserialize the provided data using either the innate typing of the scheme or the
                                                  	// default kind, group, and version provided. It returns a decoded object as well as the kind, group, and
                                                  	// version from the serialized data, or an error. If into is non-nil, it will be used as the target type
                                                  	// and implementations may choose to use it rather than reallocating an object. However, the object is not
                                                  	// guaranteed to be populated. The returned object is not guaranteed to match into. If defaults are
                                                  	// provided, they are applied to the data by default. If no defaults or partial defaults are provided, the
                                                  	// type of the into may be used to guide conversion decisions.
                                                  	Decode(data []byte, defaults *schema.GroupVersionKind, into Object) (Object, *schema.GroupVersionKind, error)
                                                  }

                                                    Decoders attempt to load an object from data.

                                                    type DefaultingSerializer

                                                    type DefaultingSerializer struct {
                                                    	Defaulter ObjectDefaulter
                                                    	Decoder   Decoder
                                                    	// Encoder is optional to allow this type to be used as both a Decoder and an Encoder
                                                    	Encoder
                                                    }

                                                      DefaultingSerializer invokes defaulting after decoding.

                                                      func (DefaultingSerializer) Decode

                                                      func (d DefaultingSerializer) Decode(data []byte, defaultGVK *schema.GroupVersionKind, into Object) (Object, *schema.GroupVersionKind, error)

                                                        Decode performs a decode and then allows the defaulter to act on the provided object.

                                                        type Encoder

                                                        type Encoder interface {
                                                        	// Encode writes an object to a stream. Implementations may return errors if the versions are
                                                        	// incompatible, or if no conversion is defined.
                                                        	Encode(obj Object, w io.Writer) error
                                                        }

                                                          Encoders write objects to a serialized form

                                                          type FieldLabelConversionFunc

                                                          type FieldLabelConversionFunc func(label, value string) (internalLabel, internalValue string, err error)

                                                            Function to convert a field selector to internal representation.

                                                            type Framer

                                                            type Framer interface {
                                                            	NewFrameReader(r io.ReadCloser) io.ReadCloser
                                                            	NewFrameWriter(w io.Writer) io.Writer
                                                            }

                                                              Framer is a factory for creating readers and writers that obey a particular framing pattern.

                                                              type GroupVersioner

                                                              type GroupVersioner interface {
                                                              	// KindForGroupVersionKinds returns a desired target group version kind for the given input, or returns ok false if no
                                                              	// target is known. In general, if the return target is not in the input list, the caller is expected to invoke
                                                              	// Scheme.New(target) and then perform a conversion between the current Go type and the destination Go type.
                                                              	// Sophisticated implementations may use additional information about the input kinds to pick a destination kind.
                                                              	KindForGroupVersionKinds(kinds []schema.GroupVersionKind) (target schema.GroupVersionKind, ok bool)
                                                              }

                                                                GroupVersioner refines a set of possible conversion targets into a single option.

                                                                var (
                                                                	// InternalGroupVersioner will always prefer the internal version for a given group version kind.
                                                                	InternalGroupVersioner GroupVersioner = internalGroupVersioner{}
                                                                	// DisabledGroupVersioner will reject all kinds passed to it.
                                                                	DisabledGroupVersioner GroupVersioner = disabledGroupVersioner{}
                                                                )

                                                                func NewMultiGroupVersioner

                                                                func NewMultiGroupVersioner(gv schema.GroupVersion, groupKinds ...schema.GroupKind) GroupVersioner

                                                                  NewMultiGroupVersioner returns the provided group version for any kind that matches one of the provided group kinds. Kind may be empty in the provided group kind, in which case any kind will match.

                                                                  type GroupVersioners

                                                                  type GroupVersioners []GroupVersioner

                                                                    GroupVersioners implements GroupVersioner and resolves to the first exact match for any kind.

                                                                    func (GroupVersioners) KindForGroupVersionKinds

                                                                    func (gvs GroupVersioners) KindForGroupVersionKinds(kinds []schema.GroupVersionKind) (schema.GroupVersionKind, bool)

                                                                      KindForGroupVersionKinds returns the first match of any of the group versioners, or false if no match occured.

                                                                      type KubeTypes

                                                                      type KubeTypes []Pair

                                                                        KubeTypes is an array to represent all available types in a parsed file. [0] is for the type itself

                                                                        func ParseDocumentationFrom

                                                                        func ParseDocumentationFrom(src string) []KubeTypes

                                                                          ParseDocumentationFrom gets all types' documentation and returns them as an array. Each type is again represented as an array (we have to use arrays as we need to be sure for the order of the fields). This function returns fields and struct definitions that have no documentation as {name, ""}.

                                                                          type MultiObjectTyper

                                                                          type MultiObjectTyper []ObjectTyper

                                                                            MultiObjectTyper returns the types of objects across multiple schemes in order.

                                                                            func (MultiObjectTyper) ObjectKinds

                                                                            func (m MultiObjectTyper) ObjectKinds(obj Object) (gvks []schema.GroupVersionKind, unversionedType bool, err error)

                                                                            func (MultiObjectTyper) Recognizes

                                                                            func (m MultiObjectTyper) Recognizes(gvk schema.GroupVersionKind) bool

                                                                            type NegotiatedSerializer

                                                                            type NegotiatedSerializer interface {
                                                                            	// SupportedMediaTypes is the media types supported for reading and writing single objects.
                                                                            	SupportedMediaTypes() []SerializerInfo
                                                                            
                                                                            	// EncoderForVersion returns an encoder that ensures objects being written to the provided
                                                                            	// serializer are in the provided group version.
                                                                            	EncoderForVersion(serializer Encoder, gv GroupVersioner) Encoder
                                                                            	// DecoderForVersion returns a decoder that ensures objects being read by the provided
                                                                            	// serializer are in the provided group version by default.
                                                                            	DecoderToVersion(serializer Decoder, gv GroupVersioner) Decoder
                                                                            }

                                                                              NegotiatedSerializer is an interface used for obtaining encoders, decoders, and serializers for multiple supported media types. This would commonly be accepted by a server component that performs HTTP content negotiation to accept multiple formats.

                                                                              type NestedObjectDecoder

                                                                              type NestedObjectDecoder interface {
                                                                              	DecodeNestedObjects(d Decoder) error
                                                                              }

                                                                                NestedObjectDecoder is an optional interface that objects may implement to be given an opportunity to decode any nested Objects / RawExtensions during serialization.

                                                                                type NestedObjectEncoder

                                                                                type NestedObjectEncoder interface {
                                                                                	EncodeNestedObjects(e Encoder) error
                                                                                }

                                                                                  NestedObjectEncoder is an optional interface that objects may implement to be given an opportunity to encode any nested Objects / RawExtensions during serialization.

                                                                                  type NoopDecoder

                                                                                  type NoopDecoder struct {
                                                                                  	Encoder
                                                                                  }

                                                                                    NoopDecoder converts an Encoder to a Serializer or Codec for code that expects them but only uses encoding.

                                                                                    func (NoopDecoder) Decode

                                                                                    func (n NoopDecoder) Decode(data []byte, gvk *schema.GroupVersionKind, into Object) (Object, *schema.GroupVersionKind, error)

                                                                                    type NoopEncoder

                                                                                    type NoopEncoder struct {
                                                                                    	Decoder
                                                                                    }

                                                                                      NoopEncoder converts an Decoder to a Serializer or Codec for code that expects them but only uses decoding.

                                                                                      func (NoopEncoder) Encode

                                                                                      func (n NoopEncoder) Encode(obj Object, w io.Writer) error

                                                                                      type Object

                                                                                      type Object interface {
                                                                                      	GetObjectKind() schema.ObjectKind
                                                                                      }

                                                                                        All API types registered with Scheme must support the Object interface. Since objects in a scheme are expected to be serialized to the wire, the interface an Object must provide to the Scheme allows serializers to set the kind, version, and group the object is represented as. An Object may choose to return a no-op ObjectKindAccessor in cases where it is not expected to be serialized.

                                                                                        func Decode

                                                                                        func Decode(d Decoder, data []byte) (Object, error)

                                                                                          Decode is a convenience wrapper for decoding data into an Object.

                                                                                          func NewEncodable

                                                                                          func NewEncodable(e Encoder, obj Object, versions ...schema.GroupVersion) Object

                                                                                            NewEncodable creates an object that will be encoded with the provided codec on demand. Provided as a convenience for test cases dealing with internal objects.

                                                                                            func NewEncodableList

                                                                                            func NewEncodableList(e Encoder, objects []Object, versions ...schema.GroupVersion) []Object

                                                                                              NewEncodableList creates an object that will be encoded with the provided codec on demand. Provided as a convenience for test cases dealing with internal objects.

                                                                                              func UseOrCreateObject

                                                                                              func UseOrCreateObject(t ObjectTyper, c ObjectCreater, gvk schema.GroupVersionKind, obj Object) (Object, error)

                                                                                                UseOrCreateObject returns obj if the canonical ObjectKind returned by the provided typer matches gvk, or invokes the ObjectCreator to instantiate a new gvk. Returns an error if the typer cannot find the object.

                                                                                                type ObjectConvertor

                                                                                                type ObjectConvertor interface {
                                                                                                	// Convert attempts to convert one object into another, or returns an error. This method does
                                                                                                	// not guarantee the in object is not mutated. The context argument will be passed to
                                                                                                	// all nested conversions.
                                                                                                	Convert(in, out, context interface{}) error
                                                                                                	// ConvertToVersion takes the provided object and converts it the provided version. This
                                                                                                	// method does not guarantee that the in object is not mutated. This method is similar to
                                                                                                	// Convert() but handles specific details of choosing the correct output version.
                                                                                                	ConvertToVersion(in Object, gv GroupVersioner) (out Object, err error)
                                                                                                	ConvertFieldLabel(version, kind, label, value string) (string, string, error)
                                                                                                }

                                                                                                  ObjectConvertor converts an object to a different version.

                                                                                                  func UnsafeObjectConvertor

                                                                                                  func UnsafeObjectConvertor(scheme *Scheme) ObjectConvertor

                                                                                                    UnsafeObjectConvertor performs object conversion without copying the object structure, for use when the converted object will not be reused or mutated. Primarily for use within versioned codecs, which use the external object for serialization but do not return it.

                                                                                                    type ObjectCopier

                                                                                                    type ObjectCopier interface {
                                                                                                    	// Copy returns an exact copy of the provided Object, or an error if the
                                                                                                    	// copy could not be completed.
                                                                                                    	Copy(Object) (Object, error)
                                                                                                    }

                                                                                                      ObjectCopier duplicates an object.

                                                                                                      type ObjectCreater

                                                                                                      type ObjectCreater interface {
                                                                                                      	New(kind schema.GroupVersionKind) (out Object, err error)
                                                                                                      }

                                                                                                        ObjectCreater contains methods for instantiating an object by kind and version.

                                                                                                        type ObjectDefaulter

                                                                                                        type ObjectDefaulter interface {
                                                                                                        	// Default takes an object (must be a pointer) and applies any default values.
                                                                                                        	// Defaulters may not error.
                                                                                                        	Default(in Object)
                                                                                                        }

                                                                                                        type ObjectTyper

                                                                                                        type ObjectTyper interface {
                                                                                                        	// ObjectKinds returns the all possible group,version,kind of the provided object, true if
                                                                                                        	// the object is unversioned, or an error if the object is not recognized
                                                                                                        	// (IsNotRegisteredError will return true).
                                                                                                        	ObjectKinds(Object) ([]schema.GroupVersionKind, bool, error)
                                                                                                        	// Recognizes returns true if the scheme is able to handle the provided version and kind,
                                                                                                        	// or more precisely that the provided version is a possible conversion or decoding
                                                                                                        	// target.
                                                                                                        	Recognizes(gvk schema.GroupVersionKind) bool
                                                                                                        }

                                                                                                          ObjectTyper contains methods for extracting the APIVersion and Kind of objects.

                                                                                                          type ObjectVersioner

                                                                                                          type ObjectVersioner interface {
                                                                                                          	ConvertToVersion(in Object, gv GroupVersioner) (out Object, err error)
                                                                                                          }

                                                                                                          type Pair

                                                                                                          type Pair struct {
                                                                                                          	Name, Doc string
                                                                                                          }

                                                                                                            Pair of strings. We keed the name of fields and the doc

                                                                                                            type ParameterCodec

                                                                                                            type ParameterCodec interface {
                                                                                                            	// DecodeParameters takes the given url.Values in the specified group version and decodes them
                                                                                                            	// into the provided object, or returns an error.
                                                                                                            	DecodeParameters(parameters url.Values, from schema.GroupVersion, into Object) error
                                                                                                            	// EncodeParameters encodes the provided object as query parameters or returns an error.
                                                                                                            	EncodeParameters(obj Object, to schema.GroupVersion) (url.Values, error)
                                                                                                            }

                                                                                                              ParameterCodec defines methods for serializing and deserializing API objects to url.Values and performing any necessary conversion. Unlike the normal Codec, query parameters are not self describing and the desired version must be specified.

                                                                                                              func NewParameterCodec

                                                                                                              func NewParameterCodec(scheme *Scheme) ParameterCodec

                                                                                                                NewParameterCodec creates a ParameterCodec capable of transforming url values into versioned objects and back.

                                                                                                                type ProtobufMarshaller

                                                                                                                type ProtobufMarshaller interface {
                                                                                                                	MarshalTo(data []byte) (int, error)
                                                                                                                }

                                                                                                                type RawExtension

                                                                                                                type RawExtension struct {
                                                                                                                	// Raw is the underlying serialization of this object.
                                                                                                                	//
                                                                                                                	// TODO: Determine how to detect ContentType and ContentEncoding of 'Raw' data.
                                                                                                                	Raw []byte `protobuf:"bytes,1,opt,name=raw"`
                                                                                                                	// Object can hold a representation of this extension - useful for working with versioned
                                                                                                                	// structs.
                                                                                                                	Object Object `json:"-"`
                                                                                                                }

                                                                                                                  RawExtension is used to hold extensions in external versions.

                                                                                                                  To use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types.

                                                                                                                  // Internal package: type MyAPIObject struct {

                                                                                                                  runtime.TypeMeta `json:",inline"`
                                                                                                                  MyPlugin runtime.Object `json:"myPlugin"`
                                                                                                                  

                                                                                                                  } type PluginA struct {

                                                                                                                  AOption string `json:"aOption"`
                                                                                                                  

                                                                                                                  }

                                                                                                                  // External package: type MyAPIObject struct {

                                                                                                                  runtime.TypeMeta `json:",inline"`
                                                                                                                  MyPlugin runtime.RawExtension `json:"myPlugin"`
                                                                                                                  

                                                                                                                  } type PluginA struct {

                                                                                                                  AOption string `json:"aOption"`
                                                                                                                  

                                                                                                                  }

                                                                                                                  // On the wire, the JSON will look something like this: {

                                                                                                                  "kind":"MyAPIObject",
                                                                                                                  "apiVersion":"v1",
                                                                                                                  "myPlugin": {
                                                                                                                  	"kind":"PluginA",
                                                                                                                  	"aOption":"foo",
                                                                                                                  },
                                                                                                                  

                                                                                                                  }

                                                                                                                  So what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)

                                                                                                                  +k8s:deepcopy-gen=true +protobuf=true +k8s:openapi-gen=true

                                                                                                                  func (*RawExtension) Descriptor

                                                                                                                  func (*RawExtension) Descriptor() ([]byte, []int)

                                                                                                                  func (*RawExtension) Marshal

                                                                                                                  func (m *RawExtension) Marshal() (data []byte, err error)

                                                                                                                  func (RawExtension) MarshalJSON

                                                                                                                  func (re RawExtension) MarshalJSON() ([]byte, error)

                                                                                                                    Marshal may get called on pointers or values, so implement MarshalJSON on value. http://stackoverflow.com/questions/21390979/custom-marshaljson-never-gets-called-in-go

                                                                                                                    func (*RawExtension) MarshalTo

                                                                                                                    func (m *RawExtension) MarshalTo(data []byte) (int, error)

                                                                                                                    func (*RawExtension) ProtoMessage

                                                                                                                    func (*RawExtension) ProtoMessage()

                                                                                                                    func (*RawExtension) Reset

                                                                                                                    func (m *RawExtension) Reset()

                                                                                                                    func (*RawExtension) Size

                                                                                                                    func (m *RawExtension) Size() (n int)

                                                                                                                    func (*RawExtension) String

                                                                                                                    func (this *RawExtension) String() string

                                                                                                                    func (*RawExtension) Unmarshal

                                                                                                                    func (m *RawExtension) Unmarshal(data []byte) error

                                                                                                                    func (*RawExtension) UnmarshalJSON

                                                                                                                    func (re *RawExtension) UnmarshalJSON(in []byte) error

                                                                                                                    type ResourceVersioner

                                                                                                                    type ResourceVersioner interface {
                                                                                                                    	SetResourceVersion(obj Object, version string) error
                                                                                                                    	ResourceVersion(obj Object) (string, error)
                                                                                                                    }

                                                                                                                      ResourceVersioner provides methods for setting and retrieving the resource version from an API object.

                                                                                                                      type Scheme

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

                                                                                                                        Scheme defines methods for serializing and deserializing API objects, a type registry for converting group, version, and kind information to and from Go schemas, and mappings between Go schemas of different versions. A scheme is the foundation for a versioned API and versioned configuration over time.

                                                                                                                        In a Scheme, a Type is a particular Go struct, a Version is a point-in-time identifier for a particular representation of that Type (typically backwards compatible), a Kind is the unique name for that Type within the Version, and a Group identifies a set of Versions, Kinds, and Types that evolve over time. An Unversioned Type is one that is not yet formally bound to a type and is promised to be backwards compatible (effectively a "v1" of a Type that does not expect to break in the future).

                                                                                                                        Schemes are not expected to change at runtime and are only threadsafe after registration is complete.

                                                                                                                        func NewScheme

                                                                                                                        func NewScheme() *Scheme

                                                                                                                          NewScheme creates a new Scheme. This scheme is pluggable by default.

                                                                                                                          func (*Scheme) AddConversionFuncs

                                                                                                                          func (s *Scheme) AddConversionFuncs(conversionFuncs ...interface{}) error

                                                                                                                            AddConversionFuncs adds functions to the list of conversion functions. The given functions should know how to convert between two of your API objects, or their sub-objects. We deduce how to call these functions from the types of their two parameters; see the comment for Converter.Register.

                                                                                                                            Note that, if you need to copy sub-objects that didn't change, you can use the conversion.Scope object that will be passed to your conversion function. Additionally, all conversions started by Scheme will set the SrcVersion and DestVersion fields on the Meta object. Example:

                                                                                                                            s.AddConversionFuncs(

                                                                                                                            func(in *InternalObject, out *ExternalObject, scope conversion.Scope) error {
                                                                                                                            	// You can depend on Meta() being non-nil, and this being set to
                                                                                                                            	// the source version, e.g., ""
                                                                                                                            	s.Meta().SrcVersion
                                                                                                                            	// You can depend on this being set to the destination version,
                                                                                                                            	// e.g., "v1".
                                                                                                                            	s.Meta().DestVersion
                                                                                                                            	// Call scope.Convert to copy sub-fields.
                                                                                                                            	s.Convert(&in.SubFieldThatMoved, &out.NewLocation.NewName, 0)
                                                                                                                            	return nil
                                                                                                                            },
                                                                                                                            

                                                                                                                            )

                                                                                                                            (For more detail about conversion functions, see Converter.Register's comment.)

                                                                                                                            Also note that the default behavior, if you don't add a conversion function, is to sanely copy fields that have the same names and same type names. It's OK if the destination type has extra fields, but it must not remove any. So you only need to add conversion functions for things with changed/removed fields.

                                                                                                                            func (*Scheme) AddDeepCopyFuncs

                                                                                                                            func (s *Scheme) AddDeepCopyFuncs(deepCopyFuncs ...interface{}) error

                                                                                                                              AddDeepCopyFuncs adds a function to the list of deep-copy functions. For the expected format of deep-copy function, see the comment for Copier.RegisterDeepCopyFunction.

                                                                                                                              func (*Scheme) AddDefaultingFuncs

                                                                                                                              func (s *Scheme) AddDefaultingFuncs(defaultingFuncs ...interface{}) error

                                                                                                                                AddDefaultingFuncs adds functions to the list of default-value functions. Each of the given functions is responsible for applying default values when converting an instance of a versioned API object into an internal API object. These functions do not need to handle sub-objects. We deduce how to call these functions from the types of their two parameters.

                                                                                                                                s.AddDefaultingFuncs(

                                                                                                                                func(obj *v1.Pod) {
                                                                                                                                	if obj.OptionalField == "" {
                                                                                                                                		obj.OptionalField = "DefaultValue"
                                                                                                                                	}
                                                                                                                                },
                                                                                                                                

                                                                                                                                )

                                                                                                                                func (*Scheme) AddFieldLabelConversionFunc

                                                                                                                                func (s *Scheme) AddFieldLabelConversionFunc(version, kind string, conversionFunc FieldLabelConversionFunc) error

                                                                                                                                  AddFieldLabelConversionFunc adds a conversion function to convert field selectors of the given kind from the given version to internal version representation.

                                                                                                                                  func (*Scheme) AddGeneratedConversionFuncs

                                                                                                                                  func (s *Scheme) AddGeneratedConversionFuncs(conversionFuncs ...interface{}) error

                                                                                                                                    Similar to AddConversionFuncs, but registers conversion functions that were automatically generated.

                                                                                                                                    func (*Scheme) AddGeneratedDeepCopyFuncs

                                                                                                                                    func (s *Scheme) AddGeneratedDeepCopyFuncs(deepCopyFuncs ...conversion.GeneratedDeepCopyFunc) error

                                                                                                                                      Similar to AddDeepCopyFuncs, but registers deep-copy functions that were automatically generated.

                                                                                                                                      func (*Scheme) AddGenericConversionFunc

                                                                                                                                      func (s *Scheme) AddGenericConversionFunc(fn conversion.GenericConversionFunc)

                                                                                                                                        AddGenericConversionFunc adds a function that accepts the ConversionFunc call pattern (for two conversion types) to the converter. These functions are checked first during a normal conversion, but are otherwise not called. Use AddConversionFuncs when registering typed conversions.

                                                                                                                                        func (*Scheme) AddIgnoredConversionType

                                                                                                                                        func (s *Scheme) AddIgnoredConversionType(from, to interface{}) error

                                                                                                                                          AddIgnoredConversionType identifies a pair of types that should be skipped by conversion (because the data inside them is explicitly dropped during conversion).

                                                                                                                                          func (*Scheme) AddKnownTypeWithName

                                                                                                                                          func (s *Scheme) AddKnownTypeWithName(gvk schema.GroupVersionKind, obj Object)

                                                                                                                                            AddKnownTypeWithName is like AddKnownTypes, but it lets you specify what this type should be encoded as. Useful for testing when you don't want to make multiple packages to define your structs. Version may not be empty - use the APIVersionInternal constant if you have a type that does not have a formal version.

                                                                                                                                            func (*Scheme) AddKnownTypes

                                                                                                                                            func (s *Scheme) AddKnownTypes(gv schema.GroupVersion, types ...Object)

                                                                                                                                              AddKnownTypes registers all types passed in 'types' as being members of version 'version'. All objects passed to types should be pointers to structs. The name that go reports for the struct becomes the "kind" field when encoding. Version may not be empty - use the APIVersionInternal constant if you have a type that does not have a formal version.

                                                                                                                                              func (*Scheme) AddStructFieldConversion

                                                                                                                                              func (s *Scheme) AddStructFieldConversion(srcFieldType interface{}, srcFieldName string, destFieldType interface{}, destFieldName string) error

                                                                                                                                                AddStructFieldConversion allows you to specify a mechanical copy for a moved or renamed struct field without writing an entire conversion function. See the comment in conversion.Converter.SetStructFieldCopy for parameter details. Call as many times as needed, even on the same fields.

                                                                                                                                                func (*Scheme) AddTypeDefaultingFunc

                                                                                                                                                func (s *Scheme) AddTypeDefaultingFunc(srcType Object, fn func(interface{}))

                                                                                                                                                  AddTypeDefaultingFuncs registers a function that is passed a pointer to an object and can default fields on the object. These functions will be invoked when Default() is called. The function will never be called unless the defaulted object matches srcType. If this function is invoked twice with the same srcType, the fn passed to the later call will be used instead.

                                                                                                                                                  func (*Scheme) AddUnversionedTypes

                                                                                                                                                  func (s *Scheme) AddUnversionedTypes(version schema.GroupVersion, types ...Object)

                                                                                                                                                    AddUnversionedTypes registers the provided types as "unversioned", which means that they follow special rules. Whenever an object of this type is serialized, it is serialized with the provided group version and is not converted. Thus unversioned objects are expected to remain backwards compatible forever, as if they were in an API group and version that would never be updated.

                                                                                                                                                    TODO: there is discussion about removing unversioned and replacing it with objects that are manifest into

                                                                                                                                                    every version with particular schemas. Resolve this method at that point.
                                                                                                                                                    

                                                                                                                                                    func (*Scheme) AllKnownTypes

                                                                                                                                                    func (s *Scheme) AllKnownTypes() map[schema.GroupVersionKind]reflect.Type

                                                                                                                                                      AllKnownTypes returns the all known types.

                                                                                                                                                      func (*Scheme) Convert

                                                                                                                                                      func (s *Scheme) Convert(in, out interface{}, context interface{}) error

                                                                                                                                                        Convert will attempt to convert in into out. Both must be pointers. For easy testing of conversion functions. Returns an error if the conversion isn't possible. You can call this with types that haven't been registered (for example, a to test conversion of types that are nested within registered types). The context interface is passed to the convertor. TODO: identify whether context should be hidden, or behind a formal context/scope

                                                                                                                                                        interface
                                                                                                                                                        

                                                                                                                                                        func (*Scheme) ConvertFieldLabel

                                                                                                                                                        func (s *Scheme) ConvertFieldLabel(version, kind, label, value string) (string, string, error)

                                                                                                                                                          Converts the given field label and value for an kind field selector from versioned representation to an unversioned one.

                                                                                                                                                          func (*Scheme) ConvertToVersion

                                                                                                                                                          func (s *Scheme) ConvertToVersion(in Object, target GroupVersioner) (Object, error)

                                                                                                                                                            ConvertToVersion attempts to convert an input object to its matching Kind in another version within this scheme. Will return an error if the provided version does not contain the inKind (or a mapping by name defined with AddKnownTypeWithName). Will also return an error if the conversion does not result in a valid Object being returned. Passes target down to the conversion methods as the Context on the scope.

                                                                                                                                                            func (*Scheme) Converter

                                                                                                                                                            func (s *Scheme) Converter() *conversion.Converter

                                                                                                                                                              Converter allows access to the converter for the scheme

                                                                                                                                                              func (*Scheme) Copy

                                                                                                                                                              func (s *Scheme) Copy(src Object) (Object, error)

                                                                                                                                                                Copy does a deep copy of an API object.

                                                                                                                                                                func (*Scheme) DeepCopy

                                                                                                                                                                func (s *Scheme) DeepCopy(src interface{}) (interface{}, error)

                                                                                                                                                                  Performs a deep copy of the given object.

                                                                                                                                                                  func (*Scheme) Default

                                                                                                                                                                  func (s *Scheme) Default(src Object)

                                                                                                                                                                    Default sets defaults on the provided Object.

                                                                                                                                                                    func (*Scheme) IsUnversioned

                                                                                                                                                                    func (s *Scheme) IsUnversioned(obj Object) (bool, bool)

                                                                                                                                                                    func (*Scheme) KnownTypes

                                                                                                                                                                    func (s *Scheme) KnownTypes(gv schema.GroupVersion) map[string]reflect.Type

                                                                                                                                                                      KnownTypes returns the types known for the given version.

                                                                                                                                                                      func (*Scheme) Log

                                                                                                                                                                      func (s *Scheme) Log(l conversion.DebugLogger)

                                                                                                                                                                        Log sets a logger on the scheme. For test purposes only

                                                                                                                                                                        func (*Scheme) New

                                                                                                                                                                        func (s *Scheme) New(kind schema.GroupVersionKind) (Object, error)

                                                                                                                                                                          New returns a new API object of the given version and name, or an error if it hasn't been registered. The version and kind fields must be specified.

                                                                                                                                                                          func (*Scheme) ObjectKind

                                                                                                                                                                          func (s *Scheme) ObjectKind(obj Object) (schema.GroupVersionKind, bool, error)

                                                                                                                                                                            ObjectKind returns the group,version,kind of the go object and true if this object is considered unversioned, or an error if it's not a pointer or is unregistered.

                                                                                                                                                                            func (*Scheme) ObjectKinds

                                                                                                                                                                            func (s *Scheme) ObjectKinds(obj Object) ([]schema.GroupVersionKind, bool, error)

                                                                                                                                                                              ObjectKinds returns all possible group,version,kind of the go object, true if the object is considered unversioned, or an error if it's not a pointer or is unregistered.

                                                                                                                                                                              func (*Scheme) Recognizes

                                                                                                                                                                              func (s *Scheme) Recognizes(gvk schema.GroupVersionKind) bool

                                                                                                                                                                                Recognizes returns true if the scheme is able to handle the provided group,version,kind of an object.

                                                                                                                                                                                func (*Scheme) RegisterInputDefaults

                                                                                                                                                                                func (s *Scheme) RegisterInputDefaults(in interface{}, fn conversion.FieldMappingFunc, defaultFlags conversion.FieldMatchingFlags) error

                                                                                                                                                                                  RegisterInputDefaults sets the provided field mapping function and field matching as the defaults for the provided input type. The fn may be nil, in which case no mapping will happen by default. Use this method to register a mechanism for handling a specific input type in conversion, such as a map[string]string to structs.

                                                                                                                                                                                  func (*Scheme) UnsafeConvertToVersion

                                                                                                                                                                                  func (s *Scheme) UnsafeConvertToVersion(in Object, target GroupVersioner) (Object, error)

                                                                                                                                                                                    UnsafeConvertToVersion will convert in to the provided target if such a conversion is possible, but does not guarantee the output object does not share fields with the input object. It attempts to be as efficient as possible when doing conversion.

                                                                                                                                                                                    type SchemeBuilder

                                                                                                                                                                                    type SchemeBuilder []func(*Scheme) error

                                                                                                                                                                                      SchemeBuilder collects functions that add things to a scheme. It's to allow code to compile without explicitly referencing generated types. You should declare one in each package that will have generated deep copy or conversion functions.

                                                                                                                                                                                      func NewSchemeBuilder

                                                                                                                                                                                      func NewSchemeBuilder(funcs ...func(*Scheme) error) SchemeBuilder

                                                                                                                                                                                        NewSchemeBuilder calls Register for you.

                                                                                                                                                                                        func (*SchemeBuilder) AddToScheme

                                                                                                                                                                                        func (sb *SchemeBuilder) AddToScheme(s *Scheme) error

                                                                                                                                                                                          AddToScheme applies all the stored functions to the scheme. A non-nil error indicates that one function failed and the attempt was abandoned.

                                                                                                                                                                                          func (*SchemeBuilder) Register

                                                                                                                                                                                          func (sb *SchemeBuilder) Register(funcs ...func(*Scheme) error)

                                                                                                                                                                                            Register adds a scheme setup function to the list.

                                                                                                                                                                                            type SelfLinker

                                                                                                                                                                                            type SelfLinker interface {
                                                                                                                                                                                            	SetSelfLink(obj Object, selfLink string) error
                                                                                                                                                                                            	SelfLink(obj Object) (string, error)
                                                                                                                                                                                            
                                                                                                                                                                                            	// Knowing Name is sometimes necessary to use a SelfLinker.
                                                                                                                                                                                            	Name(obj Object) (string, error)
                                                                                                                                                                                            	// Knowing Namespace is sometimes necessary to use a SelfLinker
                                                                                                                                                                                            	Namespace(obj Object) (string, error)
                                                                                                                                                                                            }

                                                                                                                                                                                              SelfLinker provides methods for setting and retrieving the SelfLink field of an API object.

                                                                                                                                                                                              type Serializer

                                                                                                                                                                                              type Serializer interface {
                                                                                                                                                                                              	Encoder
                                                                                                                                                                                              	Decoder
                                                                                                                                                                                              }

                                                                                                                                                                                                Serializer is the core interface for transforming objects into a serialized format and back. Implementations may choose to perform conversion of the object, but no assumptions should be made.

                                                                                                                                                                                                func NewBase64Serializer

                                                                                                                                                                                                func NewBase64Serializer(e Encoder, d Decoder) Serializer

                                                                                                                                                                                                type SerializerInfo

                                                                                                                                                                                                type SerializerInfo struct {
                                                                                                                                                                                                	// MediaType is the value that represents this serializer over the wire.
                                                                                                                                                                                                	MediaType string
                                                                                                                                                                                                	// EncodesAsText indicates this serializer can be encoded to UTF-8 safely.
                                                                                                                                                                                                	EncodesAsText bool
                                                                                                                                                                                                	// Serializer is the individual object serializer for this media type.
                                                                                                                                                                                                	Serializer Serializer
                                                                                                                                                                                                	// PrettySerializer, if set, can serialize this object in a form biased towards
                                                                                                                                                                                                	// readability.
                                                                                                                                                                                                	PrettySerializer Serializer
                                                                                                                                                                                                	// StreamSerializer, if set, describes the streaming serialization format
                                                                                                                                                                                                	// for this media type.
                                                                                                                                                                                                	StreamSerializer *StreamSerializerInfo
                                                                                                                                                                                                }

                                                                                                                                                                                                  SerializerInfo contains information about a specific serialization format

                                                                                                                                                                                                  func SerializerInfoForMediaType

                                                                                                                                                                                                  func SerializerInfoForMediaType(types []SerializerInfo, mediaType string) (SerializerInfo, bool)

                                                                                                                                                                                                    SerializerInfoForMediaType returns the first info in types that has a matching media type (which cannot include media-type parameters), or the first info with an empty media type, or false if no type matches.

                                                                                                                                                                                                    type StorageSerializer

                                                                                                                                                                                                    type StorageSerializer interface {
                                                                                                                                                                                                    	// SupportedMediaTypes are the media types supported for reading and writing objects.
                                                                                                                                                                                                    	SupportedMediaTypes() []SerializerInfo
                                                                                                                                                                                                    
                                                                                                                                                                                                    	// UniversalDeserializer returns a Serializer that can read objects in multiple supported formats
                                                                                                                                                                                                    	// by introspecting the data at rest.
                                                                                                                                                                                                    	UniversalDeserializer() Decoder
                                                                                                                                                                                                    
                                                                                                                                                                                                    	// EncoderForVersion returns an encoder that ensures objects being written to the provided
                                                                                                                                                                                                    	// serializer are in the provided group version.
                                                                                                                                                                                                    	EncoderForVersion(serializer Encoder, gv GroupVersioner) Encoder
                                                                                                                                                                                                    	// DecoderForVersion returns a decoder that ensures objects being read by the provided
                                                                                                                                                                                                    	// serializer are in the provided group version by default.
                                                                                                                                                                                                    	DecoderToVersion(serializer Decoder, gv GroupVersioner) Decoder
                                                                                                                                                                                                    }

                                                                                                                                                                                                      StorageSerializer is an interface used for obtaining encoders, decoders, and serializers that can read and write data at rest. This would commonly be used by client tools that must read files, or server side storage interfaces that persist restful objects.

                                                                                                                                                                                                      type StreamSerializerInfo

                                                                                                                                                                                                      type StreamSerializerInfo struct {
                                                                                                                                                                                                      	// EncodesAsText indicates this serializer can be encoded to UTF-8 safely.
                                                                                                                                                                                                      	EncodesAsText bool
                                                                                                                                                                                                      	// Serializer is the top level object serializer for this type when streaming
                                                                                                                                                                                                      	Serializer
                                                                                                                                                                                                      	// Framer is the factory for retrieving streams that separate objects on the wire
                                                                                                                                                                                                      	Framer
                                                                                                                                                                                                      }

                                                                                                                                                                                                        StreamSerializerInfo contains information about a specific stream serialization format

                                                                                                                                                                                                        type TypeMeta

                                                                                                                                                                                                        type TypeMeta struct {
                                                                                                                                                                                                        	// +optional
                                                                                                                                                                                                        	APIVersion string `json:"apiVersion,omitempty" yaml:"apiVersion,omitempty" protobuf:"bytes,1,opt,name=apiVersion"`
                                                                                                                                                                                                        	// +optional
                                                                                                                                                                                                        	Kind string `json:"kind,omitempty" yaml:"kind,omitempty" protobuf:"bytes,2,opt,name=kind"`
                                                                                                                                                                                                        }

                                                                                                                                                                                                          TypeMeta is shared by all top level objects. The proper way to use it is to inline it in your type, like this: type MyAwesomeAPIObject struct {

                                                                                                                                                                                                          runtime.TypeMeta    `json:",inline"`
                                                                                                                                                                                                          ... // other fields
                                                                                                                                                                                                          

                                                                                                                                                                                                          } func (obj *MyAwesomeAPIObject) SetGroupVersionKind(gvk *metav1.GroupVersionKind) { metav1.UpdateTypeMeta(obj,gvk) }; GroupVersionKind() *GroupVersionKind

                                                                                                                                                                                                          TypeMeta is provided here for convenience. You may use it directly from this package or define your own with the same fields.

                                                                                                                                                                                                          +k8s:deepcopy-gen=true +protobuf=true +k8s:openapi-gen=true

                                                                                                                                                                                                          func (*TypeMeta) Descriptor

                                                                                                                                                                                                          func (*TypeMeta) Descriptor() ([]byte, []int)

                                                                                                                                                                                                          func (*TypeMeta) GroupVersionKind

                                                                                                                                                                                                          func (obj *TypeMeta) GroupVersionKind() schema.GroupVersionKind

                                                                                                                                                                                                            GroupVersionKind satisfies the ObjectKind interface for all objects that embed TypeMeta

                                                                                                                                                                                                            func (*TypeMeta) Marshal

                                                                                                                                                                                                            func (m *TypeMeta) Marshal() (data []byte, err error)

                                                                                                                                                                                                            func (*TypeMeta) MarshalTo

                                                                                                                                                                                                            func (m *TypeMeta) MarshalTo(data []byte) (int, error)

                                                                                                                                                                                                            func (*TypeMeta) ProtoMessage

                                                                                                                                                                                                            func (*TypeMeta) ProtoMessage()

                                                                                                                                                                                                            func (*TypeMeta) Reset

                                                                                                                                                                                                            func (m *TypeMeta) Reset()

                                                                                                                                                                                                            func (*TypeMeta) SetGroupVersionKind

                                                                                                                                                                                                            func (obj *TypeMeta) SetGroupVersionKind(gvk schema.GroupVersionKind)

                                                                                                                                                                                                              SetGroupVersionKind satisfies the ObjectKind interface for all objects that embed TypeMeta

                                                                                                                                                                                                              func (*TypeMeta) Size

                                                                                                                                                                                                              func (m *TypeMeta) Size() (n int)

                                                                                                                                                                                                              func (*TypeMeta) String

                                                                                                                                                                                                              func (this *TypeMeta) String() string

                                                                                                                                                                                                              func (*TypeMeta) Unmarshal

                                                                                                                                                                                                              func (m *TypeMeta) Unmarshal(data []byte) error

                                                                                                                                                                                                              type Unknown

                                                                                                                                                                                                              type Unknown struct {
                                                                                                                                                                                                              	TypeMeta `json:",inline" protobuf:"bytes,1,opt,name=typeMeta"`
                                                                                                                                                                                                              	// Raw will hold the complete serialized object which couldn't be matched
                                                                                                                                                                                                              	// with a registered type. Most likely, nothing should be done with this
                                                                                                                                                                                                              	// except for passing it through the system.
                                                                                                                                                                                                              	Raw []byte `protobuf:"bytes,2,opt,name=raw"`
                                                                                                                                                                                                              	// ContentEncoding is encoding used to encode 'Raw' data.
                                                                                                                                                                                                              	// Unspecified means no encoding.
                                                                                                                                                                                                              	ContentEncoding string `protobuf:"bytes,3,opt,name=contentEncoding"`
                                                                                                                                                                                                              	// ContentType  is serialization method used to serialize 'Raw'.
                                                                                                                                                                                                              	// Unspecified means ContentTypeJSON.
                                                                                                                                                                                                              	ContentType string `protobuf:"bytes,4,opt,name=contentType"`
                                                                                                                                                                                                              }

                                                                                                                                                                                                                Unknown allows api objects with unknown types to be passed-through. This can be used to deal with the API objects from a plug-in. Unknown objects still have functioning TypeMeta features-- kind, version, etc. TODO: Make this object have easy access to field based accessors and settors for metadata and field mutatation.

                                                                                                                                                                                                                +k8s:deepcopy-gen=true +protobuf=true +k8s:openapi-gen=true

                                                                                                                                                                                                                func (*Unknown) Descriptor

                                                                                                                                                                                                                func (*Unknown) Descriptor() ([]byte, []int)

                                                                                                                                                                                                                func (*Unknown) GetObjectKind

                                                                                                                                                                                                                func (obj *Unknown) GetObjectKind() schema.ObjectKind

                                                                                                                                                                                                                func (*Unknown) Marshal

                                                                                                                                                                                                                func (m *Unknown) Marshal() (data []byte, err error)

                                                                                                                                                                                                                func (Unknown) MarshalJSON

                                                                                                                                                                                                                func (re Unknown) MarshalJSON() ([]byte, error)

                                                                                                                                                                                                                  Marshal may get called on pointers or values, so implement MarshalJSON on value. http://stackoverflow.com/questions/21390979/custom-marshaljson-never-gets-called-in-go

                                                                                                                                                                                                                  func (*Unknown) MarshalTo

                                                                                                                                                                                                                  func (m *Unknown) MarshalTo(data []byte) (int, error)

                                                                                                                                                                                                                  func (*Unknown) NestedMarshalTo

                                                                                                                                                                                                                  func (m *Unknown) NestedMarshalTo(data []byte, b ProtobufMarshaller, size uint64) (int, error)

                                                                                                                                                                                                                    NestedMarshalTo allows a caller to avoid extra allocations during serialization of an Unknown that will contain an object that implements ProtobufMarshaller.

                                                                                                                                                                                                                    func (*Unknown) ProtoMessage

                                                                                                                                                                                                                    func (*Unknown) ProtoMessage()

                                                                                                                                                                                                                    func (*Unknown) Reset

                                                                                                                                                                                                                    func (m *Unknown) Reset()

                                                                                                                                                                                                                    func (*Unknown) Size

                                                                                                                                                                                                                    func (m *Unknown) Size() (n int)

                                                                                                                                                                                                                    func (*Unknown) String

                                                                                                                                                                                                                    func (this *Unknown) String() string

                                                                                                                                                                                                                    func (*Unknown) Unmarshal

                                                                                                                                                                                                                    func (m *Unknown) Unmarshal(data []byte) error

                                                                                                                                                                                                                    func (*Unknown) UnmarshalJSON

                                                                                                                                                                                                                    func (re *Unknown) UnmarshalJSON(in []byte) error

                                                                                                                                                                                                                    type Unstructured

                                                                                                                                                                                                                    type Unstructured interface {
                                                                                                                                                                                                                    	// IsUnstructuredObject is a marker interface to allow objects that can be serialized but not introspected
                                                                                                                                                                                                                    	// to bypass conversion.
                                                                                                                                                                                                                    	IsUnstructuredObject()
                                                                                                                                                                                                                    	// IsList returns true if this type is a list or matches the list convention - has an array called "items".
                                                                                                                                                                                                                    	IsList() bool
                                                                                                                                                                                                                    	// UnstructuredContent returns a non-nil, mutable map of the contents of this object. Values may be
                                                                                                                                                                                                                    	// []interface{}, map[string]interface{}, or any primitive type. Contents are typically serialized to
                                                                                                                                                                                                                    	// and from JSON.
                                                                                                                                                                                                                    	UnstructuredContent() map[string]interface{}
                                                                                                                                                                                                                    }

                                                                                                                                                                                                                      Unstructured objects store values as map[string]interface{}, with only values that can be serialized to JSON allowed.

                                                                                                                                                                                                                      type VersionedObjects

                                                                                                                                                                                                                      type VersionedObjects struct {
                                                                                                                                                                                                                      	// Objects is the set of objects retrieved during decoding, in order of conversion.
                                                                                                                                                                                                                      	// The 0 index is the object as serialized on the wire. If conversion has occurred,
                                                                                                                                                                                                                      	// other objects may be present. The right most object is the same as would be returned
                                                                                                                                                                                                                      	// by a normal Decode call.
                                                                                                                                                                                                                      	Objects []Object
                                                                                                                                                                                                                      }

                                                                                                                                                                                                                        VersionedObjects is used by Decoders to give callers a way to access all versions of an object during the decoding process.

                                                                                                                                                                                                                        func (*VersionedObjects) First

                                                                                                                                                                                                                        func (obj *VersionedObjects) First() Object

                                                                                                                                                                                                                          First returns the leftmost object in the VersionedObjects array, which is usually the object as serialized on the wire.

                                                                                                                                                                                                                          func (*VersionedObjects) GetObjectKind

                                                                                                                                                                                                                          func (obj *VersionedObjects) GetObjectKind() schema.ObjectKind

                                                                                                                                                                                                                            GetObjectKind implements Object for VersionedObjects, returning an empty ObjectKind interface if no objects are provided, or the ObjectKind interface of the object in the highest array position.

                                                                                                                                                                                                                            func (*VersionedObjects) Last

                                                                                                                                                                                                                            func (obj *VersionedObjects) Last() Object

                                                                                                                                                                                                                              Last is the rightmost object in the VersionedObjects array, which is the object after all transformations have been applied. This is the same object that would be returned by Decode in a normal invocation (without VersionedObjects in the into argument).

                                                                                                                                                                                                                              Directories

                                                                                                                                                                                                                              Path Synopsis
                                                                                                                                                                                                                              Package schema is a generated protocol buffer package.
                                                                                                                                                                                                                              Package schema is a generated protocol buffer package.
                                                                                                                                                                                                                              protobuf
                                                                                                                                                                                                                              Package protobuf provides a Kubernetes serializer for the protobuf format.
                                                                                                                                                                                                                              Package protobuf provides a Kubernetes serializer for the protobuf format.
                                                                                                                                                                                                                              streaming
                                                                                                                                                                                                                              Package streaming implements encoder and decoder for streams of runtime.Objects over io.Writer/Readers.
                                                                                                                                                                                                                              Package streaming implements encoder and decoder for streams of runtime.Objects over io.Writer/Readers.