reflect/protoreflect/value_union.go

// Copyright 2018 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package protoreflect

import (
	"fmt"
	"math"
	"reflect"
)

// The protoreflect API uses a custom Value union type instead of interface{}
// to keep the future open for performance optimizations. Using an interface{}
// always incurs an allocation for primitives (e.g., int64) since it needs to
// be boxed on the heap (as interfaces can only contain pointers natively).
// Instead, we represent the Value union as a flat struct that internally keeps
// track of which type is set. Using unsafe, the Value union can be reduced
// down to 24B, which is identical in size to a slice.
//
// The latest compiler (Go1.11) currently suffers from some limitations:
//	• With inlining, the compiler should be able to statically prove that
//	only one of these switch cases are taken and inline one specific case.
//	See https://golang.org/issue/22310.

// ValueOf returns a Value initialized with the concrete value stored in v.
// This panics if the type does not match one of the allowed types in the
// Value union.
//
// After calling ValueOf on a []byte, the slice must no longer be mutated.
func ValueOf(v interface{}) Value {
	switch v := v.(type) {
	case nil:
		return Value{}
	case bool:
		if v {
			return Value{typ: boolType, num: 1}
		} else {
			return Value{typ: boolType, num: 0}
		}
	case int32:
		return Value{typ: int32Type, num: uint64(v)}
	case int64:
		return Value{typ: int64Type, num: uint64(v)}
	case uint32:
		return Value{typ: uint32Type, num: uint64(v)}
	case uint64:
		return Value{typ: uint64Type, num: uint64(v)}
	case float32:
		return Value{typ: float32Type, num: uint64(math.Float64bits(float64(v)))}
	case float64:
		return Value{typ: float64Type, num: uint64(math.Float64bits(float64(v)))}
	case string:
		return valueOfString(v)
	case []byte:
		return valueOfBytes(v[:len(v):len(v)])
	case EnumNumber:
		return Value{typ: enumType, num: uint64(v)}
	case Message, Vector, Map:
		return valueOfIface(v)
	default:
		// TODO: Special case ProtoEnum, ProtoMessage, *[]T, and *map[K]V?
		// Note: this would violate the documented invariant in Interface.
		panic(fmt.Sprintf("invalid type: %v", reflect.TypeOf(v)))
	}
}

// IsNull reports whether v is empty (has no value).
func (v Value) IsNull() bool {
	return v.typ == nilType
}

// Interface returns v as an interface{}.
// Returned []byte values must not be mutated.
//
// Invariant: v == ValueOf(v).Interface()
func (v Value) Interface() interface{} {
	switch v.typ {
	case nilType:
		return nil
	case boolType:
		return v.Bool()
	case int32Type:
		return int32(v.Int())
	case int64Type:
		return int64(v.Int())
	case uint32Type:
		return uint32(v.Uint())
	case uint64Type:
		return uint64(v.Uint())
	case float32Type:
		return float32(v.Float())
	case float64Type:
		return float64(v.Float())
	case stringType:
		return v.String()
	case bytesType:
		return v.Bytes()
	case enumType:
		return v.Enum()
	default:
		return v.getIface()
	}
}

// Bool returns v as a bool and panics if the type is not a bool.
func (v Value) Bool() bool {
	switch v.typ {
	case boolType:
		return v.num > 0
	default:
		panic("proto: value type mismatch")
	}
}

// Int returns v as a int64 and panics if the type is not a int32 or int64.
func (v Value) Int() int64 {
	switch v.typ {
	case int32Type, int64Type:
		return int64(v.num)
	default:
		panic("proto: value type mismatch")
	}
}

// Uint returns v as a uint64 and panics if the type is not a uint32 or uint64.
func (v Value) Uint() uint64 {
	switch v.typ {
	case uint32Type, uint64Type:
		return uint64(v.num)
	default:
		panic("proto: value type mismatch")
	}
}

// Float returns v as a float64 and panics if the type is not a float32 or float64.
func (v Value) Float() float64 {
	switch v.typ {
	case float32Type, float64Type:
		return math.Float64frombits(uint64(v.num))
	default:
		panic("proto: value type mismatch")
	}
}

// String returns v as a string. Since this method implements fmt.Stringer,
// this returns the formatted string value for any non-string type.
func (v Value) String() string {
	switch v.typ {
	case stringType:
		return v.getString()
	default:
		return fmt.Sprint(v.Interface())
	}
}

// Bytes returns v as a []byte and panics if the type is not a []byte.
// The returned slice must not be mutated.
func (v Value) Bytes() []byte {
	switch v.typ {
	case bytesType:
		return v.getBytes()
	default:
		panic("proto: value type mismatch")
	}
}

// Enum returns v as a EnumNumber and panics if the type is not a EnumNumber.
func (v Value) Enum() EnumNumber {
	switch v.typ {
	case enumType:
		return EnumNumber(v.num)
	default:
		panic("proto: value type mismatch")
	}
}

// Message returns v as a Message and panics if the type is not a Message.
func (v Value) Message() Message {
	switch v := v.getIface().(type) {
	case Message:
		return v
	default:
		panic("proto: value type mismatch")
	}
}

// Vector returns v as a Vector and panics if the type is not a Vector.
func (v Value) Vector() Vector {
	switch v := v.getIface().(type) {
	case Vector:
		return v
	default:
		panic("proto: value type mismatch")
	}
}

// Map returns v as a Map and panics if the type is not a Map.
func (v Value) Map() Map {
	switch v := v.getIface().(type) {
	case Map:
		return v
	default:
		panic("proto: value type mismatch")
	}
}

// MapKey returns v as a MapKey and panics for invalid MapKey types.
func (v Value) MapKey() MapKey {
	switch v.typ {
	case boolType, int32Type, int64Type, uint32Type, uint64Type, stringType:
		return MapKey(v)
	}
	panic("proto: invalid map key type")
}

// IsNull reports whether v is empty (has no value).
func (k MapKey) IsNull() bool {
	return Value(k).IsNull()
}

// Interface returns k as an interface{}.
func (k MapKey) Interface() interface{} {
	return Value(k).Interface()
}

// Bool returns k as a bool and panics if the type is not a bool.
func (k MapKey) Bool() bool {
	return Value(k).Bool()
}

// Int returns k as a int64 and panics if the type is not a int32 or int64.
func (k MapKey) Int() int64 {
	return Value(k).Int()
}

// Uint returns k as a uint64 and panics if the type is not a uint32 or uint64.
func (k MapKey) Uint() uint64 {
	return Value(k).Uint()
}

// String returns k as a string. Since this method implements fmt.Stringer,
// this returns the formatted string value for any non-string type.
func (k MapKey) String() string {
	return Value(k).String()
}

// Value returns k as a Value.
func (k MapKey) Value() Value {
	return Value(k)
}