fix #241, support 32bit platform

any.go

@@ -7,6 +7,7 @@ import (
 	"reflect"
 	"unsafe"
 	"github.com/v2pro/plz/reflect2"
+	"strconv"
 )
 
 // Any generic object representation.
@@ -101,6 +102,9 @@ func Wrap(val interface{}) Any {
 	case reflect.String:
 		return WrapString(val.(string))
 	case reflect.Int:
+		if strconv.IntSize == 32 {
+			return WrapInt32(int32(val.(int)))
+		}
 		return WrapInt64(int64(val.(int)))
 	case reflect.Int8:
 		return WrapInt32(int32(val.(int8)))
@@ -111,7 +115,15 @@ func Wrap(val interface{}) Any {
 	case reflect.Int64:
 		return WrapInt64(val.(int64))
 	case reflect.Uint:
+		if strconv.IntSize == 32 {
+			return WrapUint32(uint32(val.(uint)))
+		}
 		return WrapUint64(uint64(val.(uint)))
+	case reflect.Uintptr:
+		if ptrSize == 32 {
+			return WrapUint32(uint32(val.(uintptr)))
+		}
+		return WrapUint64(uint64(val.(uintptr)))
 	case reflect.Uint8:
 		return WrapUint32(uint32(val.(uint8)))
 	case reflect.Uint16:

iter_int.go

@@ -22,11 +22,17 @@ func init() {
 
 // ReadUint read uint
 func (iter *Iterator) ReadUint() uint {
+	if strconv.IntSize == 32 {
+		return uint(iter.ReadUint32())
+	}
 	return uint(iter.ReadUint64())
 }
 
 // ReadInt read int
 func (iter *Iterator) ReadInt() int {
+	if strconv.IntSize == 32 {
+		return int(iter.ReadInt32())
+	}
 	return int(iter.ReadInt64())
 }
 

reflect_native.go

@@ -5,8 +5,11 @@ import (
 	"reflect"
 	"unsafe"
 	"github.com/v2pro/plz/reflect2"
+	"strconv"
 )
 
+const ptrSize = 32 << uintptr(^uintptr(0)>>63)
+
 func createEncoderOfNative(ctx *ctx, typ reflect2.Type) ValEncoder {
 	if typ.Kind() == reflect.Slice && typ.(reflect2.SliceType).Elem().Kind() == reflect.Uint8 {
 		sliceDecoder := decoderOfSlice(ctx, typ)
@@ -24,7 +27,10 @@ func createEncoderOfNative(ctx *ctx, typ reflect2.Type) ValEncoder {
 		if typeName != "int" {
 			return encoderOfType(ctx, reflect2.TypeOfPtr((*int)(nil)).Elem())
 		}
-		return &intCodec{}
+		if strconv.IntSize == 32 {
+			return &int32Codec{}
+		}
+		return &int64Codec{}
 	case reflect.Int8:
 		if typeName != "int8" {
 			return encoderOfType(ctx, reflect2.TypeOfPtr((*int8)(nil)).Elem())
@@ -49,7 +55,10 @@ func createEncoderOfNative(ctx *ctx, typ reflect2.Type) ValEncoder {
 		if typeName != "uint" {
 			return encoderOfType(ctx, reflect2.TypeOfPtr((*uint)(nil)).Elem())
 		}
-		return &uintCodec{}
+		if strconv.IntSize == 32 {
+			return &uint32Codec{}
+		}
+		return &uint64Codec{}
 	case reflect.Uint8:
 		if typeName != "uint8" {
 			return encoderOfType(ctx, reflect2.TypeOfPtr((*uint8)(nil)).Elem())
@@ -69,7 +78,10 @@ func createEncoderOfNative(ctx *ctx, typ reflect2.Type) ValEncoder {
 		if typeName != "uintptr" {
 			return encoderOfType(ctx, reflect2.TypeOfPtr((*uintptr)(nil)).Elem())
 		}
-		return &uintptrCodec{}
+		if ptrSize == 32 {
+			return &uint32Codec{}
+		}
+		return &uint64Codec{}
 	case reflect.Uint64:
 		if typeName != "uint64" {
 			return encoderOfType(ctx, reflect2.TypeOfPtr((*uint64)(nil)).Elem())
@@ -110,7 +122,10 @@ func createDecoderOfNative(ctx *ctx, typ reflect2.Type) ValDecoder {
 		if typeName != "int" {
 			return decoderOfType(ctx, reflect2.TypeOfPtr((*int)(nil)).Elem())
 		}
-		return &intCodec{}
+		if strconv.IntSize == 32 {
+			return &int32Codec{}
+		}
+		return &int64Codec{}
 	case reflect.Int8:
 		if typeName != "int8" {
 			return decoderOfType(ctx, reflect2.TypeOfPtr((*int8)(nil)).Elem())
@@ -135,7 +150,10 @@ func createDecoderOfNative(ctx *ctx, typ reflect2.Type) ValDecoder {
 		if typeName != "uint" {
 			return decoderOfType(ctx, reflect2.TypeOfPtr((*uint)(nil)).Elem())
 		}
-		return &uintCodec{}
+		if strconv.IntSize == 32 {
+			return &uint32Codec{}
+		}
+		return &uint64Codec{}
 	case reflect.Uint8:
 		if typeName != "uint8" {
 			return decoderOfType(ctx, reflect2.TypeOfPtr((*uint8)(nil)).Elem())
@@ -155,7 +173,10 @@ func createDecoderOfNative(ctx *ctx, typ reflect2.Type) ValDecoder {
 		if typeName != "uintptr" {
 			return decoderOfType(ctx, reflect2.TypeOfPtr((*uintptr)(nil)).Elem())
 		}
-		return &uintptrCodec{}
+		if ptrSize == 32 {
+			return &uint32Codec{}
+		}
+		return &uint64Codec{}
 	case reflect.Uint64:
 		if typeName != "uint64" {
 			return decoderOfType(ctx, reflect2.TypeOfPtr((*uint64)(nil)).Elem())
@@ -196,40 +217,6 @@ func (codec *stringCodec) IsEmpty(ptr unsafe.Pointer) bool {
 	return *((*string)(ptr)) == ""
 }
 
-type intCodec struct {
-}
-
-func (codec *intCodec) Decode(ptr unsafe.Pointer, iter *Iterator) {
-	if !iter.ReadNil() {
-		*((*int)(ptr)) = iter.ReadInt()
-	}
-}
-
-func (codec *intCodec) Encode(ptr unsafe.Pointer, stream *Stream) {
-	stream.WriteInt(*((*int)(ptr)))
-}
-
-func (codec *intCodec) IsEmpty(ptr unsafe.Pointer) bool {
-	return *((*int)(ptr)) == 0
-}
-
-type uintptrCodec struct {
-}
-
-func (codec *uintptrCodec) Decode(ptr unsafe.Pointer, iter *Iterator) {
-	if !iter.ReadNil() {
-		*((*uintptr)(ptr)) = uintptr(iter.ReadUint64())
-	}
-}
-
-func (codec *uintptrCodec) Encode(ptr unsafe.Pointer, stream *Stream) {
-	stream.WriteUint64(uint64(*((*uintptr)(ptr))))
-}
-
-func (codec *uintptrCodec) IsEmpty(ptr unsafe.Pointer) bool {
-	return *((*uintptr)(ptr)) == 0
-}
-
 type int8Codec struct {
 }
 
@@ -298,24 +285,6 @@ func (codec *int64Codec) IsEmpty(ptr unsafe.Pointer) bool {
 	return *((*int64)(ptr)) == 0
 }
 
-type uintCodec struct {
-}
-
-func (codec *uintCodec) Decode(ptr unsafe.Pointer, iter *Iterator) {
-	if !iter.ReadNil() {
-		*((*uint)(ptr)) = iter.ReadUint()
-		return
-	}
-}
-
-func (codec *uintCodec) Encode(ptr unsafe.Pointer, stream *Stream) {
-	stream.WriteUint(*((*uint)(ptr)))
-}
-
-func (codec *uintCodec) IsEmpty(ptr unsafe.Pointer) bool {
-	return *((*uint)(ptr)) == 0
-}
-
 type uint8Codec struct {
 }
 

reflect_struct_encoder.go

@@ -47,38 +47,12 @@ func encoderOfStruct(ctx *ctx, typ reflect2.Type) ValEncoder {
 }
 
 func createCheckIsEmpty(ctx *ctx, typ reflect2.Type) checkIsEmpty {
+	encoder := createEncoderOfNative(ctx, typ)
+	if encoder != nil {
+		return encoder
+	}
 	kind := typ.Kind()
 	switch kind {
-	case reflect.String:
-		return &stringCodec{}
-	case reflect.Int:
-		return &intCodec{}
-	case reflect.Int8:
-		return &int8Codec{}
-	case reflect.Int16:
-		return &int16Codec{}
-	case reflect.Int32:
-		return &int32Codec{}
-	case reflect.Int64:
-		return &int64Codec{}
-	case reflect.Uint:
-		return &uintCodec{}
-	case reflect.Uint8:
-		return &uint8Codec{}
-	case reflect.Uint16:
-		return &uint16Codec{}
-	case reflect.Uint32:
-		return &uint32Codec{}
-	case reflect.Uintptr:
-		return &uintptrCodec{}
-	case reflect.Uint64:
-		return &uint64Codec{}
-	case reflect.Float32:
-		return &float32Codec{}
-	case reflect.Float64:
-		return &float64Codec{}
-	case reflect.Bool:
-		return &boolCodec{}
 	case reflect.Interface:
 		return &dynamicEncoder{typ}
 	case reflect.Struct: