stack = new ArrayList();
30 | private JsonObject current;
31 | private boolean named;
32 | private OutputType outputType = OutputType.json;
33 | private boolean quoteLongValues = false;
34 |
35 | public JsonWriter (Writer writer) {
36 | this.writer = writer;
37 | }
38 |
39 | public Writer getWriter () {
40 | return writer;
41 | }
42 |
43 | /** Sets the type of JSON output. Default is {@link OutputType#minimal}. */
44 | public void setOutputType (OutputType outputType) {
45 | this.outputType = outputType;
46 | }
47 |
48 | /** When true, quotes long, double, BigInteger, BigDecimal types to prevent truncation in languages like JavaScript and PHP.
49 | * This is not necessary when using libgdx, which handles these types without truncation. Default is false. */
50 | public void setQuoteLongValues (boolean quoteLongValues) {
51 | this.quoteLongValues = quoteLongValues;
52 | }
53 |
54 | public JsonWriter name (String name) throws IOException {
55 | if (current == null || current.array) throw new IllegalStateException("Current item must be an object.");
56 | if (!current.needsComma)
57 | current.needsComma = true;
58 | else
59 | writer.write(',');
60 | writer.write(outputType.quoteName(name));
61 | writer.write(':');
62 | named = true;
63 | return this;
64 | }
65 |
66 | public JsonWriter object () throws IOException {
67 | requireCommaOrName();
68 | stack.add(current = new JsonObject(false));
69 | return this;
70 | }
71 |
72 | public JsonWriter array () throws IOException {
73 | requireCommaOrName();
74 | stack.add(current = new JsonObject(true));
75 | return this;
76 | }
77 |
78 | public JsonWriter value (Object value) throws IOException {
79 | if (quoteLongValues
80 | && (value instanceof Long || value instanceof Double || value instanceof BigDecimal || value instanceof BigInteger)) {
81 | value = value.toString();
82 | } else if (value instanceof Number) {
83 | Number number = (Number)value;
84 | long longValue = number.longValue();
85 | if (number.doubleValue() == longValue) value = longValue;
86 | }
87 | requireCommaOrName();
88 | writer.write(outputType.quoteValue(value));
89 | return this;
90 | }
91 |
92 | /** Writes the specified JSON value, without quoting or escaping. */
93 | public JsonWriter json (String json) throws IOException {
94 | requireCommaOrName();
95 | writer.write(json);
96 | return this;
97 | }
98 |
99 | private void requireCommaOrName () throws IOException {
100 | if (current == null) return;
101 | if (current.array) {
102 | if (!current.needsComma)
103 | current.needsComma = true;
104 | else
105 | writer.write(',');
106 | } else {
107 | if (!named) throw new IllegalStateException("Name must be set.");
108 | named = false;
109 | }
110 | }
111 |
112 | public JsonWriter object (String name) throws IOException {
113 | return name(name).object();
114 | }
115 |
116 | public JsonWriter array (String name) throws IOException {
117 | return name(name).array();
118 | }
119 |
120 | public JsonWriter set (String name, Object value) throws IOException {
121 | return name(name).value(value);
122 | }
123 |
124 | /** Writes the specified JSON value, without quoting or escaping. */
125 | public JsonWriter json (String name, String json) throws IOException {
126 | return name(name).json(json);
127 | }
128 |
129 | public JsonWriter pop () throws IOException {
130 | if (named) throw new IllegalStateException("Expected an object, array, or value since a name was set.");
131 | stack.remove(stack.size() - 1).close();
132 | current = stack.size() == 0 ? null : stack.get(stack.size() - 1);
133 | return this;
134 | }
135 |
136 | public void write (char[] cbuf, int off, int len) throws IOException {
137 | writer.write(cbuf, off, len);
138 | }
139 |
140 | public void flush () throws IOException {
141 | writer.flush();
142 | }
143 |
144 | public void close () throws IOException {
145 | while (stack.size() > 0)
146 | pop();
147 | writer.close();
148 | }
149 |
150 | private class JsonObject {
151 | final boolean array;
152 | boolean needsComma;
153 |
154 | JsonObject (boolean array) throws IOException {
155 | this.array = array;
156 | writer.write(array ? '[' : '{');
157 | }
158 |
159 | void close () throws IOException {
160 | writer.write(array ? ']' : '}');
161 | }
162 | }
163 | }
164 |
--------------------------------------------------------------------------------
/src/com/esotericsoftware/jsonbeans/Null.java:
--------------------------------------------------------------------------------
1 |
2 | package com.esotericsoftware.jsonbeans;
3 |
4 | import java.lang.annotation.Documented;
5 | import java.lang.annotation.ElementType;
6 | import java.lang.annotation.Target;
7 |
8 | /** An element with this annotation claims that the element may have a {@code null} value. Apart from documentation purposes this
9 | * annotation is intended to be used by static analysis tools to validate against probable runtime errors or contract violations.
10 | * @author maltaisn */
11 | @Documented
12 | @Target({ElementType.METHOD, ElementType.FIELD, ElementType.PARAMETER, ElementType.LOCAL_VARIABLE})
13 | public @interface Null {
14 | }
15 |
--------------------------------------------------------------------------------
/src/com/esotericsoftware/jsonbeans/ObjectMap.java:
--------------------------------------------------------------------------------
1 | /*******************************************************************************
2 | * Copyright 2011 See AUTHORS file.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | ******************************************************************************/
16 |
17 | package com.esotericsoftware.jsonbeans;
18 |
19 | import java.util.ArrayList;
20 | import java.util.Arrays;
21 | import java.util.Iterator;
22 | import java.util.List;
23 | import java.util.NoSuchElementException;
24 |
25 | /** An unordered map where the keys and values are objects. Null keys are not allowed. No allocation is done except when growing
26 | * the table size.
27 | *
28 | * This class performs fast contains and remove (typically O(1), worst case O(n) but that is rare in practice). Add may be
29 | * slightly slower, depending on hash collisions. Hashcodes are rehashed to reduce collisions and the need to resize. Load factors
30 | * greater than 0.91 greatly increase the chances to resize to the next higher POT size.
31 | *
32 | * Unordered sets and maps are not designed to provide especially fast iteration.
33 | *
34 | * This implementation uses linear probing with the backward shift algorithm for removal. Hashcodes are rehashed using Fibonacci
35 | * hashing, instead of the more common power-of-two mask, to better distribute poor hashCodes (see Malte
37 | * Skarupke's blog post). Linear probing continues to work even when all hashCodes collide, just more slowly.
38 | * @author Nathan Sweet
39 | * @author Tommy Ettinger */
40 | public class ObjectMap implements Iterable> {
41 | static final Object dummy = new Object();
42 |
43 | public int size;
44 |
45 | K[] keyTable;
46 | V[] valueTable;
47 |
48 | float loadFactor;
49 | int threshold;
50 |
51 | /** Used by {@link #place(Object)} to bit shift the upper bits of a {@code long} into a usable range (>= 0 and <=
52 | * {@link #mask}). The shift can be negative, which is convenient to match the number of bits in mask: if mask is a 7-bit
53 | * number, a shift of -7 shifts the upper 7 bits into the lowest 7 positions. This class sets the shift > 32 and < 64,
54 | * which if used with an int will still move the upper bits of an int to the lower bits due to Java's implicit modulus on
55 | * shifts.
56 | *
57 | * {@link #mask} can also be used to mask the low bits of a number, which may be faster for some hashcodes, if
58 | * {@link #place(Object)} is overridden. */
59 | protected int shift;
60 |
61 | /** A bitmask used to confine hashcodes to the size of the table. Must be all 1 bits in its low positions, ie a power of two
62 | * minus 1. If {@link #place(Object)} is overriden, this can be used instead of {@link #shift} to isolate usable bits of a
63 | * hash. */
64 | protected int mask;
65 |
66 | /** Creates a new map with an initial capacity of 51 and a load factor of 0.8. */
67 | public ObjectMap () {
68 | this(51, 0.8f);
69 | }
70 |
71 | /** Creates a new map with a load factor of 0.8.
72 | * @param initialCapacity If not a power of two, it is increased to the next nearest power of two. */
73 | public ObjectMap (int initialCapacity) {
74 | this(initialCapacity, 0.8f);
75 | }
76 |
77 | /** Creates a new map with the specified initial capacity and load factor. This map will hold initialCapacity items before
78 | * growing the backing table.
79 | * @param initialCapacity If not a power of two, it is increased to the next nearest power of two. */
80 | public ObjectMap (int initialCapacity, float loadFactor) {
81 | if (loadFactor <= 0f || loadFactor >= 1f)
82 | throw new IllegalArgumentException("loadFactor must be > 0 and < 1: " + loadFactor);
83 | this.loadFactor = loadFactor;
84 |
85 | int tableSize = tableSize(initialCapacity, loadFactor);
86 | threshold = (int)(tableSize * loadFactor);
87 | mask = tableSize - 1;
88 | shift = Long.numberOfLeadingZeros(mask);
89 |
90 | keyTable = (K[])new Object[tableSize];
91 | valueTable = (V[])new Object[tableSize];
92 | }
93 |
94 | /** Creates a new map identical to the specified map. */
95 | public ObjectMap (ObjectMap map) {
96 | this((int)(map.keyTable.length * map.loadFactor), map.loadFactor);
97 | System.arraycopy(map.keyTable, 0, keyTable, 0, map.keyTable.length);
98 | System.arraycopy(map.valueTable, 0, valueTable, 0, map.valueTable.length);
99 | size = map.size;
100 | }
101 |
102 | /** Returns an index >= 0 and <= {@link #mask} for the specified {@code item}.
103 | *
104 | * The default implementation uses Fibonacci hashing on the item's {@link Object#hashCode()}: the hashcode is multiplied by a
105 | * long constant (2 to the 64th, divided by the golden ratio) then the uppermost bits are shifted into the lowest positions to
106 | * obtain an index in the desired range. Multiplication by a long may be slower than int (eg on GWT) but greatly improves
107 | * rehashing, allowing even very poor hashcodes, such as those that only differ in their upper bits, to be used without high
108 | * collision rates. Fibonacci hashing has increased collision rates when all or most hashcodes are multiples of larger
109 | * Fibonacci numbers (see Malte
111 | * Skarupke's blog post).
112 | *
113 | * This method can be overriden to customizing hashing. This may be useful eg in the unlikely event that most hashcodes are
114 | * Fibonacci numbers, if keys provide poor or incorrect hashcodes, or to simplify hashing if keys provide high quality
115 | * hashcodes and don't need Fibonacci hashing: {@code return item.hashCode() & mask;} */
116 | protected int place (K item) {
117 | return (int)(item.hashCode() * 0x9E3779B97F4A7C15L >>> shift);
118 | }
119 |
120 | /** Returns the index of the key if already present, else -(index + 1) for the next empty index. This can be overridden in this
121 | * pacakge to compare for equality differently than {@link Object#equals(Object)}. */
122 | int locateKey (K key) {
123 | if (key == null) throw new IllegalArgumentException("key cannot be null.");
124 | K[] keyTable = this.keyTable;
125 | for (int i = place(key);; i = i + 1 & mask) {
126 | K other = keyTable[i];
127 | if (other == null) return -(i + 1); // Empty space is available.
128 | if (other.equals(key)) return i; // Same key was found.
129 | }
130 | }
131 |
132 | /** Returns the old value associated with the specified key, or null. */
133 | @Null
134 | public V put (K key, @Null V value) {
135 | int i = locateKey(key);
136 | if (i >= 0) { // Existing key was found.
137 | V oldValue = valueTable[i];
138 | valueTable[i] = value;
139 | return oldValue;
140 | }
141 | i = -(i + 1); // Empty space was found.
142 | keyTable[i] = key;
143 | valueTable[i] = value;
144 | if (++size >= threshold) resize(keyTable.length << 1);
145 | return null;
146 | }
147 |
148 | public void putAll (ObjectMap map) {
149 | ensureCapacity(map.size);
150 | K[] keyTable = map.keyTable;
151 | V[] valueTable = map.valueTable;
152 | K key;
153 | for (int i = 0, n = keyTable.length; i < n; i++) {
154 | key = keyTable[i];
155 | if (key != null) put(key, valueTable[i]);
156 | }
157 | }
158 |
159 | /** Skips checks for existing keys, doesn't increment size. */
160 | private void putResize (K key, @Null V value) {
161 | K[] keyTable = this.keyTable;
162 | for (int i = place(key);; i = (i + 1) & mask) {
163 | if (keyTable[i] == null) {
164 | keyTable[i] = key;
165 | valueTable[i] = value;
166 | return;
167 | }
168 | }
169 | }
170 |
171 | /** Returns the value for the specified key, or null if the key is not in the map. */
172 | @Null
173 | public V get (T key) {
174 | int i = locateKey(key);
175 | return i < 0 ? null : valueTable[i];
176 | }
177 |
178 | /** Returns the value for the specified key, or the default value if the key is not in the map. */
179 | public V get (K key, @Null V defaultValue) {
180 | int i = locateKey(key);
181 | return i < 0 ? defaultValue : valueTable[i];
182 | }
183 |
184 | @Null
185 | public V remove (K key) {
186 | int i = locateKey(key);
187 | if (i < 0) return null;
188 | K[] keyTable = this.keyTable;
189 | V[] valueTable = this.valueTable;
190 | V oldValue = valueTable[i];
191 | int mask = this.mask, next = i + 1 & mask;
192 | while ((key = keyTable[next]) != null) {
193 | int placement = place(key);
194 | if ((next - placement & mask) > (i - placement & mask)) {
195 | keyTable[i] = key;
196 | valueTable[i] = valueTable[next];
197 | i = next;
198 | }
199 | next = next + 1 & mask;
200 | }
201 | keyTable[i] = null;
202 | valueTable[i] = null;
203 | size--;
204 | return oldValue;
205 | }
206 |
207 | /** Returns true if the map has one or more items. */
208 | public boolean notEmpty () {
209 | return size > 0;
210 | }
211 |
212 | /** Returns true if the map is empty. */
213 | public boolean isEmpty () {
214 | return size == 0;
215 | }
216 |
217 | /** Reduces the size of the backing arrays to be the specified capacity / loadFactor, or less. If the capacity is already less,
218 | * nothing is done. If the map contains more items than the specified capacity, the next highest power of two capacity is used
219 | * instead. */
220 | public void shrink (int maximumCapacity) {
221 | if (maximumCapacity < 0) throw new IllegalArgumentException("maximumCapacity must be >= 0: " + maximumCapacity);
222 | int tableSize = tableSize(maximumCapacity, loadFactor);
223 | if (keyTable.length > tableSize) resize(tableSize);
224 | }
225 |
226 | /** Clears the map and reduces the size of the backing arrays to be the specified capacity / loadFactor, if they are larger. */
227 | public void clear (int maximumCapacity) {
228 | int tableSize = tableSize(maximumCapacity, loadFactor);
229 | if (keyTable.length <= tableSize) {
230 | clear();
231 | return;
232 | }
233 | size = 0;
234 | resize(tableSize);
235 | }
236 |
237 | public void clear () {
238 | if (size == 0) return;
239 | size = 0;
240 | Arrays.fill(keyTable, null);
241 | Arrays.fill(valueTable, null);
242 | }
243 |
244 | /** Returns true if the specified value is in the map. Note this traverses the entire map and compares every value, which may
245 | * be an expensive operation.
246 | * @param identity If true, uses == to compare the specified value with values in the map. If false, uses
247 | * {@link #equals(Object)}. */
248 | public boolean containsValue (@Null Object value, boolean identity) {
249 | V[] valueTable = this.valueTable;
250 | if (value == null) {
251 | K[] keyTable = this.keyTable;
252 | for (int i = valueTable.length - 1; i >= 0; i--)
253 | if (keyTable[i] != null && valueTable[i] == null) return true;
254 | } else if (identity) {
255 | for (int i = valueTable.length - 1; i >= 0; i--)
256 | if (valueTable[i] == value) return true;
257 | } else {
258 | for (int i = valueTable.length - 1; i >= 0; i--)
259 | if (value.equals(valueTable[i])) return true;
260 | }
261 | return false;
262 | }
263 |
264 | public boolean containsKey (K key) {
265 | return locateKey(key) >= 0;
266 | }
267 |
268 | /** Returns the key for the specified value, or null if it is not in the map. Note this traverses the entire map and compares
269 | * every value, which may be an expensive operation.
270 | * @param identity If true, uses == to compare the specified value with values in the map. If false, uses
271 | * {@link #equals(Object)}. */
272 | @Null
273 | public K findKey (@Null Object value, boolean identity) {
274 | V[] valueTable = this.valueTable;
275 | if (value == null) {
276 | K[] keyTable = this.keyTable;
277 | for (int i = valueTable.length - 1; i >= 0; i--)
278 | if (keyTable[i] != null && valueTable[i] == null) return keyTable[i];
279 | } else if (identity) {
280 | for (int i = valueTable.length - 1; i >= 0; i--)
281 | if (valueTable[i] == value) return keyTable[i];
282 | } else {
283 | for (int i = valueTable.length - 1; i >= 0; i--)
284 | if (value.equals(valueTable[i])) return keyTable[i];
285 | }
286 | return null;
287 | }
288 |
289 | /** Increases the size of the backing array to accommodate the specified number of additional items / loadFactor. Useful before
290 | * adding many items to avoid multiple backing array resizes. */
291 | public void ensureCapacity (int additionalCapacity) {
292 | int tableSize = tableSize(size + additionalCapacity, loadFactor);
293 | if (keyTable.length < tableSize) resize(tableSize);
294 | }
295 |
296 | final void resize (int newSize) {
297 | int oldCapacity = keyTable.length;
298 | threshold = (int)(newSize * loadFactor);
299 | mask = newSize - 1;
300 | shift = Long.numberOfLeadingZeros(mask);
301 |
302 | K[] oldKeyTable = keyTable;
303 | V[] oldValueTable = valueTable;
304 |
305 | keyTable = (K[])new Object[newSize];
306 | valueTable = (V[])new Object[newSize];
307 |
308 | if (size > 0) {
309 | for (int i = 0; i < oldCapacity; i++) {
310 | K key = oldKeyTable[i];
311 | if (key != null) putResize(key, oldValueTable[i]);
312 | }
313 | }
314 | }
315 |
316 | public int hashCode () {
317 | int h = size;
318 | K[] keyTable = this.keyTable;
319 | V[] valueTable = this.valueTable;
320 | for (int i = 0, n = keyTable.length; i < n; i++) {
321 | K key = keyTable[i];
322 | if (key != null) {
323 | h += key.hashCode();
324 | V value = valueTable[i];
325 | if (value != null) h += value.hashCode();
326 | }
327 | }
328 | return h;
329 | }
330 |
331 | public boolean equals (Object obj) {
332 | if (obj == this) return true;
333 | if (!(obj instanceof ObjectMap)) return false;
334 | ObjectMap other = (ObjectMap)obj;
335 | if (other.size != size) return false;
336 | K[] keyTable = this.keyTable;
337 | V[] valueTable = this.valueTable;
338 | for (int i = 0, n = keyTable.length; i < n; i++) {
339 | K key = keyTable[i];
340 | if (key != null) {
341 | V value = valueTable[i];
342 | if (value == null) {
343 | if (other.get(key, dummy) != null) return false;
344 | } else {
345 | if (!value.equals(other.get(key))) return false;
346 | }
347 | }
348 | }
349 | return true;
350 | }
351 |
352 | /** Uses == for comparison of each value. */
353 | public boolean equalsIdentity (@Null Object obj) {
354 | if (obj == this) return true;
355 | if (!(obj instanceof ObjectMap)) return false;
356 | ObjectMap other = (ObjectMap)obj;
357 | if (other.size != size) return false;
358 | K[] keyTable = this.keyTable;
359 | V[] valueTable = this.valueTable;
360 | for (int i = 0, n = keyTable.length; i < n; i++) {
361 | K key = keyTable[i];
362 | if (key != null && valueTable[i] != other.get(key, dummy)) return false;
363 | }
364 | return true;
365 | }
366 |
367 | public String toString (String separator) {
368 | return toString(separator, false);
369 | }
370 |
371 | public String toString () {
372 | return toString(", ", true);
373 | }
374 |
375 | private String toString (String separator, boolean braces) {
376 | if (size == 0) return braces ? "{}" : "";
377 | java.lang.StringBuilder buffer = new java.lang.StringBuilder(32);
378 | if (braces) buffer.append('{');
379 | K[] keyTable = this.keyTable;
380 | V[] valueTable = this.valueTable;
381 | int i = keyTable.length;
382 | while (i-- > 0) {
383 | K key = keyTable[i];
384 | if (key == null) continue;
385 | buffer.append(key == this ? "(this)" : key);
386 | buffer.append('=');
387 | V value = valueTable[i];
388 | buffer.append(value == this ? "(this)" : value);
389 | break;
390 | }
391 | while (i-- > 0) {
392 | K key = keyTable[i];
393 | if (key == null) continue;
394 | buffer.append(separator);
395 | buffer.append(key == this ? "(this)" : key);
396 | buffer.append('=');
397 | V value = valueTable[i];
398 | buffer.append(value == this ? "(this)" : value);
399 | }
400 | if (braces) buffer.append('}');
401 | return buffer.toString();
402 | }
403 |
404 | public Entries iterator () {
405 | return entries();
406 | }
407 |
408 | /** Returns an iterator for the entries in the map. Remove is supported. */
409 | public Entries entries () {
410 | return new Entries(this);
411 | }
412 |
413 | /** Returns an iterator for the values in the map. Remove is supported. */
414 | public Values values () {
415 | return new Values(this);
416 | }
417 |
418 | /** Returns an iterator for the keys in the map. Remove is supported. */
419 | public Keys keys () {
420 | return new Keys(this);
421 | }
422 |
423 | static public int tableSize (int capacity, float loadFactor) {
424 | if (capacity < 0) throw new IllegalArgumentException("capacity must be >= 0: " + capacity);
425 | int tableSize = nextPowerOfTwo(Math.max(2, (int)Math.ceil(capacity / loadFactor)));
426 | if (tableSize > 1 << 30) throw new IllegalArgumentException("The required capacity is too large: " + capacity);
427 | return tableSize;
428 | }
429 |
430 | static public int nextPowerOfTwo (int value) {
431 | if (value == 0) return 1;
432 | value--;
433 | value |= value >> 1;
434 | value |= value >> 2;
435 | value |= value >> 4;
436 | value |= value >> 8;
437 | value |= value >> 16;
438 | return value + 1;
439 | }
440 |
441 | static public class Entry {
442 | public K key;
443 | @Null public V value;
444 |
445 | public String toString () {
446 | return key + "=" + value;
447 | }
448 | }
449 |
450 | static private abstract class MapIterator implements Iterable, Iterator {
451 | public boolean hasNext;
452 |
453 | final ObjectMap map;
454 | int nextIndex, currentIndex;
455 |
456 | public MapIterator (ObjectMap map) {
457 | this.map = map;
458 | reset();
459 | }
460 |
461 | public void reset () {
462 | currentIndex = -1;
463 | nextIndex = -1;
464 | findNextIndex();
465 | }
466 |
467 | void findNextIndex () {
468 | K[] keyTable = map.keyTable;
469 | for (int n = keyTable.length; ++nextIndex < n;) {
470 | if (keyTable[nextIndex] != null) {
471 | hasNext = true;
472 | return;
473 | }
474 | }
475 | hasNext = false;
476 | }
477 |
478 | public void remove () {
479 | int i = currentIndex;
480 | if (i < 0) throw new IllegalStateException("next must be called before remove.");
481 | K[] keyTable = map.keyTable;
482 | V[] valueTable = map.valueTable;
483 | int mask = map.mask, next = i + 1 & mask;
484 | K key;
485 | while ((key = keyTable[next]) != null) {
486 | int placement = map.place(key);
487 | if ((next - placement & mask) > (i - placement & mask)) {
488 | keyTable[i] = key;
489 | valueTable[i] = valueTable[next];
490 | i = next;
491 | }
492 | next = next + 1 & mask;
493 | }
494 | keyTable[i] = null;
495 | valueTable[i] = null;
496 | map.size--;
497 | if (i != currentIndex) --nextIndex;
498 | currentIndex = -1;
499 | }
500 | }
501 |
502 | static public class Entries extends MapIterator> {
503 | Entry entry = new Entry();
504 |
505 | public Entries (ObjectMap map) {
506 | super(map);
507 | }
508 |
509 | /** Note the same entry instance is returned each time this method is called. */
510 | public Entry next () {
511 | if (!hasNext) throw new NoSuchElementException();
512 | K[] keyTable = map.keyTable;
513 | entry.key = keyTable[nextIndex];
514 | entry.value = map.valueTable[nextIndex];
515 | currentIndex = nextIndex;
516 | findNextIndex();
517 | return entry;
518 | }
519 |
520 | public boolean hasNext () {
521 | return hasNext;
522 | }
523 |
524 | public Entries iterator () {
525 | return this;
526 | }
527 | }
528 |
529 | static public class Values extends MapIterator {
530 | public Values (ObjectMap map) {
531 | super((ObjectMap)map);
532 | }
533 |
534 | public boolean hasNext () {
535 | return hasNext;
536 | }
537 |
538 | @Null
539 | public V next () {
540 | if (!hasNext) throw new NoSuchElementException();
541 | V value = map.valueTable[nextIndex];
542 | currentIndex = nextIndex;
543 | findNextIndex();
544 | return value;
545 | }
546 |
547 | public Values iterator () {
548 | return this;
549 | }
550 |
551 | /** Returns a new list containing the remaining keys. */
552 | public ArrayList toList () {
553 | return toList(new ArrayList(map.size));
554 | }
555 |
556 | /** Adds the remaining keys to the list. */
557 | public > T toList (T array) {
558 | while (hasNext)
559 | array.add(next());
560 | return array;
561 | }
562 | }
563 |
564 | static public class Keys extends MapIterator {
565 | public Keys (ObjectMap map) {
566 | super((ObjectMap)map);
567 | }
568 |
569 | public boolean hasNext () {
570 | return hasNext;
571 | }
572 |
573 | public K next () {
574 | if (!hasNext) throw new NoSuchElementException();
575 | K key = map.keyTable[nextIndex];
576 | currentIndex = nextIndex;
577 | findNextIndex();
578 | return key;
579 | }
580 |
581 | public Keys iterator () {
582 | return this;
583 | }
584 |
585 | /** Returns a new list containing the remaining keys. */
586 | public ArrayList toList () {
587 | return toList(new ArrayList(map.size));
588 | }
589 |
590 | /** Adds the remaining keys to the list. */
591 | public > T toList (T array) {
592 | while (hasNext)
593 | array.add(next());
594 | return array;
595 | }
596 | }
597 | }
598 |
--------------------------------------------------------------------------------
/src/com/esotericsoftware/jsonbeans/OrderedMap.java:
--------------------------------------------------------------------------------
1 |
2 | package com.esotericsoftware.jsonbeans;
3 |
4 | import java.util.ArrayList;
5 | import java.util.List;
6 | import java.util.NoSuchElementException;
7 |
8 | /** An {@link ObjectMap} that also stores keys in an {@link ArrayList} using the insertion order. Null keys are not allowed. No
9 | * allocation is done except when growing the table size.
10 | *
11 | * Iteration over the {@link #entries()}, {@link #keys()}, and {@link #values()} is ordered and faster than an unordered map. Keys
12 | * can also be accessed and the order changed using {@link #orderedKeys()}. There is some additional overhead for put and remove.
13 | *
14 | * This class performs fast contains (typically O(1), worst case O(n) but that is rare in practice). Remove is somewhat slower due
15 | * to {@link #orderedKeys()}. Add may be slightly slower, depending on hash collisions. Hashcodes are rehashed to reduce
16 | * collisions and the need to resize. Load factors greater than 0.91 greatly increase the chances to resize to the next higher POT
17 | * size.
18 | *
19 | * Unordered sets and maps are not designed to provide especially fast iteration. Iteration is faster with OrderedSet and
20 | * OrderedMap.
21 | *
22 | * This implementation uses linear probing with the backward shift algorithm for removal. Hashcodes are rehashed using Fibonacci
23 | * hashing, instead of the more common power-of-two mask, to better distribute poor hashCodes (see Malte
25 | * Skarupke's blog post). Linear probing continues to work even when all hashCodes collide, just more slowly.
26 | * @author Nathan Sweet
27 | * @author Tommy Ettinger */
28 | public class OrderedMap extends ObjectMap {
29 | final ArrayList keys;
30 |
31 | public OrderedMap () {
32 | keys = new ArrayList();
33 | }
34 |
35 | public OrderedMap (int initialCapacity) {
36 | super(initialCapacity);
37 | keys = new ArrayList(initialCapacity);
38 | }
39 |
40 | public OrderedMap (int initialCapacity, float loadFactor) {
41 | super(initialCapacity, loadFactor);
42 | keys = new ArrayList(initialCapacity);
43 | }
44 |
45 | public OrderedMap (OrderedMap map) {
46 | super(map);
47 | keys = new ArrayList(map.keys);
48 | }
49 |
50 | public V put (K key, V value) {
51 | int i = locateKey(key);
52 | if (i >= 0) { // Existing key was found.
53 | V oldValue = valueTable[i];
54 | valueTable[i] = value;
55 | return oldValue;
56 | }
57 | i = -(i + 1); // Empty space was found.
58 | keyTable[i] = key;
59 | valueTable[i] = value;
60 | keys.add(key);
61 | if (++size >= threshold) resize(keyTable.length << 1);
62 | return null;
63 | }
64 |
65 | public void putAll (OrderedMap map) {
66 | ensureCapacity(map.size);
67 | ArrayList keys = map.keys;
68 | for (int i = 0, n = map.keys.size(); i < n; i++) {
69 | K key = keys.get(i);
70 | put(key, map.get((T)key));
71 | }
72 | }
73 |
74 | public V remove (K key) {
75 | keys.remove(key);
76 | return super.remove(key);
77 | }
78 |
79 | public V removeIndex (int index) {
80 | return super.remove(keys.remove(index));
81 | }
82 |
83 | /** Changes the key {@code before} to {@code after} without changing its position in the order or its value. Returns true if
84 | * {@code after} has been added to the OrderedMap and {@code before} has been removed; returns false if {@code after} is
85 | * already present or {@code before} is not present. If you are iterating over an OrderedMap and have an index, you should
86 | * prefer {@link #alterIndex(int, Object)}, which doesn't need to search for an index like this does and so can be faster.
87 | * @param before a key that must be present for this to succeed
88 | * @param after a key that must not be in this map for this to succeed
89 | * @return true if {@code before} was removed and {@code after} was added, false otherwise */
90 | public boolean alter (K before, K after) {
91 | if (containsKey(after)) return false;
92 | int index = keys.indexOf(before);
93 | if (index == -1) return false;
94 | super.put(after, super.remove(before));
95 | keys.set(index, after);
96 | return true;
97 | }
98 |
99 | /** Changes the key at the given {@code index} in the order to {@code after}, without changing the ordering of other entries or
100 | * any values. If {@code after} is already present, this returns false; it will also return false if {@code index} is invalid
101 | * for the size of this map. Otherwise, it returns true. Unlike {@link #alter(Object, Object)}, this operates in constant time.
102 | * @param index the index in the order of the key to change; must be non-negative and less than {@link #size}
103 | * @param after the key that will replace the contents at {@code index}; this key must not be present for this to succeed
104 | * @return true if {@code after} successfully replaced the key at {@code index}, false otherwise */
105 | public boolean alterIndex (int index, K after) {
106 | if (index < 0 || index >= size || containsKey(after)) return false;
107 | super.put(after, super.remove(keys.get(index)));
108 | keys.set(index, after);
109 | return true;
110 | }
111 |
112 | public void clear (int maximumCapacity) {
113 | keys.clear();
114 | super.clear(maximumCapacity);
115 | }
116 |
117 | public void clear () {
118 | keys.clear();
119 | super.clear();
120 | }
121 |
122 | public ArrayList orderedKeys () {
123 | return keys;
124 | }
125 |
126 | public Entries iterator () {
127 | return entries();
128 | }
129 |
130 | /** Returns an iterator for the entries in the map. Remove is supported. */
131 | public Entries entries () {
132 | return new OrderedMapEntries(this);
133 | }
134 |
135 | /** Returns an iterator for the values in the map. Remove is supported. */
136 | public Values values () {
137 | return new OrderedMapValues(this);
138 | }
139 |
140 | /** Returns an iterator for the keys in the map. Remove is supported. */
141 | public Keys keys () {
142 | return new OrderedMapKeys(this);
143 | }
144 |
145 | public String toString () {
146 | if (size == 0) return "{}";
147 | java.lang.StringBuilder buffer = new java.lang.StringBuilder(32);
148 | buffer.append('{');
149 | ArrayList keys = this.keys;
150 | for (int i = 0, n = keys.size(); i < n; i++) {
151 | K key = keys.get(i);
152 | if (i > 0) buffer.append(", ");
153 | buffer.append(key);
154 | buffer.append('=');
155 | buffer.append(get(key));
156 | }
157 | buffer.append('}');
158 | return buffer.toString();
159 | }
160 |
161 | static public class OrderedMapEntries extends Entries {
162 | private ArrayList keys;
163 |
164 | public OrderedMapEntries (OrderedMap map) {
165 | super(map);
166 | keys = map.keys;
167 | }
168 |
169 | public void reset () {
170 | currentIndex = -1;
171 | nextIndex = 0;
172 | hasNext = map.size > 0;
173 | }
174 |
175 | public Entry next () {
176 | if (!hasNext) throw new NoSuchElementException();
177 | currentIndex = nextIndex;
178 | entry.key = keys.get(nextIndex);
179 | entry.value = map.get(entry.key);
180 | nextIndex++;
181 | hasNext = nextIndex < map.size;
182 | return entry;
183 | }
184 |
185 | public void remove () {
186 | if (currentIndex < 0) throw new IllegalStateException("next must be called before remove.");
187 | map.remove(entry.key);
188 | nextIndex--;
189 | currentIndex = -1;
190 | }
191 | }
192 |
193 | static public class OrderedMapKeys extends Keys {
194 | private ArrayList keys;
195 |
196 | public OrderedMapKeys (OrderedMap map) {
197 | super(map);
198 | keys = map.keys;
199 | }
200 |
201 | public void reset () {
202 | currentIndex = -1;
203 | nextIndex = 0;
204 | hasNext = map.size > 0;
205 | }
206 |
207 | public K next () {
208 | if (!hasNext) throw new NoSuchElementException();
209 | K key = keys.get(nextIndex);
210 | currentIndex = nextIndex;
211 | nextIndex++;
212 | hasNext = nextIndex < map.size;
213 | return key;
214 | }
215 |
216 | public void remove () {
217 | if (currentIndex < 0) throw new IllegalStateException("next must be called before remove.");
218 | ((OrderedMap)map).removeIndex(currentIndex);
219 | nextIndex = currentIndex;
220 | currentIndex = -1;
221 | }
222 | }
223 |
224 | static public class OrderedMapValues extends Values {
225 | private ArrayList keys;
226 |
227 | public OrderedMapValues (OrderedMap map) {
228 | super(map);
229 | keys = map.keys;
230 | }
231 |
232 | public void reset () {
233 | currentIndex = -1;
234 | nextIndex = 0;
235 | hasNext = map.size > 0;
236 | }
237 |
238 | public V next () {
239 | if (!hasNext) throw new NoSuchElementException();
240 | V value = map.get(keys.get(nextIndex));
241 | currentIndex = nextIndex;
242 | nextIndex++;
243 | hasNext = nextIndex < map.size;
244 | return value;
245 | }
246 |
247 | public void remove () {
248 | if (currentIndex < 0) throw new IllegalStateException("next must be called before remove.");
249 | ((OrderedMap)map).removeIndex(currentIndex);
250 | nextIndex = currentIndex;
251 | currentIndex = -1;
252 | }
253 |
254 | public > T toList (T array) {
255 | int n = keys.size();
256 | for (int i = nextIndex; i < n; i++)
257 | array.add(map.get(keys.get(i)));
258 | currentIndex = n - 1;
259 | nextIndex = n;
260 | hasNext = false;
261 | return array;
262 | }
263 |
264 | public ArrayList toList () {
265 | return toList(new ArrayList(keys.size() - nextIndex));
266 | }
267 | }
268 | }
269 |
--------------------------------------------------------------------------------
/src/com/esotericsoftware/jsonbeans/OutputType.java:
--------------------------------------------------------------------------------
1 |
2 | package com.esotericsoftware.jsonbeans;
3 |
4 | import java.util.regex.Pattern;
5 |
6 | public enum OutputType {
7 | /** Normal JSON, with all its double quotes. */
8 | json,
9 | /** Like JSON, but names are only double quoted if necessary. */
10 | javascript,
11 | /** Like JSON, but:
12 | *
13 | * - Names only require double quotes if they start with
space or any of ":,}/ or they contain
14 | * // or /* or :.
15 | * - Values only require double quotes if they start with
space or any of ":,{[]/ or they contain
16 | * // or /* or any of }], or they are equal to true, false ,
17 | * or null.
18 | * - Newlines are treated as commas, making commas optional in many cases.
19 | *
- C style comments may be used:
//... or /*...*/
20 | *
21 | */
22 | minimal;
23 |
24 | static private Pattern javascriptPattern = Pattern.compile("^[a-zA-Z_$][a-zA-Z_$0-9]*$");
25 | static private Pattern minimalNamePattern = Pattern.compile("^[^\":,}/ ][^:]*$");
26 | static private Pattern minimalValuePattern = Pattern.compile("^[^\":,{\\[\\]/ ][^}\\],]*$");
27 |
28 | public String quoteValue (Object value) {
29 | if (value == null) return "null";
30 | String string = value.toString();
31 | if (value instanceof Number || value instanceof Boolean) return string;
32 | StringBuilder buffer = new StringBuilder(string);
33 | replace(buffer, '\\', "\\\\");
34 | replace(buffer, '\r', "\\r");
35 | replace(buffer, '\n', "\\n");
36 | replace(buffer, '\t', "\\t");
37 | if (this == OutputType.minimal && !string.equals("true") && !string.equals("false") && !string.equals("null")
38 | && !string.contains("//") && !string.contains("/*")) {
39 | int length = buffer.length();
40 | if (length > 0 && buffer.charAt(length - 1) != ' ' && minimalValuePattern.matcher(buffer).matches())
41 | return buffer.toString();
42 | }
43 | return '"' + replace(buffer, '"', "\\\"").toString() + '"';
44 | }
45 |
46 | public String quoteName (String value) {
47 | StringBuilder buffer = new StringBuilder(value);
48 | replace(buffer, '\\', "\\\\");
49 | replace(buffer, '\r', "\\r");
50 | replace(buffer, '\n', "\\n");
51 | replace(buffer, '\t', "\\t");
52 | switch (this) {
53 | case minimal:
54 | if (!value.contains("//") && !value.contains("/*") && minimalNamePattern.matcher(buffer).matches())
55 | return buffer.toString();
56 | case javascript:
57 | if (javascriptPattern.matcher(buffer).matches()) return buffer.toString();
58 | }
59 | return '"' + replace(buffer, '"', "\\\"").toString() + '"';
60 | }
61 |
62 | static private StringBuilder replace (StringBuilder buffer, char find, String replace) {
63 | int replaceLength = replace.length();
64 | int index = 0;
65 | while (true) {
66 | while (true) {
67 | if (index == buffer.length()) return buffer;
68 | if (buffer.charAt(index) == find) break;
69 | index++;
70 | }
71 | buffer.replace(index, index + 1, replace);
72 | index += replaceLength;
73 | }
74 | }
75 | }
76 |
--------------------------------------------------------------------------------
/src/com/esotericsoftware/jsonbeans/ReadOnlySerializer.java:
--------------------------------------------------------------------------------
1 |
2 | package com.esotericsoftware.jsonbeans;
3 |
4 | public abstract class ReadOnlySerializer implements JsonSerializer {
5 | public void write (Json json, T object, Class knownType) {
6 | }
7 |
8 | abstract public T read (Json json, JsonValue jsonData, Class type);
9 | }
10 |
--------------------------------------------------------------------------------