github.com/timstclair/heapster@v0.20.0-alpha1/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/meta/help.go (about) 1 /* 2 Copyright 2015 The Kubernetes Authors All rights reserved. 3 4 Licensed under the Apache License, Version 2.0 (the "License"); 5 you may not use this file except in compliance with the License. 6 You may obtain a copy of the License at 7 8 http://www.apache.org/licenses/LICENSE-2.0 9 10 Unless required by applicable law or agreed to in writing, software 11 distributed under the License is distributed on an "AS IS" BASIS, 12 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 See the License for the specific language governing permissions and 14 limitations under the License. 15 */ 16 17 package meta 18 19 import ( 20 "fmt" 21 "reflect" 22 23 "k8s.io/kubernetes/pkg/conversion" 24 "k8s.io/kubernetes/pkg/runtime" 25 ) 26 27 // IsListType returns true if the provided Object has a slice called Items 28 func IsListType(obj runtime.Object) bool { 29 _, err := GetItemsPtr(obj) 30 return err == nil 31 } 32 33 // GetItemsPtr returns a pointer to the list object's Items member. 34 // If 'list' doesn't have an Items member, it's not really a list type 35 // and an error will be returned. 36 // This function will either return a pointer to a slice, or an error, but not both. 37 func GetItemsPtr(list runtime.Object) (interface{}, error) { 38 v, err := conversion.EnforcePtr(list) 39 if err != nil { 40 return nil, err 41 } 42 items := v.FieldByName("Items") 43 if !items.IsValid() { 44 return nil, fmt.Errorf("no Items field in %#v", list) 45 } 46 switch items.Kind() { 47 case reflect.Interface, reflect.Ptr: 48 target := reflect.TypeOf(items.Interface()).Elem() 49 if target.Kind() != reflect.Slice { 50 return nil, fmt.Errorf("items: Expected slice, got %s", target.Kind()) 51 } 52 return items.Interface(), nil 53 case reflect.Slice: 54 return items.Addr().Interface(), nil 55 default: 56 return nil, fmt.Errorf("items: Expected slice, got %s", items.Kind()) 57 } 58 } 59 60 // ExtractList returns obj's Items element as an array of runtime.Objects. 61 // Returns an error if obj is not a List type (does not have an Items member). 62 func ExtractList(obj runtime.Object) ([]runtime.Object, error) { 63 itemsPtr, err := GetItemsPtr(obj) 64 if err != nil { 65 return nil, err 66 } 67 items, err := conversion.EnforcePtr(itemsPtr) 68 if err != nil { 69 return nil, err 70 } 71 list := make([]runtime.Object, items.Len()) 72 for i := range list { 73 raw := items.Index(i) 74 switch item := raw.Interface().(type) { 75 case runtime.Object: 76 list[i] = item 77 case runtime.RawExtension: 78 list[i] = &runtime.Unknown{ 79 RawJSON: item.RawJSON, 80 } 81 default: 82 var found bool 83 if list[i], found = raw.Addr().Interface().(runtime.Object); !found { 84 return nil, fmt.Errorf("%v: item[%v]: Expected object, got %#v(%s)", obj, i, raw.Interface(), raw.Kind()) 85 } 86 } 87 } 88 return list, nil 89 } 90 91 // objectSliceType is the type of a slice of Objects 92 var objectSliceType = reflect.TypeOf([]runtime.Object{}) 93 94 // SetList sets the given list object's Items member have the elements given in 95 // objects. 96 // Returns an error if list is not a List type (does not have an Items member), 97 // or if any of the objects are not of the right type. 98 func SetList(list runtime.Object, objects []runtime.Object) error { 99 itemsPtr, err := GetItemsPtr(list) 100 if err != nil { 101 return err 102 } 103 items, err := conversion.EnforcePtr(itemsPtr) 104 if err != nil { 105 return err 106 } 107 if items.Type() == objectSliceType { 108 items.Set(reflect.ValueOf(objects)) 109 return nil 110 } 111 slice := reflect.MakeSlice(items.Type(), len(objects), len(objects)) 112 for i := range objects { 113 dest := slice.Index(i) 114 src, err := conversion.EnforcePtr(objects[i]) 115 if err != nil { 116 return err 117 } 118 if src.Type().AssignableTo(dest.Type()) { 119 dest.Set(src) 120 } else if src.Type().ConvertibleTo(dest.Type()) { 121 dest.Set(src.Convert(dest.Type())) 122 } else { 123 return fmt.Errorf("item[%d]: Type mismatch: Expected %v, got %v", i, dest.Type(), src.Type()) 124 } 125 } 126 items.Set(slice) 127 return nil 128 }