-
Notifications
You must be signed in to change notification settings - Fork 32
/
list.go
119 lines (106 loc) · 3.27 KB
/
list.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
package tftypes
import (
"fmt"
)
// List is a Terraform type representing an ordered collection of elements, all
// of the same type.
type List struct {
ElementType Type
// used to make this type uncomparable
// see https://golang.org/ref/spec#Comparison_operators
// this enforces the use of Is, instead
_ []struct{}
}
// ApplyTerraform5AttributePathStep applies an AttributePathStep to a List,
// returning the Type found at that AttributePath within the List. If the
// AttributePathStep cannot be applied to the List, an ErrInvalidStep error
// will be returned.
func (l List) ApplyTerraform5AttributePathStep(step AttributePathStep) (interface{}, error) {
switch s := step.(type) {
case ElementKeyInt:
if int64(s) < 0 {
return nil, ErrInvalidStep
}
return l.ElementType, nil
default:
return nil, ErrInvalidStep
}
}
// Equal returns true if the two Lists are exactly equal. Unlike Is, passing in
// a List with no ElementType will always return false.
func (l List) Equal(o Type) bool {
v, ok := o.(List)
if !ok {
return false
}
if l.ElementType == nil || v.ElementType == nil {
// when doing exact comparisons, we can't compare types that
// don't have element types set, so we just consider them not
// equal
return false
}
return l.ElementType.Equal(v.ElementType)
}
// UsableAs returns whether the two Lists are type compatible.
//
// If the other type is DynamicPseudoType, it will return true.
// If the other type is not a List, it will return false.
// If the other List does not have a type compatible ElementType, it will
// return false.
func (l List) UsableAs(o Type) bool {
if o.Is(DynamicPseudoType) {
return true
}
v, ok := o.(List)
if !ok {
return false
}
return l.ElementType.UsableAs(v.ElementType)
}
// Is returns whether `t` is a List type or not. It does not perform any
// ElementType checks.
func (l List) Is(t Type) bool {
_, ok := t.(List)
return ok
}
func (l List) String() string {
return "tftypes.List[" + l.ElementType.String() + "]"
}
func (l List) private() {}
func (l List) supportedGoTypes() []string {
return []string{"[]tftypes.Value"}
}
func valueFromList(typ Type, in interface{}) (Value, error) {
switch value := in.(type) {
case []Value:
var valType Type
for pos, v := range value {
if !v.Type().UsableAs(typ) {
return Value{}, NewAttributePath().WithElementKeyInt(pos).NewErrorf("can't use %s as %s", v.Type(), typ)
}
if valType == nil {
valType = v.Type()
}
if !v.Type().Equal(valType) {
return Value{}, fmt.Errorf("lists must only contain one type of element, saw %s and %s", valType, v.Type())
}
}
return Value{
typ: List{ElementType: typ},
value: value,
}, nil
default:
return Value{}, fmt.Errorf("tftypes.NewValue can't use %T as a tftypes.List; expected types are: %s", in, formattedSupportedGoTypes(List{}))
}
}
// MarshalJSON returns a JSON representation of the full type signature of `l`,
// including its ElementType.
//
// Deprecated: this is not meant to be called by third-party code.
func (l List) MarshalJSON() ([]byte, error) {
elementType, err := l.ElementType.MarshalJSON()
if err != nil {
return nil, fmt.Errorf("error marshaling tftypes.List's element type %T to JSON: %w", l.ElementType, err)
}
return []byte(`["list",` + string(elementType) + `]`), nil
}