initial work to go [u]int->[u]int32

node/value_test.go

@@ -78,7 +78,7 @@ func TestToUnionList(t *testing.T) {
  fc.RequireEqual(t, nil, meta.Compile(m))
  v, err := NewValue(u, []string{"32"})
  fc.AssertEqual(t, nil, err)
- fc.AssertEqual(t, []int{32}, v.Value())
+ fc.AssertEqual(t, []int32{32}, v.Value())
 
  v, err = NewValue(u, []string{"thirty-two", "thirty-three"})
  fc.AssertEqual(t, nil, err)

nodeutil/node.go

@@ -403,11 +403,15 @@ func (ref *Node) readValue(m meta.Definition) (reflect.Value, error) {
  return empty, err
  }
  v, err := c.get(m)
+ var t reflect.Type
+ if v.IsValid() {
+ t = v.Type()
+ }
  if err != nil {
  return empty, err
  }
  if ref.OnRead != nil {
- return ref.OnRead(ref, m, v.Type(), v)
+ return ref.OnRead(ref, m, t, v)
  }
  return v, nil
 }

val/conv.go

@@ -404,47 +404,48 @@ func toUInt16List(val interface{}) ([]uint16, error) {
  return nil, fmt.Errorf("cannot coerse '%T' to []uint16", val)
 }
 
-func toInt32(val interface{}) (n int, err error) {
+func toInt32(val interface{}) (n int32, err error) {
  switch x := val.(type) {
  case int8:
- return int(x), nil
+ return int32(x), nil
  case uint8:
- return int(x), nil
+ return int32(x), nil
  case int16:
- return int(x), nil
+ return int32(x), nil
  case uint16:
- return int(x), nil
+ return int32(x), nil
  case int32:
- return int(x), nil
+ return int32(x), nil
  case uint32:
- return int(x), nil
+ return int32(x), nil
  case uint:
- return int(x), nil
+ return int32(x), nil
  case int:
- return x, nil
+ return int32(x), nil
  case int64:
- return int(x), nil
+ return int32(x), nil
  case string:
- return strconv.Atoi(x)
+ i, err := strconv.ParseUint(x, 10, 32)
+ return int32(i), err
  case float64:
- return int(x), nil
+ return int32(x), nil
  case float32:
- return int(x), nil
+ return int32(x), nil
  default:
  i, err := toInt64(val)
  if err == nil && i >= math.MinInt32 && i <= math.MaxUint32 {
- return int(i), nil
+ return int32(i), nil
  }
  }
  return 0, fmt.Errorf("cannot coerse '%T' to int32", val)
 }
 
-func toInt32List(val interface{}) ([]int, error) {
+func toInt32List(val interface{}) ([]int32, error) {
  switch x := val.(type) {
- case []int:
- return x, nil
  case []int32:
- l := make([]int, len(x))
+ return x, nil
+ case []int:
+ l := make([]int32, len(x))
  var err error
  for i := 0; i < len(x); i++ {
  if l[i], err = toInt32(x[i]); err != nil {
@@ -453,7 +454,7 @@ func toInt32List(val interface{}) ([]int, error) {
  }
  return l, nil
  case []interface{}:
- l := make([]int, len(x))
+ l := make([]int32, len(x))
  var err error
  for i := 0; i < len(x); i++ {
  if l[i], err = toInt32(x[i]); err != nil {
@@ -462,7 +463,7 @@ func toInt32List(val interface{}) ([]int, error) {
  }
  return l, nil
  case []float64:
- l := make([]int, len(x))
+ l := make([]int32, len(x))
  var err error
  for i := 0; i < len(x); i++ {
  if l[i], err = toInt32(x[i]); err != nil {
@@ -471,7 +472,7 @@ func toInt32List(val interface{}) ([]int, error) {
  }
  return l, nil
  case []string:
- l := make([]int, len(x))
+ l := make([]int32, len(x))
  var err error
  for i := 0; i < len(x); i++ {
  if l[i], err = toInt32(x[i]); err != nil {
@@ -481,45 +482,45 @@ func toInt32List(val interface{}) ([]int, error) {
  return l, nil
  default:
  if i, notSingle := toInt32(val); notSingle == nil {
- return []int{i}, nil
+ return []int32{i}, nil
  }
  }
  return nil, fmt.Errorf("cannot coerse '%T' to []int", val)
 }
 
-func toUInt32(val interface{}) (uint, error) {
+func toUInt32(val interface{}) (uint32, error) {
  switch x := val.(type) {
  case int8:
- return uint(x), nil
+ return uint32(x), nil
  case uint8:
- return uint(x), nil
+ return uint32(x), nil
  case int16:
- return uint(x), nil
+ return uint32(x), nil
  case uint16:
- return uint(x), nil
+ return uint32(x), nil
  case int32:
- return uint(x), nil
- case uint32:
- return uint(x), nil
- case int:
- return uint(x), nil
+ return uint32(x), nil
  case uint:
+ return uint32(x), nil
+ case int:
+ return uint32(x), nil
+ case uint32:
  return x, nil
  default:
  i, err := toUInt64(val)
  if err == nil && i >= 0 && i <= math.MaxUint32 {
- return uint(i), nil
+ return uint32(i), nil
  }
  }
  return 0, fmt.Errorf("cannot coerse '%T' to uint32", val)
 }
 
-func toUInt32List(val interface{}) ([]uint, error) {
+func toUInt32List(val interface{}) ([]uint32, error) {
  switch x := val.(type) {
- case []uint:
- return x, nil
  case []uint32:
- l := make([]uint, len(x))
+ return x, nil
+ case []uint:
+ l := make([]uint32, len(x))
  var err error
  for i := 0; i < len(x); i++ {
  if l[i], err = toUInt32(x[i]); err != nil {
@@ -528,7 +529,7 @@ func toUInt32List(val interface{}) ([]uint, error) {
  }
  return l, nil
  case []interface{}:
- l := make([]uint, len(x))
+ l := make([]uint32, len(x))
  var err error
  for i := 0; i < len(x); i++ {
  if l[i], err = toUInt32(x[i]); err != nil {
@@ -537,7 +538,7 @@ func toUInt32List(val interface{}) ([]uint, error) {
  }
  return l, nil
  case []float64:
- l := make([]uint, len(x))
+ l := make([]uint32, len(x))
  var err error
  for i := 0; i < len(x); i++ {
  if l[i], err = toUInt32(x[i]); err != nil {
@@ -546,7 +547,7 @@ func toUInt32List(val interface{}) ([]uint, error) {
  }
  return l, nil
  case []string:
- l := make([]uint, len(x))
+ l := make([]uint32, len(x))
  var err error
  for i := 0; i < len(x); i++ {
  if l[i], err = toUInt32(x[i]); err != nil {
@@ -556,7 +557,7 @@ func toUInt32List(val interface{}) ([]uint, error) {
  return l, nil
  default:
  if i, notSingle := toUInt32(val); notSingle == nil {
- return []uint{i}, nil
+ return []uint32{i}, nil
  }
  }
  return nil, fmt.Errorf("cannot coerse '%T' to []int", val)

val/conv_test.go

@@ -123,22 +123,22 @@ func Test_Conv(t *testing.T) {
  {
  F: FmtInt32List,
  In: 0,
- Out: []int{0},
+ Out: []int32{0},
  },
  {
  F: FmtInt32List,
  In: []float64{99, 98},
- Out: []int{99, 98},
+ Out: []int32{99, 98},
  },
  {
  F: FmtInt32List,
  In: []string{"99", "98"},
- Out: []int{99, 98},
+ Out: []int32{99, 98},
  },
  {
  F: FmtInt32List,
  In: []interface{}{"99", 98},
- Out: []int{99, 98},
+ Out: []int32{99, 98},
  },
  ////////////
  {

val/types.go

@@ -383,7 +383,7 @@ func (x UInt16List) Item(i int) Value {
 
 ///////////////////////
 
-type Int32 int
+type Int32 int32
 
 func (Int32) Format() Format {
  return FmtInt32
@@ -407,18 +407,18 @@ func (x Int32) Int64() int64 {
 
 ///////////////////////
 
-type Int32List []int
+type Int32List []int32
 
 func (Int32List) Format() Format {
  return FmtInt32List
 }
 
 func (x Int32List) String() string {
- return fmt.Sprintf("%v", []int(x))
+ return fmt.Sprintf("%v", []int32(x))
 }
 
 func (x Int32List) Value() interface{} {
- return []int(x)
+ return []int32(x)
 }
 
 func (x Int32List) Len() int {
@@ -431,7 +431,7 @@ func (x Int32List) Item(i int) Value {
 
 ///////////////////////
 
-type UInt32 uint
+type UInt32 uint32
 
 func (UInt32) Format() Format {
  return FmtUInt32
@@ -461,18 +461,18 @@ func (x UInt32) Int64() int64 {
 
 ///////////////////////
 
-type UInt32List []uint
+type UInt32List []uint32
 
 func (UInt32List) Format() Format {
  return FmtUInt32List
 }
 
 func (x UInt32List) String() string {
- return fmt.Sprintf("%v", []uint(x))
+ return fmt.Sprintf("%v", []uint32(x))
 }
 
 func (x UInt32List) Value() interface{} {
- return []uint(x)
+ return []uint32(x)
 }
 
 func (x UInt32List) Len() int {