github/kubernetes
1
0
Fork 0
mirror of https://github.com/k3s-io/kubernetes.git synced 2025-07-23 03:41:45 +00:00
Code Issues Projects Releases Wiki Activity

Remove generic conversion function

Browse Source
This commit is contained in:
Clayton Coleman 2018-07-03 13:38:18 -04:00
parent ba95744bc5
commit b5a266141c
No known key found for this signature in database
GPG Key ID: 3D16906B4F1C5CB3
4 changed files with 1 additions and 142 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

99
pkg/apis/core/v1/conversion.go
View File

@ -30,105 +30,6 @@ import (
"k8s.io/kubernetes/pkg/apis/extensions"
)
// This is a "fast-path" that avoids reflection for common types. It focuses on the objects that are
// converted the most in the cluster.
// TODO: generate one of these for every external API group - this is to prove the impact
func addFastPathConversionFuncs(scheme *runtime.Scheme) error {
scheme.AddGenericConversionFunc(func(objA, objB interface{}, s conversion.Scope) (bool, error) {
switch a := objA.(type) {
case *v1.Pod:
switch b := objB.(type) {
case *core.Pod:
return true, Convert_v1_Pod_To_core_Pod(a, b, s)
}
case *core.Pod:
switch b := objB.(type) {
case *v1.Pod:
return true, Convert_core_Pod_To_v1_Pod(a, b, s)
}
case *v1.Event:
switch b := objB.(type) {
case *core.Event:
return true, Convert_v1_Event_To_core_Event(a, b, s)
}
case *core.Event:
switch b := objB.(type) {
case *v1.Event:
return true, Convert_core_Event_To_v1_Event(a, b, s)
}
case *v1.ReplicationController:
switch b := objB.(type) {
case *core.ReplicationController:
return true, Convert_v1_ReplicationController_To_core_ReplicationController(a, b, s)
}
case *core.ReplicationController:
switch b := objB.(type) {
case *v1.ReplicationController:
return true, Convert_core_ReplicationController_To_v1_ReplicationController(a, b, s)
}
case *v1.Node:
switch b := objB.(type) {
case *core.Node:
return true, Convert_v1_Node_To_core_Node(a, b, s)
}
case *core.Node:
switch b := objB.(type) {
case *v1.Node:
return true, Convert_core_Node_To_v1_Node(a, b, s)
}
case *v1.Namespace:
switch b := objB.(type) {
case *core.Namespace:
return true, Convert_v1_Namespace_To_core_Namespace(a, b, s)
}
case *core.Namespace:
switch b := objB.(type) {
case *v1.Namespace:
return true, Convert_core_Namespace_To_v1_Namespace(a, b, s)
}
case *v1.Service:
switch b := objB.(type) {
case *core.Service:
return true, Convert_v1_Service_To_core_Service(a, b, s)
}
case *core.Service:
switch b := objB.(type) {
case *v1.Service:
return true, Convert_core_Service_To_v1_Service(a, b, s)
}
case *v1.Endpoints:
switch b := objB.(type) {
case *core.Endpoints:
return true, Convert_v1_Endpoints_To_core_Endpoints(a, b, s)
}
case *core.Endpoints:
switch b := objB.(type) {
case *v1.Endpoints:
return true, Convert_core_Endpoints_To_v1_Endpoints(a, b, s)
}
case *metav1.WatchEvent:
switch b := objB.(type) {
case *metav1.InternalEvent:
return true, metav1.Convert_versioned_Event_to_versioned_InternalEvent(a, b, s)
}
case *metav1.InternalEvent:
switch b := objB.(type) {
case *metav1.WatchEvent:
return true, metav1.Convert_versioned_InternalEvent_to_versioned_Event(a, b, s)
}
}
return false, nil
})
return nil
}
func addConversionFuncs(scheme *runtime.Scheme) error {
// Add non-generated conversion functions
err := scheme.AddConversionFuncs(

2
pkg/apis/core/v1/register.go
View File

@ -30,7 +30,7 @@ func init() {
// We only register manually written functions here. The registration of the
// generated functions takes place in the generated files. The separation
// makes the code compile even when the generated files are missing.
localSchemeBuilder.Register(addDefaultingFuncs, addConversionFuncs, addFastPathConversionFuncs)
localSchemeBuilder.Register(addDefaultingFuncs, addConversionFuncs)
}
// TODO: remove these global varialbes

22
staging/src/k8s.io/apimachinery/pkg/conversion/converter.go
View File

@ -53,11 +53,6 @@ type Converter struct {
conversionFuncs ConversionFuncs
generatedConversionFuncs ConversionFuncs
// genericConversions are called during normal conversion to offer a "fast-path"
// that avoids all reflection. These methods are not called outside of the .Convert()
// method.
genericConversions []GenericConversionFunc
// Set of conversions that should be treated as a no-op
ignoredConversions map[typePair]struct{}
@ -102,14 +97,6 @@ func NewConverter(nameFn NameFunc) *Converter {
return c
}
// 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 (c *Converter) AddGenericConversionFunc(fn GenericConversionFunc) {
c.genericConversions = append(c.genericConversions, fn)
}
// 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 {
@ -480,15 +467,6 @@ func (f FieldMatchingFlags) IsSet(flag FieldMatchingFlags) bool {
// 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{}, flags FieldMatchingFlags, meta *Meta) error {
// TODO: deprecated, will be removed in favor of untyped conversion
if len(c.genericConversions) > 0 {
s := &scope{converter: c, flags: flags, meta: meta}
for _, fn := range c.genericConversions {
if ok, err := fn(src, dest, s); ok {
return err
}
}
}
return c.doConversion(src, dest, flags, meta, c.convert)
}

20
staging/src/k8s.io/apimachinery/pkg/runtime/scheme.go
View File

@ -296,15 +296,6 @@ func (s *Scheme) New(kind schema.GroupVersionKind) (Object, error) {
return nil, NewNotRegisteredErrForKind(s.schemeName, kind)
}
// 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.
// DEPRECATED: Use AddConversionFunc
func (s *Scheme) AddGenericConversionFunc(fn conversion.GenericConversionFunc) {
s.converter.AddGenericConversionFunc(fn)
}
// Log sets a logger on the scheme. For test purposes only
func (s *Scheme) Log(l conversion.DebugLogger) {
s.converter.Debug = l
@ -356,17 +347,6 @@ func (s *Scheme) AddConversionFuncs(conversionFuncs ...interface{}) error {
return nil
}
// AddGeneratedConversionFuncs registers conversion functions that were
// automatically generated.
func (s *Scheme) AddGeneratedConversionFuncs(conversionFuncs ...interface{}) error {
for _, f := range conversionFuncs {
if err := s.converter.RegisterGeneratedConversionFunc(f); err != nil {
return err
}
}
return nil
}
// AddConversionFunc 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.