// Copyright 2016-2018, Pulumi Corporation. // // 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 mapper import ( "reflect" "github.com/pulumi/pulumi/sdk/v3/go/common/util/contract" ) // Encode encodes a strongly typed struct into a weakly typed JSON-like property bag. func (md *mapper) Encode(source interface{}) (map[string]interface{}, MappingError) { if source == nil { return nil, nil } return md.encode(reflect.ValueOf(source)) } func (md *mapper) encode(vsrc reflect.Value) (map[string]interface{}, MappingError) { contract.Requiref(vsrc.IsValid(), "vsrc", "value must be valid") // Fetch the type; if it's a pointer, do a quick nil check, otherwise operate on its underlying type. vsrcType := vsrc.Type() if vsrcType.Kind() == reflect.Ptr { if vsrc.IsNil() { return nil, nil } vsrc = vsrc.Elem() vsrcType = vsrc.Type() } contract.Assertf(vsrcType.Kind() == reflect.Struct, "Source %v must be a struct type with `pulumi:\"x\"` tags to direct encoding (kind %v)", vsrcType, vsrcType.Kind()) // Fetch the source type, allocate a fresh object, and start encoding into it. var errs []error obj := make(map[string]interface{}) for _, fldtag := range md.structFieldsTags(vsrc.Type()) { if !fldtag.Skip { key := fldtag.Key fld := vsrc.FieldByName(fldtag.Info.Name) v, err := md.encodeValue(fld) if err != nil { errs = append(errs, err.Failures()...) } else if v == nil { if !fldtag.Optional && !md.opts.IgnoreMissing { // The field doesn't exist and yet it is required; issue an error. errs = append(errs, NewMissingError(vsrcType, key)) } } else { obj[key] = v } } } // If there are no errors, return nil; else manufacture a decode error object. var err MappingError if len(errs) > 0 { err = NewMappingError(errs) } return obj, err } // EncodeValue decodes primitive type fields. For fields of complex types, we use custom deserialization. func (md *mapper) EncodeValue(v interface{}) (interface{}, MappingError) { if v == nil { return nil, nil } return md.encodeValue(reflect.ValueOf(v)) } func (md *mapper) encodeValue(vsrc reflect.Value) (interface{}, MappingError) { contract.Requiref(vsrc.IsValid(), "vsrc", "value must be valid") // Otherwise, try to map to the closest JSON-like destination type we can. switch k := vsrc.Kind(); k { // Primitive types: case reflect.Bool: return vsrc.Bool(), nil case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: return float64(vsrc.Int()), nil case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: return float64(vsrc.Uint()), nil case reflect.Float32, reflect.Float64: return vsrc.Float(), nil case reflect.String: return vsrc.String(), nil // Pointers: case reflect.Ptr: if vsrc.IsNil() { return nil, nil } return md.encodeValue(vsrc.Elem()) // Slices and maps: case reflect.Slice: if vsrc.IsNil() { return nil, nil } slice := make([]interface{}, vsrc.Len()) var errs []error for i := 0; i < vsrc.Len(); i++ { ev := vsrc.Index(i) if elem, err := md.encodeValue(ev); err != nil { errs = append(errs, err.Failures()...) } else { slice[i] = elem } } if errs == nil { return slice, nil } return nil, NewMappingError(errs) case reflect.Map: if vsrc.IsNil() { return nil, nil } ktype := vsrc.Type().Key() contract.Assertf(ktype.Kind() == reflect.String, "expected map with string keys, got %v (%v)", ktype, ktype.Kind()) iter := vsrc.MapRange() mmap := make(map[string]interface{}, vsrc.Len()) var errs []error for iter.Next() { if val, err := md.encodeValue(iter.Value()); err != nil { errs = append(errs, err.Failures()...) } else { mmap[iter.Key().String()] = val } } if errs == nil { return mmap, nil } return nil, NewMappingError(errs) // Structs and interface{}: case reflect.Struct: return md.encode(vsrc) case reflect.Interface: if vsrc.IsNil() { return nil, nil } return md.encodeValue(vsrc.Elem()) // Cases we don't handle case reflect.Invalid, reflect.Complex64, reflect.Complex128, reflect.Array, reflect.Chan, reflect.Func, reflect.UnsafePointer: contract.Failf("Unrecognized field type '%v' during encoding", k) default: contract.Failf("Unrecognized field type '%v' during encoding", k) } return nil, nil }