go/json-iterator
1
0
Fork 0
mirror of https://github.com/json-iterator/go.git synced 2025-04-14 11:18:49 +02:00
Code Issues Releases Activity

#68 string to float32

Browse Source
This commit is contained in:
Tao Wen 2017-06-20 16:17:00 +08:00
parent 417011b497
commit 2ea4d48e1f
2 changed files with 62 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

70
extra/fuzzy_decoder.go
View File

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

14
extra/fuzzy_decoder_test.go
View File

@ -57,3 +57,17 @@ func Test_large_float_to_int(t *testing.T) {
var val int var val int
should.NotNil(jsoniter.UnmarshalFromString(`1234512345123451234512345.0`, &val)) 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)
}