mirror of
https://github.com/opentofu/opentofu.git
synced 2024-12-30 10:47:14 -06:00
cdd9464f9a
This is part of a general effort to move all of Terraform's non-library package surface under internal in order to reinforce that these are for internal use within Terraform only. If you were previously importing packages under this prefix into an external codebase, you could pin to an earlier release tag as an interim solution until you've make a plan to achieve the same functionality some other way.
710 lines
21 KiB
Go
710 lines
21 KiB
Go
package funcs
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"math/big"
|
|
"sort"
|
|
|
|
"github.com/zclconf/go-cty/cty"
|
|
"github.com/zclconf/go-cty/cty/convert"
|
|
"github.com/zclconf/go-cty/cty/function"
|
|
"github.com/zclconf/go-cty/cty/function/stdlib"
|
|
"github.com/zclconf/go-cty/cty/gocty"
|
|
)
|
|
|
|
var LengthFunc = function.New(&function.Spec{
|
|
Params: []function.Parameter{
|
|
{
|
|
Name: "value",
|
|
Type: cty.DynamicPseudoType,
|
|
AllowDynamicType: true,
|
|
AllowUnknown: true,
|
|
AllowMarked: true,
|
|
},
|
|
},
|
|
Type: func(args []cty.Value) (cty.Type, error) {
|
|
collTy := args[0].Type()
|
|
switch {
|
|
case collTy == cty.String || collTy.IsTupleType() || collTy.IsObjectType() || collTy.IsListType() || collTy.IsMapType() || collTy.IsSetType() || collTy == cty.DynamicPseudoType:
|
|
return cty.Number, nil
|
|
default:
|
|
return cty.Number, errors.New("argument must be a string, a collection type, or a structural type")
|
|
}
|
|
},
|
|
Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
|
|
coll := args[0]
|
|
collTy := args[0].Type()
|
|
marks := coll.Marks()
|
|
switch {
|
|
case collTy == cty.DynamicPseudoType:
|
|
return cty.UnknownVal(cty.Number).WithMarks(marks), nil
|
|
case collTy.IsTupleType():
|
|
l := len(collTy.TupleElementTypes())
|
|
return cty.NumberIntVal(int64(l)).WithMarks(marks), nil
|
|
case collTy.IsObjectType():
|
|
l := len(collTy.AttributeTypes())
|
|
return cty.NumberIntVal(int64(l)).WithMarks(marks), nil
|
|
case collTy == cty.String:
|
|
// We'll delegate to the cty stdlib strlen function here, because
|
|
// it deals with all of the complexities of tokenizing unicode
|
|
// grapheme clusters.
|
|
return stdlib.Strlen(coll)
|
|
case collTy.IsListType() || collTy.IsSetType() || collTy.IsMapType():
|
|
return coll.Length(), nil
|
|
default:
|
|
// Should never happen, because of the checks in our Type func above
|
|
return cty.UnknownVal(cty.Number), errors.New("impossible value type for length(...)")
|
|
}
|
|
},
|
|
})
|
|
|
|
// AllTrueFunc constructs a function that returns true if all elements of the
|
|
// list are true. If the list is empty, return true.
|
|
var AllTrueFunc = function.New(&function.Spec{
|
|
Params: []function.Parameter{
|
|
{
|
|
Name: "list",
|
|
Type: cty.List(cty.Bool),
|
|
},
|
|
},
|
|
Type: function.StaticReturnType(cty.Bool),
|
|
Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
|
|
result := cty.True
|
|
for it := args[0].ElementIterator(); it.Next(); {
|
|
_, v := it.Element()
|
|
if !v.IsKnown() {
|
|
return cty.UnknownVal(cty.Bool), nil
|
|
}
|
|
if v.IsNull() {
|
|
return cty.False, nil
|
|
}
|
|
result = result.And(v)
|
|
if result.False() {
|
|
return cty.False, nil
|
|
}
|
|
}
|
|
return result, nil
|
|
},
|
|
})
|
|
|
|
// AnyTrueFunc constructs a function that returns true if any element of the
|
|
// list is true. If the list is empty, return false.
|
|
var AnyTrueFunc = function.New(&function.Spec{
|
|
Params: []function.Parameter{
|
|
{
|
|
Name: "list",
|
|
Type: cty.List(cty.Bool),
|
|
},
|
|
},
|
|
Type: function.StaticReturnType(cty.Bool),
|
|
Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
|
|
result := cty.False
|
|
var hasUnknown bool
|
|
for it := args[0].ElementIterator(); it.Next(); {
|
|
_, v := it.Element()
|
|
if !v.IsKnown() {
|
|
hasUnknown = true
|
|
continue
|
|
}
|
|
if v.IsNull() {
|
|
continue
|
|
}
|
|
result = result.Or(v)
|
|
if result.True() {
|
|
return cty.True, nil
|
|
}
|
|
}
|
|
if hasUnknown {
|
|
return cty.UnknownVal(cty.Bool), nil
|
|
}
|
|
return result, nil
|
|
},
|
|
})
|
|
|
|
// CoalesceFunc constructs a function that takes any number of arguments and
|
|
// returns the first one that isn't empty. This function was copied from go-cty
|
|
// stdlib and modified so that it returns the first *non-empty* non-null element
|
|
// from a sequence, instead of merely the first non-null.
|
|
var CoalesceFunc = function.New(&function.Spec{
|
|
Params: []function.Parameter{},
|
|
VarParam: &function.Parameter{
|
|
Name: "vals",
|
|
Type: cty.DynamicPseudoType,
|
|
AllowUnknown: true,
|
|
AllowDynamicType: true,
|
|
AllowNull: true,
|
|
},
|
|
Type: func(args []cty.Value) (ret cty.Type, err error) {
|
|
argTypes := make([]cty.Type, len(args))
|
|
for i, val := range args {
|
|
argTypes[i] = val.Type()
|
|
}
|
|
retType, _ := convert.UnifyUnsafe(argTypes)
|
|
if retType == cty.NilType {
|
|
return cty.NilType, errors.New("all arguments must have the same type")
|
|
}
|
|
return retType, nil
|
|
},
|
|
Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
|
|
for _, argVal := range args {
|
|
// We already know this will succeed because of the checks in our Type func above
|
|
argVal, _ = convert.Convert(argVal, retType)
|
|
if !argVal.IsKnown() {
|
|
return cty.UnknownVal(retType), nil
|
|
}
|
|
if argVal.IsNull() {
|
|
continue
|
|
}
|
|
if retType == cty.String && argVal.RawEquals(cty.StringVal("")) {
|
|
continue
|
|
}
|
|
|
|
return argVal, nil
|
|
}
|
|
return cty.NilVal, errors.New("no non-null, non-empty-string arguments")
|
|
},
|
|
})
|
|
|
|
// IndexFunc constructs a function that finds the element index for a given value in a list.
|
|
var IndexFunc = function.New(&function.Spec{
|
|
Params: []function.Parameter{
|
|
{
|
|
Name: "list",
|
|
Type: cty.DynamicPseudoType,
|
|
},
|
|
{
|
|
Name: "value",
|
|
Type: cty.DynamicPseudoType,
|
|
},
|
|
},
|
|
Type: function.StaticReturnType(cty.Number),
|
|
Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
|
|
if !(args[0].Type().IsListType() || args[0].Type().IsTupleType()) {
|
|
return cty.NilVal, errors.New("argument must be a list or tuple")
|
|
}
|
|
|
|
if !args[0].IsKnown() {
|
|
return cty.UnknownVal(cty.Number), nil
|
|
}
|
|
|
|
if args[0].LengthInt() == 0 { // Easy path
|
|
return cty.NilVal, errors.New("cannot search an empty list")
|
|
}
|
|
|
|
for it := args[0].ElementIterator(); it.Next(); {
|
|
i, v := it.Element()
|
|
eq, err := stdlib.Equal(v, args[1])
|
|
if err != nil {
|
|
return cty.NilVal, err
|
|
}
|
|
if !eq.IsKnown() {
|
|
return cty.UnknownVal(cty.Number), nil
|
|
}
|
|
if eq.True() {
|
|
return i, nil
|
|
}
|
|
}
|
|
return cty.NilVal, errors.New("item not found")
|
|
|
|
},
|
|
})
|
|
|
|
// LookupFunc constructs a function that performs dynamic lookups of map types.
|
|
var LookupFunc = function.New(&function.Spec{
|
|
Params: []function.Parameter{
|
|
{
|
|
Name: "inputMap",
|
|
Type: cty.DynamicPseudoType,
|
|
AllowMarked: true,
|
|
},
|
|
{
|
|
Name: "key",
|
|
Type: cty.String,
|
|
AllowMarked: true,
|
|
},
|
|
},
|
|
VarParam: &function.Parameter{
|
|
Name: "default",
|
|
Type: cty.DynamicPseudoType,
|
|
AllowUnknown: true,
|
|
AllowDynamicType: true,
|
|
AllowNull: true,
|
|
AllowMarked: true,
|
|
},
|
|
Type: func(args []cty.Value) (ret cty.Type, err error) {
|
|
if len(args) < 1 || len(args) > 3 {
|
|
return cty.NilType, fmt.Errorf("lookup() takes two or three arguments, got %d", len(args))
|
|
}
|
|
|
|
ty := args[0].Type()
|
|
|
|
switch {
|
|
case ty.IsObjectType():
|
|
if !args[1].IsKnown() {
|
|
return cty.DynamicPseudoType, nil
|
|
}
|
|
|
|
keyVal, _ := args[1].Unmark()
|
|
key := keyVal.AsString()
|
|
if ty.HasAttribute(key) {
|
|
return args[0].GetAttr(key).Type(), nil
|
|
} else if len(args) == 3 {
|
|
// if the key isn't found but a default is provided,
|
|
// return the default type
|
|
return args[2].Type(), nil
|
|
}
|
|
return cty.DynamicPseudoType, function.NewArgErrorf(0, "the given object has no attribute %q", key)
|
|
case ty.IsMapType():
|
|
if len(args) == 3 {
|
|
_, err = convert.Convert(args[2], ty.ElementType())
|
|
if err != nil {
|
|
return cty.NilType, function.NewArgErrorf(2, "the default value must have the same type as the map elements")
|
|
}
|
|
}
|
|
return ty.ElementType(), nil
|
|
default:
|
|
return cty.NilType, function.NewArgErrorf(0, "lookup() requires a map as the first argument")
|
|
}
|
|
},
|
|
Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
|
|
var defaultVal cty.Value
|
|
defaultValueSet := false
|
|
|
|
if len(args) == 3 {
|
|
// intentionally leave default value marked
|
|
defaultVal = args[2]
|
|
defaultValueSet = true
|
|
}
|
|
|
|
// keep track of marks from the collection and key
|
|
var markses []cty.ValueMarks
|
|
|
|
// unmark collection, retain marks to reapply later
|
|
mapVar, mapMarks := args[0].Unmark()
|
|
markses = append(markses, mapMarks)
|
|
|
|
// include marks on the key in the result
|
|
keyVal, keyMarks := args[1].Unmark()
|
|
if len(keyMarks) > 0 {
|
|
markses = append(markses, keyMarks)
|
|
}
|
|
lookupKey := keyVal.AsString()
|
|
|
|
if !mapVar.IsKnown() {
|
|
return cty.UnknownVal(retType).WithMarks(markses...), nil
|
|
}
|
|
|
|
if mapVar.Type().IsObjectType() {
|
|
if mapVar.Type().HasAttribute(lookupKey) {
|
|
return mapVar.GetAttr(lookupKey).WithMarks(markses...), nil
|
|
}
|
|
} else if mapVar.HasIndex(cty.StringVal(lookupKey)) == cty.True {
|
|
return mapVar.Index(cty.StringVal(lookupKey)).WithMarks(markses...), nil
|
|
}
|
|
|
|
if defaultValueSet {
|
|
defaultVal, err = convert.Convert(defaultVal, retType)
|
|
if err != nil {
|
|
return cty.NilVal, err
|
|
}
|
|
return defaultVal.WithMarks(markses...), nil
|
|
}
|
|
|
|
return cty.UnknownVal(cty.DynamicPseudoType).WithMarks(markses...), fmt.Errorf(
|
|
"lookup failed to find '%s'", lookupKey)
|
|
},
|
|
})
|
|
|
|
// MatchkeysFunc constructs a function that constructs a new list by taking a
|
|
// subset of elements from one list whose indexes match the corresponding
|
|
// indexes of values in another list.
|
|
var MatchkeysFunc = function.New(&function.Spec{
|
|
Params: []function.Parameter{
|
|
{
|
|
Name: "values",
|
|
Type: cty.List(cty.DynamicPseudoType),
|
|
},
|
|
{
|
|
Name: "keys",
|
|
Type: cty.List(cty.DynamicPseudoType),
|
|
},
|
|
{
|
|
Name: "searchset",
|
|
Type: cty.List(cty.DynamicPseudoType),
|
|
},
|
|
},
|
|
Type: func(args []cty.Value) (cty.Type, error) {
|
|
ty, _ := convert.UnifyUnsafe([]cty.Type{args[1].Type(), args[2].Type()})
|
|
if ty == cty.NilType {
|
|
return cty.NilType, errors.New("keys and searchset must be of the same type")
|
|
}
|
|
|
|
// the return type is based on args[0] (values)
|
|
return args[0].Type(), nil
|
|
},
|
|
Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
|
|
if !args[0].IsKnown() {
|
|
return cty.UnknownVal(cty.List(retType.ElementType())), nil
|
|
}
|
|
|
|
if args[0].LengthInt() != args[1].LengthInt() {
|
|
return cty.ListValEmpty(retType.ElementType()), errors.New("length of keys and values should be equal")
|
|
}
|
|
|
|
output := make([]cty.Value, 0)
|
|
values := args[0]
|
|
|
|
// Keys and searchset must be the same type.
|
|
// We can skip error checking here because we've already verified that
|
|
// they can be unified in the Type function
|
|
ty, _ := convert.UnifyUnsafe([]cty.Type{args[1].Type(), args[2].Type()})
|
|
keys, _ := convert.Convert(args[1], ty)
|
|
searchset, _ := convert.Convert(args[2], ty)
|
|
|
|
// if searchset is empty, return an empty list.
|
|
if searchset.LengthInt() == 0 {
|
|
return cty.ListValEmpty(retType.ElementType()), nil
|
|
}
|
|
|
|
if !values.IsWhollyKnown() || !keys.IsWhollyKnown() {
|
|
return cty.UnknownVal(retType), nil
|
|
}
|
|
|
|
i := 0
|
|
for it := keys.ElementIterator(); it.Next(); {
|
|
_, key := it.Element()
|
|
for iter := searchset.ElementIterator(); iter.Next(); {
|
|
_, search := iter.Element()
|
|
eq, err := stdlib.Equal(key, search)
|
|
if err != nil {
|
|
return cty.NilVal, err
|
|
}
|
|
if !eq.IsKnown() {
|
|
return cty.ListValEmpty(retType.ElementType()), nil
|
|
}
|
|
if eq.True() {
|
|
v := values.Index(cty.NumberIntVal(int64(i)))
|
|
output = append(output, v)
|
|
break
|
|
}
|
|
}
|
|
i++
|
|
}
|
|
|
|
// if we haven't matched any key, then output is an empty list.
|
|
if len(output) == 0 {
|
|
return cty.ListValEmpty(retType.ElementType()), nil
|
|
}
|
|
return cty.ListVal(output), nil
|
|
},
|
|
})
|
|
|
|
// OneFunc returns either the first element of a one-element list, or null
|
|
// if given a zero-element list.
|
|
var OneFunc = function.New(&function.Spec{
|
|
Params: []function.Parameter{
|
|
{
|
|
Name: "list",
|
|
Type: cty.DynamicPseudoType,
|
|
},
|
|
},
|
|
Type: func(args []cty.Value) (cty.Type, error) {
|
|
ty := args[0].Type()
|
|
switch {
|
|
case ty.IsListType() || ty.IsSetType():
|
|
return ty.ElementType(), nil
|
|
case ty.IsTupleType():
|
|
etys := ty.TupleElementTypes()
|
|
switch len(etys) {
|
|
case 0:
|
|
// No specific type information, so we'll ultimately return
|
|
// a null value of unknown type.
|
|
return cty.DynamicPseudoType, nil
|
|
case 1:
|
|
return etys[0], nil
|
|
}
|
|
}
|
|
return cty.NilType, function.NewArgErrorf(0, "must be a list, set, or tuple value with either zero or one elements")
|
|
},
|
|
Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
|
|
val := args[0]
|
|
ty := val.Type()
|
|
|
|
// Our parameter spec above doesn't set AllowUnknown or AllowNull,
|
|
// so we can assume our top-level collection is both known and non-null
|
|
// in here.
|
|
|
|
switch {
|
|
case ty.IsListType() || ty.IsSetType():
|
|
lenVal := val.Length()
|
|
if !lenVal.IsKnown() {
|
|
return cty.UnknownVal(retType), nil
|
|
}
|
|
var l int
|
|
err := gocty.FromCtyValue(lenVal, &l)
|
|
if err != nil {
|
|
// It would be very strange to get here, because that would
|
|
// suggest that the length is either not a number or isn't
|
|
// an integer, which would suggest a bug in cty.
|
|
return cty.NilVal, fmt.Errorf("invalid collection length: %s", err)
|
|
}
|
|
switch l {
|
|
case 0:
|
|
return cty.NullVal(retType), nil
|
|
case 1:
|
|
var ret cty.Value
|
|
// We'll use an iterator here because that works for both lists
|
|
// and sets, whereas indexing directly would only work for lists.
|
|
// Since we've just checked the length, we should only actually
|
|
// run this loop body once.
|
|
for it := val.ElementIterator(); it.Next(); {
|
|
_, ret = it.Element()
|
|
}
|
|
return ret, nil
|
|
}
|
|
case ty.IsTupleType():
|
|
etys := ty.TupleElementTypes()
|
|
switch len(etys) {
|
|
case 0:
|
|
return cty.NullVal(retType), nil
|
|
case 1:
|
|
ret := val.Index(cty.NumberIntVal(0))
|
|
return ret, nil
|
|
}
|
|
}
|
|
return cty.NilVal, function.NewArgErrorf(0, "must be a list, set, or tuple value with either zero or one elements")
|
|
},
|
|
})
|
|
|
|
// SumFunc constructs a function that returns the sum of all
|
|
// numbers provided in a list
|
|
var SumFunc = function.New(&function.Spec{
|
|
Params: []function.Parameter{
|
|
{
|
|
Name: "list",
|
|
Type: cty.DynamicPseudoType,
|
|
},
|
|
},
|
|
Type: function.StaticReturnType(cty.Number),
|
|
Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
|
|
|
|
if !args[0].CanIterateElements() {
|
|
return cty.NilVal, function.NewArgErrorf(0, "cannot sum noniterable")
|
|
}
|
|
|
|
if args[0].LengthInt() == 0 { // Easy path
|
|
return cty.NilVal, function.NewArgErrorf(0, "cannot sum an empty list")
|
|
}
|
|
|
|
arg := args[0].AsValueSlice()
|
|
ty := args[0].Type()
|
|
|
|
if !ty.IsListType() && !ty.IsSetType() && !ty.IsTupleType() {
|
|
return cty.NilVal, function.NewArgErrorf(0, fmt.Sprintf("argument must be list, set, or tuple. Received %s", ty.FriendlyName()))
|
|
}
|
|
|
|
if !args[0].IsWhollyKnown() {
|
|
return cty.UnknownVal(cty.Number), nil
|
|
}
|
|
|
|
// big.Float.Add can panic if the input values are opposing infinities,
|
|
// so we must catch that here in order to remain within
|
|
// the cty Function abstraction.
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
if _, ok := r.(big.ErrNaN); ok {
|
|
ret = cty.NilVal
|
|
err = fmt.Errorf("can't compute sum of opposing infinities")
|
|
} else {
|
|
// not a panic we recognize
|
|
panic(r)
|
|
}
|
|
}
|
|
}()
|
|
|
|
s := arg[0]
|
|
if s.IsNull() {
|
|
return cty.NilVal, function.NewArgErrorf(0, "argument must be list, set, or tuple of number values")
|
|
}
|
|
for _, v := range arg[1:] {
|
|
if v.IsNull() {
|
|
return cty.NilVal, function.NewArgErrorf(0, "argument must be list, set, or tuple of number values")
|
|
}
|
|
v, err = convert.Convert(v, cty.Number)
|
|
if err != nil {
|
|
return cty.NilVal, function.NewArgErrorf(0, "argument must be list, set, or tuple of number values")
|
|
}
|
|
s = s.Add(v)
|
|
}
|
|
|
|
return s, nil
|
|
},
|
|
})
|
|
|
|
// TransposeFunc constructs a function that takes a map of lists of strings and
|
|
// swaps the keys and values to produce a new map of lists of strings.
|
|
var TransposeFunc = function.New(&function.Spec{
|
|
Params: []function.Parameter{
|
|
{
|
|
Name: "values",
|
|
Type: cty.Map(cty.List(cty.String)),
|
|
},
|
|
},
|
|
Type: function.StaticReturnType(cty.Map(cty.List(cty.String))),
|
|
Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
|
|
inputMap := args[0]
|
|
if !inputMap.IsWhollyKnown() {
|
|
return cty.UnknownVal(retType), nil
|
|
}
|
|
|
|
outputMap := make(map[string]cty.Value)
|
|
tmpMap := make(map[string][]string)
|
|
|
|
for it := inputMap.ElementIterator(); it.Next(); {
|
|
inKey, inVal := it.Element()
|
|
for iter := inVal.ElementIterator(); iter.Next(); {
|
|
_, val := iter.Element()
|
|
if !val.Type().Equals(cty.String) {
|
|
return cty.MapValEmpty(cty.List(cty.String)), errors.New("input must be a map of lists of strings")
|
|
}
|
|
|
|
outKey := val.AsString()
|
|
if _, ok := tmpMap[outKey]; !ok {
|
|
tmpMap[outKey] = make([]string, 0)
|
|
}
|
|
outVal := tmpMap[outKey]
|
|
outVal = append(outVal, inKey.AsString())
|
|
sort.Strings(outVal)
|
|
tmpMap[outKey] = outVal
|
|
}
|
|
}
|
|
|
|
for outKey, outVal := range tmpMap {
|
|
values := make([]cty.Value, 0)
|
|
for _, v := range outVal {
|
|
values = append(values, cty.StringVal(v))
|
|
}
|
|
outputMap[outKey] = cty.ListVal(values)
|
|
}
|
|
|
|
if len(outputMap) == 0 {
|
|
return cty.MapValEmpty(cty.List(cty.String)), nil
|
|
}
|
|
|
|
return cty.MapVal(outputMap), nil
|
|
},
|
|
})
|
|
|
|
// ListFunc constructs a function that takes an arbitrary number of arguments
|
|
// and returns a list containing those values in the same order.
|
|
//
|
|
// This function is deprecated in Terraform v0.12
|
|
var ListFunc = function.New(&function.Spec{
|
|
Params: []function.Parameter{},
|
|
VarParam: &function.Parameter{
|
|
Name: "vals",
|
|
Type: cty.DynamicPseudoType,
|
|
AllowUnknown: true,
|
|
AllowDynamicType: true,
|
|
AllowNull: true,
|
|
},
|
|
Type: func(args []cty.Value) (ret cty.Type, err error) {
|
|
return cty.DynamicPseudoType, fmt.Errorf("the \"list\" function was deprecated in Terraform v0.12 and is no longer available; use tolist([ ... ]) syntax to write a literal list")
|
|
},
|
|
Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
|
|
return cty.DynamicVal, fmt.Errorf("the \"list\" function was deprecated in Terraform v0.12 and is no longer available; use tolist([ ... ]) syntax to write a literal list")
|
|
},
|
|
})
|
|
|
|
// MapFunc constructs a function that takes an even number of arguments and
|
|
// returns a map whose elements are constructed from consecutive pairs of arguments.
|
|
//
|
|
// This function is deprecated in Terraform v0.12
|
|
var MapFunc = function.New(&function.Spec{
|
|
Params: []function.Parameter{},
|
|
VarParam: &function.Parameter{
|
|
Name: "vals",
|
|
Type: cty.DynamicPseudoType,
|
|
AllowUnknown: true,
|
|
AllowDynamicType: true,
|
|
AllowNull: true,
|
|
},
|
|
Type: func(args []cty.Value) (ret cty.Type, err error) {
|
|
return cty.DynamicPseudoType, fmt.Errorf("the \"map\" function was deprecated in Terraform v0.12 and is no longer available; use tomap({ ... }) syntax to write a literal map")
|
|
},
|
|
Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
|
|
return cty.DynamicVal, fmt.Errorf("the \"map\" function was deprecated in Terraform v0.12 and is no longer available; use tomap({ ... }) syntax to write a literal map")
|
|
},
|
|
})
|
|
|
|
// Length returns the number of elements in the given collection or number of
|
|
// Unicode characters in the given string.
|
|
func Length(collection cty.Value) (cty.Value, error) {
|
|
return LengthFunc.Call([]cty.Value{collection})
|
|
}
|
|
|
|
// AllTrue returns true if all elements of the list are true. If the list is empty,
|
|
// return true.
|
|
func AllTrue(collection cty.Value) (cty.Value, error) {
|
|
return AllTrueFunc.Call([]cty.Value{collection})
|
|
}
|
|
|
|
// AnyTrue returns true if any element of the list is true. If the list is empty,
|
|
// return false.
|
|
func AnyTrue(collection cty.Value) (cty.Value, error) {
|
|
return AnyTrueFunc.Call([]cty.Value{collection})
|
|
}
|
|
|
|
// Coalesce takes any number of arguments and returns the first one that isn't empty.
|
|
func Coalesce(args ...cty.Value) (cty.Value, error) {
|
|
return CoalesceFunc.Call(args)
|
|
}
|
|
|
|
// Index finds the element index for a given value in a list.
|
|
func Index(list, value cty.Value) (cty.Value, error) {
|
|
return IndexFunc.Call([]cty.Value{list, value})
|
|
}
|
|
|
|
// List takes any number of list arguments and returns a list containing those
|
|
// values in the same order.
|
|
func List(args ...cty.Value) (cty.Value, error) {
|
|
return ListFunc.Call(args)
|
|
}
|
|
|
|
// Lookup performs a dynamic lookup into a map.
|
|
// There are two required arguments, map and key, plus an optional default,
|
|
// which is a value to return if no key is found in map.
|
|
func Lookup(args ...cty.Value) (cty.Value, error) {
|
|
return LookupFunc.Call(args)
|
|
}
|
|
|
|
// Map takes an even number of arguments and returns a map whose elements are constructed
|
|
// from consecutive pairs of arguments.
|
|
func Map(args ...cty.Value) (cty.Value, error) {
|
|
return MapFunc.Call(args)
|
|
}
|
|
|
|
// Matchkeys constructs a new list by taking a subset of elements from one list
|
|
// whose indexes match the corresponding indexes of values in another list.
|
|
func Matchkeys(values, keys, searchset cty.Value) (cty.Value, error) {
|
|
return MatchkeysFunc.Call([]cty.Value{values, keys, searchset})
|
|
}
|
|
|
|
// One returns either the first element of a one-element list, or null
|
|
// if given a zero-element list..
|
|
func One(list cty.Value) (cty.Value, error) {
|
|
return OneFunc.Call([]cty.Value{list})
|
|
}
|
|
|
|
// Sum adds numbers in a list, set, or tuple
|
|
func Sum(list cty.Value) (cty.Value, error) {
|
|
return SumFunc.Call([]cty.Value{list})
|
|
}
|
|
|
|
// Transpose takes a map of lists of strings and swaps the keys and values to
|
|
// produce a new map of lists of strings.
|
|
func Transpose(values cty.Value) (cty.Value, error) {
|
|
return TransposeFunc.Call([]cty.Value{values})
|
|
}
|