121 lines
3.7 KiB
Go
121 lines
3.7 KiB
Go
package funcs
|
|
|
|
import (
|
|
"fmt"
|
|
|
|
"github.com/zclconf/go-cty/cty"
|
|
"github.com/zclconf/go-cty/cty/function"
|
|
"github.com/zclconf/go-cty/cty/function/stdlib"
|
|
"github.com/zclconf/go-cty/cty/gocty"
|
|
)
|
|
|
|
var ElementFunc = function.New(&function.Spec{
|
|
Params: []function.Parameter{
|
|
{
|
|
Name: "list",
|
|
Type: cty.DynamicPseudoType,
|
|
},
|
|
{
|
|
Name: "index",
|
|
Type: cty.Number,
|
|
},
|
|
},
|
|
Type: func(args []cty.Value) (cty.Type, error) {
|
|
list := args[0]
|
|
listTy := list.Type()
|
|
switch {
|
|
case listTy.IsListType():
|
|
return listTy.ElementType(), nil
|
|
case listTy.IsTupleType():
|
|
etys := listTy.TupleElementTypes()
|
|
var index int
|
|
err := gocty.FromCtyValue(args[1], &index)
|
|
if err != nil {
|
|
// e.g. fractional number where whole number is required
|
|
return cty.DynamicPseudoType, fmt.Errorf("invalid index: %s", err)
|
|
}
|
|
if len(etys) == 0 {
|
|
return cty.DynamicPseudoType, fmt.Errorf("cannot use element function with an empty list")
|
|
}
|
|
index = index % len(etys)
|
|
return etys[index], nil
|
|
default:
|
|
return cty.DynamicPseudoType, fmt.Errorf("cannot read elements from %s", listTy.FriendlyName())
|
|
}
|
|
},
|
|
Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
|
|
var index int
|
|
err := gocty.FromCtyValue(args[1], &index)
|
|
if err != nil {
|
|
// can't happen because we checked this in the Type function above
|
|
return cty.DynamicVal, fmt.Errorf("invalid index: %s", err)
|
|
}
|
|
l := args[0].LengthInt()
|
|
if l == 0 {
|
|
return cty.DynamicVal, fmt.Errorf("cannot use element function with an empty list")
|
|
}
|
|
index = index % l
|
|
|
|
// We did all the necessary type checks in the type function above,
|
|
// so this is guaranteed not to fail.
|
|
return args[0].Index(cty.NumberIntVal(int64(index))), nil
|
|
},
|
|
})
|
|
|
|
var LengthFunc = function.New(&function.Spec{
|
|
Params: []function.Parameter{
|
|
{
|
|
Name: "value",
|
|
Type: cty.DynamicPseudoType,
|
|
AllowDynamicType: true,
|
|
AllowUnknown: true,
|
|
},
|
|
},
|
|
Type: func(args []cty.Value) (cty.Type, error) {
|
|
collTy := args[0].Type()
|
|
switch {
|
|
case collTy == cty.String || collTy.IsTupleType() || collTy.IsListType() || collTy.IsMapType() || collTy.IsSetType() || collTy == cty.DynamicPseudoType:
|
|
return cty.Number, nil
|
|
default:
|
|
return cty.Number, fmt.Errorf("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()
|
|
switch {
|
|
case collTy == cty.DynamicPseudoType:
|
|
return cty.UnknownVal(cty.Number), nil
|
|
case collTy.IsTupleType():
|
|
l := len(collTy.TupleElementTypes())
|
|
return cty.NumberIntVal(int64(l)), nil
|
|
case collTy.IsObjectType():
|
|
l := len(collTy.AttributeTypes())
|
|
return cty.NumberIntVal(int64(l)), 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), fmt.Errorf("impossible value type for length(...)")
|
|
}
|
|
},
|
|
})
|
|
|
|
// Element returns a single element from a given list at the given index. If
|
|
// index is greater than the length of the list then it is wrapped modulo
|
|
// the list length.
|
|
func Element(list, index cty.Value) (cty.Value, error) {
|
|
return ElementFunc.Call([]cty.Value{list, index})
|
|
}
|
|
|
|
// 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})
|
|
}
|