1 files changed, 76 insertions, 0 deletions

diff --git a/vendor/github.com/zclconf/go-cty/cty/convert/conversion_object.go b/vendor/github.com/zclconf/go-cty/cty/convert/conversion_object.go
new file mode 100644
index 0000000..62dabb8
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/convert/conversion_object.go
@@ -0,0 +1,76 @@
+package convert
+
+import (
+        "github.com/zclconf/go-cty/cty"
+)
+
+// conversionObjectToObject returns a conversion that will make the input
+// object type conform to the output object type, if possible.
+//
+// Conversion is possible only if the output type is a subset of the input
+// type, meaning that each attribute of the output type has a corresponding
+// attribute in the input type where a recursive conversion is available.
+//
+// Shallow object conversions work the same for both safe and unsafe modes,
+// but the safety flag is passed on to recursive conversions and may thus
+// limit the above definition of "subset".
+func conversionObjectToObject(in, out cty.Type, unsafe bool) conversion {
+        inAtys := in.AttributeTypes()
+        outAtys := out.AttributeTypes()
+        attrConvs := make(map[string]conversion)
+
+        for name, outAty := range outAtys {
+                inAty, exists := inAtys[name]
+                if !exists {
+                        // No conversion is available, then.
+                        return nil
+                }
+
+                if inAty.Equals(outAty) {
+                        // No conversion needed, but we'll still record the attribute
+                        // in our map for later reference.
+                        attrConvs[name] = nil
+                        continue
+                }
+
+                attrConvs[name] = getConversion(inAty, outAty, unsafe)
+                if attrConvs[name] == nil {
+                        // If a recursive conversion isn't available, then our top-level
+                        // configuration is impossible too.
+                        return nil
+                }
+        }
+
+        // If we get here then a conversion is possible, using the attribute
+        // conversions given in attrConvs.
+        return func(val cty.Value, path cty.Path) (cty.Value, error) {
+                attrVals := make(map[string]cty.Value, len(attrConvs))
+                path = append(path, nil)
+                pathStep := &path[len(path)-1]
+
+                for it := val.ElementIterator(); it.Next(); {
+                        nameVal, val := it.Element()
+                        var err error
+
+                        name := nameVal.AsString()
+                        *pathStep = cty.GetAttrStep{
+                                Name: name,
+                        }
+
+                        conv, exists := attrConvs[name]
+                        if !exists {
+                                continue
+                        }
+                        if conv != nil {
+                                val, err = conv(val, path)
+                                if err != nil {
+                                        return cty.NilVal, err
+                                }
+                        }
+
+                        attrVals[name] = val
+                }
+
+                return cty.ObjectVal(attrVals), nil
+        }
+}