1 files changed, 191 insertions, 0 deletions

diff --git a/vendor/github.com/zclconf/go-cty/cty/element_iterator.go b/vendor/github.com/zclconf/go-cty/cty/element_iterator.go
new file mode 100644
index 0000000..0bf84c7
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/element_iterator.go
@@ -0,0 +1,191 @@
+package cty
+
+import (
+        "sort"
+
+        "github.com/zclconf/go-cty/cty/set"
+)
+
+// ElementIterator is the interface type returned by Value.ElementIterator to
+// allow the caller to iterate over elements of a collection-typed value.
+//
+// Its usage pattern is as follows:
+//
+//     it := val.ElementIterator()
+//     for it.Next() {
+//         key, val := it.Element()
+//         // ...
+//     }
+type ElementIterator interface {
+        Next() bool
+        Element() (key Value, value Value)
+}
+
+func canElementIterator(val Value) bool {
+        switch {
+        case val.ty.IsListType():
+                return true
+        case val.ty.IsMapType():
+                return true
+        case val.ty.IsSetType():
+                return true
+        case val.ty.IsTupleType():
+                return true
+        case val.ty.IsObjectType():
+                return true
+        default:
+                return false
+        }
+}
+
+func elementIterator(val Value) ElementIterator {
+        switch {
+        case val.ty.IsListType():
+                return &listElementIterator{
+                        ety:  val.ty.ElementType(),
+                        vals: val.v.([]interface{}),
+                        idx:  -1,
+                }
+        case val.ty.IsMapType():
+                // We iterate the keys in a predictable lexicographical order so
+                // that results will always be stable given the same input map.
+                rawMap := val.v.(map[string]interface{})
+                keys := make([]string, 0, len(rawMap))
+                for key := range rawMap {
+                        keys = append(keys, key)
+                }
+                sort.Strings(keys)
+
+                return &mapElementIterator{
+                        ety:  val.ty.ElementType(),
+                        vals: rawMap,
+                        keys: keys,
+                        idx:  -1,
+                }
+        case val.ty.IsSetType():
+                rawSet := val.v.(set.Set)
+                return &setElementIterator{
+                        ety:   val.ty.ElementType(),
+                        setIt: rawSet.Iterator(),
+                }
+        case val.ty.IsTupleType():
+                return &tupleElementIterator{
+                        etys: val.ty.TupleElementTypes(),
+                        vals: val.v.([]interface{}),
+                        idx:  -1,
+                }
+        case val.ty.IsObjectType():
+                // We iterate the keys in a predictable lexicographical order so
+                // that results will always be stable given the same object type.
+                atys := val.ty.AttributeTypes()
+                keys := make([]string, 0, len(atys))
+                for key := range atys {
+                        keys = append(keys, key)
+                }
+                sort.Strings(keys)
+
+                return &objectElementIterator{
+                        atys:      atys,
+                        vals:      val.v.(map[string]interface{}),
+                        attrNames: keys,
+                        idx:       -1,
+                }
+        default:
+                panic("attempt to iterate on non-collection, non-tuple type")
+        }
+}
+
+type listElementIterator struct {
+        ety  Type
+        vals []interface{}
+        idx  int
+}
+
+func (it *listElementIterator) Element() (Value, Value) {
+        i := it.idx
+        return NumberIntVal(int64(i)), Value{
+                ty: it.ety,
+                v:  it.vals[i],
+        }
+}
+
+func (it *listElementIterator) Next() bool {
+        it.idx++
+        return it.idx < len(it.vals)
+}
+
+type mapElementIterator struct {
+        ety  Type
+        vals map[string]interface{}
+        keys []string
+        idx  int
+}
+
+func (it *mapElementIterator) Element() (Value, Value) {
+        key := it.keys[it.idx]
+        return StringVal(key), Value{
+                ty: it.ety,
+                v:  it.vals[key],
+        }
+}
+
+func (it *mapElementIterator) Next() bool {
+        it.idx++
+        return it.idx < len(it.keys)
+}
+
+type setElementIterator struct {
+        ety   Type
+        setIt *set.Iterator
+}
+
+func (it *setElementIterator) Element() (Value, Value) {
+        val := Value{
+                ty: it.ety,
+                v:  it.setIt.Value(),
+        }
+        return val, val
+}
+
+func (it *setElementIterator) Next() bool {
+        return it.setIt.Next()
+}
+
+type tupleElementIterator struct {
+        etys []Type
+        vals []interface{}
+        idx  int
+}
+
+func (it *tupleElementIterator) Element() (Value, Value) {
+        i := it.idx
+        return NumberIntVal(int64(i)), Value{
+                ty: it.etys[i],
+                v:  it.vals[i],
+        }
+}
+
+func (it *tupleElementIterator) Next() bool {
+        it.idx++
+        return it.idx < len(it.vals)
+}
+
+type objectElementIterator struct {
+        atys      map[string]Type
+        vals      map[string]interface{}
+        attrNames []string
+        idx       int
+}
+
+func (it *objectElementIterator) Element() (Value, Value) {
+        key := it.attrNames[it.idx]
+        return StringVal(key), Value{
+                ty: it.atys[key],
+                v:  it.vals[key],
+        }
+}
+
+func (it *objectElementIterator) Next() bool {
+        it.idx++
+        return it.idx < len(it.attrNames)
+}