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.
126 lines
3.0 KiB
Go
126 lines
3.0 KiB
Go
package cty
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/gob"
|
|
"fmt"
|
|
"math/big"
|
|
)
|
|
|
|
// GobEncode is an implementation of the gob.GobEncoder interface, which
|
|
// allows Values to be included in structures encoded with encoding/gob.
|
|
//
|
|
// Currently it is not possible to represent values of capsule types in gob,
|
|
// because the types themselves cannot be represented.
|
|
func (val Value) GobEncode() ([]byte, error) {
|
|
buf := &bytes.Buffer{}
|
|
enc := gob.NewEncoder(buf)
|
|
|
|
gv := gobValue{
|
|
Version: 0,
|
|
Ty: val.ty,
|
|
V: val.v,
|
|
}
|
|
|
|
err := enc.Encode(gv)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error encoding cty.Value: %s", err)
|
|
}
|
|
|
|
return buf.Bytes(), nil
|
|
}
|
|
|
|
// GobDecode is an implementation of the gob.GobDecoder interface, which
|
|
// inverts the operation performed by GobEncode. See the documentation of
|
|
// GobEncode for considerations when using cty.Value instances with gob.
|
|
func (val *Value) GobDecode(buf []byte) error {
|
|
r := bytes.NewReader(buf)
|
|
dec := gob.NewDecoder(r)
|
|
|
|
var gv gobValue
|
|
err := dec.Decode(&gv)
|
|
if err != nil {
|
|
return fmt.Errorf("error decoding cty.Value: %s", err)
|
|
}
|
|
if gv.Version != 0 {
|
|
return fmt.Errorf("unsupported cty.Value encoding version %d; only 0 is supported", gv.Version)
|
|
}
|
|
|
|
// big.Float seems to, for some reason, lose its "pointerness" when we
|
|
// round-trip it, so we'll fix that here.
|
|
if bf, ok := gv.V.(big.Float); ok {
|
|
gv.V = &bf
|
|
}
|
|
|
|
val.ty = gv.Ty
|
|
val.v = gv.V
|
|
|
|
return nil
|
|
}
|
|
|
|
// GobEncode is an implementation of the gob.GobEncoder interface, which
|
|
// allows Types to be included in structures encoded with encoding/gob.
|
|
//
|
|
// Currently it is not possible to represent capsule types in gob.
|
|
func (t Type) GobEncode() ([]byte, error) {
|
|
buf := &bytes.Buffer{}
|
|
enc := gob.NewEncoder(buf)
|
|
|
|
gt := gobType{
|
|
Version: 0,
|
|
Impl: t.typeImpl,
|
|
}
|
|
|
|
err := enc.Encode(gt)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error encoding cty.Type: %s", err)
|
|
}
|
|
|
|
return buf.Bytes(), nil
|
|
}
|
|
|
|
// GobDecode is an implementatino of the gob.GobDecoder interface, which
|
|
// reverses the encoding performed by GobEncode to allow types to be recovered
|
|
// from gob buffers.
|
|
func (t *Type) GobDecode(buf []byte) error {
|
|
r := bytes.NewReader(buf)
|
|
dec := gob.NewDecoder(r)
|
|
|
|
var gt gobType
|
|
err := dec.Decode(>)
|
|
if err != nil {
|
|
return fmt.Errorf("error decoding cty.Type: %s", err)
|
|
}
|
|
if gt.Version != 0 {
|
|
return fmt.Errorf("unsupported cty.Type encoding version %d; only 0 is supported", gt.Version)
|
|
}
|
|
|
|
t.typeImpl = gt.Impl
|
|
|
|
return nil
|
|
}
|
|
|
|
// Capsule types cannot currently be gob-encoded, because they rely on pointer
|
|
// equality and we have no way to recover the original pointer on decode.
|
|
func (t *capsuleType) GobEncode() ([]byte, error) {
|
|
return nil, fmt.Errorf("cannot gob-encode capsule type %q", t.FriendlyName(friendlyTypeName))
|
|
}
|
|
|
|
func (t *capsuleType) GobDecode() ([]byte, error) {
|
|
return nil, fmt.Errorf("cannot gob-decode capsule type %q", t.FriendlyName(friendlyTypeName))
|
|
}
|
|
|
|
type gobValue struct {
|
|
Version int
|
|
Ty Type
|
|
V interface{}
|
|
}
|
|
|
|
type gobType struct {
|
|
Version int
|
|
Impl typeImpl
|
|
}
|
|
|
|
type gobCapsuleTypeImpl struct {
|
|
}
|