diff options
Diffstat (limited to 'vendor/github.com/zclconf/go-cty/cty/tuple_type.go')
-rw-r--r-- | vendor/github.com/zclconf/go-cty/cty/tuple_type.go | 121 |
1 files changed, 121 insertions, 0 deletions
diff --git a/vendor/github.com/zclconf/go-cty/cty/tuple_type.go b/vendor/github.com/zclconf/go-cty/cty/tuple_type.go new file mode 100644 index 0000000..b98349e --- /dev/null +++ b/vendor/github.com/zclconf/go-cty/cty/tuple_type.go | |||
@@ -0,0 +1,121 @@ | |||
1 | package cty | ||
2 | |||
3 | import ( | ||
4 | "fmt" | ||
5 | ) | ||
6 | |||
7 | type typeTuple struct { | ||
8 | typeImplSigil | ||
9 | ElemTypes []Type | ||
10 | } | ||
11 | |||
12 | // Tuple creates a tuple type with the given element types. | ||
13 | // | ||
14 | // After a slice is passed to this function the caller must no longer access | ||
15 | // the underlying array, since ownership is transferred to this library. | ||
16 | func Tuple(elemTypes []Type) Type { | ||
17 | return Type{ | ||
18 | typeTuple{ | ||
19 | ElemTypes: elemTypes, | ||
20 | }, | ||
21 | } | ||
22 | } | ||
23 | |||
24 | func (t typeTuple) Equals(other Type) bool { | ||
25 | if ot, ok := other.typeImpl.(typeTuple); ok { | ||
26 | if len(t.ElemTypes) != len(ot.ElemTypes) { | ||
27 | // Fast path: if we don't have the same number of elements | ||
28 | // then we can't possibly be equal. | ||
29 | return false | ||
30 | } | ||
31 | |||
32 | for i, ty := range t.ElemTypes { | ||
33 | oty := ot.ElemTypes[i] | ||
34 | if !ok { | ||
35 | return false | ||
36 | } | ||
37 | if !oty.Equals(ty) { | ||
38 | return false | ||
39 | } | ||
40 | } | ||
41 | |||
42 | return true | ||
43 | } | ||
44 | return false | ||
45 | } | ||
46 | |||
47 | func (t typeTuple) FriendlyName() string { | ||
48 | // There isn't really a friendly way to write a tuple type due to its | ||
49 | // complexity, so we'll just do something English-ish. Callers will | ||
50 | // probably want to make some extra effort to avoid ever printing out | ||
51 | // a tuple type FriendlyName in its entirety. For example, could | ||
52 | // produce an error message by diffing two object types and saying | ||
53 | // something like "Expected attribute foo to be string, but got number". | ||
54 | // TODO: Finish this | ||
55 | return "tuple" | ||
56 | } | ||
57 | |||
58 | func (t typeTuple) GoString() string { | ||
59 | if len(t.ElemTypes) == 0 { | ||
60 | return "cty.EmptyTuple" | ||
61 | } | ||
62 | return fmt.Sprintf("cty.Tuple(%#v)", t.ElemTypes) | ||
63 | } | ||
64 | |||
65 | // EmptyTuple is a shorthand for Tuple([]Type{}), to more easily talk about | ||
66 | // the empty tuple type. | ||
67 | var EmptyTuple Type | ||
68 | |||
69 | // EmptyTupleVal is the only possible non-null, non-unknown value of type | ||
70 | // EmptyTuple. | ||
71 | var EmptyTupleVal Value | ||
72 | |||
73 | func init() { | ||
74 | EmptyTuple = Tuple([]Type{}) | ||
75 | EmptyTupleVal = Value{ | ||
76 | ty: EmptyTuple, | ||
77 | v: []interface{}{}, | ||
78 | } | ||
79 | } | ||
80 | |||
81 | // IsTupleType returns true if the given type is an object type, regardless | ||
82 | // of its element type. | ||
83 | func (t Type) IsTupleType() bool { | ||
84 | _, ok := t.typeImpl.(typeTuple) | ||
85 | return ok | ||
86 | } | ||
87 | |||
88 | // Length returns the number of elements of the receiving tuple type. | ||
89 | // Will panic if the reciever isn't a tuple type; use IsTupleType to determine | ||
90 | // whether this operation will succeed. | ||
91 | func (t Type) Length() int { | ||
92 | if ot, ok := t.typeImpl.(typeTuple); ok { | ||
93 | return len(ot.ElemTypes) | ||
94 | } | ||
95 | panic("Length on non-tuple Type") | ||
96 | } | ||
97 | |||
98 | // TupleElementType returns the type of the element with the given index. Will | ||
99 | // panic if the receiver is not a tuple type (use IsTupleType to confirm) | ||
100 | // or if the index is out of range (use Length to confirm). | ||
101 | func (t Type) TupleElementType(idx int) Type { | ||
102 | if ot, ok := t.typeImpl.(typeTuple); ok { | ||
103 | return ot.ElemTypes[idx] | ||
104 | } | ||
105 | panic("TupleElementType on non-tuple Type") | ||
106 | } | ||
107 | |||
108 | // TupleElementTypes returns a slice of the recieving tuple type's element | ||
109 | // types. Will panic if the receiver is not a tuple type (use IsTupleType | ||
110 | // to confirm). | ||
111 | // | ||
112 | // The returned slice is part of the internal state of the type, and is provided | ||
113 | // for read access only. It is forbidden for any caller to modify the | ||
114 | // underlying array. For many purposes the element-related methods of Value | ||
115 | // are more appropriate and more convenient to use. | ||
116 | func (t Type) TupleElementTypes() []Type { | ||
117 | if ot, ok := t.typeImpl.(typeTuple); ok { | ||
118 | return ot.ElemTypes | ||
119 | } | ||
120 | panic("TupleElementTypes on non-tuple Type") | ||
121 | } | ||