decode number to interface{} as int64 rather than float64

[thockin]

I have a case where I need to decode into an interface{} as an int64, rather than float64. Is there a way to request that? Ideally it would be automatic - if the encoded value is a whole number, use int64, else use float64.

stdlib has decoder.UseNumber which is closer to what we need...

[taowen]

RegisterTypeDecoder for interface{} then check for WhatIsNext

[thockin]

Are there examples? I want this to be as transparent as possible.

…

On Thu, Aug 10, 2017 at 9:56 PM, Tao Wen ***@***.***> wrote: RegisterTypeDecoder for interface{} then check for WhatIsNext — You are receiving this because you authored the thread. Reply to this email directly, view it on GitHub <#145 (comment)>, or mute the thread <https://github.com/notifications/unsubscribe-auth/AFVgVE__I0sHU1vtu2rIrrJRoYed0Eybks5sW98HgaJpZM4O0JJF> .

[taowen]

func Test_unmarshal_empty_interface_as_int64(t *testing.T) {
	var obj interface{}
	RegisterTypeDecoderFunc("interface {}", func(ptr unsafe.Pointer, iter *Iterator) {
		switch iter.WhatIsNext() {
		case NumberValue:
			*(*interface{})(ptr) = iter.ReadInt64()
		default:
			*(*interface{})(ptr) = iter.Read()
		}
	})
	should := require.New(t)
	Unmarshal([]byte("100"), &obj)
	should.Equal(int64(100), obj)
	Unmarshal([]byte(`"hello"`), &obj)
	should.Equal("hello", obj)
}

[thockin]

Is there any way to tell if the next value looks like an int vs looks like a float?

…

On Thu, Aug 10, 2017 at 11:16 PM, Tao Wen ***@***.***> wrote: func Test_unmarshal_empty_interface_as_int64(t *testing.T) { var obj interface{} RegisterTypeDecoderFunc("interface {}", func(ptr unsafe.Pointer, iter *Iterator) { switch iter.WhatIsNext() { case NumberValue: *(*interface{})(ptr) = iter.ReadInt64() default: *(*interface{})(ptr) = iter.Read() } }) should := require.New(t) Unmarshal([]byte("100"), &obj) should.Equal(int64(100), obj) Unmarshal([]byte(`"hello"`), &obj) should.Equal("hello", obj) } — You are receiving this because you authored the thread. Reply to this email directly, view it on GitHub <#145 (comment)>, or mute the thread <https://github.com/notifications/unsubscribe-auth/AFVgVM94U9C_sKjx6Ekn2Z5McOhgQB4Vks5sW_G3gaJpZM4O0JJF> .

[taowen]

var number json.Number
iter.ReadVal(&number)

then you check the number is int or float. event it is int, it might overflow int64 as well.

[thockin]

Would you be open to a PR that made that a config flag? DecodeIntsToInt64 or somethign?

[thockin]

I added this:

func init() {
    decodeNumberAsInt64IfPossible := func(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
        switch iter.WhatIsNext() {
        case jsoniter.NumberValue:
            var number json.Number
            iter.ReadVal(&number)
            i, err := strconv.ParseInt(string(number), 10, 64) 
            if err == nil {
                *(*interface{})(ptr) = i 
                return
            }
            f, err := strconv.ParseFloat(string(number), 64) 
            if err == nil {
                *(*interface{})(ptr) = f 
                return
            }
            // Not much we can do here.
        default:
            *(*interface{})(ptr) = iter.Read()
        }
    }
    jsoniter.RegisterTypeDecoderFunc("interface{}", decodeNumberAsInt64IfPossible)
}

I can tell it is being registered (throw in a panic). but my callback is never called. We are decoding into a []interface{} here, and I am getting a float64 out.

Am I doing something wrong?

[taowen]

"interface {}" not "interface{}"

DecodeIntsToInt64 LGTM

[thockin]

Ahh, got it to kind of work. Not sure I want to keep it, but it does work. :) Thanks.

[thockin]

This doesn't seem to catch []interface {} - the inner value gets decoded as a float and my function is never called.

[thockin]

Or rather, this doesn't seem to call any further type decoder functions (recursive).

[taowen]

func Test_unmarshal_empty_interface_as_int64(t *testing.T) {
	var obj interface{}
	RegisterTypeDecoderFunc("interface {}", func(ptr unsafe.Pointer, iter *Iterator) {
		switch iter.WhatIsNext() {
		case NumberValue:
			*(*interface{})(ptr) = iter.ReadInt64()
		default:
			*(*interface{})(ptr) = iter.Read()
		}
	})
	should := require.New(t)
	Unmarshal([]byte("100"), &obj)
	should.Equal(int64(100), obj)
	Unmarshal([]byte(`"hello"`), &obj)
	should.Equal("hello", obj)
	var arr []interface{}
	Unmarshal([]byte("[100]"), &arr)
	should.Equal(int64(100), arr[0])
}

seems []interface{} is working properly. can you give me a failing test case?

[thockin]

I want to decode a JSON array of numbers into an interface{} and have it process array member with my function.

JSON [ 100, 200, 300 ] => Go interface{}([]interface{ uint64(100), uint64(200), uint64(300) })

func Test_thockin(t *testing.T) {
    var obj interface{}
    RegisterTypeDecoderFunc("interface {}", func(ptr unsafe.Pointer, iter *Iterator) {
        switch iter.WhatIsNext() {
        case NumberValue:
            *(*interface{})(ptr) = iter.ReadInt64()
        default:
            *(*interface{})(ptr) = iter.Read()
        }
    })  
    should := require.New(t)
    Unmarshal([]byte("[100]"), &obj)
    spew.Dump(obj)
    should.Equal([]int64{100}, obj)
}

iter.Read() does not recurse into decoder functions.

[taowen]

You have to copy & paste the implementation code of iter.Read() to your custom decoder, and change

	case ArrayValue:
		arr := []interface{}{}
		iter.ReadArrayCB(func(iter *Iterator) bool {
			arr = append(arr, iter.Read())
			return true
		})
		return arr

before reading into the element of array, there is no way to know it is a int or string. so it will be using []interface{}. For example, if the input is [], do we still use []int64 as the type?

[thockin]

I would expect that, of the target type is interface{}, and you need to decode an array, you would decode to []interface{}, and recursively decode each value in the array, using decoder funcs for interface{}, for each element.

…

On Aug 21, 2017 6:56 PM, "Tao Wen" ***@***.***> wrote: You have to copy & paste the implementation code of iter.Read() to your custom decoder, and change case ArrayValue: arr := []interface{}{} iter.ReadArrayCB(func(iter *Iterator) bool { arr = append(arr, iter.Read()) return true }) return arr before reading into the element of array, there is no way to know it is a int or string. so it will be using []interface{}. For example, if the input is [], do we still use []int64 as the type? — You are receiving this because you authored the thread. Reply to this email directly, view it on GitHub <#145 (comment)>, or mute the thread <https://github.com/notifications/unsubscribe-auth/AFVgVM4NVeeRry_lLBkjkFcEGw_5Wc7Dks5sajUxgaJpZM4O0JJF> .