mirror of
https://github.com/letic/terraform-provider-google.git
synced 2024-07-24 10:35:59 +00:00
961c878e0d
Switch to using Go modules. This migrates our vendor.json to use Go 1.11's modules system, and replaces the vendor folder with the output of go mod vendor. The vendored code should remain basically the same; I believe some tree shaking of packages and support scripts/licenses/READMEs/etc. happened. This also fixes Travis and our Makefile to no longer use govendor.
90 lines
2.9 KiB
Go
90 lines
2.9 KiB
Go
package cty
|
|
|
|
import (
|
|
"fmt"
|
|
"reflect"
|
|
)
|
|
|
|
type capsuleType struct {
|
|
typeImplSigil
|
|
Name string
|
|
GoType reflect.Type
|
|
}
|
|
|
|
func (t *capsuleType) Equals(other Type) bool {
|
|
if otherP, ok := other.typeImpl.(*capsuleType); ok {
|
|
// capsule types compare by pointer identity
|
|
return otherP == t
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (t *capsuleType) FriendlyName(mode friendlyTypeNameMode) string {
|
|
return t.Name
|
|
}
|
|
|
|
func (t *capsuleType) GoString() string {
|
|
// To get a useful representation of our native type requires some
|
|
// shenanigans.
|
|
victimVal := reflect.Zero(t.GoType)
|
|
return fmt.Sprintf("cty.Capsule(%q, reflect.TypeOf(%#v))", t.Name, victimVal.Interface())
|
|
}
|
|
|
|
// Capsule creates a new Capsule type.
|
|
//
|
|
// A Capsule type is a special type that can be used to transport arbitrary
|
|
// Go native values of a given type through the cty type system. A language
|
|
// that uses cty as its type system might, for example, provide functions
|
|
// that return capsule-typed values and then other functions that operate
|
|
// on those values.
|
|
//
|
|
// From cty's perspective, Capsule types have a few interesting characteristics,
|
|
// described in the following paragraphs.
|
|
//
|
|
// Each capsule type has an associated Go native type that it is able to
|
|
// transport. Capsule types compare by identity, so each call to the
|
|
// Capsule function creates an entirely-distinct cty Type, even if two calls
|
|
// use the same native type.
|
|
//
|
|
// Each capsule-typed value contains a pointer to a value of the given native
|
|
// type. A capsule-typed value supports no operations except equality, and
|
|
// equality is implemented by pointer identity of the encapsulated pointer.
|
|
//
|
|
// The given name is used as the new type's "friendly name". This can be any
|
|
// string in principle, but will usually be a short, all-lowercase name aimed
|
|
// at users of the embedding language (i.e. not mention Go-specific details)
|
|
// and will ideally not create ambiguity with any predefined cty type.
|
|
//
|
|
// Capsule types are never introduced by any standard cty operation, so a
|
|
// calling application opts in to including them within its own type system
|
|
// by creating them and introducing them via its own functions. At that point,
|
|
// the application is responsible for dealing with any capsule-typed values
|
|
// that might be returned.
|
|
func Capsule(name string, nativeType reflect.Type) Type {
|
|
return Type{
|
|
&capsuleType{
|
|
Name: name,
|
|
GoType: nativeType,
|
|
},
|
|
}
|
|
}
|
|
|
|
// IsCapsuleType returns true if this type is a capsule type, as created
|
|
// by cty.Capsule .
|
|
func (t Type) IsCapsuleType() bool {
|
|
_, ok := t.typeImpl.(*capsuleType)
|
|
return ok
|
|
}
|
|
|
|
// EncapsulatedType returns the encapsulated native type of a capsule type,
|
|
// or panics if the receiver is not a Capsule type.
|
|
//
|
|
// Is IsCapsuleType to determine if this method is safe to call.
|
|
func (t Type) EncapsulatedType() reflect.Type {
|
|
impl, ok := t.typeImpl.(*capsuleType)
|
|
if !ok {
|
|
panic("not a capsule type")
|
|
}
|
|
return impl.GoType
|
|
}
|