Rietveld Code Review Tool
Help | Bug tracker | Discussion group | Source code | Sign in
(362)

Unified Diff: src/pkg/reflect/value.go

Issue 4281055: code review 4281055: reflect: new Type and Value definitions (Closed)
Patch Set: diff -r ce9962e29e4b https://go.googlecode.com/hg Created 12 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments. Please Sign in to add in-line comments.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « src/pkg/reflect/type.go ('k') | no next file » | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: src/pkg/reflect/value.go
===================================================================
--- a/src/pkg/reflect/value.go
+++ b/src/pkg/reflect/value.go
@@ -41,10 +41,482 @@
}
}
-// Value is the common interface to reflection values.
-// The implementations of Value (e.g., ArrayValue, StructValue)
+// Value is the reflection interface to a Go value.
+//
+// Not all methods apply to all kinds of values. Restrictions,
+// if any, are noted in the documentation for each method.
+// Use the Kind method to find out the kind of value before
+// calling kind-specific methods. Calling a method
+// inappropriate to the kind of type causes a run time panic.
+//
+// The zero Value represents no value.
+// Its IsValid method returns false, its Kind method returns Invalid,
+// its String method returns "<invalid Value>", and all other methods panic.
+// Most functions and methods never return an invalid value.
+// If one does, its documentation states the conditions explicitly.
+type Value struct {
+ Internal valueInterface
+}
+
+// TODO(rsc): This implementation of Value is a just a façade
+// in front of the old implementation, now called valueInterface.
+// A future CL will change it to a real implementation.
+// Changing the API is already a big enough step for one CL.
+
+// A ValueError occurs when a Value method is invoked on
+// a Value that does not support it. Such cases are documented
+// in the description of each method.
+type ValueError struct {
+ Method string
+ Kind Kind
+}
+
+func (e *ValueError) String() string {
+ if e.Kind == 0 {
+ return "reflect: call of " + e.Method + " on zero Value"
+ }
+ return "reflect: call of " + e.Method + " on " + e.Kind.String() + " Value"
+}
+
+// methodName returns the name of the calling method,
+// assumed to be two stack frames above.
+func methodName() string {
+ pc, _, _, _ := runtime.Caller(2)
+ f := runtime.FuncForPC(pc)
+ if f == nil {
+ return "unknown method"
+ }
+ return f.Name()
+}
+
+func (v Value) internal() valueInterface {
+ vi := v.Internal
+ if vi == nil {
+ panic(&ValueError{methodName(), 0})
+ }
+ return vi
+}
+
+func (v Value) panicIfNot(want Kind) valueInterface {
+ vi := v.Internal
+ if vi == nil {
+ panic(&ValueError{methodName(), 0})
+ }
+ if k := vi.Kind(); k != want {
+ panic(&ValueError{methodName(), k})
+ }
+ return vi
+}
+
+func (v Value) panicIfNots(wants []Kind) valueInterface {
+ vi := v.Internal
+ if vi == nil {
+ panic(&ValueError{methodName(), 0})
+ }
+ k := vi.Kind()
+ for _, want := range wants {
+ if k == want {
+ return vi
+ }
+ }
+ panic(&ValueError{methodName(), k})
+}
+
+// Addr returns a pointer value representing the address of v.
+// It panics if CanAddr() returns false.
+// Addr is typically used to obtain a pointer to a struct field
+// or slice element in order to call a method that requires a
+// pointer receiver.
+func (v Value) Addr() Value {
+ return v.internal().Addr()
+}
+
+// Bool returns v's underlying value.
+// It panics if v's kind is not Bool.
+func (v Value) Bool() bool {
+ u := v.panicIfNot(Bool).(*boolValue)
+ return u.Get()
+}
+
+// CanAddr returns true if the value's address can be obtained with Addr.
+// Such values are called addressable. A value is addressable if it is
+// an element of a slice, an element of an addressable array,
+// a field of an addressable struct, the result of dereferencing a pointer,
+// or the result of a call to NewValue, MakeChan, MakeMap, or Zero.
+// If CanAddr returns false, calling Addr will panic.
+func (v Value) CanAddr() bool {
+ return v.internal().CanAddr()
+}
+
+// CanSet returns true if the value of v can be changed.
+// Values obtained by the use of unexported struct fields
+// can be read but not set.
+// If CanSet returns false, calling Set or any type-specific
+// setter (e.g., SetBool, SetInt64) will panic.
+func (v Value) CanSet() bool {
+ return v.internal().CanSet()
+}
+
+// Call calls the function v with the input parameters in.
+// It panics if v's Kind is not Func.
+// It returns the output parameters as Values.
+func (v Value) Call(in []Value) []Value {
+ return v.panicIfNot(Func).(*funcValue).Call(in)
+}
+
+var capKinds = []Kind{Array, Chan, Slice}
+
+type capper interface {
+ Cap() int
+}
+
+// Cap returns v's capacity.
+// It panics if v's Kind is not Array, Chan, or Slice.
+func (v Value) Cap() int {
+ return v.panicIfNots(capKinds).(capper).Cap()
+}
+
+// Close closes the channel v.
+// It panics if v's Kind is not Chan.
+func (v Value) Close() {
+ v.panicIfNot(Chan).(*chanValue).Close()
+}
+
+var complexKinds = []Kind{Complex64, Complex128}
+
+// Complex returns v's underlying value, as a complex128.
+// It panics if v's Kind is not Complex64 or Complex128
+func (v Value) Complex() complex128 {
+ return v.panicIfNots(complexKinds).(*complexValue).Get()
+}
+
+var interfaceOrPtr = []Kind{Interface, Ptr}
+
+type elemer interface {
+ Elem() Value
+}
+
+// Elem returns the value that the interface v contains
+// or that the pointer v points to.
+// It panics if v's Kind is not Interface or Ptr.
+// It returns the zero Value if v is nil.
+func (v Value) Elem() Value {
+ return v.panicIfNots(interfaceOrPtr).(elemer).Elem()
+}
+
+// Field returns the i'th field of the struct v.
+// It panics if v's Kind is not Struct.
+func (v Value) Field(i int) Value {
+ return v.panicIfNot(Struct).(*structValue).Field(i)
+}
+
+// FieldByIndex returns the nested field corresponding to index.
+// It panics if v's Kind is not struct.
+func (v Value) FieldByIndex(index []int) Value {
+ return v.panicIfNot(Struct).(*structValue).FieldByIndex(index)
+}
+
+// FieldByName returns the struct field with the given name.
+// It returns the zero Value if no field was found.
+// It panics if v's Kind is not struct.
+func (v Value) FieldByName(name string) Value {
+ return v.panicIfNot(Struct).(*structValue).FieldByName(name)
+}
+
+// FieldByNameFunc returns the struct field with a name
+// that satisfies the match function.
+// It panics if v's Kind is not struct.
+// It returns the zero Value if no field was found.
+func (v Value) FieldByNameFunc(match func(string) bool) Value {
+ return v.panicIfNot(Struct).(*structValue).FieldByNameFunc(match)
+}
+
+var floatKinds = []Kind{Float32, Float64}
+
+// Float returns v's underlying value, as an float64.
+// It panics if v's Kind is not Float32 or Float64
+func (v Value) Float() float64 {
+ return v.panicIfNots(floatKinds).(*floatValue).Get()
+}
+
+var arrayOrSlice = []Kind{Array, Slice}
+
+// Index returns v's i'th element.
+// It panics if v's Kind is not Array or Slice.
+func (v Value) Index(i int) Value {
+ return v.panicIfNots(arrayOrSlice).(arrayOrSliceValue).Elem(i)
+}
+
+var intKinds = []Kind{Int, Int8, Int16, Int32, Int64}
+
+// Int returns v's underlying value, as an int64.
+// It panics if v's Kind is not a sized or unsized Int kind.
+func (v Value) Int() int64 {
+ return v.panicIfNots(intKinds).(*intValue).Get()
+}
+
+// Interface returns v's value as an interface{}.
+// If v is a method obtained by invoking Value.Method
+// (as opposed to Type.Method), Interface cannot return an
+// interface value, so it panics.
+func (v Value) Interface() interface{} {
+ return v.internal().Interface()
+}
+
+// InterfaceData returns the interface v's value as a uintptr pair.
+// It panics if v's Kind is not Interface.
+func (v Value) InterfaceData() [2]uintptr {
+ return v.panicIfNot(Interface).(*interfaceValue).Get()
+}
+
+var nilKinds = []Kind{Chan, Func, Interface, Map, Ptr, Slice}
+
+type isNiller interface {
+ IsNil() bool
+}
+
+// IsNil returns true if v is a nil value.
+// It panics if v's Kind is not Chan, Func, Interface, Map, Ptr, or Slice.
+func (v Value) IsNil() bool {
+ return v.panicIfNots(nilKinds).(isNiller).IsNil()
+}
+
+// IsValid returns true if v represents a value.
+// It returns false if v is the zero Value.
+// If IsValid returns false, all other methods except String panic.
+// Most functions and methods never return an invalid value.
+// If one does, its documentation states the conditions explicitly.
+func (v Value) IsValid() bool {
+ return v.Internal != nil
+}
+
+// Kind returns v's Kind.
+// If v is the zero Value (IsValid returns false), Kind returns Invalid.
+func (v Value) Kind() Kind {
+ if v.Internal == nil {
+ return Invalid
+ }
+ return v.internal().Kind()
+}
+
+var lenKinds = []Kind{Array, Chan, Map, Slice}
+
+type lenner interface {
+ Len() int
+}
+
+// Len returns v's length.
+// It panics if v's Kind is not Array, Chan, Map, or Slice.
+func (v Value) Len() int {
+ return v.panicIfNots(lenKinds).(lenner).Len()
+}
+
+// MapIndex returns the value associated with key in the map v.
+// It panics if v's Kind is not Map.
+// It returns the zero Value if key is not found in the map.
+func (v Value) MapIndex(key Value) Value {
+ return v.panicIfNot(Map).(*mapValue).Elem(key)
+}
+
+// MapKeys returns a slice containing all the keys present in the map,
+// in unspecified order.
+// It panics if v's Kind is not Map.
+func (v Value) MapKeys() []Value {
+ return v.panicIfNot(Map).(*mapValue).Keys()
+}
+
+// Method returns a function value corresponding to v's i'th method.
+// The arguments to a Call on the returned function should not include
+// a receiver; the returned function will always use v as the receiver.
+func (v Value) Method(i int) Value {
+ return v.internal().Method(i)
+}
+
+// NumField returns the number of fields in the struct v.
+// It panics if v's Kind is not Struct.
+func (v Value) NumField() int {
+ return v.panicIfNot(Struct).(*structValue).NumField()
+}
+
+// OverflowComplex returns true if the complex128 x cannot be represented by v's type.
+// It panics if v's Kind is not Complex64 or Complex128.
+func (v Value) OverflowComplex(x complex128) bool {
+ return v.panicIfNots(complexKinds).(*complexValue).Overflow(x)
+}
+
+// OverflowFloat returns true if the float64 x cannot be represented by v's type.
+// It panics if v's Kind is not Float32 or Float64.
+func (v Value) OverflowFloat(x float64) bool {
+ return v.panicIfNots(floatKinds).(*floatValue).Overflow(x)
+}
+
+// OverflowInt returns true if the int64 x cannot be represented by v's type.
+// It panics if v's Kind is not a sized or unsized Int kind.
+func (v Value) OverflowInt(x int64) bool {
+ return v.panicIfNots(intKinds).(*intValue).Overflow(x)
+}
+
+// OverflowUint returns true if the uint64 x cannot be represented by v's type.
+// It panics if v's Kind is not a sized or unsized Uint kind.
+func (v Value) OverflowUint(x uint64) bool {
+ return v.panicIfNots(uintKinds).(*uintValue).Overflow(x)
+}
+
+var pointerKinds = []Kind{Chan, Func, Map, Ptr, Slice, UnsafePointer}
+
+type uintptrGetter interface {
+ Get() uintptr
+}
+
+// Pointer returns v's value as a uintptr.
+// It returns uintptr instead of unsafe.Pointer so that
+// code using reflect cannot obtain unsafe.Pointers
+// without importing the unsafe package explicitly.
+// It panics if v's Kind is not Chan, Func, Map, Ptr, Slice, or UnsafePointer.
+func (v Value) Pointer() uintptr {
+ return v.panicIfNots(pointerKinds).(uintptrGetter).Get()
+}
+
+
+// Recv receives and returns a value from the channel v.
+// It panics if v's Kind is not Chan.
+// The receive blocks until a value is ready.
+// The boolean value ok is true if the value x corresponds to a send
+// on the channel, false if it is a zero value received because the channel is closed.
+func (v Value) Recv() (x Value, ok bool) {
+ return v.panicIfNot(Chan).(*chanValue).Recv()
+}
+
+// Send sends x on the channel v.
+// It panics if v's kind is not Chan or if x's type is not the same type as v's element type.
+func (v Value) Send(x Value) {
+ v.panicIfNot(Chan).(*chanValue).Send(x)
+}
+
+// Set assigns x to the value v; x must have the same type as v.
+// It panics if CanSet() returns false or if x is the zero Value.
+func (v Value) Set(x Value) {
+ x.internal()
+ v.internal().SetValue(x)
+}
+
+// SetBool sets v's underlying value.
+// It panics if v's Kind is not Bool or if CanSet() is false.
+func (v Value) SetBool(x bool) {
+ v.panicIfNot(Bool).(*boolValue).Set(x)
+}
+
+// SetComplex sets v's underlying value to x.
+// It panics if v's Kind is not Complex64 or Complex128, or if CanSet() is false.
+func (v Value) SetComplex(x complex128) {
+ v.panicIfNots(complexKinds).(*complexValue).Set(x)
+}
+
+// SetFloat sets v's underlying value to x.
+// It panics if v's Kind is not Float32 or Float64, or if CanSet() is false.
+func (v Value) SetFloat(x float64) {
+ v.panicIfNots(floatKinds).(*floatValue).Set(x)
+}
+
+// SetInt sets v's underlying value to x.
+// It panics if v's Kind is not a sized or unsized Int kind, or if CanSet() is false.
+func (v Value) SetInt(x int64) {
+ v.panicIfNots(intKinds).(*intValue).Set(x)
+}
+
+// SetLen sets v's length to n.
+// It panics if v's Kind is not Slice.
+func (v Value) SetLen(n int) {
+ v.panicIfNot(Slice).(*sliceValue).SetLen(n)
+}
+
+// SetMapIndex sets the value associated with key in the map v to val.
+// It panics if v's Kind is not Map.
+// If val is the zero Value, SetMapIndex deletes the key from the map.
+func (v Value) SetMapIndex(key, val Value) {
+ v.panicIfNot(Map).(*mapValue).SetElem(key, val)
+}
+
+// SetUint sets v's underlying value to x.
+// It panics if v's Kind is not a sized or unsized Uint kind, or if CanSet() is false.
+func (v Value) SetUint(x uint64) {
+ v.panicIfNots(uintKinds).(*uintValue).Set(x)
+}
+
+// SetPointer sets the unsafe.Pointer value v to x.
+// It panics if v's Kind is not UnsafePointer.
+func (v Value) SetPointer(x unsafe.Pointer) {
+ v.panicIfNot(UnsafePointer).(*unsafePointerValue).Set(x)
+}
+
+// SetString sets v's underlying value to x.
+// It panics if v's Kind is not String or if CanSet() is false.
+func (v Value) SetString(x string) {
+ v.panicIfNot(String).(*stringValue).Set(x)
+}
+
+// BUG(rsc): Value.Slice should allow slicing arrays.
+
+// Slice returns a slice of v.
+// It panics if v's Kind is not Slice.
+func (v Value) Slice(beg, end int) Value {
+ return v.panicIfNot(Slice).(*sliceValue).Slice(beg, end)
+}
+
+// String returns the string v's underlying value, as a string.
+// String is a special case because of Go's String method convention.
+// Unlike the other getters, it does not panic if v's Kind is not String.
+// Instead, it returns a string of the form "<T value>" where T is v's type.
+func (v Value) String() string {
+ vi := v.Internal
+ if vi == nil {
+ return "<invalid Value>"
+ }
+ if vi.Kind() == String {
+ return vi.(*stringValue).Get()
+ }
+ return "<" + vi.Type().String() + " Value>"
+}
+
+// TryRecv attempts to receive a value from the channel v but will not block.
+// It panics if v's Kind is not Chan.
+// If the receive cannot finish without blocking, x is the zero Value.
+// The boolean ok is true if the value x corresponds to a send
+// on the channel, false if it is a zero value received because the channel is closed.
+func (v Value) TryRecv() (x Value, ok bool) {
+ return v.panicIfNot(Chan).(*chanValue).TryRecv()
+}
+
+// TrySend attempts to send x on the channel v but will not block.
+// It panics if v's Kind is not Chan.
+// It returns true if the value was sent, false otherwise.
+func (v Value) TrySend(x Value) bool {
+ return v.panicIfNot(Chan).(*chanValue).TrySend(x)
+}
+
+// Type returns v's type.
+func (v Value) Type() Type {
+ return v.internal().Type()
+}
+
+var uintKinds = []Kind{Uint, Uint8, Uint16, Uint32, Uint64, Uintptr}
+
+// Uint returns v's underlying value, as a uint64.
+// It panics if v's Kind is not a sized or unsized Uint kind.
+func (v Value) Uint() uint64 {
+ return v.panicIfNots(uintKinds).(*uintValue).Get()
+}
+
+// UnsafeAddr returns a pointer to v's data.
+// It is for advanced clients that also import the "unsafe" package.
+func (v Value) UnsafeAddr() uintptr {
+ return v.internal().UnsafeAddr()
+}
+
+// valueInterface is the common interface to reflection values.
+// The implementations of Value (e.g., arrayValue, structValue)
// have additional type-specific methods.
-type Value interface {
+type valueInterface interface {
// Type returns the value's type.
Type() Type
@@ -64,7 +536,7 @@
// Such values are called addressable. A value is addressable if it is
// an element of a slice, an element of an addressable array,
// a field of an addressable struct, the result of dereferencing a pointer,
- // or the result of a call to NewValue, MakeChan, MakeMap, or MakeZero.
+ // or the result of a call to NewValue, MakeChan, MakeMap, or Zero.
// If CanAddr returns false, calling Addr will panic.
CanAddr() bool
@@ -72,17 +544,19 @@
// If the value is not addressable, Addr panics.
// Addr is typically used to obtain a pointer to a struct field or slice element
// in order to call a method that requires a pointer receiver.
- Addr() *PtrValue
+ Addr() Value
// UnsafeAddr returns a pointer to the underlying data.
// It is for advanced clients that also import the "unsafe" package.
UnsafeAddr() uintptr
- // Method returns a FuncValue corresponding to the value's i'th method.
- // The arguments to a Call on the returned FuncValue
- // should not include a receiver; the FuncValue will use
+ // Method returns a funcValue corresponding to the value's i'th method.
+ // The arguments to a Call on the returned funcValue
+ // should not include a receiver; the funcValue will use
// the value as the receiver.
- Method(i int) *FuncValue
+ Method(i int) Value
+
+ Kind() Kind
getAddr() addr
}
@@ -97,7 +571,7 @@
// value is the common implementation of most values.
// It is embedded in other, public struct types, but always
// with a unique tag like "uint" or "float" so that the client cannot
-// convert from, say, *UintValue to *FloatValue.
+// convert from, say, *uintValue to *floatValue.
type value struct {
typ Type
addr addr
@@ -106,7 +580,9 @@
func (v *value) Type() Type { return v.typ }
-func (v *value) Addr() *PtrValue {
+func (v *value) Kind() Kind { return v.typ.Kind() }
+
+func (v *value) Addr() Value {
if !v.CanAddr() {
panic("reflect: cannot take address of value")
}
@@ -119,7 +595,7 @@
// the caller would get the address of a -
// but it doesn't match the Go model.
// The language doesn't let you say &&v.
- return newValue(PtrTo(v.typ), addr(&a), flag).(*PtrValue)
+ return newValue(PtrTo(v.typ), addr(&a), flag)
}
func (v *value) UnsafeAddr() uintptr { return uintptr(v.addr) }
@@ -127,7 +603,8 @@
func (v *value) getAddr() addr { return v.addr }
func (v *value) Interface() interface{} {
- if typ, ok := v.typ.(*InterfaceType); ok {
+ typ := v.typ
+ if typ.Kind() == Interface {
// There are two different representations of interface values,
// one if the interface type has methods and one if it doesn't.
// These two representations require different expressions
@@ -153,16 +630,16 @@
* basic types
*/
-// BoolValue represents a bool value.
-type BoolValue struct {
+// boolValue represents a bool value.
+type boolValue struct {
value "bool"
}
// Get returns the underlying bool value.
-func (v *BoolValue) Get() bool { return *(*bool)(v.addr) }
+func (v *boolValue) Get() bool { return *(*bool)(v.addr) }
// Set sets v to the value x.
-func (v *BoolValue) Set(x bool) {
+func (v *boolValue) Set(x bool) {
if !v.CanSet() {
panic(cannotSet)
}
@@ -170,15 +647,15 @@
}
// Set sets v to the value x.
-func (v *BoolValue) SetValue(x Value) { v.Set(x.(*BoolValue).Get()) }
+func (v *boolValue) SetValue(x Value) { v.Set(x.Bool()) }
-// FloatValue represents a float value.
-type FloatValue struct {
+// floatValue represents a float value.
+type floatValue struct {
value "float"
}
// Get returns the underlying int value.
-func (v *FloatValue) Get() float64 {
+func (v *floatValue) Get() float64 {
switch v.typ.Kind() {
case Float32:
return float64(*(*float32)(v.addr))
@@ -189,7 +666,7 @@
}
// Set sets v to the value x.
-func (v *FloatValue) Set(x float64) {
+func (v *floatValue) Set(x float64) {
if !v.CanSet() {
panic(cannotSet)
}
@@ -204,7 +681,7 @@
}
// Overflow returns true if x cannot be represented by the type of v.
-func (v *FloatValue) Overflow(x float64) bool {
+func (v *floatValue) Overflow(x float64) bool {
if v.typ.Size() == 8 {
return false
}
@@ -215,15 +692,15 @@
}
// Set sets v to the value x.
-func (v *FloatValue) SetValue(x Value) { v.Set(x.(*FloatValue).Get()) }
+func (v *floatValue) SetValue(x Value) { v.Set(x.Float()) }
-// ComplexValue represents a complex value.
-type ComplexValue struct {
+// complexValue represents a complex value.
+type complexValue struct {
value "complex"
}
// Get returns the underlying complex value.
-func (v *ComplexValue) Get() complex128 {
+func (v *complexValue) Get() complex128 {
switch v.typ.Kind() {
case Complex64:
return complex128(*(*complex64)(v.addr))
@@ -234,7 +711,7 @@
}
// Set sets v to the value x.
-func (v *ComplexValue) Set(x complex128) {
+func (v *complexValue) Set(x complex128) {
if !v.CanSet() {
panic(cannotSet)
}
@@ -248,16 +725,33 @@
}
}
+// How did we forget this one?
+func (v *complexValue) Overflow(x complex128) bool {
+ if v.typ.Size() == 16 {
+ return false
+ }
+ r := real(x)
+ i := imag(x)
+ if r < 0 {
+ r = -r
+ }
+ if i < 0 {
+ i = -i
+ }
+ return math.MaxFloat32 <= r && r <= math.MaxFloat64 ||
+ math.MaxFloat32 <= i && i <= math.MaxFloat64
+}
+
// Set sets v to the value x.
-func (v *ComplexValue) SetValue(x Value) { v.Set(x.(*ComplexValue).Get()) }
+func (v *complexValue) SetValue(x Value) { v.Set(x.Complex()) }
-// IntValue represents an int value.
-type IntValue struct {
+// intValue represents an int value.
+type intValue struct {
value "int"
}
// Get returns the underlying int value.
-func (v *IntValue) Get() int64 {
+func (v *intValue) Get() int64 {
switch v.typ.Kind() {
case Int:
return int64(*(*int)(v.addr))
@@ -274,7 +768,7 @@
}
// Set sets v to the value x.
-func (v *IntValue) Set(x int64) {
+func (v *intValue) Set(x int64) {
if !v.CanSet() {
panic(cannotSet)
}
@@ -295,10 +789,10 @@
}
// Set sets v to the value x.
-func (v *IntValue) SetValue(x Value) { v.Set(x.(*IntValue).Get()) }
+func (v *intValue) SetValue(x Value) { v.Set(x.Int()) }
// Overflow returns true if x cannot be represented by the type of v.
-func (v *IntValue) Overflow(x int64) bool {
+func (v *intValue) Overflow(x int64) bool {
bitSize := uint(v.typ.Bits())
trunc := (x << (64 - bitSize)) >> (64 - bitSize)
return x != trunc
@@ -310,16 +804,16 @@
Len int
}
-// StringValue represents a string value.
-type StringValue struct {
+// stringValue represents a string value.
+type stringValue struct {
value "string"
}
// Get returns the underlying string value.
-func (v *StringValue) Get() string { return *(*string)(v.addr) }
+func (v *stringValue) Get() string { return *(*string)(v.addr) }
// Set sets v to the value x.
-func (v *StringValue) Set(x string) {
+func (v *stringValue) Set(x string) {
if !v.CanSet() {
panic(cannotSet)
}
@@ -327,15 +821,18 @@
}
// Set sets v to the value x.
-func (v *StringValue) SetValue(x Value) { v.Set(x.(*StringValue).Get()) }
+func (v *stringValue) SetValue(x Value) {
+ // Do the kind check explicitly, because x.String() does not.
+ v.Set(x.panicIfNot(String).(*stringValue).Get())
+}
-// UintValue represents a uint value.
-type UintValue struct {
+// uintValue represents a uint value.
+type uintValue struct {
value "uint"
}
// Get returns the underlying uuint value.
-func (v *UintValue) Get() uint64 {
+func (v *uintValue) Get() uint64 {
switch v.typ.Kind() {
case Uint:
return uint64(*(*uint)(v.addr))
@@ -354,7 +851,7 @@
}
// Set sets v to the value x.
-func (v *UintValue) Set(x uint64) {
+func (v *uintValue) Set(x uint64) {
if !v.CanSet() {
panic(cannotSet)
}
@@ -377,17 +874,17 @@
}
// Overflow returns true if x cannot be represented by the type of v.
-func (v *UintValue) Overflow(x uint64) bool {
+func (v *uintValue) Overflow(x uint64) bool {
bitSize := uint(v.typ.Bits())
trunc := (x << (64 - bitSize)) >> (64 - bitSize)
return x != trunc
}
// Set sets v to the value x.
-func (v *UintValue) SetValue(x Value) { v.Set(x.(*UintValue).Get()) }
+func (v *uintValue) SetValue(x Value) { v.Set(x.Uint()) }
-// UnsafePointerValue represents an unsafe.Pointer value.
-type UnsafePointerValue struct {
+// unsafePointerValue represents an unsafe.Pointer value.
+type unsafePointerValue struct {
value "unsafe.Pointer"
}
@@ -395,10 +892,10 @@
// Get returns uintptr, not unsafe.Pointer, so that
// programs that do not import "unsafe" cannot
// obtain a value of unsafe.Pointer type from "reflect".
-func (v *UnsafePointerValue) Get() uintptr { return uintptr(*(*unsafe.Pointer)(v.addr)) }
+func (v *unsafePointerValue) Get() uintptr { return uintptr(*(*unsafe.Pointer)(v.addr)) }
// Set sets v to the value x.
-func (v *UnsafePointerValue) Set(x unsafe.Pointer) {
+func (v *unsafePointerValue) Set(x unsafe.Pointer) {
if !v.CanSet() {
panic(cannotSet)
}
@@ -406,8 +903,10 @@
}
// Set sets v to the value x.
-func (v *UnsafePointerValue) SetValue(x Value) {
- v.Set(unsafe.Pointer(x.(*UnsafePointerValue).Get()))
+func (v *unsafePointerValue) SetValue(x Value) {
+ // Do the kind check explicitly, because x.UnsafePointer
+ // applies to more than just the UnsafePointer Kind.
+ v.Set(unsafe.Pointer(x.panicIfNot(UnsafePointer).(*unsafePointerValue).Get()))
}
func typesMustMatch(t1, t2 Type) {
@@ -421,9 +920,9 @@
*/
// ArrayOrSliceValue is the common interface
-// implemented by both ArrayValue and SliceValue.
-type ArrayOrSliceValue interface {
- Value
+// implemented by both arrayValue and sliceValue.
+type arrayOrSliceValue interface {
+ valueInterface
Len() int
Cap() int
Elem(i int) Value
@@ -432,7 +931,7 @@
// grow grows the slice s so that it can hold extra more values, allocating
// more capacity if needed. It also returns the old and new slice lengths.
-func grow(s *SliceValue, extra int) (*SliceValue, int, int) {
+func grow(s Value, extra int) (Value, int, int) {
i0 := s.Len()
i1 := i0 + extra
if i1 < i0 {
@@ -453,24 +952,25 @@
}
}
}
- t := MakeSlice(s.Type().(*SliceType), i1, m)
+ t := MakeSlice(s.Type(), i1, m)
Copy(t, s)
return t, i0, i1
}
// Append appends the values x to a slice s and returns the resulting slice.
// Each x must have the same type as s' element type.
-func Append(s *SliceValue, x ...Value) *SliceValue {
+func Append(s Value, x ...Value) Value {
s, i0, i1 := grow(s, len(x))
+ sa := s.panicIfNot(Slice).(*sliceValue)
for i, j := i0, 0; i < i1; i, j = i+1, j+1 {
- s.Elem(i).SetValue(x[j])
+ sa.Elem(i).Set(x[j])
}
return s
}
// AppendSlice appends a slice t to a slice s and returns the resulting slice.
// The slices s and t must have the same element type.
-func AppendSlice(s, t *SliceValue) *SliceValue {
+func AppendSlice(s, t Value) Value {
s, i0, i1 := grow(s, t.Len())
Copy(s.Slice(i0, i1), t)
return s
@@ -479,51 +979,56 @@
// Copy copies the contents of src into dst until either
// dst has been filled or src has been exhausted.
// It returns the number of elements copied.
-// The arrays dst and src must have the same element type.
-func Copy(dst, src ArrayOrSliceValue) int {
+// Dst and src each must be a slice or array, and they
+// must have the same element type.
+func Copy(dst, src Value) int {
// TODO: This will have to move into the runtime
// once the real gc goes in.
- de := dst.Type().(ArrayOrSliceType).Elem()
- se := src.Type().(ArrayOrSliceType).Elem()
+ de := dst.Type().Elem()
+ se := src.Type().Elem()
typesMustMatch(de, se)
n := dst.Len()
if xn := src.Len(); n > xn {
n = xn
}
- memmove(dst.addr(), src.addr(), uintptr(n)*de.Size())
+ memmove(dst.panicIfNots(arrayOrSlice).(arrayOrSliceValue).addr(),
+ src.panicIfNots(arrayOrSlice).(arrayOrSliceValue).addr(),
+ uintptr(n)*de.Size())
return n
}
-// An ArrayValue represents an array.
-type ArrayValue struct {
+// An arrayValue represents an array.
+type arrayValue struct {
value "array"
}
// Len returns the length of the array.
-func (v *ArrayValue) Len() int { return v.typ.(*ArrayType).Len() }
+func (v *arrayValue) Len() int { return v.typ.Len() }
// Cap returns the capacity of the array (equal to Len()).
-func (v *ArrayValue) Cap() int { return v.typ.(*ArrayType).Len() }
+func (v *arrayValue) Cap() int { return v.typ.Len() }
// addr returns the base address of the data in the array.
-func (v *ArrayValue) addr() addr { return v.value.addr }
+func (v *arrayValue) addr() addr { return v.value.addr }
// Set assigns x to v.
// The new value x must have the same type as v.
-func (v *ArrayValue) Set(x *ArrayValue) {
+func (v *arrayValue) Set(x *arrayValue) {
if !v.CanSet() {
panic(cannotSet)
}
typesMustMatch(v.typ, x.typ)
- Copy(v, x)
+ Copy(Value{v}, Value{x})
}
// Set sets v to the value x.
-func (v *ArrayValue) SetValue(x Value) { v.Set(x.(*ArrayValue)) }
+func (v *arrayValue) SetValue(x Value) {
+ v.Set(x.panicIfNot(Array).(*arrayValue))
+}
// Elem returns the i'th element of v.
-func (v *ArrayValue) Elem(i int) Value {
- typ := v.typ.(*ArrayType).Elem()
+func (v *arrayValue) Elem(i int) Value {
+ typ := v.typ.Elem()
n := v.Len()
if i < 0 || i >= n {
panic("array index out of bounds")
@@ -543,28 +1048,28 @@
Cap int
}
-// A SliceValue represents a slice.
-type SliceValue struct {
+// A sliceValue represents a slice.
+type sliceValue struct {
value "slice"
}
-func (v *SliceValue) slice() *SliceHeader { return (*SliceHeader)(v.value.addr) }
+func (v *sliceValue) slice() *SliceHeader { return (*SliceHeader)(v.value.addr) }
// IsNil returns whether v is a nil slice.
-func (v *SliceValue) IsNil() bool { return v.slice().Data == 0 }
+func (v *sliceValue) IsNil() bool { return v.slice().Data == 0 }
// Len returns the length of the slice.
-func (v *SliceValue) Len() int { return int(v.slice().Len) }
+func (v *sliceValue) Len() int { return int(v.slice().Len) }
// Cap returns the capacity of the slice.
-func (v *SliceValue) Cap() int { return int(v.slice().Cap) }
+func (v *sliceValue) Cap() int { return int(v.slice().Cap) }
// addr returns the base address of the data in the slice.
-func (v *SliceValue) addr() addr { return addr(v.slice().Data) }
+func (v *sliceValue) addr() addr { return addr(v.slice().Data) }
// SetLen changes the length of v.
// The new length n must be between 0 and the capacity, inclusive.
-func (v *SliceValue) SetLen(n int) {
+func (v *sliceValue) SetLen(n int) {
s := v.slice()
if n < 0 || n > int(s.Cap) {
panic("reflect: slice length out of range in SetLen")
@@ -574,7 +1079,7 @@
// Set assigns x to v.
// The new value x must have the same type as v.
-func (v *SliceValue) Set(x *SliceValue) {
+func (v *sliceValue) Set(x *sliceValue) {
if !v.CanSet() {
panic(cannotSet)
}
@@ -583,23 +1088,25 @@
}
// Set sets v to the value x.
-func (v *SliceValue) SetValue(x Value) { v.Set(x.(*SliceValue)) }
+func (v *sliceValue) SetValue(x Value) {
+ v.Set(x.panicIfNot(Slice).(*sliceValue))
+}
// Get returns the uintptr address of the v.Cap()'th element. This gives
// the same result for all slices of the same array.
// It is mainly useful for printing.
-func (v *SliceValue) Get() uintptr {
- typ := v.typ.(*SliceType)
+func (v *sliceValue) Get() uintptr {
+ typ := v.typ
return uintptr(v.addr()) + uintptr(v.Cap())*typ.Elem().Size()
}
// Slice returns a sub-slice of the slice v.
-func (v *SliceValue) Slice(beg, end int) *SliceValue {
+func (v *sliceValue) Slice(beg, end int) Value {
cap := v.Cap()
if beg < 0 || end < beg || end > cap {
panic("slice index out of bounds")
}
- typ := v.typ.(*SliceType)
+ typ := v.typ
s := new(SliceHeader)
s.Data = uintptr(v.addr()) + uintptr(beg)*typ.Elem().Size()
s.Len = end - beg
@@ -611,12 +1118,12 @@
if v.flag&canStore != 0 {
flag |= canStore
}
- return newValue(typ, addr(s), flag).(*SliceValue)
+ return newValue(typ, addr(s), flag)
}
// Elem returns the i'th element of v.
-func (v *SliceValue) Elem(i int) Value {
- typ := v.typ.(*SliceType).Elem()
+func (v *sliceValue) Elem(i int) Value {
+ typ := v.typ.Elem()
n := v.Len()
if i < 0 || i >= n {
panic("reflect: slice index out of range")
@@ -631,30 +1138,33 @@
// MakeSlice creates a new zero-initialized slice value
// for the specified slice type, length, and capacity.
-func MakeSlice(typ *SliceType, len, cap int) *SliceValue {
+func MakeSlice(typ Type, len, cap int) Value {
+ if typ.Kind() != Slice {
+ panic("reflect: MakeSlice of non-slice type")
+ }
s := &SliceHeader{
Data: uintptr(unsafe.NewArray(typ.Elem(), cap)),
Len: len,
Cap: cap,
}
- return newValue(typ, addr(s), canAddr|canSet|canStore).(*SliceValue)
+ return newValue(typ, addr(s), canAddr|canSet|canStore)
}
/*
* chan
*/
-// A ChanValue represents a chan.
-type ChanValue struct {
+// A chanValue represents a chan.
+type chanValue struct {
value "chan"
}
// IsNil returns whether v is a nil channel.
-func (v *ChanValue) IsNil() bool { return *(*uintptr)(v.addr) == 0 }
+func (v *chanValue) IsNil() bool { return *(*uintptr)(v.addr) == 0 }
// Set assigns x to v.
// The new value x must have the same type as v.
-func (v *ChanValue) Set(x *ChanValue) {
+func (v *chanValue) Set(x *chanValue) {
if !v.CanSet() {
panic(cannotSet)
}
@@ -663,11 +1173,13 @@
}
// Set sets v to the value x.
-func (v *ChanValue) SetValue(x Value) { v.Set(x.(*ChanValue)) }
+func (v *chanValue) SetValue(x Value) {
+ v.Set(x.panicIfNot(Chan).(*chanValue))
+}
// Get returns the uintptr value of v.
// It is mainly useful for printing.
-func (v *ChanValue) Get() uintptr { return *(*uintptr)(v.addr) }
+func (v *chanValue) Get() uintptr { return *(*uintptr)(v.addr) }
// implemented in ../pkg/runtime/reflect.cgo
func makechan(typ *runtime.ChanType, size uint32) (ch *byte)
@@ -678,59 +1190,59 @@
func chancap(ch *byte) int32
// Close closes the channel.
-func (v *ChanValue) Close() {
+func (v *chanValue) Close() {
ch := *(**byte)(v.addr)
chanclose(ch)
}
-func (v *ChanValue) Len() int {
+func (v *chanValue) Len() int {
ch := *(**byte)(v.addr)
return int(chanlen(ch))
}
-func (v *ChanValue) Cap() int {
+func (v *chanValue) Cap() int {
ch := *(**byte)(v.addr)
return int(chancap(ch))
}
// internal send; non-blocking if selected != nil
-func (v *ChanValue) send(x Value, selected *bool) {
- t := v.Type().(*ChanType)
- if t.Dir()&SendDir == 0 {
+func (v *chanValue) send(x Value, selected *bool) {
+ t := v.Type()
+ if t.ChanDir()&SendDir == 0 {
panic("send on recv-only channel")
}
typesMustMatch(t.Elem(), x.Type())
ch := *(**byte)(v.addr)
- chansend(ch, (*byte)(x.getAddr()), selected)
+ chansend(ch, (*byte)(x.internal().getAddr()), selected)
}
// internal recv; non-blocking if selected != nil
-func (v *ChanValue) recv(selected *bool) (Value, bool) {
- t := v.Type().(*ChanType)
- if t.Dir()&RecvDir == 0 {
+func (v *chanValue) recv(selected *bool) (Value, bool) {
+ t := v.Type()
+ if t.ChanDir()&RecvDir == 0 {
panic("recv on send-only channel")
}
ch := *(**byte)(v.addr)
- x := MakeZero(t.Elem())
+ x := Zero(t.Elem())
var ok bool
- chanrecv(ch, (*byte)(x.getAddr()), selected, &ok)
+ chanrecv(ch, (*byte)(x.internal().getAddr()), selected, &ok)
return x, ok
}
// Send sends x on the channel v.
-func (v *ChanValue) Send(x Value) { v.send(x, nil) }
+func (v *chanValue) Send(x Value) { v.send(x, nil) }
// Recv receives and returns a value from the channel v.
// The receive blocks until a value is ready.
// The boolean value ok is true if the value x corresponds to a send
// on the channel, false if it is a zero value received because the channel is closed.
-func (v *ChanValue) Recv() (x Value, ok bool) {
+func (v *chanValue) Recv() (x Value, ok bool) {
return v.recv(nil)
}
// TrySend attempts to sends x on the channel v but will not block.
// It returns true if the value was sent, false otherwise.
-func (v *ChanValue) TrySend(x Value) bool {
+func (v *chanValue) TrySend(x Value) bool {
var selected bool
v.send(x, &selected)
return selected
@@ -741,25 +1253,29 @@
// If the receive can finish without blocking, TryRecv returns x != nil.
// The boolean value ok is true if the value x corresponds to a send
// on the channel, false if it is a zero value received because the channel is closed.
-func (v *ChanValue) TryRecv() (x Value, ok bool) {
+func (v *chanValue) TryRecv() (x Value, ok bool) {
var selected bool
x, ok = v.recv(&selected)
if !selected {
- return nil, false
+ return Value{}, false
}
return x, ok
}
// MakeChan creates a new channel with the specified type and buffer size.
-func MakeChan(typ *ChanType, buffer int) *ChanValue {
+func MakeChan(typ Type, buffer int) Value {
+ if typ.Kind() != Chan {
+ panic("reflect: MakeChan of non-chan type")
+ }
if buffer < 0 {
panic("MakeChan: negative buffer size")
}
- if typ.Dir() != BothDir {
+ if typ.ChanDir() != BothDir {
panic("MakeChan: unidirectional channel type")
}
- v := MakeZero(typ).(*ChanValue)
- *(**byte)(v.addr) = makechan((*runtime.ChanType)(unsafe.Pointer(typ)), uint32(buffer))
+ v := Zero(typ)
+ ch := v.panicIfNot(Chan).(*chanValue)
+ *(**byte)(ch.addr) = makechan((*runtime.ChanType)(unsafe.Pointer(typ.(*commonType))), uint32(buffer))
return v
}
@@ -767,23 +1283,23 @@
* func
*/
-// A FuncValue represents a function value.
-type FuncValue struct {
+// A funcValue represents a function value.
+type funcValue struct {
value "func"
first *value
isInterface bool
}
// IsNil returns whether v is a nil function.
-func (v *FuncValue) IsNil() bool { return *(*uintptr)(v.addr) == 0 }
+func (v *funcValue) IsNil() bool { return *(*uintptr)(v.addr) == 0 }
// Get returns the uintptr value of v.
// It is mainly useful for printing.
-func (v *FuncValue) Get() uintptr { return *(*uintptr)(v.addr) }
+func (v *funcValue) Get() uintptr { return *(*uintptr)(v.addr) }
// Set assigns x to v.
// The new value x must have the same type as v.
-func (v *FuncValue) Set(x *FuncValue) {
+func (v *funcValue) Set(x *funcValue) {
if !v.CanSet() {
panic(cannotSet)
}
@@ -792,21 +1308,23 @@
}
// Set sets v to the value x.
-func (v *FuncValue) SetValue(x Value) { v.Set(x.(*FuncValue)) }
+func (v *funcValue) SetValue(x Value) {
+ v.Set(x.panicIfNot(Func).(*funcValue))
+}
-// Method returns a FuncValue corresponding to v's i'th method.
-// The arguments to a Call on the returned FuncValue
-// should not include a receiver; the FuncValue will use v
+// Method returns a funcValue corresponding to v's i'th method.
+// The arguments to a Call on the returned funcValue
+// should not include a receiver; the funcValue will use v
// as the receiver.
-func (v *value) Method(i int) *FuncValue {
+func (v *value) Method(i int) Value {
t := v.Type().uncommon()
if t == nil || i < 0 || i >= len(t.methods) {
- return nil
+ panic("reflect: Method index out of range")
}
p := &t.methods[i]
fn := p.tfn
- fv := &FuncValue{value: value{toType(*p.typ), addr(&fn), 0}, first: v, isInterface: false}
- return fv
+ fv := &funcValue{value: value{toType(p.typ), addr(&fn), 0}, first: v, isInterface: false}
+ return Value{fv}
}
// implemented in ../pkg/runtime/*/asm.s
@@ -820,23 +1338,23 @@
// If fv is a method obtained by invoking Value.Method
// (as opposed to Type.Method), Interface cannot return an
// interface value, so it panics.
-func (fv *FuncValue) Interface() interface{} {
+func (fv *funcValue) Interface() interface{} {
if fv.first != nil {
- panic("FuncValue: cannot create interface value for method with bound receiver")
+ panic("funcValue: cannot create interface value for method with bound receiver")
}
return fv.value.Interface()
}
// Call calls the function fv with input parameters in.
// It returns the function's output parameters as Values.
-func (fv *FuncValue) Call(in []Value) []Value {
- t := fv.Type().(*FuncType)
+func (fv *funcValue) Call(in []Value) []Value {
+ t := fv.Type()
nin := len(in)
if fv.first != nil && !fv.isInterface {
nin++
}
if nin != t.NumIn() {
- panic("FuncValue: wrong argument count")
+ panic("funcValue: wrong argument count")
}
nout := t.NumOut()
@@ -906,7 +1424,7 @@
a := uintptr(tv.Align())
off = (off + a - 1) &^ (a - 1)
n := tv.Size()
- memmove(addr(ptr+off), v.getAddr(), n)
+ memmove(addr(ptr+off), v.internal().getAddr(), n)
off += n
}
off = (off + ptrSize - 1) &^ (ptrSize - 1)
@@ -922,9 +1440,9 @@
tv := t.Out(i)
a := uintptr(tv.Align())
off = (off + a - 1) &^ (a - 1)
- v := MakeZero(tv)
+ v := Zero(tv)
n := tv.Size()
- memmove(v.getAddr(), addr(ptr+off), n)
+ memmove(v.internal().getAddr(), addr(ptr+off), n)
ret[i] = v
off += n
}
@@ -936,40 +1454,37 @@
* interface
*/
-// An InterfaceValue represents an interface value.
-type InterfaceValue struct {
+// An interfaceValue represents an interface value.
+type interfaceValue struct {
value "interface"
}
// IsNil returns whether v is a nil interface value.
-func (v *InterfaceValue) IsNil() bool { return v.Interface() == nil }
+func (v *interfaceValue) IsNil() bool { return v.Interface() == nil }
// No single uinptr Get because v.Interface() is available.
// Get returns the two words that represent an interface in the runtime.
// Those words are useful only when playing unsafe games.
-func (v *InterfaceValue) Get() [2]uintptr {
+func (v *interfaceValue) Get() [2]uintptr {
return *(*[2]uintptr)(v.addr)
}
// Elem returns the concrete value stored in the interface value v.
-func (v *InterfaceValue) Elem() Value { return NewValue(v.Interface()) }
+func (v *interfaceValue) Elem() Value { return NewValue(v.Interface()) }
// ../runtime/reflect.cgo
-func setiface(typ *InterfaceType, x *interface{}, addr addr)
+func setiface(typ *interfaceType, x *interface{}, addr addr)
// Set assigns x to v.
-func (v *InterfaceValue) Set(x Value) {
- var i interface{}
- if x != nil {
- i = x.Interface()
- }
+func (v *interfaceValue) Set(x Value) {
+ i := x.Interface()
if !v.CanSet() {
panic(cannotSet)
}
// Two different representations; see comment in Get.
// Empty interface is easy.
- t := v.typ.(*InterfaceType)
+ t := (*interfaceType)(unsafe.Pointer(v.typ.(*commonType)))
if t.NumMethod() == 0 {
*(*interface{})(v.addr) = i
return
@@ -980,16 +1495,16 @@
}
// Set sets v to the value x.
-func (v *InterfaceValue) SetValue(x Value) { v.Set(x) }
+func (v *interfaceValue) SetValue(x Value) { v.Set(x) }
-// Method returns a FuncValue corresponding to v's i'th method.
-// The arguments to a Call on the returned FuncValue
-// should not include a receiver; the FuncValue will use v
+// Method returns a funcValue corresponding to v's i'th method.
+// The arguments to a Call on the returned funcValue
+// should not include a receiver; the funcValue will use v
// as the receiver.
-func (v *InterfaceValue) Method(i int) *FuncValue {
- t := v.Type().(*InterfaceType)
+func (v *interfaceValue) Method(i int) Value {
+ t := (*interfaceType)(unsafe.Pointer(v.Type().(*commonType)))
if t == nil || i < 0 || i >= len(t.methods) {
- return nil
+ panic("reflect: Method index out of range")
}
p := &t.methods[i]
@@ -999,25 +1514,25 @@
// Function pointer is at p.perm in the table.
fn := tab.Fn[i]
- fv := &FuncValue{value: value{toType(*p.typ), addr(&fn), 0}, first: data, isInterface: true}
- return fv
+ fv := &funcValue{value: value{toType(p.typ), addr(&fn), 0}, first: data, isInterface: true}
+ return Value{fv}
}
/*
* map
*/
-// A MapValue represents a map value.
-type MapValue struct {
+// A mapValue represents a map value.
+type mapValue struct {
value "map"
}
// IsNil returns whether v is a nil map value.
-func (v *MapValue) IsNil() bool { return *(*uintptr)(v.addr) == 0 }
+func (v *mapValue) IsNil() bool { return *(*uintptr)(v.addr) == 0 }
// Set assigns x to v.
// The new value x must have the same type as v.
-func (v *MapValue) Set(x *MapValue) {
+func (v *mapValue) Set(x *mapValue) {
if !v.CanSet() {
panic(cannotSet)
}
@@ -1030,17 +1545,13 @@
}
// Set sets v to the value x.
-func (v *MapValue) SetValue(x Value) {
- if x == nil {
- v.Set(nil)
- return
- }
- v.Set(x.(*MapValue))
+func (v *mapValue) SetValue(x Value) {
+ v.Set(x.panicIfNot(Map).(*mapValue))
}
// Get returns the uintptr value of v.
// It is mainly useful for printing.
-func (v *MapValue) Get() uintptr { return *(*uintptr)(v.addr) }
+func (v *mapValue) Get() uintptr { return *(*uintptr)(v.addr) }
// implemented in ../pkg/runtime/reflect.cgo
func mapaccess(m, key, val *byte) bool
@@ -1053,36 +1564,36 @@
// Elem returns the value associated with key in the map v.
// It returns nil if key is not found in the map.
-func (v *MapValue) Elem(key Value) Value {
- t := v.Type().(*MapType)
+func (v *mapValue) Elem(key Value) Value {
+ t := v.Type()
typesMustMatch(t.Key(), key.Type())
m := *(**byte)(v.addr)
if m == nil {
- return nil
+ return Value{}
}
- newval := MakeZero(t.Elem())
- if !mapaccess(m, (*byte)(key.getAddr()), (*byte)(newval.getAddr())) {
- return nil
+ newval := Zero(t.Elem())
+ if !mapaccess(m, (*byte)(key.internal().getAddr()), (*byte)(newval.internal().getAddr())) {
+ return Value{}
}
return newval
}
// SetElem sets the value associated with key in the map v to val.
// If val is nil, Put deletes the key from map.
-func (v *MapValue) SetElem(key, val Value) {
- t := v.Type().(*MapType)
+func (v *mapValue) SetElem(key, val Value) {
+ t := v.Type()
typesMustMatch(t.Key(), key.Type())
var vaddr *byte
- if val != nil {
+ if val.IsValid() {
typesMustMatch(t.Elem(), val.Type())
- vaddr = (*byte)(val.getAddr())
+ vaddr = (*byte)(val.internal().getAddr())
}
m := *(**byte)(v.addr)
- mapassign(m, (*byte)(key.getAddr()), vaddr)
+ mapassign(m, (*byte)(key.internal().getAddr()), vaddr)
}
// Len returns the number of keys in the map v.
-func (v *MapValue) Len() int {
+func (v *mapValue) Len() int {
m := *(**byte)(v.addr)
if m == nil {
return 0
@@ -1092,8 +1603,8 @@
// Keys returns a slice containing all the keys present in the map,
// in unspecified order.
-func (v *MapValue) Keys() []Value {
- tk := v.Type().(*MapType).Key()
+func (v *mapValue) Keys() []Value {
+ tk := v.Type().Key()
m := *(**byte)(v.addr)
mlen := int32(0)
if m != nil {
@@ -1103,8 +1614,8 @@
a := make([]Value, mlen)
var i int
for i = 0; i < len(a); i++ {
- k := MakeZero(tk)
- if !mapiterkey(it, (*byte)(k.getAddr())) {
+ k := Zero(tk)
+ if !mapiterkey(it, (*byte)(k.internal().getAddr())) {
break
}
a[i] = k
@@ -1114,9 +1625,13 @@
}
// MakeMap creates a new map of the specified type.
-func MakeMap(typ *MapType) *MapValue {
- v := MakeZero(typ).(*MapValue)
- *(**byte)(v.addr) = makemap((*runtime.MapType)(unsafe.Pointer(typ)))
+func MakeMap(typ Type) Value {
+ if typ.Kind() != Map {
+ panic("reflect: MakeMap of non-map type")
+ }
+ v := Zero(typ)
+ m := v.panicIfNot(Map).(*mapValue)
+ *(**byte)(m.addr) = makemap((*runtime.MapType)(unsafe.Pointer(typ.(*commonType))))
return v
}
@@ -1124,21 +1639,21 @@
* ptr
*/
-// A PtrValue represents a pointer.
-type PtrValue struct {
+// A ptrValue represents a pointer.
+type ptrValue struct {
value "ptr"
}
// IsNil returns whether v is a nil pointer.
-func (v *PtrValue) IsNil() bool { return *(*uintptr)(v.addr) == 0 }
+func (v *ptrValue) IsNil() bool { return *(*uintptr)(v.addr) == 0 }
// Get returns the uintptr value of v.
// It is mainly useful for printing.
-func (v *PtrValue) Get() uintptr { return *(*uintptr)(v.addr) }
+func (v *ptrValue) Get() uintptr { return *(*uintptr)(v.addr) }
// Set assigns x to v.
// The new value x must have the same type as v, and x.Elem().CanSet() must be true.
-func (v *PtrValue) Set(x *PtrValue) {
+func (v *ptrValue) Set(x *ptrValue) {
if x == nil {
*(**uintptr)(v.addr) = nil
return
@@ -1156,25 +1671,21 @@
}
// Set sets v to the value x.
-func (v *PtrValue) SetValue(x Value) {
- if x == nil {
- v.Set(nil)
- return
- }
- v.Set(x.(*PtrValue))
+func (v *ptrValue) SetValue(x Value) {
+ v.Set(x.panicIfNot(Ptr).(*ptrValue))
}
// PointTo changes v to point to x.
// If x is a nil Value, PointTo sets v to nil.
-func (v *PtrValue) PointTo(x Value) {
- if x == nil {
+func (v *ptrValue) PointTo(x Value) {
+ if !x.IsValid() {
*(**uintptr)(v.addr) = nil
return
}
if !x.CanSet() {
panic("cannot set x; cannot point to x")
}
- typesMustMatch(v.typ.(*PtrType).Elem(), x.Type())
+ typesMustMatch(v.typ.Elem(), x.Type())
// TODO: This will have to move into the runtime
// once the new gc goes in.
*(*uintptr)(v.addr) = x.UnsafeAddr()
@@ -1182,39 +1693,39 @@
// Elem returns the value that v points to.
// If v is a nil pointer, Elem returns a nil Value.
-func (v *PtrValue) Elem() Value {
+func (v *ptrValue) Elem() Value {
if v.IsNil() {
- return nil
+ return Value{}
}
flag := canAddr
if v.flag&canStore != 0 {
flag |= canSet | canStore
}
- return newValue(v.typ.(*PtrType).Elem(), *(*addr)(v.addr), flag)
+ return newValue(v.typ.Elem(), *(*addr)(v.addr), flag)
}
// Indirect returns the value that v points to.
// If v is a nil pointer, Indirect returns a nil Value.
// If v is not a pointer, Indirect returns v.
func Indirect(v Value) Value {
- if pv, ok := v.(*PtrValue); ok {
- return pv.Elem()
+ if v.Kind() != Ptr {
+ return v
}
- return v
+ return v.panicIfNot(Ptr).(*ptrValue).Elem()
}
/*
* struct
*/
-// A StructValue represents a struct value.
-type StructValue struct {
+// A structValue represents a struct value.
+type structValue struct {
value "struct"
}
// Set assigns x to v.
// The new value x must have the same type as v.
-func (v *StructValue) Set(x *StructValue) {
+func (v *structValue) Set(x *structValue) {
// TODO: This will have to move into the runtime
// once the gc goes in.
if !v.CanSet() {
@@ -1225,13 +1736,15 @@
}
// Set sets v to the value x.
-func (v *StructValue) SetValue(x Value) { v.Set(x.(*StructValue)) }
+func (v *structValue) SetValue(x Value) {
+ v.Set(x.panicIfNot(Struct).(*structValue))
+}
// Field returns the i'th field of the struct.
-func (v *StructValue) Field(i int) Value {
- t := v.typ.(*StructType)
+func (v *structValue) Field(i int) Value {
+ t := v.typ
if i < 0 || i >= t.NumField() {
- return nil
+ panic("reflect: Field index out of range")
}
f := t.Field(i)
flag := v.flag
@@ -1243,102 +1756,102 @@
}
// FieldByIndex returns the nested field corresponding to index.
-func (t *StructValue) FieldByIndex(index []int) (v Value) {
- v = t
+func (t *structValue) FieldByIndex(index []int) (v Value) {
+ v = Value{t}
for i, x := range index {
if i > 0 {
- if p, ok := v.(*PtrValue); ok {
- v = p.Elem()
+ if v.Kind() == Ptr {
+ v = v.Elem()
}
- if s, ok := v.(*StructValue); ok {
- t = s
- } else {
- v = nil
- return
+ if v.Kind() != Struct {
+ return Value{}
}
}
- v = t.Field(x)
+ v = v.Field(x)
}
return
}
// FieldByName returns the struct field with the given name.
// The result is nil if no field was found.
-func (t *StructValue) FieldByName(name string) Value {
- if f, ok := t.Type().(*StructType).FieldByName(name); ok {
+func (t *structValue) FieldByName(name string) Value {
+ if f, ok := t.Type().FieldByName(name); ok {
return t.FieldByIndex(f.Index)
}
- return nil
+ return Value{}
}
// FieldByNameFunc returns the struct field with a name that satisfies the
// match function.
// The result is nil if no field was found.
-func (t *StructValue) FieldByNameFunc(match func(string) bool) Value {
- if f, ok := t.Type().(*StructType).FieldByNameFunc(match); ok {
+func (t *structValue) FieldByNameFunc(match func(string) bool) Value {
+ if f, ok := t.Type().FieldByNameFunc(match); ok {
return t.FieldByIndex(f.Index)
}
- return nil
+ return Value{}
}
// NumField returns the number of fields in the struct.
-func (v *StructValue) NumField() int { return v.typ.(*StructType).NumField() }
+func (v *structValue) NumField() int { return v.typ.NumField() }
/*
* constructors
*/
// NewValue returns a new Value initialized to the concrete value
-// stored in the interface i. NewValue(nil) returns nil.
+// stored in the interface i. NewValue(nil) returns the zero Value.
func NewValue(i interface{}) Value {
if i == nil {
- return nil
+ return Value{}
}
- t, a := unsafe.Reflect(i)
- return newValue(toType(t), addr(a), canSet|canAddr|canStore)
+ _, a := unsafe.Reflect(i)
+ return newValue(Typeof(i), addr(a), canSet|canAddr|canStore)
}
func newValue(typ Type, addr addr, flag uint32) Value {
v := value{typ, addr, flag}
- switch typ.(type) {
- case *ArrayType:
- return &ArrayValue{v}
- case *BoolType:
- return &BoolValue{v}
- case *ChanType:
- return &ChanValue{v}
- case *FloatType:
- return &FloatValue{v}
- case *FuncType:
- return &FuncValue{value: v}
- case *ComplexType:
- return &ComplexValue{v}
- case *IntType:
- return &IntValue{v}
- case *InterfaceType:
- return &InterfaceValue{v}
- case *MapType:
- return &MapValue{v}
- case *PtrType:
- return &PtrValue{v}
- case *SliceType:
- return &SliceValue{v}
- case *StringType:
- return &StringValue{v}
- case *StructType:
- return &StructValue{v}
- case *UintType:
- return &UintValue{v}
- case *UnsafePointerType:
- return &UnsafePointerValue{v}
+ switch typ.Kind() {
+ case Array:
+ return Value{&arrayValue{v}}
+ case Bool:
+ return Value{&boolValue{v}}
+ case Chan:
+ return Value{&chanValue{v}}
+ case Float32, Float64:
+ return Value{&floatValue{v}}
+ case Func:
+ return Value{&funcValue{value: v}}
+ case Complex64, Complex128:
+ return Value{&complexValue{v}}
+ case Int, Int8, Int16, Int32, Int64:
+ return Value{&intValue{v}}
+ case Interface:
+ return Value{&interfaceValue{v}}
+ case Map:
+ return Value{&mapValue{v}}
+ case Ptr:
+ return Value{&ptrValue{v}}
+ case Slice:
+ return Value{&sliceValue{v}}
+ case String:
+ return Value{&stringValue{v}}
+ case Struct:
+ return Value{&structValue{v}}
+ case Uint, Uint8, Uint16, Uint32, Uint64, Uintptr:
+ return Value{&uintValue{v}}
+ case UnsafePointer:
+ return Value{&unsafePointerValue{v}}
}
panic("newValue" + typ.String())
}
-// MakeZero returns a zero Value for the specified Type.
-func MakeZero(typ Type) Value {
+// Zero returns a Value representing a zero value for the specified type.
+// The result is different from the zero value of the Value struct,
+// which represents no value at all.
+// For example, Zero(Typeof(42)) returns a Value with Kind Int and value 0.
+func Zero(typ Type) Value {
if typ == nil {
- return nil
+ panic("reflect: Zero(nil)")
}
return newValue(typ, addr(unsafe.New(typ)), canSet|canAddr|canStore)
}
« no previous file with comments | « src/pkg/reflect/type.go ('k') | no next file » | no next file with comments »

Powered by Google App Engine
RSS Feeds Recent Issues | This issue
This is Rietveld f62528b