You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
121 lines
3.6 KiB
121 lines
3.6 KiB
// Package jsontypes supports decoding for interface types whose concrete
|
|
// implementations need to be stored as JSON. To do this, concrete values are
|
|
// packaged in wrapper objects having the form:
|
|
//
|
|
// {
|
|
// "type": "<type-tag>",
|
|
// "value": <json-encoding-of-value>
|
|
// }
|
|
//
|
|
// This package provides a registry for type tag strings and functions to
|
|
// encode and decode wrapper objects.
|
|
package jsontypes
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"fmt"
|
|
"reflect"
|
|
)
|
|
|
|
// The Tagged interface must be implemented by a type in order to register it
|
|
// with the jsontypes package. The TypeTag method returns a string label that
|
|
// is used to distinguish objects of that type.
|
|
type Tagged interface {
|
|
TypeTag() string
|
|
}
|
|
|
|
// registry records the mapping from type tags to value types.
|
|
var registry = struct {
|
|
types map[string]reflect.Type
|
|
}{types: make(map[string]reflect.Type)}
|
|
|
|
// register adds v to the type registry. It reports an error if the tag
|
|
// returned by v is already registered.
|
|
func register(v Tagged) error {
|
|
tag := v.TypeTag()
|
|
if t, ok := registry.types[tag]; ok {
|
|
return fmt.Errorf("type tag %q already registered to %v", tag, t)
|
|
}
|
|
registry.types[tag] = reflect.TypeOf(v)
|
|
return nil
|
|
}
|
|
|
|
// MustRegister adds v to the type registry. It will panic if the tag returned
|
|
// by v is already registered. This function is meant for use during program
|
|
// initialization.
|
|
func MustRegister(v Tagged) {
|
|
if err := register(v); err != nil {
|
|
panic(err)
|
|
}
|
|
}
|
|
|
|
type wrapper struct {
|
|
Type string `json:"type"`
|
|
Value json.RawMessage `json:"value"`
|
|
}
|
|
|
|
// Marshal marshals a JSON wrapper object containing v. If v == nil, Marshal
|
|
// returns the JSON "null" value without error.
|
|
func Marshal(v Tagged) ([]byte, error) {
|
|
if v == nil {
|
|
return []byte("null"), nil
|
|
}
|
|
data, err := json.Marshal(v)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return json.Marshal(wrapper{
|
|
Type: v.TypeTag(),
|
|
Value: data,
|
|
})
|
|
}
|
|
|
|
// Unmarshal unmarshals a JSON wrapper object into v. It reports an error if
|
|
// the data do not encode a valid wrapper object, if the wrapper's type tag is
|
|
// not registered with jsontypes, or if the resulting value is not compatible
|
|
// with the type of v.
|
|
func Unmarshal(data []byte, v interface{}) error {
|
|
// Verify that the target is some kind of pointer.
|
|
target := reflect.ValueOf(v)
|
|
if target.Kind() != reflect.Ptr {
|
|
return fmt.Errorf("target %T is not a pointer", v)
|
|
} else if target.IsZero() {
|
|
return fmt.Errorf("target is a nil %T", v)
|
|
}
|
|
baseType := target.Type().Elem()
|
|
if isNull(data) {
|
|
target.Elem().Set(reflect.Zero(baseType))
|
|
return nil
|
|
}
|
|
|
|
var w wrapper
|
|
dec := json.NewDecoder(bytes.NewReader(data))
|
|
dec.DisallowUnknownFields()
|
|
if err := dec.Decode(&w); err != nil {
|
|
return fmt.Errorf("invalid type wrapper: %w", err)
|
|
}
|
|
typ, ok := registry.types[w.Type]
|
|
if !ok {
|
|
return fmt.Errorf("unknown type tag for %T: %q", v, w.Type)
|
|
}
|
|
if typ.AssignableTo(baseType) {
|
|
// ok: registered type is directly assignable to the target
|
|
} else if typ.Kind() == reflect.Ptr && typ.Elem().AssignableTo(baseType) {
|
|
typ = typ.Elem()
|
|
// ok: registered type is a pointer to a value assignable to the target
|
|
} else {
|
|
return fmt.Errorf("type %v is not assignable to %v", typ, baseType)
|
|
}
|
|
obj := reflect.New(typ) // we need a pointer to unmarshal
|
|
if err := json.Unmarshal(w.Value, obj.Interface()); err != nil {
|
|
return fmt.Errorf("decoding wrapped value: %w", err)
|
|
}
|
|
target.Elem().Set(obj.Elem())
|
|
return nil
|
|
}
|
|
|
|
// isNull reports true if data is empty or is the JSON "null" value.
|
|
func isNull(data []byte) bool {
|
|
return len(data) == 0 || bytes.Equal(data, []byte("null"))
|
|
}
|