Skip to content
This repository was archived by the owner on Dec 15, 2025. It is now read-only.

Commit 63ea5e3

Browse files
taowentaowen
committed
move encoder/decoder of native
1 parent 895a19f commit 63ea5e3

File tree

2 files changed

+181
-159
lines changed

2 files changed

+181
-159
lines changed

‎reflect.go‎

Lines changed: 8 additions & 158 deletions
Original file line numberDiff line numberDiff line change
@@ -118,92 +118,17 @@ func createDecoderOfType(cfg *frozenConfig, prefix string, typ reflect.Type) Val
118118
if decoder != nil {
119119
return decoder
120120
}
121-
if typ.Kind() == reflect.Slice && typ.Elem().Kind() == reflect.Uint8 {
122-
sliceDecoder := decoderOfSlice(cfg, prefix, typ)
123-
return &base64Codec{sliceDecoder: sliceDecoder}
124-
}
125121
if typ == anyType {
126122
return &directAnyCodec{}
127123
}
128124
if typ.Implements(anyType) {
129125
return &anyCodec{}
130126
}
127+
decoder = createDecoderOfNative(cfg, prefix, typ)
128+
if decoder != nil {
129+
return decoder
130+
}
131131
switch typ.Kind() {
132-
case reflect.String:
133-
if typeName != "string" {
134-
return decoderOfType(cfg, prefix, reflect.TypeOf((*string)(nil)).Elem())
135-
}
136-
return &stringCodec{}
137-
case reflect.Int:
138-
if typeName != "int" {
139-
return decoderOfType(cfg, prefix, reflect.TypeOf((*int)(nil)).Elem())
140-
}
141-
return &intCodec{}
142-
case reflect.Int8:
143-
if typeName != "int8" {
144-
return decoderOfType(cfg, prefix, reflect.TypeOf((*int8)(nil)).Elem())
145-
}
146-
return &int8Codec{}
147-
case reflect.Int16:
148-
if typeName != "int16" {
149-
return decoderOfType(cfg, prefix, reflect.TypeOf((*int16)(nil)).Elem())
150-
}
151-
return &int16Codec{}
152-
case reflect.Int32:
153-
if typeName != "int32" {
154-
return decoderOfType(cfg, prefix, reflect.TypeOf((*int32)(nil)).Elem())
155-
}
156-
return &int32Codec{}
157-
case reflect.Int64:
158-
if typeName != "int64" {
159-
return decoderOfType(cfg, prefix, reflect.TypeOf((*int64)(nil)).Elem())
160-
}
161-
return &int64Codec{}
162-
case reflect.Uint:
163-
if typeName != "uint" {
164-
return decoderOfType(cfg, prefix, reflect.TypeOf((*uint)(nil)).Elem())
165-
}
166-
return &uintCodec{}
167-
case reflect.Uint8:
168-
if typeName != "uint8" {
169-
return decoderOfType(cfg, prefix, reflect.TypeOf((*uint8)(nil)).Elem())
170-
}
171-
return &uint8Codec{}
172-
case reflect.Uint16:
173-
if typeName != "uint16" {
174-
return decoderOfType(cfg, prefix, reflect.TypeOf((*uint16)(nil)).Elem())
175-
}
176-
return &uint16Codec{}
177-
case reflect.Uint32:
178-
if typeName != "uint32" {
179-
return decoderOfType(cfg, prefix, reflect.TypeOf((*uint32)(nil)).Elem())
180-
}
181-
return &uint32Codec{}
182-
case reflect.Uintptr:
183-
if typeName != "uintptr" {
184-
return decoderOfType(cfg, prefix, reflect.TypeOf((*uintptr)(nil)).Elem())
185-
}
186-
return &uintptrCodec{}
187-
case reflect.Uint64:
188-
if typeName != "uint64" {
189-
return decoderOfType(cfg, prefix, reflect.TypeOf((*uint64)(nil)).Elem())
190-
}
191-
return &uint64Codec{}
192-
case reflect.Float32:
193-
if typeName != "float32" {
194-
return decoderOfType(cfg, prefix, reflect.TypeOf((*float32)(nil)).Elem())
195-
}
196-
return &float32Codec{}
197-
case reflect.Float64:
198-
if typeName != "float64" {
199-
return decoderOfType(cfg, prefix, reflect.TypeOf((*float64)(nil)).Elem())
200-
}
201-
return &float64Codec{}
202-
case reflect.Bool:
203-
if typeName != "bool" {
204-
return decoderOfType(cfg, prefix, reflect.TypeOf((*bool)(nil)).Elem())
205-
}
206-
return &boolCodec{}
207132
case reflect.Interface:
208133
if typ.NumMethod() == 0 {
209134
return &emptyInterfaceCodec{}
@@ -305,9 +230,6 @@ func createEncoderOfType(cfg *frozenConfig, prefix string, typ reflect.Type) Val
305230
if encoder != nil {
306231
return encoder
307232
}
308-
if typ.Kind() == reflect.Slice && typ.Elem().Kind() == reflect.Uint8 {
309-
return &base64Codec{}
310-
}
311233
if typ == anyType {
312234
return &directAnyCodec{}
313235
}
@@ -370,84 +292,12 @@ func createCheckIsEmpty(cfg *frozenConfig, typ reflect.Type) checkIsEmpty {
370292
}
371293

372294
func createEncoderOfSimpleType(cfg *frozenConfig, prefix string, typ reflect.Type) ValEncoder {
373-
typeName := typ.String()
295+
encoder := createEncoderOfNative(cfg, prefix, typ)
296+
if encoder != nil {
297+
return encoder
298+
}
374299
kind := typ.Kind()
375300
switch kind {
376-
case reflect.String:
377-
if typeName != "string" {
378-
return encoderOfType(cfg, prefix, reflect.TypeOf((*string)(nil)).Elem())
379-
}
380-
return &stringCodec{}
381-
case reflect.Int:
382-
if typeName != "int" {
383-
return encoderOfType(cfg, prefix, reflect.TypeOf((*int)(nil)).Elem())
384-
}
385-
return &intCodec{}
386-
case reflect.Int8:
387-
if typeName != "int8" {
388-
return encoderOfType(cfg, prefix, reflect.TypeOf((*int8)(nil)).Elem())
389-
}
390-
return &int8Codec{}
391-
case reflect.Int16:
392-
if typeName != "int16" {
393-
return encoderOfType(cfg, prefix, reflect.TypeOf((*int16)(nil)).Elem())
394-
}
395-
return &int16Codec{}
396-
case reflect.Int32:
397-
if typeName != "int32" {
398-
return encoderOfType(cfg, prefix, reflect.TypeOf((*int32)(nil)).Elem())
399-
}
400-
return &int32Codec{}
401-
case reflect.Int64:
402-
if typeName != "int64" {
403-
return encoderOfType(cfg, prefix, reflect.TypeOf((*int64)(nil)).Elem())
404-
}
405-
return &int64Codec{}
406-
case reflect.Uint:
407-
if typeName != "uint" {
408-
return encoderOfType(cfg, prefix, reflect.TypeOf((*uint)(nil)).Elem())
409-
}
410-
return &uintCodec{}
411-
case reflect.Uint8:
412-
if typeName != "uint8" {
413-
return encoderOfType(cfg, prefix, reflect.TypeOf((*uint8)(nil)).Elem())
414-
}
415-
return &uint8Codec{}
416-
case reflect.Uint16:
417-
if typeName != "uint16" {
418-
return encoderOfType(cfg, prefix, reflect.TypeOf((*uint16)(nil)).Elem())
419-
}
420-
return &uint16Codec{}
421-
case reflect.Uint32:
422-
if typeName != "uint32" {
423-
return encoderOfType(cfg, prefix, reflect.TypeOf((*uint32)(nil)).Elem())
424-
}
425-
return &uint32Codec{}
426-
case reflect.Uintptr:
427-
if typeName != "uintptr" {
428-
return encoderOfType(cfg, prefix, reflect.TypeOf((*uintptr)(nil)).Elem())
429-
}
430-
return &uintptrCodec{}
431-
case reflect.Uint64:
432-
if typeName != "uint64" {
433-
return encoderOfType(cfg, prefix, reflect.TypeOf((*uint64)(nil)).Elem())
434-
}
435-
return &uint64Codec{}
436-
case reflect.Float32:
437-
if typeName != "float32" {
438-
return encoderOfType(cfg, prefix, reflect.TypeOf((*float32)(nil)).Elem())
439-
}
440-
return &float32Codec{}
441-
case reflect.Float64:
442-
if typeName != "float64" {
443-
return encoderOfType(cfg, prefix, reflect.TypeOf((*float64)(nil)).Elem())
444-
}
445-
return &float64Codec{}
446-
case reflect.Bool:
447-
if typeName != "bool" {
448-
return encoderOfType(cfg, prefix, reflect.TypeOf((*bool)(nil)).Elem())
449-
}
450-
return &boolCodec{}
451301
case reflect.Interface:
452302
return &dynamicEncoder{reflect2.Type2(typ)}
453303
case reflect.Struct:

‎reflect_native.go‎

Lines changed: 173 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2,12 +2,184 @@ package jsoniter
22

33
import (
44
"encoding/base64"
5-
"encoding/json"
65
"reflect"
76
"unsafe"
87
"github.com/v2pro/plz/reflect2"
98
)
109

10+
func createEncoderOfNative(cfg *frozenConfig, prefix string, typ reflect.Type) ValEncoder {
11+
if typ.Kind() == reflect.Slice && typ.Elem().Kind() == reflect.Uint8 {
12+
sliceDecoder := decoderOfSlice(cfg, prefix, typ)
13+
return &base64Codec{sliceDecoder: sliceDecoder}
14+
}
15+
typeName := typ.String()
16+
kind := typ.Kind()
17+
switch kind {
18+
case reflect.String:
19+
if typeName != "string" {
20+
return encoderOfType(cfg, prefix, reflect.TypeOf((*string)(nil)).Elem())
21+
}
22+
return &stringCodec{}
23+
case reflect.Int:
24+
if typeName != "int" {
25+
return encoderOfType(cfg, prefix, reflect.TypeOf((*int)(nil)).Elem())
26+
}
27+
return &intCodec{}
28+
case reflect.Int8:
29+
if typeName != "int8" {
30+
return encoderOfType(cfg, prefix, reflect.TypeOf((*int8)(nil)).Elem())
31+
}
32+
return &int8Codec{}
33+
case reflect.Int16:
34+
if typeName != "int16" {
35+
return encoderOfType(cfg, prefix, reflect.TypeOf((*int16)(nil)).Elem())
36+
}
37+
return &int16Codec{}
38+
case reflect.Int32:
39+
if typeName != "int32" {
40+
return encoderOfType(cfg, prefix, reflect.TypeOf((*int32)(nil)).Elem())
41+
}
42+
return &int32Codec{}
43+
case reflect.Int64:
44+
if typeName != "int64" {
45+
return encoderOfType(cfg, prefix, reflect.TypeOf((*int64)(nil)).Elem())
46+
}
47+
return &int64Codec{}
48+
case reflect.Uint:
49+
if typeName != "uint" {
50+
return encoderOfType(cfg, prefix, reflect.TypeOf((*uint)(nil)).Elem())
51+
}
52+
return &uintCodec{}
53+
case reflect.Uint8:
54+
if typeName != "uint8" {
55+
return encoderOfType(cfg, prefix, reflect.TypeOf((*uint8)(nil)).Elem())
56+
}
57+
return &uint8Codec{}
58+
case reflect.Uint16:
59+
if typeName != "uint16" {
60+
return encoderOfType(cfg, prefix, reflect.TypeOf((*uint16)(nil)).Elem())
61+
}
62+
return &uint16Codec{}
63+
case reflect.Uint32:
64+
if typeName != "uint32" {
65+
return encoderOfType(cfg, prefix, reflect.TypeOf((*uint32)(nil)).Elem())
66+
}
67+
return &uint32Codec{}
68+
case reflect.Uintptr:
69+
if typeName != "uintptr" {
70+
return encoderOfType(cfg, prefix, reflect.TypeOf((*uintptr)(nil)).Elem())
71+
}
72+
return &uintptrCodec{}
73+
case reflect.Uint64:
74+
if typeName != "uint64" {
75+
return encoderOfType(cfg, prefix, reflect.TypeOf((*uint64)(nil)).Elem())
76+
}
77+
return &uint64Codec{}
78+
case reflect.Float32:
79+
if typeName != "float32" {
80+
return encoderOfType(cfg, prefix, reflect.TypeOf((*float32)(nil)).Elem())
81+
}
82+
return &float32Codec{}
83+
case reflect.Float64:
84+
if typeName != "float64" {
85+
return encoderOfType(cfg, prefix, reflect.TypeOf((*float64)(nil)).Elem())
86+
}
87+
return &float64Codec{}
88+
case reflect.Bool:
89+
if typeName != "bool" {
90+
return encoderOfType(cfg, prefix, reflect.TypeOf((*bool)(nil)).Elem())
91+
}
92+
return &boolCodec{}
93+
}
94+
return nil
95+
}
96+
97+
func createDecoderOfNative(cfg *frozenConfig, prefix string, typ reflect.Type) ValDecoder {
98+
if typ.Kind() == reflect.Slice && typ.Elem().Kind() == reflect.Uint8 {
99+
sliceDecoder := decoderOfSlice(cfg, prefix, typ)
100+
return &base64Codec{sliceDecoder: sliceDecoder}
101+
}
102+
typeName := typ.String()
103+
switch typ.Kind() {
104+
case reflect.String:
105+
if typeName != "string" {
106+
return decoderOfType(cfg, prefix, reflect.TypeOf((*string)(nil)).Elem())
107+
}
108+
return &stringCodec{}
109+
case reflect.Int:
110+
if typeName != "int" {
111+
return decoderOfType(cfg, prefix, reflect.TypeOf((*int)(nil)).Elem())
112+
}
113+
return &intCodec{}
114+
case reflect.Int8:
115+
if typeName != "int8" {
116+
return decoderOfType(cfg, prefix, reflect.TypeOf((*int8)(nil)).Elem())
117+
}
118+
return &int8Codec{}
119+
case reflect.Int16:
120+
if typeName != "int16" {
121+
return decoderOfType(cfg, prefix, reflect.TypeOf((*int16)(nil)).Elem())
122+
}
123+
return &int16Codec{}
124+
case reflect.Int32:
125+
if typeName != "int32" {
126+
return decoderOfType(cfg, prefix, reflect.TypeOf((*int32)(nil)).Elem())
127+
}
128+
return &int32Codec{}
129+
case reflect.Int64:
130+
if typeName != "int64" {
131+
return decoderOfType(cfg, prefix, reflect.TypeOf((*int64)(nil)).Elem())
132+
}
133+
return &int64Codec{}
134+
case reflect.Uint:
135+
if typeName != "uint" {
136+
return decoderOfType(cfg, prefix, reflect.TypeOf((*uint)(nil)).Elem())
137+
}
138+
return &uintCodec{}
139+
case reflect.Uint8:
140+
if typeName != "uint8" {
141+
return decoderOfType(cfg, prefix, reflect.TypeOf((*uint8)(nil)).Elem())
142+
}
143+
return &uint8Codec{}
144+
case reflect.Uint16:
145+
if typeName != "uint16" {
146+
return decoderOfType(cfg, prefix, reflect.TypeOf((*uint16)(nil)).Elem())
147+
}
148+
return &uint16Codec{}
149+
case reflect.Uint32:
150+
if typeName != "uint32" {
151+
return decoderOfType(cfg, prefix, reflect.TypeOf((*uint32)(nil)).Elem())
152+
}
153+
return &uint32Codec{}
154+
case reflect.Uintptr:
155+
if typeName != "uintptr" {
156+
return decoderOfType(cfg, prefix, reflect.TypeOf((*uintptr)(nil)).Elem())
157+
}
158+
return &uintptrCodec{}
159+
case reflect.Uint64:
160+
if typeName != "uint64" {
161+
return decoderOfType(cfg, prefix, reflect.TypeOf((*uint64)(nil)).Elem())
162+
}
163+
return &uint64Codec{}
164+
case reflect.Float32:
165+
if typeName != "float32" {
166+
return decoderOfType(cfg, prefix, reflect.TypeOf((*float32)(nil)).Elem())
167+
}
168+
return &float32Codec{}
169+
case reflect.Float64:
170+
if typeName != "float64" {
171+
return decoderOfType(cfg, prefix, reflect.TypeOf((*float64)(nil)).Elem())
172+
}
173+
return &float64Codec{}
174+
case reflect.Bool:
175+
if typeName != "bool" {
176+
return decoderOfType(cfg, prefix, reflect.TypeOf((*bool)(nil)).Elem())
177+
}
178+
return &boolCodec{}
179+
}
180+
return nil
181+
}
182+
11183
type stringCodec struct {
12184
}
13185

0 commit comments

Comments
 (0)