#68 string to float32

extra/fuzzy_decoder.go

@@ -14,11 +14,12 @@ const MinInt = -MaxInt - 1
 
 func RegisterFuzzyDecoders() {
 	jsoniter.RegisterTypeDecoder("string", &FuzzyStringDecoder{})
-	jsoniter.RegisterTypeDecoder("int", &FuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator, errorReporter *jsoniter.Iterator) {
+	jsoniter.RegisterTypeDecoder("float32", &FuzzyFloat32Decoder{})
+	jsoniter.RegisterTypeDecoder("int", &FuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
 		if isFloat {
 			val := iter.ReadFloat64()
 			if val > float64(MaxInt) || val < float64(MinInt) {
-				errorReporter.ReportError("fuzzy decode int", "exceed range")
+				iter.ReportError("fuzzy decode int", "exceed range")
 				return
 			}
 			*((*int)(ptr)) = int(val)
@@ -26,11 +27,11 @@ func RegisterFuzzyDecoders() {
 			*((*int)(ptr)) = iter.ReadInt()
 		}
 	}})
-	jsoniter.RegisterTypeDecoder("uint", &FuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator, errorReporter *jsoniter.Iterator) {
+	jsoniter.RegisterTypeDecoder("uint", &FuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
 		if isFloat {
 			val := iter.ReadFloat64()
 			if val > float64(MaxUint) || val < 0 {
-				errorReporter.ReportError("fuzzy decode uint", "exceed range")
+				iter.ReportError("fuzzy decode uint", "exceed range")
 				return
 			}
 			*((*uint)(ptr)) = uint(val)
@@ -38,11 +39,11 @@ func RegisterFuzzyDecoders() {
 			*((*uint)(ptr)) = iter.ReadUint()
 		}
 	}})
-	jsoniter.RegisterTypeDecoder("int8", &FuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator, errorReporter *jsoniter.Iterator) {
+	jsoniter.RegisterTypeDecoder("int8", &FuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
 		if isFloat {
 			val := iter.ReadFloat64()
 			if val > float64(math.MaxInt8) || val < float64(math.MinInt8) {
-				errorReporter.ReportError("fuzzy decode int8", "exceed range")
+				iter.ReportError("fuzzy decode int8", "exceed range")
 				return
 			}
 			*((*int8)(ptr)) = int8(val)
@@ -50,11 +51,11 @@ func RegisterFuzzyDecoders() {
 			*((*int8)(ptr)) = iter.ReadInt8()
 		}
 	}})
-	jsoniter.RegisterTypeDecoder("uint8", &FuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator, errorReporter *jsoniter.Iterator) {
+	jsoniter.RegisterTypeDecoder("uint8", &FuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
 		if isFloat {
 			val := iter.ReadFloat64()
 			if val > float64(math.MaxUint8) || val < 0 {
-				errorReporter.ReportError("fuzzy decode uint8", "exceed range")
+				iter.ReportError("fuzzy decode uint8", "exceed range")
 				return
 			}
 			*((*uint8)(ptr)) = uint8(val)
@@ -62,11 +63,11 @@ func RegisterFuzzyDecoders() {
 			*((*uint8)(ptr)) = iter.ReadUint8()
 		}
 	}})
-	jsoniter.RegisterTypeDecoder("int16", &FuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator, errorReporter *jsoniter.Iterator) {
+	jsoniter.RegisterTypeDecoder("int16", &FuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
 		if isFloat {
 			val := iter.ReadFloat64()
 			if val > float64(math.MaxInt16) || val < float64(math.MinInt16) {
-				errorReporter.ReportError("fuzzy decode int16", "exceed range")
+				iter.ReportError("fuzzy decode int16", "exceed range")
 				return
 			}
 			*((*int16)(ptr)) = int16(val)
@@ -74,11 +75,11 @@ func RegisterFuzzyDecoders() {
 			*((*int16)(ptr)) = iter.ReadInt16()
 		}
 	}})
-	jsoniter.RegisterTypeDecoder("uint16", &FuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator, errorReporter *jsoniter.Iterator) {
+	jsoniter.RegisterTypeDecoder("uint16", &FuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
 		if isFloat {
 			val := iter.ReadFloat64()
 			if val > float64(math.MaxUint16) || val < 0 {
-				errorReporter.ReportError("fuzzy decode uint16", "exceed range")
+				iter.ReportError("fuzzy decode uint16", "exceed range")
 				return
 			}
 			*((*uint16)(ptr)) = uint16(val)
@@ -86,11 +87,11 @@ func RegisterFuzzyDecoders() {
 			*((*uint16)(ptr)) = iter.ReadUint16()
 		}
 	}})
-	jsoniter.RegisterTypeDecoder("int32", &FuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator, errorReporter *jsoniter.Iterator) {
+	jsoniter.RegisterTypeDecoder("int32", &FuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
 		if isFloat {
 			val := iter.ReadFloat64()
 			if val > float64(math.MaxInt32) || val < float64(math.MinInt32) {
-				errorReporter.ReportError("fuzzy decode int32", "exceed range")
+				iter.ReportError("fuzzy decode int32", "exceed range")
 				return
 			}
 			*((*int32)(ptr)) = int32(val)
@@ -98,11 +99,11 @@ func RegisterFuzzyDecoders() {
 			*((*int32)(ptr)) = iter.ReadInt32()
 		}
 	}})
-	jsoniter.RegisterTypeDecoder("uint32", &FuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator, errorReporter *jsoniter.Iterator) {
+	jsoniter.RegisterTypeDecoder("uint32", &FuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
 		if isFloat {
 			val := iter.ReadFloat64()
 			if val > float64(math.MaxUint32) || val < 0 {
-				errorReporter.ReportError("fuzzy decode uint32", "exceed range")
+				iter.ReportError("fuzzy decode uint32", "exceed range")
 				return
 			}
 			*((*uint32)(ptr)) = uint32(val)
@@ -110,11 +111,11 @@ func RegisterFuzzyDecoders() {
 			*((*uint32)(ptr)) = iter.ReadUint32()
 		}
 	}})
-	jsoniter.RegisterTypeDecoder("int64", &FuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator, errorReporter *jsoniter.Iterator) {
+	jsoniter.RegisterTypeDecoder("int64", &FuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
 		if isFloat {
 			val := iter.ReadFloat64()
 			if val > float64(math.MaxInt64) || val < float64(math.MinInt64) {
-				errorReporter.ReportError("fuzzy decode int64", "exceed range")
+				iter.ReportError("fuzzy decode int64", "exceed range")
 				return
 			}
 			*((*int64)(ptr)) = int64(val)
@@ -122,11 +123,11 @@ func RegisterFuzzyDecoders() {
 			*((*int64)(ptr)) = iter.ReadInt64()
 		}
 	}})
-	jsoniter.RegisterTypeDecoder("uint64", &FuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator, errorReporter *jsoniter.Iterator) {
+	jsoniter.RegisterTypeDecoder("uint64", &FuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
 		if isFloat {
 			val := iter.ReadFloat64()
 			if val > float64(math.MaxUint64) || val < 0 {
-				errorReporter.ReportError("fuzzy decode uint64", "exceed range")
+				iter.ReportError("fuzzy decode uint64", "exceed range")
 				return
 			}
 			*((*uint64)(ptr)) = uint64(val)
@@ -154,7 +155,7 @@ func (decoder *FuzzyStringDecoder) Decode(ptr unsafe.Pointer, iter *jsoniter.Ite
 }
 
 type FuzzyIntegerDecoder struct {
-	fun func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator, errorReporter *jsoniter.Iterator)
+	fun func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator)
 }
 
 func (decoder *FuzzyIntegerDecoder) Decode(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
@@ -173,5 +174,30 @@ func (decoder *FuzzyIntegerDecoder) Decode(ptr unsafe.Pointer, iter *jsoniter.It
 	newIter := iter.Config().BorrowIterator([]byte(str))
 	defer iter.Config().ReturnIterator(newIter)
 	isFloat := strings.IndexByte(str, '.') != -1
-	decoder.fun(isFloat, ptr, newIter, iter)
+	decoder.fun(isFloat, ptr, newIter)
+	if newIter.Error != nil {
+		iter.Error = newIter.Error
+	}
+}
+
+type FuzzyFloat32Decoder struct {
+}
+
+func (decoder *FuzzyFloat32Decoder) Decode(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+	valueType := iter.WhatIsNext()
+	var str string
+	switch valueType {
+	case jsoniter.Number:
+		*((*float32)(ptr)) = iter.ReadFloat32()
+	case jsoniter.String:
+		str = iter.ReadString()
+		newIter := iter.Config().BorrowIterator([]byte(str))
+		defer iter.Config().ReturnIterator(newIter)
+		*((*float32)(ptr)) = newIter.ReadFloat32()
+		if newIter.Error != nil {
+			iter.Error = newIter.Error
+		}
+	default:
+		iter.ReportError("FuzzyFloat32Decoder", "not number or string")
+	}
 }

extra/fuzzy_decoder_test.go

@@ -57,3 +57,17 @@ func Test_large_float_to_int(t *testing.T) {
 	var val int
 	should.NotNil(jsoniter.UnmarshalFromString(`1234512345123451234512345.0`, &val))
 }
+
+func Test_string_to_float32(t *testing.T) {
+	should := require.New(t)
+	var val float32
+	should.Nil(jsoniter.UnmarshalFromString(`"100"`, &val))
+	should.Equal(float32(100), val)
+}
+
+func Test_float_to_float32(t *testing.T) {
+	should := require.New(t)
+	var val float32
+	should.Nil(jsoniter.UnmarshalFromString(`1.23`, &val))
+	should.Equal(float32(1.23), val)
+}