podman

1
package jsoniter
2

3
import (
4
	"encoding/json"
5
	"io"
6
	"reflect"
7
	"sync"
8
	"unsafe"
9

10
	"github.com/modern-go/concurrent"
11
	"github.com/modern-go/reflect2"
12
)
13

14
// Config customize how the API should behave.
15
// The API is created from Config by Froze.
16
type Config struct {
17
	IndentionStep                 int
18
	MarshalFloatWith6Digits       bool
19
	EscapeHTML                    bool
20
	SortMapKeys                   bool
21
	UseNumber                     bool
22
	DisallowUnknownFields         bool
23
	TagKey                        string
24
	OnlyTaggedField               bool
25
	ValidateJsonRawMessage        bool
26
	ObjectFieldMustBeSimpleString bool
27
	CaseSensitive                 bool
28
}
29

30
// API the public interface of this package.
31
// Primary Marshal and Unmarshal.
32
type API interface {
33
	IteratorPool
34
	StreamPool
35
	MarshalToString(v interface{}) (string, error)
36
	Marshal(v interface{}) ([]byte, error)
37
	MarshalIndent(v interface{}, prefix, indent string) ([]byte, error)
38
	UnmarshalFromString(str string, v interface{}) error
39
	Unmarshal(data []byte, v interface{}) error
40
	Get(data []byte, path ...interface{}) Any
41
	NewEncoder(writer io.Writer) *Encoder
42
	NewDecoder(reader io.Reader) *Decoder
43
	Valid(data []byte) bool
44
	RegisterExtension(extension Extension)
45
	DecoderOf(typ reflect2.Type) ValDecoder
46
	EncoderOf(typ reflect2.Type) ValEncoder
47
}
48

49
// ConfigDefault the default API
50
var ConfigDefault = Config{
51
	EscapeHTML: true,
52
}.Froze()
53

54
// ConfigCompatibleWithStandardLibrary tries to be 100% compatible with standard library behavior
55
var ConfigCompatibleWithStandardLibrary = Config{
56
	EscapeHTML:             true,
57
	SortMapKeys:            true,
58
	ValidateJsonRawMessage: true,
59
}.Froze()
60

61
// ConfigFastest marshals float with only 6 digits precision
62
var ConfigFastest = Config{
63
	EscapeHTML:                    false,
64
	MarshalFloatWith6Digits:       true, // will lose precession
65
	ObjectFieldMustBeSimpleString: true, // do not unescape object field
66
}.Froze()
67

68
type frozenConfig struct {
69
	configBeforeFrozen            Config
70
	sortMapKeys                   bool
71
	indentionStep                 int
72
	objectFieldMustBeSimpleString bool
73
	onlyTaggedField               bool
74
	disallowUnknownFields         bool
75
	decoderCache                  *concurrent.Map
76
	encoderCache                  *concurrent.Map
77
	encoderExtension              Extension
78
	decoderExtension              Extension
79
	extraExtensions               []Extension
80
	streamPool                    *sync.Pool
81
	iteratorPool                  *sync.Pool
82
	caseSensitive                 bool
83
}
84

85
func (cfg *frozenConfig) initCache() {
86
	cfg.decoderCache = concurrent.NewMap()
87
	cfg.encoderCache = concurrent.NewMap()
88
}
89

90
func (cfg *frozenConfig) addDecoderToCache(cacheKey uintptr, decoder ValDecoder) {
91
	cfg.decoderCache.Store(cacheKey, decoder)
92
}
93

94
func (cfg *frozenConfig) addEncoderToCache(cacheKey uintptr, encoder ValEncoder) {
95
	cfg.encoderCache.Store(cacheKey, encoder)
96
}
97

98
func (cfg *frozenConfig) getDecoderFromCache(cacheKey uintptr) ValDecoder {
99
	decoder, found := cfg.decoderCache.Load(cacheKey)
100
	if found {
101
		return decoder.(ValDecoder)
102
	}
103
	return nil
104
}
105

106
func (cfg *frozenConfig) getEncoderFromCache(cacheKey uintptr) ValEncoder {
107
	encoder, found := cfg.encoderCache.Load(cacheKey)
108
	if found {
109
		return encoder.(ValEncoder)
110
	}
111
	return nil
112
}
113

114
var cfgCache = concurrent.NewMap()
115

116
func getFrozenConfigFromCache(cfg Config) *frozenConfig {
117
	obj, found := cfgCache.Load(cfg)
118
	if found {
119
		return obj.(*frozenConfig)
120
	}
121
	return nil
122
}
123

124
func addFrozenConfigToCache(cfg Config, frozenConfig *frozenConfig) {
125
	cfgCache.Store(cfg, frozenConfig)
126
}
127

128
// Froze forge API from config
129
func (cfg Config) Froze() API {
130
	api := &frozenConfig{
131
		sortMapKeys:                   cfg.SortMapKeys,
132
		indentionStep:                 cfg.IndentionStep,
133
		objectFieldMustBeSimpleString: cfg.ObjectFieldMustBeSimpleString,
134
		onlyTaggedField:               cfg.OnlyTaggedField,
135
		disallowUnknownFields:         cfg.DisallowUnknownFields,
136
		caseSensitive:                 cfg.CaseSensitive,
137
	}
138
	api.streamPool = &sync.Pool{
139
		New: func() interface{} {
140
			return NewStream(api, nil, 512)
141
		},
142
	}
143
	api.iteratorPool = &sync.Pool{
144
		New: func() interface{} {
145
			return NewIterator(api)
146
		},
147
	}
148
	api.initCache()
149
	encoderExtension := EncoderExtension{}
150
	decoderExtension := DecoderExtension{}
151
	if cfg.MarshalFloatWith6Digits {
152
		api.marshalFloatWith6Digits(encoderExtension)
153
	}
154
	if cfg.EscapeHTML {
155
		api.escapeHTML(encoderExtension)
156
	}
157
	if cfg.UseNumber {
158
		api.useNumber(decoderExtension)
159
	}
160
	if cfg.ValidateJsonRawMessage {
161
		api.validateJsonRawMessage(encoderExtension)
162
	}
163
	api.encoderExtension = encoderExtension
164
	api.decoderExtension = decoderExtension
165
	api.configBeforeFrozen = cfg
166
	return api
167
}
168

169
func (cfg Config) frozeWithCacheReuse(extraExtensions []Extension) *frozenConfig {
170
	api := getFrozenConfigFromCache(cfg)
171
	if api != nil {
172
		return api
173
	}
174
	api = cfg.Froze().(*frozenConfig)
175
	for _, extension := range extraExtensions {
176
		api.RegisterExtension(extension)
177
	}
178
	addFrozenConfigToCache(cfg, api)
179
	return api
180
}
181

182
func (cfg *frozenConfig) validateJsonRawMessage(extension EncoderExtension) {
183
	encoder := &funcEncoder{func(ptr unsafe.Pointer, stream *Stream) {
184
		rawMessage := *(*json.RawMessage)(ptr)
185
		iter := cfg.BorrowIterator([]byte(rawMessage))
186
		defer cfg.ReturnIterator(iter)
187
		iter.Read()
188
		if iter.Error != nil && iter.Error != io.EOF {
189
			stream.WriteRaw("null")
190
		} else {
191
			stream.WriteRaw(string(rawMessage))
192
		}
193
	}, func(ptr unsafe.Pointer) bool {
194
		return len(*((*json.RawMessage)(ptr))) == 0
195
	}}
196
	extension[reflect2.TypeOfPtr((*json.RawMessage)(nil)).Elem()] = encoder
197
	extension[reflect2.TypeOfPtr((*RawMessage)(nil)).Elem()] = encoder
198
}
199

200
func (cfg *frozenConfig) useNumber(extension DecoderExtension) {
201
	extension[reflect2.TypeOfPtr((*interface{})(nil)).Elem()] = &funcDecoder{func(ptr unsafe.Pointer, iter *Iterator) {
202
		exitingValue := *((*interface{})(ptr))
203
		if exitingValue != nil && reflect.TypeOf(exitingValue).Kind() == reflect.Ptr {
204
			iter.ReadVal(exitingValue)
205
			return
206
		}
207
		if iter.WhatIsNext() == NumberValue {
208
			*((*interface{})(ptr)) = json.Number(iter.readNumberAsString())
209
		} else {
210
			*((*interface{})(ptr)) = iter.Read()
211
		}
212
	}}
213
}
214
func (cfg *frozenConfig) getTagKey() string {
215
	tagKey := cfg.configBeforeFrozen.TagKey
216
	if tagKey == "" {
217
		return "json"
218
	}
219
	return tagKey
220
}
221

222
func (cfg *frozenConfig) RegisterExtension(extension Extension) {
223
	cfg.extraExtensions = append(cfg.extraExtensions, extension)
224
	copied := cfg.configBeforeFrozen
225
	cfg.configBeforeFrozen = copied
226
}
227

228
type lossyFloat32Encoder struct {
229
}
230

231
func (encoder *lossyFloat32Encoder) Encode(ptr unsafe.Pointer, stream *Stream) {
232
	stream.WriteFloat32Lossy(*((*float32)(ptr)))
233
}
234

235
func (encoder *lossyFloat32Encoder) IsEmpty(ptr unsafe.Pointer) bool {
236
	return *((*float32)(ptr)) == 0
237
}
238

239
type lossyFloat64Encoder struct {
240
}
241

242
func (encoder *lossyFloat64Encoder) Encode(ptr unsafe.Pointer, stream *Stream) {
243
	stream.WriteFloat64Lossy(*((*float64)(ptr)))
244
}
245

246
func (encoder *lossyFloat64Encoder) IsEmpty(ptr unsafe.Pointer) bool {
247
	return *((*float64)(ptr)) == 0
248
}
249

250
// EnableLossyFloatMarshalling keeps 10**(-6) precision
251
// for float variables for better performance.
252
func (cfg *frozenConfig) marshalFloatWith6Digits(extension EncoderExtension) {
253
	// for better performance
254
	extension[reflect2.TypeOfPtr((*float32)(nil)).Elem()] = &lossyFloat32Encoder{}
255
	extension[reflect2.TypeOfPtr((*float64)(nil)).Elem()] = &lossyFloat64Encoder{}
256
}
257

258
type htmlEscapedStringEncoder struct {
259
}
260

261
func (encoder *htmlEscapedStringEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
262
	str := *((*string)(ptr))
263
	stream.WriteStringWithHTMLEscaped(str)
264
}
265

266
func (encoder *htmlEscapedStringEncoder) IsEmpty(ptr unsafe.Pointer) bool {
267
	return *((*string)(ptr)) == ""
268
}
269

270
func (cfg *frozenConfig) escapeHTML(encoderExtension EncoderExtension) {
271
	encoderExtension[reflect2.TypeOfPtr((*string)(nil)).Elem()] = &htmlEscapedStringEncoder{}
272
}
273

274
func (cfg *frozenConfig) cleanDecoders() {
275
	typeDecoders = map[string]ValDecoder{}
276
	fieldDecoders = map[string]ValDecoder{}
277
	*cfg = *(cfg.configBeforeFrozen.Froze().(*frozenConfig))
278
}
279

280
func (cfg *frozenConfig) cleanEncoders() {
281
	typeEncoders = map[string]ValEncoder{}
282
	fieldEncoders = map[string]ValEncoder{}
283
	*cfg = *(cfg.configBeforeFrozen.Froze().(*frozenConfig))
284
}
285

286
func (cfg *frozenConfig) MarshalToString(v interface{}) (string, error) {
287
	stream := cfg.BorrowStream(nil)
288
	defer cfg.ReturnStream(stream)
289
	stream.WriteVal(v)
290
	if stream.Error != nil {
291
		return "", stream.Error
292
	}
293
	return string(stream.Buffer()), nil
294
}
295

296
func (cfg *frozenConfig) Marshal(v interface{}) ([]byte, error) {
297
	stream := cfg.BorrowStream(nil)
298
	defer cfg.ReturnStream(stream)
299
	stream.WriteVal(v)
300
	if stream.Error != nil {
301
		return nil, stream.Error
302
	}
303
	result := stream.Buffer()
304
	copied := make([]byte, len(result))
305
	copy(copied, result)
306
	return copied, nil
307
}
308

309
func (cfg *frozenConfig) MarshalIndent(v interface{}, prefix, indent string) ([]byte, error) {
310
	if prefix != "" {
311
		panic("prefix is not supported")
312
	}
313
	for _, r := range indent {
314
		if r != ' ' {
315
			panic("indent can only be space")
316
		}
317
	}
318
	newCfg := cfg.configBeforeFrozen
319
	newCfg.IndentionStep = len(indent)
320
	return newCfg.frozeWithCacheReuse(cfg.extraExtensions).Marshal(v)
321
}
322

323
func (cfg *frozenConfig) UnmarshalFromString(str string, v interface{}) error {
324
	data := []byte(str)
325
	iter := cfg.BorrowIterator(data)
326
	defer cfg.ReturnIterator(iter)
327
	iter.ReadVal(v)
328
	c := iter.nextToken()
329
	if c == 0 {
330
		if iter.Error == io.EOF {
331
			return nil
332
		}
333
		return iter.Error
334
	}
335
	iter.ReportError("Unmarshal", "there are bytes left after unmarshal")
336
	return iter.Error
337
}
338

339
func (cfg *frozenConfig) Get(data []byte, path ...interface{}) Any {
340
	iter := cfg.BorrowIterator(data)
341
	defer cfg.ReturnIterator(iter)
342
	return locatePath(iter, path)
343
}
344

345
func (cfg *frozenConfig) Unmarshal(data []byte, v interface{}) error {
346
	iter := cfg.BorrowIterator(data)
347
	defer cfg.ReturnIterator(iter)
348
	iter.ReadVal(v)
349
	c := iter.nextToken()
350
	if c == 0 {
351
		if iter.Error == io.EOF {
352
			return nil
353
		}
354
		return iter.Error
355
	}
356
	iter.ReportError("Unmarshal", "there are bytes left after unmarshal")
357
	return iter.Error
358
}
359

360
func (cfg *frozenConfig) NewEncoder(writer io.Writer) *Encoder {
361
	stream := NewStream(cfg, writer, 512)
362
	return &Encoder{stream}
363
}
364

365
func (cfg *frozenConfig) NewDecoder(reader io.Reader) *Decoder {
366
	iter := Parse(cfg, reader, 512)
367
	return &Decoder{iter}
368
}
369

370
func (cfg *frozenConfig) Valid(data []byte) bool {
371
	iter := cfg.BorrowIterator(data)
372
	defer cfg.ReturnIterator(iter)
373
	iter.Skip()
374
	return iter.Error == nil
375
}
376