code review 224105: more on type complex.

src/pkg/reflect/value.go

 // Copyright 2009 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 reflect
 
 import (
         "runtime"
         "unsafe"
 )
@@ skipping 168 matching lines @@
 func (v *Float64Value) Set(x float64) {
         if !v.canSet {
                 panic(cannotSet)
         }
         *(*float64)(v.addr) = x
 }
 
 // Set sets v to the value x.
 func (v *Float64Value) SetValue(x Value) { v.Set(x.(*Float64Value).Get()) }
 
+//// ComplexValue represents a complex value.
+//type ComplexValue struct {
+//      value
+//}
+//
+//// Get returns the underlying complex value.
+//func (v *ComplexValue) Get() complex { return *(*complex)(v.addr) }
+//
+//// Set sets v to the value x.
+//func (v *ComplexValue) Set(x complex) {
+//      if !v.canSet {
+//              panic(cannotSet)
+//      }
+//      *(*complex)(v.addr) = x
+//}
+//
+//// Set sets v to the value x.
+//func (v *ComplexValue) SetValue(x Value) { v.Set(x.(*ComplexValue).Get()) }
+//
+//// Complex64Value represents a complex64 value.
+//type Complex64Value struct {
+//      value
+//}
+//
+//// Get returns the underlying complex64 value.
+//func (v *Complex64Value) Get() complex64 { return *(*complex64)(v.addr) }
+//
+//// Set sets v to the value x.
+//func (v *Complex64Value) Set(x complex64) {
+//      if !v.canSet {
+//              panic(cannotSet)
+//      }
+//      *(*complex64)(v.addr) = x
+//}
+//
+//// Set sets v to the value x.
+//func (v *Complex64Value) SetValue(x Value) { v.Set(x.(*Complex64Value).Get()) }
+//
+//// Complex128Value represents a complex128 value.
+//type Complex128Value struct {
+//      value
+//}
+//
+//// Get returns the underlying complex128 value.
+//func (v *Complex128Value) Get() complex128 { return *(*complex128)(v.addr) }
+//
+//// Set sets v to the value x.
+//func (v *Complex128Value) Set(x complex128) {
+//      if !v.canSet {
+//              panic(cannotSet)
+//      }
+//      *(*complex128)(v.addr) = x
+//}
+//
+//// Set sets v to the value x.
+//func (v *Complex128Value) SetValue(x Value) { v.Set(x.(*Complex128Value).Get()) }
+
 // IntValue represents an int value.
 type IntValue struct {
         value
 }
 
 // Get returns the underlying int value.
 func (v *IntValue) Get() int { return *(*int)(v.addr) }
 
 // Set sets v to the value x.
 func (v *IntValue) Set(x int) {
@@ skipping 1040 matching lines @@
         case *BoolType:
                 return (*BoolValue)(v)
         case *ChanType:
                 return (*ChanValue)(v)
         case *FloatType:
                 return (*FloatValue)(v)
         case *Float32Type:
                 return (*Float32Value)(v)
         case *Float64Type:
                 return (*Float64Value)(v)
+                //      case *ComplexType:
+                //              return (*ComplexValue)(v)
+                //      case *Complex64Type:
+                //              return (*Complex64Value)(v)
+                //      case *Complex128Type:
+                //              return (*Complex128Value)(v)
         case *IntType:
                 return (*IntValue)(v)
         case *Int8Type:
                 return (*Int8Value)(v)
         case *Int16Type:
                 return (*Int16Value)(v)
         case *Int32Type:
                 return (*Int32Value)(v)
         case *Int64Type:
                 return (*Int64Value)(v)
@@ skipping 27 matching lines @@
         panicln("newValue", typ.String())
 }
 
 // MakeZero returns a zero Value for the specified Type.
 func MakeZero(typ Type) Value {
         if typ == nil {
                 return nil
         }
         return newValue(typ, addr(unsafe.New(typ)), true)
 }