-
Notifications
You must be signed in to change notification settings - Fork 60
/
JsonProvider.java
511 lines (469 loc) · 16.7 KB
/
JsonProvider.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
/*
* Copyright (c) 2011, 2021 Oracle and/or its affiliates. All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v. 2.0, which is available at
* http://www.eclipse.org/legal/epl-2.0.
*
* This Source Code may also be made available under the following Secondary
* Licenses when the conditions for such availability set forth in the
* Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
* version 2 with the GNU Classpath Exception, which is available at
* https://www.gnu.org/software/classpath/license.html.
*
* SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
*/
package jakarta.json.spi;
import jakarta.json.*;
import jakarta.json.stream.JsonGenerator;
import jakarta.json.stream.JsonGeneratorFactory;
import jakarta.json.stream.JsonParser;
import jakarta.json.stream.JsonParserFactory;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.io.Writer;
import java.util.Collection;
import java.util.Iterator;
import java.util.Map;
import java.util.ServiceLoader;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Optional;
/**
* Service provider for JSON processing objects.
*
* <p>All the methods in this class are safe for use by multiple concurrent
* threads.
*
* @see ServiceLoader
*/
public abstract class JsonProvider {
/**
* A constant representing the name of the default
* {@code JsonProvider} implementation class.
*/
private static final String DEFAULT_PROVIDER
= "org.eclipse.jsonp.JsonProviderImpl";
/**
* Default constructor.
*/
protected JsonProvider() {
}
/**
* Creates a JSON provider object. The provider is loaded using the
* {@link ServiceLoader#load(Class)} method. If there are no available
* service providers, this method returns the default service provider.
* Users are recommended to cache the result of this method.
*
* @see ServiceLoader
* @return a JSON provider
*/
public static JsonProvider provider() {
ServiceLoader<JsonProvider> loader = ServiceLoader.load(JsonProvider.class);
Iterator<JsonProvider> it = loader.iterator();
if (it.hasNext()) {
return it.next();
}
try {
Class<?> clazz = Class.forName(DEFAULT_PROVIDER);
return (JsonProvider) clazz.getConstructor().newInstance();
} catch (ClassNotFoundException x) {
throw new JsonException(
"Provider " + DEFAULT_PROVIDER + " not found", x);
} catch (Exception x) {
throw new JsonException(
"Provider " + DEFAULT_PROVIDER + " could not be instantiated: " + x,
x);
}
}
/**
* Creates a JSON parser from a character stream.
*
* @param reader i/o reader from which JSON is to be read
* @return a JSON parser
*/
public abstract JsonParser createParser(Reader reader);
/**
* Creates a JSON parser from the specified byte stream.
* The character encoding of the stream is determined
* as defined in <a href="http://tools.ietf.org/rfc/rfc7159.txt">RFC 7159
* </a>.
*
* @param in i/o stream from which JSON is to be read
* @throws JsonException if encoding cannot be determined
* or i/o error (IOException would be cause of JsonException)
* @return a JSON parser
*/
public abstract JsonParser createParser(InputStream in);
/**
* Creates a parser factory for creating {@link JsonParser} instances.
*
* @return a JSON parser factory
*
public abstract JsonParserFactory createParserFactory();
*/
/**
* Creates a parser factory for creating {@link JsonParser} instances.
* The factory is configured with the specified map of
* provider specific configuration properties. Provider implementations
* should ignore any unsupported configuration properties specified in
* the map.
*
* @param config a map of provider specific properties to configure the
* JSON parsers. The map may be empty or null
* @return a JSON parser factory
*/
public abstract JsonParserFactory createParserFactory(Map<String, ?> config);
/**
* Creates a JSON generator for writing JSON text to a character stream.
*
* @param writer a i/o writer to which JSON is written
* @return a JSON generator
*/
public abstract JsonGenerator createGenerator(Writer writer);
/**
* Creates a JSON generator for writing JSON text to a byte stream.
*
* @param out i/o stream to which JSON is written
* @return a JSON generator
*/
public abstract JsonGenerator createGenerator(OutputStream out);
/**
* Creates a generator factory for creating {@link JsonGenerator} instances.
*
* @return a JSON generator factory
*
public abstract JsonGeneratorFactory createGeneratorFactory();
*/
/**
* Creates a generator factory for creating {@link JsonGenerator} instances.
* The factory is configured with the specified map of provider specific
* configuration properties. Provider implementations should
* ignore any unsupported configuration properties specified in the map.
*
* @param config a map of provider specific properties to configure the
* JSON generators. The map may be empty or null
* @return a JSON generator factory
*/
public abstract JsonGeneratorFactory createGeneratorFactory(Map<String, ?> config);
/**
* Creates a JSON reader from a character stream.
*
* @param reader a reader from which JSON is to be read
* @return a JSON reader
*/
public abstract JsonReader createReader(Reader reader);
/**
* Creates a JSON reader from a byte stream. The character encoding of
* the stream is determined as described in
* <a href="http://tools.ietf.org/rfc/rfc7159.txt">RFC 7159</a>.
*
* @param in a byte stream from which JSON is to be read
* @return a JSON reader
*/
public abstract JsonReader createReader(InputStream in);
/**
* Creates a JSON writer to write a
* JSON {@link JsonObject object} or {@link JsonArray array}
* structure to the specified character stream.
*
* @param writer to which JSON object or array is written
* @return a JSON writer
*/
public abstract JsonWriter createWriter(Writer writer);
/**
* Creates a JSON writer to write a
* JSON {@link JsonObject object} or {@link JsonArray array}
* structure to the specified byte stream. Characters written to
* the stream are encoded into bytes using UTF-8 encoding.
*
* @param out to which JSON object or array is written
* @return a JSON writer
*/
public abstract JsonWriter createWriter(OutputStream out);
/**
* Creates a writer factory for creating {@link JsonWriter} objects.
* The factory is configured with the specified map of provider specific
* configuration properties. Provider implementations should ignore any
* unsupported configuration properties specified in the map.
*
* @param config a map of provider specific properties to configure the
* JSON writers. The map may be empty or null
* @return a JSON writer factory
*/
public abstract JsonWriterFactory createWriterFactory(Map<String,?> config);
/**
* Creates a reader factory for creating {@link JsonReader} objects.
* The factory is configured with the specified map of provider specific
* configuration properties. Provider implementations should ignore any
* unsupported configuration properties specified in the map.
*
* @param config a map of provider specific properties to configure the
* JSON readers. The map may be empty or null
* @return a JSON reader factory
*/
public abstract JsonReaderFactory createReaderFactory(Map<String,?> config);
/**
* Creates a JSON object builder.
*
* @return a JSON object builder
*/
public abstract JsonObjectBuilder createObjectBuilder();
/**
* Creates a JSON object builder, initialized with the specified object.
*
* @param object the initial JSON object in the builder
* @return a JSON object builder
*
* @since 1.1
*/
public JsonObjectBuilder createObjectBuilder(JsonObject object) {
throw new UnsupportedOperationException();
}
/**
* Creates a JSON object builder, initialized with the data from specified {@code map}.
* If the @{code map} contains {@link Optional}s then resulting JSON object builder
* contains the key from the {@code map} only if the {@link Optional} is not empty.
*
* @param map the initial object in the builder
* @return a JSON object builder
* @exception IllegalArgumentException if the value from the {@code map} cannot be converted
* to the corresponding {@link JsonValue}
*
* @since 1.1
*/
public JsonObjectBuilder createObjectBuilder(Map<String, ?> map) {
throw new UnsupportedOperationException();
}
/**
* Creates a JSON array builder.
*
* @return a JSON array builder
*/
public abstract JsonArrayBuilder createArrayBuilder();
/**
* Creates a JSON array builder, initialized with the specified array.
*
* @param array the initial JSON array in the builder
* @return a JSON array builder
*
* @since 1.1
*/
public JsonArrayBuilder createArrayBuilder(JsonArray array) {
throw new UnsupportedOperationException();
}
/**
* Creates JSON Pointer (<a href="http://tools.ietf.org/html/rfc6901">RFC 6901</a>)
* from given {@code jsonPointer} string.
* <ul>
* <li>An empty {@code jsonPointer} string defines a reference to the target itself.</li>
* <li>If the {@code jsonPointer} string is non-empty, it must be a sequence of '{@code /}' prefixed tokens.</li>
* </ul>
*
* @param jsonPointer the JSON Pointer string
* @throws NullPointerException if {@code jsonPointer} is {@code null}
* @throws JsonException if {@code jsonPointer} is not a valid JSON Pointer
* @return a JSON Pointer
*
* @since 1.1
*/
public JsonPointer createPointer(String jsonPointer) {
throw new UnsupportedOperationException();
}
/**
* Creates a JSON Patch builder (<a href="http://tools.ietf.org/html/rfc6902">RFC 6902</a>).
*
* @return a JSON Patch builder
*
* @since 1.1
*/
public JsonPatchBuilder createPatchBuilder() {
throw new UnsupportedOperationException();
}
/**
* Creates a JSON Patch builder
* (<a href="http://tools.ietf.org/html/rfc6902">RFC 6902</a>),
* initialized with the specified operations.
*
* @param array the initial patch operations
* @return a JSON Patch builder
*
* @since 1.1
*/
public JsonPatchBuilder createPatchBuilder(JsonArray array) {
throw new UnsupportedOperationException();
}
/**
* Creates a JSON Patch (<a href="http://tools.ietf.org/html/rfc6902">RFC 6902</a>)
* from the specified operations.
*
* @param array patch operations
* @return a JSON Patch
*
* @since 1.1
*/
public JsonPatch createPatch(JsonArray array) {
throw new UnsupportedOperationException();
}
/**
* Generates a JSON Patch (<a href="http://tools.ietf.org/html/rfc6902">RFC 6902</a>)
* from the source and target {@code JsonStructure}.
* The generated JSON Patch need not be unique.
*
* @param source the source
* @param target the target, must be the same type as the source
* @return a JSON Patch which when applied to the source, yields the target
*
* @since 1.1
*/
public JsonPatch createDiff(JsonStructure source, JsonStructure target) {
throw new UnsupportedOperationException();
}
/**
* Creates JSON Merge Patch (<a href="http://tools.ietf.org/html/rfc7396">RFC 7396</a>)
* from specified {@code JsonValue}.
*
* @param patch the patch
* @return a JSON Merge Patch
*
* @since 1.1
*/
public JsonMergePatch createMergePatch(JsonValue patch) {
throw new UnsupportedOperationException();
}
/**
* Generates a JSON Merge Patch (<a href="http://tools.ietf.org/html/rfc7396">RFC 7396</a>)
* from the source and target {@code JsonValue}s
* which when applied to the {@code source}, yields the {@code target}.
*
* @param source the source
* @param target the target
* @return a JSON Merge Patch
*
* @since 1.1
*/
public JsonMergePatch createMergeDiff(JsonValue source, JsonValue target) {
throw new UnsupportedOperationException();
}
/**
* Creates a JSON array builder, initialized with the content of specified {@code collection}.
* If the @{code collection} contains {@link Optional}s then resulting JSON array builder
* contains the value from the {@code collection} only if the {@link Optional} is not empty.
*
* @param collection the initial data for the builder
* @return a JSON array builder
* @exception IllegalArgumentException if the value from the {@code collection} cannot be converted
* to the corresponding {@link JsonValue}
*
* @since 1.1
*/
public JsonArrayBuilder createArrayBuilder(Collection<?> collection) {
throw new UnsupportedOperationException();
}
/**
* Creates a builder factory for creating {@link JsonArrayBuilder}
* and {@link JsonObjectBuilder} objects.
* The factory is configured with the specified map of provider specific
* configuration properties. Provider implementations should ignore any
* unsupported configuration properties specified in the map.
*
* @param config a map of provider specific properties to configure the
* JSON builders. The map may be empty or null
* @return a JSON builder factory
*/
public abstract JsonBuilderFactory createBuilderFactory(Map<String,?> config);
/**
* Creates a JsonString.
*
* @param value a JSON string
* @return the JsonString for the string
*
* @since 1.1
*/
public JsonString createValue(String value) {
throw new UnsupportedOperationException();
}
/**
* Creates a JsonNumber.
*
* @param value a JSON number
* @return the JsonNumber for the number
*
* @since 1.1
*/
public JsonNumber createValue(int value) {
throw new UnsupportedOperationException();
}
/**
* Creates a JsonNumber.
*
* @param value a JSON number
* @return the JsonNumber for the number
*
* @since 1.1
*/
public JsonNumber createValue(long value) {
throw new UnsupportedOperationException();
}
/**
* Creates a JsonNumber.
*
* @param value a JSON number
* @return the JsonNumber for the number
*
* @since 1.1
*/
public JsonNumber createValue(double value) {
throw new UnsupportedOperationException();
}
/**
* Creates a JsonNumber.
*
* @param value a JSON number
* @return the JsonNumber for the number
*
* @since 1.1
*/
public JsonNumber createValue(BigDecimal value) {
throw new UnsupportedOperationException();
}
/**
* Creates a JsonNumber.
*
* @param value a JSON number
* @return the JsonNumber for the number
*
* @since 1.1
*/
public JsonNumber createValue(BigInteger value) {
throw new UnsupportedOperationException();
}
/**
* Creates a JsonNumber.
*
* When it is not implemented it checks the type and delegates
* to an existing method that already handles that type. It throws
* UnsupportedOperationException in case the type is not known.
*
* @param number a JSON number
* @return the JsonNumber for the number
*
* @since 2.1
*/
public JsonNumber createValue(Number number) {
if (number instanceof Integer) {
return createValue(number.intValue());
} else if (number instanceof Long) {
return createValue(number.longValue());
} else if (number instanceof Double) {
return createValue(number.doubleValue());
} else if (number instanceof BigInteger) {
return createValue((BigInteger) number);
} else if (number instanceof BigDecimal) {
return createValue((BigDecimal) number);
} else {
throw new UnsupportedOperationException(number + " type is not known");
}
}
}