summaryrefslogtreecommitdiff
path: root/vendor/k8s.io/apimachinery/pkg/conversion/converter.go
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/k8s.io/apimachinery/pkg/conversion/converter.go')
-rw-r--r--vendor/k8s.io/apimachinery/pkg/conversion/converter.go233
1 files changed, 0 insertions, 233 deletions
diff --git a/vendor/k8s.io/apimachinery/pkg/conversion/converter.go b/vendor/k8s.io/apimachinery/pkg/conversion/converter.go
deleted file mode 100644
index 791348476..000000000
--- a/vendor/k8s.io/apimachinery/pkg/conversion/converter.go
+++ /dev/null
@@ -1,233 +0,0 @@
-/*
-Copyright 2014 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package conversion
-
-import (
- "fmt"
- "reflect"
-)
-
-type typePair struct {
- source reflect.Type
- dest reflect.Type
-}
-
-type NameFunc func(t reflect.Type) string
-
-var DefaultNameFunc = func(t reflect.Type) string { return t.Name() }
-
-// ConversionFunc converts the object a into the object b, reusing arrays or objects
-// or pointers if necessary. It should return an error if the object cannot be converted
-// or if some data is invalid. If you do not wish a and b to share fields or nested
-// objects, you must copy a before calling this function.
-type ConversionFunc func(a, b interface{}, scope Scope) error
-
-// Converter knows how to convert one type to another.
-type Converter struct {
- // Map from the conversion pair to a function which can
- // do the conversion.
- conversionFuncs ConversionFuncs
- generatedConversionFuncs ConversionFuncs
-
- // Set of conversions that should be treated as a no-op
- ignoredConversions map[typePair]struct{}
- ignoredUntypedConversions map[typePair]struct{}
-
- // nameFunc is called to retrieve the name of a type; this name is used for the
- // purpose of deciding whether two types match or not (i.e., will we attempt to
- // do a conversion). The default returns the go type name.
- nameFunc func(t reflect.Type) string
-}
-
-// NewConverter creates a new Converter object.
-func NewConverter(nameFn NameFunc) *Converter {
- c := &Converter{
- conversionFuncs: NewConversionFuncs(),
- generatedConversionFuncs: NewConversionFuncs(),
- ignoredConversions: make(map[typePair]struct{}),
- ignoredUntypedConversions: make(map[typePair]struct{}),
- nameFunc: nameFn,
- }
- c.RegisterUntypedConversionFunc(
- (*[]byte)(nil), (*[]byte)(nil),
- func(a, b interface{}, s Scope) error {
- return Convert_Slice_byte_To_Slice_byte(a.(*[]byte), b.(*[]byte), s)
- },
- )
- return c
-}
-
-// WithConversions returns a Converter that is a copy of c but with the additional
-// fns merged on top.
-func (c *Converter) WithConversions(fns ConversionFuncs) *Converter {
- copied := *c
- copied.conversionFuncs = c.conversionFuncs.Merge(fns)
- return &copied
-}
-
-// DefaultMeta returns meta for a given type.
-func (c *Converter) DefaultMeta(t reflect.Type) *Meta {
- return &Meta{}
-}
-
-// Convert_Slice_byte_To_Slice_byte prevents recursing into every byte
-func Convert_Slice_byte_To_Slice_byte(in *[]byte, out *[]byte, s Scope) error {
- if *in == nil {
- *out = nil
- return nil
- }
- *out = make([]byte, len(*in))
- copy(*out, *in)
- return nil
-}
-
-// Scope is passed to conversion funcs to allow them to continue an ongoing conversion.
-// If multiple converters exist in the system, Scope will allow you to use the correct one
-// from a conversion function--that is, the one your conversion function was called by.
-type Scope interface {
- // Call Convert to convert sub-objects. Note that if you call it with your own exact
- // parameters, you'll run out of stack space before anything useful happens.
- Convert(src, dest interface{}) error
-
- // Meta returns any information originally passed to Convert.
- Meta() *Meta
-}
-
-func NewConversionFuncs() ConversionFuncs {
- return ConversionFuncs{
- untyped: make(map[typePair]ConversionFunc),
- }
-}
-
-type ConversionFuncs struct {
- untyped map[typePair]ConversionFunc
-}
-
-// AddUntyped adds the provided conversion function to the lookup table for the types that are
-// supplied as a and b. a and b must be pointers or an error is returned. This method overwrites
-// previously defined functions.
-func (c ConversionFuncs) AddUntyped(a, b interface{}, fn ConversionFunc) error {
- tA, tB := reflect.TypeOf(a), reflect.TypeOf(b)
- if tA.Kind() != reflect.Ptr {
- return fmt.Errorf("the type %T must be a pointer to register as an untyped conversion", a)
- }
- if tB.Kind() != reflect.Ptr {
- return fmt.Errorf("the type %T must be a pointer to register as an untyped conversion", b)
- }
- c.untyped[typePair{tA, tB}] = fn
- return nil
-}
-
-// Merge returns a new ConversionFuncs that contains all conversions from
-// both other and c, with other conversions taking precedence.
-func (c ConversionFuncs) Merge(other ConversionFuncs) ConversionFuncs {
- merged := NewConversionFuncs()
- for k, v := range c.untyped {
- merged.untyped[k] = v
- }
- for k, v := range other.untyped {
- merged.untyped[k] = v
- }
- return merged
-}
-
-// Meta is supplied by Scheme, when it calls Convert.
-type Meta struct {
- // Context is an optional field that callers may use to pass info to conversion functions.
- Context interface{}
-}
-
-// scope contains information about an ongoing conversion.
-type scope struct {
- converter *Converter
- meta *Meta
-}
-
-// Convert continues a conversion.
-func (s *scope) Convert(src, dest interface{}) error {
- return s.converter.Convert(src, dest, s.meta)
-}
-
-// Meta returns the meta object that was originally passed to Convert.
-func (s *scope) Meta() *Meta {
- return s.meta
-}
-
-// RegisterUntypedConversionFunc registers a function that converts between a and b by passing objects of those
-// types to the provided function. The function *must* accept objects of a and b - this machinery will not enforce
-// any other guarantee.
-func (c *Converter) RegisterUntypedConversionFunc(a, b interface{}, fn ConversionFunc) error {
- return c.conversionFuncs.AddUntyped(a, b, fn)
-}
-
-// RegisterGeneratedUntypedConversionFunc registers a function that converts between a and b by passing objects of those
-// types to the provided function. The function *must* accept objects of a and b - this machinery will not enforce
-// any other guarantee.
-func (c *Converter) RegisterGeneratedUntypedConversionFunc(a, b interface{}, fn ConversionFunc) error {
- return c.generatedConversionFuncs.AddUntyped(a, b, fn)
-}
-
-// RegisterIgnoredConversion registers a "no-op" for conversion, where any requested
-// conversion between from and to is ignored.
-func (c *Converter) RegisterIgnoredConversion(from, to interface{}) error {
- typeFrom := reflect.TypeOf(from)
- typeTo := reflect.TypeOf(to)
- if reflect.TypeOf(from).Kind() != reflect.Ptr {
- return fmt.Errorf("expected pointer arg for 'from' param 0, got: %v", typeFrom)
- }
- if typeTo.Kind() != reflect.Ptr {
- return fmt.Errorf("expected pointer arg for 'to' param 1, got: %v", typeTo)
- }
- c.ignoredConversions[typePair{typeFrom.Elem(), typeTo.Elem()}] = struct{}{}
- c.ignoredUntypedConversions[typePair{typeFrom, typeTo}] = struct{}{}
- return nil
-}
-
-// Convert will translate src to dest if it knows how. Both must be pointers.
-// If no conversion func is registered and the default copying mechanism
-// doesn't work on this type pair, an error will be returned.
-// 'meta' is given to allow you to pass information to conversion functions,
-// it is not used by Convert() other than storing it in the scope.
-// Not safe for objects with cyclic references!
-func (c *Converter) Convert(src, dest interface{}, meta *Meta) error {
- pair := typePair{reflect.TypeOf(src), reflect.TypeOf(dest)}
- scope := &scope{
- converter: c,
- meta: meta,
- }
-
- // ignore conversions of this type
- if _, ok := c.ignoredUntypedConversions[pair]; ok {
- return nil
- }
- if fn, ok := c.conversionFuncs.untyped[pair]; ok {
- return fn(src, dest, scope)
- }
- if fn, ok := c.generatedConversionFuncs.untyped[pair]; ok {
- return fn(src, dest, scope)
- }
-
- dv, err := EnforcePtr(dest)
- if err != nil {
- return err
- }
- sv, err := EnforcePtr(src)
- if err != nil {
- return err
- }
- return fmt.Errorf("converting (%s) to (%s): unknown conversion", sv.Type(), dv.Type())
-}