deps: github.com/hashicorp/terraform@sdk-v0.11-with-go-modules

Updated via: go get github.com/hashicorp/terraform@sdk-v0.11-with-go-modules and go mod tidy

1 files changed, 68 insertions, 0 deletions

diff --git a/vendor/github.com/zclconf/go-cty/cty/map_type.go b/vendor/github.com/zclconf/go-cty/cty/map_type.go
new file mode 100644
index 0000000..ae9abae
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/map_type.go
@@ -0,0 +1,68 @@
+package cty
+
+import (
+        "fmt"
+)
+
+// TypeList instances represent specific list types. Each distinct ElementType
+// creates a distinct, non-equal list type.
+type typeMap struct {
+        typeImplSigil
+        ElementTypeT Type
+}
+
+// Map creates a map type with the given element Type.
+//
+// Map types are CollectionType implementations.
+func Map(elem Type) Type {
+        return Type{
+                typeMap{
+                        ElementTypeT: elem,
+                },
+        }
+}
+
+// Equals returns true if the other Type is a map whose element type is
+// equal to that of the receiver.
+func (t typeMap) Equals(other Type) bool {
+        ot, isMap := other.typeImpl.(typeMap)
+        if !isMap {
+                return false
+        }
+
+        return t.ElementTypeT.Equals(ot.ElementTypeT)
+}
+
+func (t typeMap) FriendlyName() string {
+        return "map of " + t.ElementTypeT.FriendlyName()
+}
+
+func (t typeMap) ElementType() Type {
+        return t.ElementTypeT
+}
+
+func (t typeMap) GoString() string {
+        return fmt.Sprintf("cty.Map(%#v)", t.ElementTypeT)
+}
+
+// IsMapType returns true if the given type is a list type, regardless of its
+// element type.
+func (t Type) IsMapType() bool {
+        _, ok := t.typeImpl.(typeMap)
+        return ok
+}
+
+// MapElementType is a convenience method that checks if the given type is
+// a map type, returning a pointer to its element type if so and nil
+// otherwise. This is intended to allow convenient conditional branches,
+// like so:
+//
+//     if et := t.MapElementType(); et != nil {
+//         // Do something with *et
+//     }
+func (t Type) MapElementType() *Type {
+        if lt, ok := t.typeImpl.(typeMap); ok {
+                return &lt.ElementTypeT
+        }
+        return nil
+}