GrepCode: net.sf.json.JSONObject (.java) - Class

Maven-Central
/
org.kohsuke.stapler / json-lib
/
2.1-rev6

2.1
2.1-rev6
2.1-rev5
2.1-rev4
2.1-rev3
2.1-rev2
/
net.sf.json.JSONObject
Find Usages
Diff
Raw
Download
HTML Widget
Stack Overflow Questions
1
   /*
2
    * Copyright 2002-2007 the original author or authors.
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
  package net.sf.json;
17
  
18
  /*
19
  Copyright (c) 2002 JSON.org
20
  
21
  Permission is hereby granted, free of charge, to any person obtaining a copy
22
  of this software and associated documentation files (the "Software"), to deal
23
  in the Software without restriction, including without limitation the rights
24
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
25
  copies of the Software, and to permit persons to whom the Software is
26
  furnished to do so, subject to the following conditions:
27
  
28
  The above copyright notice and this permission notice shall be included in all
29
  copies or substantial portions of the Software.
30
  
31
  The Software shall be used for Good, not Evil.
32
  
33
  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
34
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
35
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
36
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
37
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
38
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
39
  SOFTWARE.
40
  */
41
  
42
  import java.beans.PropertyDescriptor;
43
  import java.io.IOException;
44
  import java.io.Writer;
45
  import java.lang.annotation.Annotation;
46
  import java.lang.reflect.Array;
47
  import java.lang.reflect.Field;
48
  import java.lang.reflect.Modifier;
49
  import java.lang.reflect.InvocationTargetException;
50
  import java.util.Collection;
51
  import java.util.Collections;
52
  import java.util.HashMap;
53
  import java.util.Iterator;
54
  import java.util.List;
55
  import java.util.Map;
56
  import java.util.Set;
57
  import java.util.TreeMap;
58
  
59
  import net.sf.ezmorph.Morpher;
60
  import net.sf.ezmorph.array.ObjectArrayMorpher;
61
  import net.sf.ezmorph.bean.BeanMorpher;
62
  import net.sf.ezmorph.object.IdentityObjectMorpher;
63
  import net.sf.json.processors.JsonBeanProcessor;
64
  import net.sf.json.processors.JsonValueProcessor;
65
  import net.sf.json.processors.JsonVerifier;
66
  import net.sf.json.regexp.RegexpUtils;
67
  import net.sf.json.util.JSONTokener;
68
  import net.sf.json.util.JSONUtils;
69
  import net.sf.json.util.PropertyFilter;
70
  
71
  import org.apache.commons.beanutils.DynaBean;
72
  import org.apache.commons.beanutils.DynaProperty;
73
  import org.apache.commons.beanutils.PropertyUtils;
74
  import org.apache.commons.lang.StringUtils;
75
  import org.apache.commons.logging.Log;
76
  import org.apache.commons.logging.LogFactory;

 A JSONObject is an unordered collection of name/value pairs. Its external
 form is a string wrapped in curly braces with colons between the names and
 values, and commas between the values and names. The internal form is an
 object having get and opt methods for accessing
 the values by name, and put methods for adding or replacing
 values by name. The values can be any of these types: Boolean,
 JSONArray, JSONObject, Number,
 String, or the JSONNull object. A JSONObject
 constructor can be used to convert an external form JSON text into an
 internal form whose values can be retrieved with the get and
 opt methods, or to convert values into a JSON text using the
 element and toString methods. A
 get method returns a value if one can be found, and throws an
 exception if one cannot be found. An opt method returns a
 default value instead of throwing an exception, and so is useful for
 obtaining optional values.
 
 The generic get() and opt() methods return an
 object, which you can cast or query for type. There are also typed
 get and opt methods that do type checking and
 type coersion for you.
 

 The put methods adds values to an object. For example,

 
     myString = new JSONObject().put("JSON", "Hello, World!").toString();

 produces the string {"JSON": "Hello, World"}.
 
 The texts produced by the toString methods strictly conform to
 the JSON sysntax rules. The constructors are more forgiving in the texts they
 will accept:
 
An extra , (comma) may appear just
 before the closing brace.
Strings may be quoted with ' (single quote).
Strings do not need to be quoted at all if they do not begin with a
 quote or single quote, and if they do not contain leading or trailing spaces,
 and if they do not contain any of these characters:
 { } [ ] / \ : , = ; # and if they do not look like numbers and
 if they are not the reserved words true, false,
 or null.
Keys can be followed by = or => as well as
 by :.
Values can be followed by ; (semicolon)
 as well as by , (comma).
Numbers may have the 0- (octal) or
 0x- (hex) prefix.
Comments written in the slashshlash, slashstar, and hash conventions
 will be ignored.
 Author(s):JSON.org
132
 
133
 public final class JSONObject extends AbstractJSON implements JSON, Map<String,Object>, Comparable {
134
 
135
    private static final Log log = LogFactory.getLog( JSONObject.class );

   
 Creates a JSONObject.

 Inspects the object type to call the correct JSONObject factory method.

 
 Parameters:object Throws:JSONException if the object can not be converted to a proper
         JSONObject.
144
 
145
 
146
    public static JSONObject fromObject( Object object ) {
147
       return fromObject( object, new JsonConfig() );
148
    }

   
 Creates a JSONObject.

 Inspects the object type to call the correct JSONObject factory method.

 
 Parameters:object Throws:JSONException if the object can not be converted to a proper
         JSONObject.
157
 
158
    public static JSONObject fromObject( Object object, JsonConfig jsonConfig ) {
159
       if( object == null || JSONUtils.isNull( object ) ){
160
          return new JSONObject( true );
161
       }else if( object instanceof Enum ){
162
          throw new JSONException( "'object' is an Enum. Use JSONArray instead" );
163
       }else if(object instanceof Annotation || (object.getClass().isAnnotation())){
164
          throw new JSONException( "'object' is an Annotation." );
165
       }else if( object instanceof JSONObject ){
166
          return _fromJSONObject( (JSONObject) object, jsonConfig );
167
       }else if( object instanceof DynaBean ){
168
          return _fromDynaBean( (DynaBean) object, jsonConfig );
169
       }else if( object instanceof JSONTokener ){
170
          return _fromJSONTokener( (JSONTokener) object, jsonConfig );
171
       }else if( object instanceof JSONString ){
172
          return _fromJSONString( (JSONString) object, jsonConfig );
173
       }else if( object instanceof Map ){
174
          return _fromMap( (Map) object, jsonConfig );
175
       }else if( object instanceof String ){
176
          return _fromString( (String) object, jsonConfig );
177
       }else if( JSONUtils.isNumber( object ) || JSONUtils.isBoolean( object )
178
             || JSONUtils.isString( object ) ){
179
          return new JSONObject();
180
       }else if( JSONUtils.isArray( object ) ){
181
          throw new JSONException( "'object' is an array. Use JSONArray instead" );
182
       }else{
183
          return _fromBean( object, jsonConfig );
184
       }
185
    }

   
 Creates a JSONDynaBean from a JSONObject.
 
189
 
190
    public Object toBean() {
191
       return toBean(this);
192
    }
193
    public static Object toBean( JSONObject jsonObject ) {
194
       if( jsonObject == null || jsonObject.isNullObject() ){
195
          return null;
196
       }
197
 
198
       DynaBean dynaBean;
199
 
200
       Map props = JSONUtils.getProperties( jsonObject );
201
       dynaBean = JSONUtils.newDynaBean( jsonObject, new JsonConfig() );
202
       for( Iterator entries = jsonObject.names()
203
             .iterator(); entries.hasNext(); ){
204
          String name = (String) entries.next();
205
          String key = JSONUtils.convertToJavaIdentifier( name, new JsonConfig() );
206
          Class type = (Class) props.get( name );
207
          Object value = jsonObject.get( name );
208
          try{
209
             if( !JSONUtils.isNull( value ) ){
210
                if( value instanceof JSONArray ){
211
                   dynaBean.set( key, JSONArray.toList( (JSONArray) value ) );
212
                }else if( String.class.isAssignableFrom( type )
213
                      || Boolean.class.isAssignableFrom( type ) || JSONUtils.isNumber( type )
214
                      || Character.class.isAssignableFrom( type )
215
                      || JSONFunction.class.isAssignableFrom( type ) ){
216
                   dynaBean.set( key, value );
217
                }else{
218
                   dynaBean.set( key, toBean( (JSONObject) value ) );
219
                }
220
             }else{
221
                if( type.isPrimitive() ){
222
                   // assume assigned default value
223
                   log.warn( "Tried to assign null value to " + key + ":" + type.getName() );
224
                   dynaBean.set( key, JSONUtils.getMorpherRegistry()
225
                         .morph( type, null ) );
226
                }else{
227
                   dynaBean.set( key, null );
228
                }
229
             }
230
          }catch( JSONException jsone ){
231
             throw jsone;
232
          }catch( Exception e ){
233
             throw new JSONException( "Error while setting property=" + name + " type" + type, e );
234
          }
235
       }
236
 
237
       return dynaBean;
238
    }
239
 
240
    public Object toBean( Class beanClass ) {
241
       return toBean(this,beanClass);
242
    }

   
 Creates a bean from a JSONObject, with a specific target class.

 
246
 
247
    public static Object toBean( JSONObject jsonObject, Class beanClass ) {
248
       JsonConfig jsonConfig = new JsonConfig();
249
       jsonConfig.setRootClass( beanClass );
250
       return toBean( jsonObject, jsonConfig );
251
    }

   
 Creates a bean from a JSONObject, with a specific target class.

 If beanClass is null, this method will return a graph of DynaBeans. Any
 attribute that is a JSONObject and matches a key in the classMap will be
 converted to that target class.

 The classMap has the following conventions:
 Every key must be an String.
Every value must be a Class.
A key may be a regular expression.

 
264
 
265
    public static Object toBean( JSONObject jsonObject, Class beanClass, Map classMap ) {
266
       JsonConfig jsonConfig = new JsonConfig();
267
       jsonConfig.setRootClass( beanClass );
268
       jsonConfig.setClassMap( classMap );
269
       return toBean( jsonObject, jsonConfig );
270
    }
271
 
272
     private interface Property {
273
        boolean isWritable();
274
        Class type();
275
        String name();
276
        void set(Object bean, Object value) throws InvocationTargetException, NoSuchMethodException, IllegalAccessException;
277
     }
278
 
279
    private static class PropertyOnMap implements Property {
280
       private final String name;
281
 
282
       private PropertyOnMap(String name) {
283
          this.name = name;
284
       }
285
 
286
       public boolean isWritable() {
287
          return true;
288
       }
289
 
290
       public String name() {
291
          return name;
292
       }
293
 
294
       public Class type() {
295
          return Object.class;
296
       }
297
 
298
       public void set(Object bean, Object value) {
299
          ((Map)bean).put(name,value);
300
       }
301
    }
302
 
303
    private static class MethodProperty implements Property {
304
       private final PropertyDescriptor pd;
305
 
306
       private MethodProperty(PropertyDescriptor pd) {
307
          this.pd = pd;
308
       }
309
 
310
       public boolean isWritable() {
311
          return pd.getWriteMethod() != null;
312
       }
313
 
314
       public String name() {
315
          return pd.getName();
316
       }
317
 
318
       public Class type() {
319
          return pd.getPropertyType();
320
       }
321
 
322
       public void set(Object bean, Object value) throws InvocationTargetException, NoSuchMethodException, IllegalAccessException {
323
          PropertyUtils.setSimpleProperty( bean, pd.getName(), value );
324
       }
325
    }
326
 
327
    private static class FieldProperty implements Property {
328
       private final Field f;
329
 
330
       private FieldProperty(Field f) {
331
          this.f = f;
332
       }
333
 
334
       public boolean isWritable() {
335
          return true;
336
       }
337
 
338
       public Class type() {
339
          return f.getType();
340
       }
341
 
342
       public String name() {
343
          return f.getName();
344
       }
345
 
346
       public void set(Object bean, Object value) throws InvocationTargetException, NoSuchMethodException, IllegalAccessException {
347
          f.set(bean,value);
348
       }
349
    }


   
 Creates a bean from a JSONObject, with the specific configuration.
 
354
 
355
    public static Object toBean( JSONObject jsonObject, JsonConfig jsonConfig ) {
356
       if( jsonObject == null || jsonObject.isNullObject() ){
357
          return null;
358
       }
359
 
360
       Class beanClass = jsonConfig.getRootClass();
361
       if( beanClass == null ){
362
          return toBean( jsonObject );
363
       }
364
 
365
       Object bean;
366
       try{
367
          if( beanClass.isInterface() ){
368
             if( !Map.class.isAssignableFrom( beanClass ) ){
369
                throw new JSONException( "beanClass is an interface. " + beanClass );
370
             }else{
371
                bean = new HashMap();
372
             }
373
          }else{
374
             bean = jsonConfig.getNewBeanInstanceStrategy()
375
                   .newInstance( beanClass, jsonObject );
376
          }
377
       }catch( JSONException jsone ){
378
          throw jsone;
379
       }catch( Exception e ){
380
          throw new JSONException( e );
381
       }
382
 
383
       return toBean(jsonObject,bean,jsonConfig);
384
    }
385
 
386
    private static Property getProperty(Class beanClass, Object bean, String key, JsonConfig jsonConfig) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
387
       if( Map.class.isAssignableFrom( beanClass ))
388
          return new PropertyOnMap(key);
389
 
390
       key = jsonConfig.isSkipJavaIdentifierTransformationInMapKeys() ? key
391
             : JSONUtils.convertToJavaIdentifier( key, jsonConfig );
392
 
393
       try {
394
          return new FieldProperty(bean.getClass().getField(key));
395
       } catch (NoSuchFieldException e) {
396
          return new MethodProperty(PropertyUtils.getPropertyDescriptor( bean, key ));
397
       }
398
    }

   
 Creates a bean from a JSONObject, with the specific configuration.
 
402
 
403
    public static Object toBean( JSONObject jsonObject, Object bean, JsonConfig jsonConfig ) {
404
       if( jsonObject == null || jsonObject.isNullObject() || bean == null ){
405
          return bean;
406
       }
407
 
408
       Class rootClass = bean.getClass();
409
       if( rootClass.isInterface() ){
410
          throw new JSONException( "Root bean is an interface. " + rootClass );
411
       }
412
 
413
       Map classMap = jsonConfig.getClassMap();
414
       if( classMap == null ){
415
          classMap = Collections.EMPTY_MAP;
416
       }
417
 
418
       Map props = JSONUtils.getProperties( jsonObject );
419
       PropertyFilter javaPropertyFilter = jsonConfig.getJavaPropertyFilter();
420
       for( Iterator entries = jsonObject.names().iterator(); entries.hasNext(); ){
421
          String name = (String) entries.next();
422
          Class type = (Class) props.get( name );
423
          Object value = jsonObject.get( name );
424
          if( javaPropertyFilter != null && javaPropertyFilter.apply( bean, name, value ) ){
425
             continue;
426
          }
427
          try{
428
             Property pd = getProperty(rootClass,bean,name,jsonConfig);
429
             if( !pd.isWritable() ){
430
                log.warn( "Property '" + pd.name() + "' has no write method. SKIPPED." );
431
                continue;
432
             }
433
 
434
             if( !JSONUtils.isNull( value ) ){
435
                if( value instanceof JSONArray){
436
                   if( List.class.isAssignableFrom( pd.type() ) ){
437
                      Class targetClass = findTargetClass( pd.name(), classMap );
438
                      targetClass = targetClass == null ? findTargetClass( name, classMap )
439
                            : targetClass;
440
                      // if targetClass is null the outcome will be a List of
441
                      // DynaBeans
442
                      // targetClass = (targetClass != null) ? targetClass :
443
                      // beanClass;
444
                      JsonConfig jsc = jsonConfig.copy();
445
                      jsc.setRootClass( targetClass );
446
                      jsc.setClassMap( classMap );
447
                      List list = JSONArray.toList( (JSONArray) value, jsc );
448
                      pd.set(bean,list);
449
                   }else{
450
                      Class innerType = JSONUtils.getInnerComponentType(pd.type());
451
                      Class targetInnerType = findTargetClass( pd.name(), classMap );
452
                      if( innerType==Object.class && targetInnerType != null
453
                            && targetInnerType!=Object.class ){
454
                         innerType = targetInnerType;
455
                      }
456
                      JsonConfig jsc = jsonConfig.copy();
457
                      jsc.setRootClass( innerType );
458
                      jsc.setClassMap( classMap );
459
                      Object array = JSONArray.toArray( (JSONArray) value, jsc );
460
                      if( innerType.isPrimitive() || JSONUtils.isNumber( innerType )
461
                            || Boolean.class==innerType
462
                            || JSONUtils.isString( innerType ) ){
463
                         array = JSONUtils.getMorpherRegistry()
464
                               .morph( Array.newInstance( innerType, 0 )
465
                                     .getClass(), array );
466
                      }else if( !array.getClass().equals(pd.type()) ){
467
                         if( !pd.type().equals( Object.class ) ){
468
                            Morpher morpher = JSONUtils.getMorpherRegistry()
469
                                  .getMorpherFor( Array.newInstance( innerType, 0 )
470
                                        .getClass() );
471
                            if( IdentityObjectMorpher.getInstance()
472
                                  .equals( morpher ) ){
473
                               ObjectArrayMorpher beanMorpher = new ObjectArrayMorpher(
474
                                     new BeanMorpher( innerType, JSONUtils.getMorpherRegistry() ) );
475
                               JSONUtils.getMorpherRegistry()
476
                                     .registerMorpher( beanMorpher );
477
                            }
478
                            array = JSONUtils.getMorpherRegistry()
479
                                  .morph( Array.newInstance( innerType, 0 )
480
                                        .getClass(), array );
481
                         }
482
                      }
483
                      pd.set(bean,array);
484
                   }
485
                }else if( String.class==type || JSONUtils.isBoolean( type )
486
                      || JSONUtils.isNumber( type ) || JSONUtils.isString( type )
487
                      || JSONFunction.class.isAssignableFrom( type ) ){
488
                   if( pd != null ){
489
                      if( jsonConfig.isHandleJettisonEmptyElement() && "".equals( value ) ){
490
                         pd.set(bean,null);
491
                      }else if( !pd.type().isInstance( value ) ){
492
                         Morpher morpher = JSONUtils.getMorpherRegistry()
493
                               .getMorpherFor( pd.type() );
494
                         if( IdentityObjectMorpher.getInstance()
495
                               .equals( morpher ) ){
496
                            log.warn( "Can't transform property '" + pd.name() + "' from "
497
                                  + type.getName() + " into " + pd.type()
498
                                        .getName() + ". Will register a default BeanMorpher" );
499
                            JSONUtils.getMorpherRegistry()
500
                                  .registerMorpher(
501
                                        new BeanMorpher( pd.type(),
502
                                              JSONUtils.getMorpherRegistry() ) );
503
                         }
504
                         pd.set(bean,JSONUtils.getMorpherRegistry()
505
                               .morph( pd.type(), value ) );
506
                      }else{
507
                         pd.set(bean,value);
508
                      }
509
                   }else if(bean instanceof Map ){
510
                      pd.set(bean,value);
511
                   }else{
512
                      log.warn( "Tried to assign property " + pd.name() + ":" + type.getName()
513
                            + " to bean of class " + bean.getClass()
514
                                  .getName() );
515
                   }
516
                }else{
517
                   if( pd != null ){
518
                      Class targetClass = pd.type();
519
                      if( jsonConfig.isHandleJettisonSingleElementArray() ){
520
                         JSONArray array = new JSONArray().element( value, jsonConfig );
521
                         Class newTargetClass = findTargetClass( pd.name(), classMap );
522
                         newTargetClass = newTargetClass == null ? findTargetClass( name, classMap )
523
                               : newTargetClass;
524
                         JsonConfig jsc = jsonConfig.copy();
525
                         jsc.setRootClass( newTargetClass );
526
                         jsc.setClassMap( classMap );
527
                         if( targetClass.isArray() ){
528
                            pd.set(bean,JSONArray.toArray( array, jsc ));
529
                         }else if( Collection.class.isAssignableFrom( targetClass ) ){
530
                            pd.set(bean,JSONArray.toList( array, jsc ));
531
                         }else if( JSONArray.class.isAssignableFrom( targetClass ) ){
532
                            pd.set(bean,array);
533
                         }else{
534
                            pd.set(bean,toBean( (JSONObject) value, jsc ));
535
                         }
536
                      }else{
537
                         if( targetClass == Object.class ){
538
                            targetClass = findTargetClass( pd.name(), classMap );
539
                            targetClass = targetClass == null ? findTargetClass( name, classMap )
540
                                  : targetClass;
541
                         }
542
                         JsonConfig jsc = jsonConfig.copy();
543
                         jsc.setRootClass( targetClass );
544
                         jsc.setClassMap( classMap );
545
                         pd.set(bean,toBean( (JSONObject) value, jsc ));
546
                      }
547
                   }else if( bean instanceof Map ){
548
                      Class targetClass = findTargetClass( pd.name(), classMap );
549
                      targetClass = targetClass == null ? findTargetClass( name, classMap )
550
                            : targetClass;
551
                      JsonConfig jsc = jsonConfig.copy();
552
                      jsc.setRootClass( targetClass );
553
                      jsc.setClassMap( classMap );
554
                      if( targetClass != null ){
555
                         pd.set(bean,toBean( (JSONObject) value, jsc ));
556
                      }else{
557
                         pd.set(bean,toBean( (JSONObject) value ));
558
                      }
559
                   }else{
560
                      log.warn( "Tried to assign property " + pd.name() + ":" + type.getName()
561
                            + " to bean of class " + bean.getClass()
562
                                  .getName() );
563
                   }
564
                }
565
             }else{
566
                if( type.isPrimitive() ){
567
                   // assume assigned default value
568
                   log.warn( "Tried to assign null value to " + pd.name() + ":" + type.getName() );
569
                   pd.set(bean,JSONUtils.getMorpherRegistry().morph( type, null ));
570
                }else{
571
                   pd.set(bean,null);
572
                }
573
             }
574
          }catch( JSONException jsone ){
575
             throw jsone;
576
          }catch( Exception e ){
577
             throw new JSONException( "Error while setting property=" + name + " type " + type, e );
578
          }
579
       }
580
 
581
       return bean;
582
    }

   
 Creates a JSONObject from a POJO.

 Supports nested maps, POJOs, and arrays/collections.

 
 Parameters:bean An object with POJO conventions Throws:JSONException if the bean can not be converted to a proper
         JSONObject.
591
 
592
    private static JSONObject _fromBean( Object bean, JsonConfig jsonConfig ) {
593
       fireObjectStartEvent( jsonConfig );
594
       if( !addInstance( bean ) ){
595
          try{
596
             return jsonConfig.getCycleDetectionStrategy()
597
                   .handleRepeatedReferenceAsObject( bean );
598
          }catch( JSONException jsone ){
599
             removeInstance( bean );
600
             fireErrorEvent( jsone, jsonConfig );
601
             throw jsone;
602
          }catch( RuntimeException e ){
603
             removeInstance( bean );
604
             JSONException jsone = new JSONException( e );
605
             fireErrorEvent( jsone, jsonConfig );
606
             throw jsone;
607
          }
608
       }
609
 
610
       JsonBeanProcessor processor = jsonConfig.findJsonBeanProcessor( bean.getClass() );
611
       if( processor != null ){
612
          try{
613
             JSONObject json = processor.processBean( bean, jsonConfig );
614
             if( json == null ){
615
                json = new JSONObject( true );
616
             }
617
             removeInstance( bean );
618
             fireObjectEndEvent( jsonConfig );
619
             return json;
620
          }catch( JSONException jsone ){
621
             removeInstance( bean );
622
             fireErrorEvent( jsone, jsonConfig );
623
             throw jsone;
624
          }catch( RuntimeException e ){
625
             removeInstance( bean );
626
             JSONException jsone = new JSONException( e );
627
             fireErrorEvent( jsone, jsonConfig );
628
             throw jsone;
629
          }
630
       }
631
 
632
       Collection exclusions = jsonConfig.getMergedExcludes();
633
       JSONObject jsonObject = new JSONObject();
634
       try{
635
          PropertyDescriptor[] pds = PropertyUtils.getPropertyDescriptors( bean );
636
          PropertyFilter jsonPropertyFilter = jsonConfig.getJsonPropertyFilter();
637
          Class beanClass = bean.getClass();
638
          for( int i = 0; i < pds.length; i++ ){
639
             String key = pds[i].getName();
640
             if( exclusions.contains( key ) ){
641
                continue;
642
             }
643
 
644
             if( jsonConfig.isIgnoreTransientFields() && isTransientField( key, beanClass ) ){
645
                continue;
646
             }
647
 
648
             Class type = pds[i].getPropertyType();
649
             if( pds[i].getReadMethod() != null ){
650
                Object value = PropertyUtils.getProperty( bean, key );
651
                if( jsonPropertyFilter != null && jsonPropertyFilter.apply( bean, key, value ) ){
652
                   continue;
653
                }
654
                JsonValueProcessor jsonValueProcessor = jsonConfig.findJsonValueProcessor(
655
                      beanClass, type, key );
656
                if( jsonValueProcessor != null ){
657
                   value = jsonValueProcessor.processObjectValue( key, value, jsonConfig );
658
                   if( !JsonVerifier.isValidJsonValue( value ) ){
659
                      throw new JSONException( "Value is not a valid JSON value. " + value );
660
                   }
661
                }
662
                setValue( jsonObject, key, value, type, jsonConfig );
663
             }else{
664
                String warning = "Property '" + key + "' has no read method. SKIPPED";
665
                fireWarnEvent( warning, jsonConfig );
666
                log.warn( warning );
667
             }
668
          }
669
 
670
          // public field
671
           for (Field f : bean.getClass().getFields()) {
672
               String key = f.getName();
673
               if (exclusions.contains(key)) continue;
674
               if (jsonConfig.isIgnoreTransientFields() && Modifier.isTransient(f.getModifiers()))   continue;
675
 
676
               Class type = f.getType();
677
               f.setAccessible(true); // while the field is public, the class might not be accessible
678
               Object value = f.get(bean);
679
               if( jsonPropertyFilter != null && jsonPropertyFilter.apply( bean, key, value ))       continue;
680
 
681
               JsonValueProcessor jsonValueProcessor = jsonConfig.findJsonValueProcessor(beanClass, type, key );
682
               if( jsonValueProcessor != null ){
683
                  value = jsonValueProcessor.processObjectValue( key, value, jsonConfig );
684
                  if( !JsonVerifier.isValidJsonValue( value ) ){
685
                     throw new JSONException( "Value is not a valid JSON value. " + value );
686
                  }
687
               }
688
               setValue( jsonObject, key, value, type, jsonConfig );
689
           }
690
       }catch( JSONException jsone ){
691
          removeInstance( bean );
692
          fireErrorEvent( jsone, jsonConfig );
693
          throw jsone;
694
       }catch( Exception e ){
695
          removeInstance( bean );
696
          JSONException jsone = new JSONException( e );
697
          fireErrorEvent( jsone, jsonConfig );
698
          throw jsone;
699
       }
700
 
701
       removeInstance( bean );
702
       fireObjectEndEvent( jsonConfig );
703
       return jsonObject;
704
    }
705
 
706
    private static JSONObject _fromDynaBean( DynaBean bean, JsonConfig jsonConfig ) {
707
       fireObjectStartEvent( jsonConfig );
708
       if( bean == null ){
709
          fireObjectEndEvent( jsonConfig );
710
          return new JSONObject( true );
711
       }
712
 
713
       if( !addInstance( bean ) ){
714
          try{
715
             return jsonConfig.getCycleDetectionStrategy()
716
                   .handleRepeatedReferenceAsObject( bean );
717
          }catch( JSONException jsone ){
718
             removeInstance( bean );
719
             fireErrorEvent( jsone, jsonConfig );
720
             throw jsone;
721
          }catch( RuntimeException e ){
722
             removeInstance( bean );
723
             JSONException jsone = new JSONException( e );
724
             fireErrorEvent( jsone, jsonConfig );
725
             throw jsone;
726
          }
727
       }
728
 
729
       JSONObject jsonObject = new JSONObject();
730
       try{
731
          DynaProperty[] props = bean.getDynaClass()
732
                .getDynaProperties();
733
          Collection exclusions = jsonConfig.getMergedExcludes();
734
          PropertyFilter jsonPropertyFilter = jsonConfig.getJsonPropertyFilter();
735
          for( int i = 0; i < props.length; i++ ){
736
             DynaProperty dynaProperty = props[i];
737
             String key = dynaProperty.getName();
738
             if( exclusions.contains( key ) ){
739
                continue;
740
             }
741
             Class type = dynaProperty.getType();
742
             Object value = bean.get( dynaProperty.getName() );
743
             if( jsonPropertyFilter != null && jsonPropertyFilter.apply( bean, key, value ) ){
744
                continue;
745
             }
746
             JsonValueProcessor jsonValueProcessor = jsonConfig.findJsonValueProcessor( type, key );
747
             if( jsonValueProcessor != null ){
748
                value = jsonValueProcessor.processObjectValue( key, value, jsonConfig );
749
                if( !JsonVerifier.isValidJsonValue( value ) ){
750
                   throw new JSONException( "Value is not a valid JSON value. " + value );
751
                }
752
             }
753
             setValue( jsonObject, key, value, type, jsonConfig );
754
          }
755
       }catch( JSONException jsone ){
756
          removeInstance( bean );
757
          fireErrorEvent( jsone, jsonConfig );
758
          throw jsone;
759
       }catch( RuntimeException e ){
760
          removeInstance( bean );
761
          JSONException jsone = new JSONException( e );
762
          fireErrorEvent( jsone, jsonConfig );
763
          throw jsone;
764
       }
765
 
766
       removeInstance( bean );
767
       fireObjectEndEvent( jsonConfig );
768
       return jsonObject;
769
    }
770
 
771
    private static JSONObject _fromJSONObject( JSONObject object, JsonConfig jsonConfig ) {
772
       fireObjectStartEvent( jsonConfig );
773
       if( object == null || object.isNullObject() ){
774
          fireObjectEndEvent( jsonConfig );
775
          return new JSONObject( true );
776
       }
777
 
778
       if( !addInstance( object ) ){
779
          try{
780
             return jsonConfig.getCycleDetectionStrategy()
781
                   .handleRepeatedReferenceAsObject( object );
782
          }catch( JSONException jsone ){
783
             removeInstance( object );
784
             fireErrorEvent( jsone, jsonConfig );
785
             throw jsone;
786
          }catch( RuntimeException e ){
787
             removeInstance( object );
788
             JSONException jsone = new JSONException( e );
789
             fireErrorEvent( jsone, jsonConfig );
790
             throw jsone;
791
          }
792
       }
793
 
794
       JSONArray sa = object.names();
795
       Collection exclusions = jsonConfig.getMergedExcludes();
796
       JSONObject jsonObject = new JSONObject();
797
       PropertyFilter jsonPropertyFilter = jsonConfig.getJsonPropertyFilter();
798
       for( Iterator i = sa.iterator(); i.hasNext(); ){
799
          String key = (String) i.next();
800
          if( exclusions.contains( key ) ){
801
             continue;
802
          }
803
          Object value = object.opt( key );
804
          if( jsonPropertyFilter != null && jsonPropertyFilter.apply( object, key, value ) ){
805
             continue;
806
          }
807
          if( jsonObject.properties.containsKey( key ) ){
808
             jsonObject.accumulate( key, value, jsonConfig );
809
             firePropertySetEvent( key, value, true, jsonConfig );
810
          }else{
811
             jsonObject._setInternal( key, value, jsonConfig );
812
             firePropertySetEvent( key, value, false, jsonConfig );
813
          }
814
       }
815
 
816
       removeInstance( object );
817
       fireObjectEndEvent( jsonConfig );
818
       return jsonObject;
819
    }
820
 
821
    private static JSONObject _fromJSONString( JSONString string, JsonConfig jsonConfig ) {
822
       return _fromJSONTokener( new JSONTokener( string.toJSONString() ), jsonConfig );
823
    }
824
 
825
    private static JSONObject _fromJSONTokener( JSONTokener tokener, JsonConfig jsonConfig ) {
826
       fireObjectStartEvent( jsonConfig );
827
 
828
       try{
829
          char c;
830
          String key;
831
          Object value;
832
 
833
          if( tokener.matches( "null.*" ) ){
834
             fireObjectEndEvent( jsonConfig );
835
             return new JSONObject( true );
836
          }
837
 
838
          if( tokener.nextClean() != '{' ){
839
             throw tokener.syntaxError( "A JSONObject text must begin with '{'" );
840
          }
841
 
842
          Collection exclusions = jsonConfig.getMergedExcludes();
843
          PropertyFilter jsonPropertyFilter = jsonConfig.getJsonPropertyFilter();
844
          JSONObject jsonObject = new JSONObject();
845
          for( ;; ){
846
             c = tokener.nextClean();
847
             switch( c ){
848
                case 0:
849
                   throw tokener.syntaxError( "A JSONObject text must end with '}'" );
850
                case '}':
851
                   fireObjectEndEvent( jsonConfig );
852
                   return jsonObject;
853
                default:
854
                   tokener.back();
855
                   key = tokener.nextValue( jsonConfig )
856
                         .toString();
857
             }
858
 
859
             /*
860
              * The key is followed by ':'. We will also tolerate '=' or '=>'.
861
              */
862
 
863
             c = tokener.nextClean();
864
             if( c == '=' ){
865
                if( tokener.next() != '>' ){
866
                   tokener.back();
867
                }
868
             }else if( c != ':' ){
869
                throw tokener.syntaxError( "Expected a ':' after a key" );
870
             }
871
             Object v = tokener.nextValue( jsonConfig );
872
             if( !JSONUtils.isFunctionHeader( v ) ){
873
                if( exclusions.contains( key ) ){
874
                   switch( tokener.nextClean() ){
875
                      case ';':
876
                      case ',':
877
                         if( tokener.nextClean() == '}' ){
878
                            fireObjectEndEvent( jsonConfig );
879
                            return jsonObject;
880
                         }
881
                         tokener.back();
882
                         break;
883
                      case '}':
884
                         fireObjectEndEvent( jsonConfig );
885
                         return jsonObject;
886
                      default:
887
                         throw tokener.syntaxError( "Expected a ',' or '}'" );
888
                   }
889
                   continue;
890
                }
891
                if( jsonPropertyFilter == null || !jsonPropertyFilter.apply( tokener, key, v ) ){
892
                   if( v instanceof String && JSONUtils.mayBeJSON( (String) v ) ){
893
                      value = JSONUtils.DOUBLE_QUOTE + v + JSONUtils.DOUBLE_QUOTE;
894
                      if( jsonObject.properties.containsKey( key ) ){
895
                         jsonObject.accumulate( key, value, jsonConfig );
896
                         firePropertySetEvent( key, value, true, jsonConfig );
897
                      }else{
898
                         jsonObject.element( key, value, jsonConfig );
899
                         firePropertySetEvent( key, value, false, jsonConfig );
900
                      }
901
                   }else{
902
                      if( jsonObject.properties.containsKey( key ) ){
903
                         jsonObject.accumulate( key, v, jsonConfig );
904
                         firePropertySetEvent( key, v, true, jsonConfig );
905
                      }else{
906
                         jsonObject.element( key, v, jsonConfig );
907
                         firePropertySetEvent( key, v, false, jsonConfig );
908
                      }
909
                   }
910
                }
911
             }else{
912
                // read params if any
913
                String params = JSONUtils.getFunctionParams( (String) v );
914
                // read function text
915
                int i = 0;
916
                StringBuffer sb = new StringBuffer();
917
                for( ;; ){
918
                   char ch = tokener.next();
919
                   if( ch == 0 ){
920
                      break;
921
                   }
922
                   if( ch == '{' ){
923
                      i++;
924
                   }
925
                   if( ch == '}' ){
926
                      i--;
927
                   }
928
                   sb.append( ch );
929
                   if( i == 0 ){
930
                      break;
931
                   }
932
                }
933
                if( i != 0 ){
934
                   throw tokener.syntaxError( "Unbalanced '{' or '}' on prop: " + v );
935
                }
936
                // trim '{' at start and '}' at end
937
                String text = sb.toString();
938
                text = text.substring( 1, text.length() - 1 )
939
                      .trim();
940
                value = new JSONFunction(
941
                      (params != null) ? StringUtils.split( params, "," ) : null, text );
942
                if( jsonPropertyFilter == null || !jsonPropertyFilter.apply( tokener, key, value ) ){
943
                   if( jsonObject.properties.containsKey( key ) ){
944
                      jsonObject.accumulate( key, value, jsonConfig );
945
                      firePropertySetEvent( key, value, true, jsonConfig );
946
                   }else{
947
                      jsonObject.element( key, value, jsonConfig );
948
                      firePropertySetEvent( key, value, false, jsonConfig );
949
                   }
950
                }
951
             }
952
 
953
             /*
954
              * Pairs are separated by ','. We will also tolerate ';'.
955
              */
956
 
957
             switch( tokener.nextClean() ){
958
                case ';':
959
                case ',':
960
                   if( tokener.nextClean() == '}' ){
961
                      fireObjectEndEvent( jsonConfig );
962
                      return jsonObject;
963
                   }
964
                   tokener.back();
965
                   break;
966
                case '}':
967
                   fireObjectEndEvent( jsonConfig );
968
                   return jsonObject;
969
                default:
970
                   throw tokener.syntaxError( "Expected a ',' or '}'" );
971
             }
972
          }
973
       }catch( JSONException jsone ){
974
          fireErrorEvent( jsone, jsonConfig );
975
          throw jsone;
976
       }
977
    }
978
 
979
    private static JSONObject _fromMap( Map map, JsonConfig jsonConfig ) {
980
       fireObjectStartEvent( jsonConfig );
981
       if( map == null ){
982
          fireObjectEndEvent( jsonConfig );
983
          return new JSONObject( true );
984
       }
985
 
986
       if( !addInstance( map ) ){
987
          try{
988
             return jsonConfig.getCycleDetectionStrategy()
989
                   .handleRepeatedReferenceAsObject( map );
990
          }catch( JSONException jsone ){
991
             removeInstance( map );
992
             fireErrorEvent( jsone, jsonConfig );
993
             throw jsone;
994
          }catch( RuntimeException e ){
995
             removeInstance( map );
996
             JSONException jsone = new JSONException( e );
997
             fireErrorEvent( jsone, jsonConfig );
998
             throw jsone;
999
          }
1000
      }
1001
1002
      Collection exclusions = jsonConfig.getMergedExcludes();
1003
      JSONObject jsonObject = new JSONObject();
1004
      PropertyFilter jsonPropertyFilter = jsonConfig.getJsonPropertyFilter();
1005
      try{
1006
         for( Iterator entries = map.entrySet()
1007
               .iterator(); entries.hasNext(); ){
1008
            Map.Entry entry = (Map.Entry) entries.next();
1009
            Object k = entry.getKey();
1010
            String key = (k instanceof String) ? (String) k : String.valueOf( k );
1011
            if( exclusions.contains( key ) ){
1012
               continue;
1013
            }
1014
            Object value = entry.getValue();
1015
            if( jsonPropertyFilter != null && jsonPropertyFilter.apply( map, key, value ) ){
1016
               continue;
1017
            }
1018
            if( value != null ){
1019
               JsonValueProcessor jsonValueProcessor = jsonConfig.findJsonValueProcessor(
1020
                     value.getClass(), key );
1021
               if( jsonValueProcessor != null ){
1022
                  value = jsonValueProcessor.processObjectValue( key, value, jsonConfig );
1023
                  if( !JsonVerifier.isValidJsonValue( value ) ){
1024
                     throw new JSONException( "Value is not a valid JSON value. " + value );
1025
                  }
1026
               }
1027
               setValue( jsonObject, key, value, value.getClass(), jsonConfig );
1028
            }else{
1029
               if( jsonObject.properties.containsKey( key ) ){
1030
                  jsonObject.accumulate( key, JSONNull.getInstance() );
1031
                  firePropertySetEvent( key, JSONNull.getInstance(), true, jsonConfig );
1032
               }else{
1033
                  jsonObject.element( key, JSONNull.getInstance() );
1034
                  firePropertySetEvent( key, JSONNull.getInstance(), false, jsonConfig );
1035
               }
1036
            }
1037
         }
1038
      }catch( JSONException jsone ){
1039
         removeInstance( map );
1040
         fireErrorEvent( jsone, jsonConfig );
1041
         throw jsone;
1042
      }catch( RuntimeException e ){
1043
         removeInstance( map );
1044
         JSONException jsone = new JSONException( e );
1045
         fireErrorEvent( jsone, jsonConfig );
1046
         throw jsone;
1047
      }
1048
1049
      removeInstance( map );
1050
      fireObjectEndEvent( jsonConfig );
1051
      return jsonObject;
1052
   }
1053
1054
   private static JSONObject _fromString( String str, JsonConfig jsonConfig ) {
1055
      if( str == null || "null".compareToIgnoreCase( str ) == 0 ){
1056
         fireObjectStartEvent( jsonConfig );
1057
         fireObjectEndEvent( jsonConfig );
1058
         return new JSONObject( true );
1059
      }
1060
      return _fromJSONTokener( new JSONTokener( str ), jsonConfig );
1061
   }

   
 Locates a Class associated to a specifi key.

 The key may be a regexp.
 
1066
1067
   private static Class findTargetClass( String key, Map classMap ) {
1068
      // try get first
1069
      Class targetClass = (Class) classMap.get( key );
1070
      if( targetClass == null ){
1071
         // try with regexp
1072
         // this will hit performance as it must iterate over all the keys
1073
         // and create a RegexpMatcher for each key
1074
         for( Iterator i = classMap.entrySet()
1075
               .iterator(); i.hasNext(); ){
1076
            Map.Entry entry = (Map.Entry) i.next();
1077
            if( RegexpUtils.getMatcher( (String) entry.getKey() )
1078
                  .matches( key ) ){
1079
               targetClass = (Class) entry.getValue();
1080
               break;
1081
            }
1082
         }
1083
      }
1084
1085
      return targetClass;
1086
   }
1087
1088
   private static boolean isTransientField( String name, Class beanClass ) {
1089
      try{
1090
         Field field = beanClass.getDeclaredField( name );
1091
         return (field.getModifiers() & Modifier.TRANSIENT) == Modifier.TRANSIENT;
1092
      }catch( Exception e ){
1093
         // swallow exception
1094
      }
1095
      return false;
1096
   }
1097
1098
   private static void setValue( JSONObject jsonObject, String key, Object value, Class type,
1099
         JsonConfig jsonConfig ) {
1100
      boolean accumulated = false;
1101
      if( value == null ){
1102
         if( JSONUtils.isArray( type ) ){
1103
            value = new JSONArray();
1104
         }else if( JSONUtils.isNumber( type ) ){
1105
            if( JSONUtils.isDouble( type ) ){
1106
               value = new Double( 0 );
1107
            }else{
1108
               value = new Integer( 0 );
1109
            }
1110
         }else if( JSONUtils.isBoolean( type ) ){
1111
            value = Boolean.FALSE;
1112
         }else if( JSONUtils.isString( type ) ){
1113
            value = "";
1114
         }else{
1115
            value = JSONNull.getInstance();
1116
         }
1117
      }
1118
      if( jsonObject.properties.containsKey( key ) ){
1119
         if( String.class.isAssignableFrom( type ) ){
1120
            Object o = jsonObject.opt( key );
1121
            if( o instanceof JSONArray ){
1122
               ((JSONArray) o).addString( (String) value );
1123
            }else{
1124
               jsonObject.properties.put( key, new JSONArray().element( o )
1125
                     .addString( (String) value ) );
1126
            }
1127
         }else{
1128
            jsonObject.accumulate( key, value, jsonConfig );
1129
         }
1130
         accumulated = true;
1131
      }else{
1132
         if( String.class.isAssignableFrom( type ) ){
1133
            jsonObject.properties.put( key, value );
1134
         }else{
1135
            jsonObject._setInternal( key, value, jsonConfig );
1136
         }
1137
      }
1138
1139
      value = jsonObject.opt( key );
1140
      if( accumulated ){
1141
         JSONArray array = (JSONArray) value;
1142
         value = array.get( array.size() - 1 );
1143
      }
1144
      firePropertySetEvent( key, value, accumulated, jsonConfig );
1145
   }
1146
1147
   // ------------------------------------------------------
1148

   
identifies this object as null
1149
1150
   private boolean nullObject;

   
 The Map where the JSONObject's properties are kept.
 
1154
1155
   private Map properties;

   
 Construct an empty JSONObject.
 
1159
1160
   public JSONObject() {
1161
      this.properties = new TreeMap();
1162
   }

   
 Creates a JSONObject that is null.
 
1166
1167
   public JSONObject( boolean isNull ) {
1168
      this();
1169
      this.nullObject = isNull;
1170
   }

   
 Accumulate values under a key. It is similar to the element method except
 that if there is already an object stored under the key then a JSONArray
 is stored under the key to hold all of the accumulated values. If there is
 already a JSONArray, then the new value is appended to it. In contrast,
 the replace method replaces the previous value.

 
 Parameters:key A key string.value An object to be accumulated under the key. Returns:this. Throws:JSONException If the value is an invalid number or if the key is
         null.
1184
1185
   public JSONObject accumulate( String key, boolean value ) {
1186
      return _accumulate( key, value ? Boolean.TRUE : Boolean.FALSE, new JsonConfig() );
1187
   }

   
 Accumulate values under a key. It is similar to the element method except
 that if there is already an object stored under the key then a JSONArray
 is stored under the key to hold all of the accumulated values. If there is
 already a JSONArray, then the new value is appended to it. In contrast,
 the replace method replaces the previous value.

 
 Parameters:key A key string.value An object to be accumulated under the key. Returns:this. Throws:JSONException If the value is an invalid number or if the key is
         null.
1201
1202
   public JSONObject accumulate( String key, double value ) {
1203
      return _accumulate( key, Double.valueOf( value ), new JsonConfig() );
1204
   }

   
 Accumulate values under a key. It is similar to the element method except
 that if there is already an object stored under the key then a JSONArray
 is stored under the key to hold all of the accumulated values. If there is
 already a JSONArray, then the new value is appended to it. In contrast,
 the replace method replaces the previous value.

 
 Parameters:key A key string.value An object to be accumulated under the key. Returns:this. Throws:JSONException If the value is an invalid number or if the key is
         null.
1218
1219
   public JSONObject accumulate( String key, int value ) {
1220
      return _accumulate( key, Integer.valueOf( value ), new JsonConfig() );
1221
   }

   
 Accumulate values under a key. It is similar to the element method except
 that if there is already an object stored under the key then a JSONArray
 is stored under the key to hold all of the accumulated values. If there is
 already a JSONArray, then the new value is appended to it. In contrast,
 the replace method replaces the previous value.

 
 Parameters:key A key string.value An object to be accumulated under the key. Returns:this. Throws:JSONException If the value is an invalid number or if the key is
         null.
1235
1236
   public JSONObject accumulate( String key, long value ) {
1237
      return _accumulate( key, Long.valueOf( value ), new JsonConfig() );
1238
   }

   
 Accumulate values under a key. It is similar to the element method except
 that if there is already an object stored under the key then a JSONArray
 is stored under the key to hold all of the accumulated values. If there is
 already a JSONArray, then the new value is appended to it. In contrast,
 the replace method replaces the previous value.

 
 Parameters:key A key string.value An object to be accumulated under the key. Returns:this. Throws:JSONException If the value is an invalid number or if the key is
         null.
1252
1253
   public JSONObject accumulate( String key, Object value ) {
1254
      return _accumulate( key, value, new JsonConfig() );
1255
   }

   
 Accumulate values under a key. It is similar to the element method except
 that if there is already an object stored under the key then a JSONArray
 is stored under the key to hold all of the accumulated values. If there is
 already a JSONArray, then the new value is appended to it. In contrast,
 the replace method replaces the previous value.

 
 Parameters:key A key string.value An object to be accumulated under the key. Returns:this. Throws:JSONException If the value is an invalid number or if the key is
         null.
1269
1270
   public JSONObject accumulate( String key, Object value, JsonConfig jsonConfig ) {
1271
      return _accumulate( key, value, jsonConfig );
1272
   }
1273
1274
   public void accumulateAll( Map map ) {
1275
      accumulateAll( map, new JsonConfig() );
1276
   }
1277
1278
   public void accumulateAll( Map map, JsonConfig jsonConfig ) {
1279
      if( map instanceof JSONObject ){
1280
         for( Iterator entries = map.entrySet()
1281
               .iterator(); entries.hasNext(); ){
1282
            Map.Entry entry = (Map.Entry) entries.next();
1283
            String key = (String) entry.getKey();
1284
            Object value = entry.getValue();
1285
            accumulate( key, value, jsonConfig );
1286
         }
1287
      }else{
1288
         for( Iterator entries = map.entrySet()
1289
               .iterator(); entries.hasNext(); ){
1290
            Map.Entry entry = (Map.Entry) entries.next();
1291
            String key = String.valueOf( entry.getKey() );
1292
            Object value = entry.getValue();
1293
            accumulate( key, value, jsonConfig );
1294
         }
1295
      }
1296
   }
1297
1298
   public void clear() {
1299
      properties.clear();
1300
   }
1301
1302
   public int compareTo( Object obj ) {
1303
      if( obj != null && (obj instanceof JSONObject) ){
1304
         JSONObject other = (JSONObject) obj;
1305
         int size1 = size();
1306
         int size2 = other.size();
1307
         if( size1 < size2 ){
1308
            return -1;
1309
         }else if( size1 > size2 ){
1310
            return 1;
1311
         }else if( this.equals( other ) ){
1312
            return 0;
1313
         }
1314
      }
1315
      return -1;
1316
   }
1317
1318
   public boolean containsKey( Object key ) {
1319
      return properties.containsKey( key );
1320
   }
1321
1322
   public boolean containsValue( Object value ) {
1323
      return containsValue( value, new JsonConfig() );
1324
   }
1325
1326
   public boolean containsValue( Object value, JsonConfig jsonConfig ) {
1327
      try{
1328
         value = processValue( value, jsonConfig );
1329
      }catch( JSONException e ){
1330
         return false;
1331
      }
1332
      return properties.containsValue( value );
1333
   }

   
 Put a key/boolean pair in the JSONObject.

 
 Parameters:key A key string.value A boolean which is the value. Returns:this. Throws:JSONException If the key is null.
1342
1343
   public JSONObject element( String key, boolean value ) {
1344
      verifyIsNull();
1345
      return element( key, value ? Boolean.TRUE : Boolean.FALSE );
1346
   }

   
 Put a key/value pair in the JSONObject, where the value will be a
 JSONArray which is produced from a Collection.

 
 Parameters:key A key string.value A Collection value. Returns:this. Throws:JSONException
1356
1357
   public JSONObject element( String key, Collection value ) {
1358
      return element( key, value, new JsonConfig() );
1359
   }

   
 Put a key/value pair in the JSONObject, where the value will be a
 JSONArray which is produced from a Collection.

 
 Parameters:key A key string.value A Collection value. Returns:this. Throws:JSONException
1369
1370
   public JSONObject element( String key, Collection value, JsonConfig jsonConfig ) {
1371
      verifyIsNull();
1372
      if( value instanceof JSONArray ){
1373
         return setInternal( key, value, jsonConfig );
1374
      }else{
1375
         return element( key, JSONArray.fromObject( value, jsonConfig ) );
1376
      }
1377
   }

   
 Put a key/double pair in the JSONObject.

 
 Parameters:key A key string.value A double which is the value. Returns:this. Throws:JSONException If the key is null or if the number is invalid.
1386
1387
   public JSONObject element( String key, double value ) {
1388
      verifyIsNull();
1389
      Double d = new Double( value );
1390
      JSONUtils.testValidity( d );
1391
      return element( key, d );
1392
   }

   
 Put a key/int pair in the JSONObject.

 
 Parameters:key A key string.value An int which is the value. Returns:this. Throws:JSONException If the key is null.
1401
1402
   public JSONObject element( String key, int value ) {
1403
      verifyIsNull();
1404
      return element( key, new Integer( value ) );
1405
   }

   
 Put a key/long pair in the JSONObject.

 
 Parameters:key A key string.value A long which is the value. Returns:this. Throws:JSONException If the key is null.
1414
1415
   public JSONObject element( String key, long value ) {
1416
      verifyIsNull();
1417
      return element( key, new Long( value ) );
1418
   }

   
 Put a key/value pair in the JSONObject, where the value will be a
 JSONObject which is produced from a Map.

 
 Parameters:key A key string.value A Map value. Returns:this. Throws:JSONException
1428
1429
   public JSONObject element( String key, Map value ) {
1430
      return element( key, value, new JsonConfig() );
1431
   }

   
 Put a key/value pair in the JSONObject, where the value will be a
 JSONObject which is produced from a Map.

 
 Parameters:key A key string.value A Map value. Returns:this. Throws:JSONException
1441
1442
   public JSONObject element( String key, Map value, JsonConfig jsonConfig ) {
1443
      verifyIsNull();
1444
      if( value instanceof JSONObject ){
1445
         return setInternal( key, value, jsonConfig );
1446
      }else{
1447
         return element( key, JSONObject.fromObject( value, jsonConfig ), jsonConfig );
1448
      }
1449
   }

   
 Put a key/value pair in the JSONObject. If the value is null, then the key
 will be removed from the JSONObject if it is present.

 If there is a previous value assigned to the key, it will call accumulate.

 
 Parameters:key A key string.value An object which is the value. It should be of one of these
        types: Boolean, Double, Integer, JSONArray, JSONObject, Long,
        String, or the JSONNull object. Returns:this. Throws:JSONException If the value is non-finite number or if the key is
         null.
1463
1464
   public JSONObject element( String key, Object value ) {
1465
      return element( key, value, new JsonConfig() );
1466
   }

   
 Put a key/value pair in the JSONObject. If the value is null, then the key
 will be removed from the JSONObject if it is present.

 If there is a previous value assigned to the key, it will call accumulate.

 
 Parameters:key A key string.value An object which is the value. It should be of one of these
        types: Boolean, Double, Integer, JSONArray, JSONObject, Long,
        String, or the JSONNull object. Returns:this. Throws:JSONException If the value is non-finite number or if the key is
         null.
1480
1481
   public JSONObject element( String key, Object value, JsonConfig jsonConfig ) {
1482
      verifyIsNull();
1483
      if( key == null ){
1484
         throw new JSONException( "Null key." );
1485
      }
1486
      if( value != null ){
1487
         value = processValue( key, value, jsonConfig );
1488
         setInternal( key, value, jsonConfig );
1489
      }else{
1490
         remove( key );
1491
      }
1492
      return this;
1493
   }

   
 Put a key/value pair in the JSONObject, but only if the key and the value
 are both non-null.

 
 Parameters:key A key string.value An object which is the value. It should be of one of these
        types: Boolean, Double, Integer, JSONArray, JSONObject, Long,
        String, or the JSONNull object. Returns:this. Throws:JSONException If the value is a non-finite number.
1505
1506
   public JSONObject elementOpt( String key, Object value ) {
1507
      return elementOpt( key, value, new JsonConfig() );
1508
   }

   
 Put a key/value pair in the JSONObject, but only if the key and the value
 are both non-null.

 
 Parameters:key A key string.value An object which is the value. It should be of one of these
        types: Boolean, Double, Integer, JSONArray, JSONObject, Long,
        String, or the JSONNull object. Returns:this. Throws:JSONException If the value is a non-finite number.
1520
1521
   public JSONObject elementOpt( String key, Object value, JsonConfig jsonConfig ) {
1522
      verifyIsNull();
1523
      if( key != null && value != null ){
1524
         element( key, value, jsonConfig );
1525
      }
1526
      return this;
1527
   }
1528
1529
   public Set entrySet() {
1530
      return properties.entrySet();
1531
   }
1532
1533
   public boolean equals( Object obj ) {
1534
      if( obj == this ){
1535
         return true;
1536
      }
1537
      if( obj == null ){
1538
         return false;
1539
      }
1540
1541
      if( !(obj instanceof JSONObject) ){
1542
         return false;
1543
      }
1544
1545
      JSONObject other = (JSONObject) obj;
1546
1547
      if( isNullObject() ){
1548
         return other.isNullObject();
1549
      }else{
1550
         if( other.isNullObject() ){
1551
            return false;
1552
         }
1553
      }
1554
1555
      if( other.size() != size() ){
1556
         return false;
1557
      }
1558
1559
      for( Iterator keys = properties.keySet()
1560
            .iterator(); keys.hasNext(); ){
1561
         String key = (String) keys.next();
1562
         if( !other.properties.containsKey( key ) ){
1563
            return false;
1564
         }
1565
         Object o1 = properties.get( key );
1566
         Object o2 = other.properties.get( key );
1567
1568
         if( JSONNull.getInstance()
1569
               .equals( o1 ) ){
1570
            if( JSONNull.getInstance()
1571
                  .equals( o2 ) ){
1572
               continue;
1573
            }else{
1574
               return false;
1575
            }
1576
         }else{
1577
            if( JSONNull.getInstance()
1578
                  .equals( o2 ) ){
1579
               return false;
1580
            }
1581
         }
1582
1583
         if( o1 instanceof String && o2 instanceof JSONFunction ){
1584
            if( !o1.equals( String.valueOf( o2 ) ) ){
1585
               return false;
1586
            }
1587
         }else if( o1 instanceof JSONFunction && o2 instanceof String ){
1588
            if( !o2.equals( String.valueOf( o1 ) ) ){
1589
               return false;
1590
            }
1591
         }else if( o1 instanceof JSONObject && o2 instanceof JSONObject ){
1592
            if( !o1.equals( o2 ) ){
1593
               return false;
1594
            }
1595
         }else if( o1 instanceof JSONArray && o2 instanceof JSONArray ){
1596
            if( !o1.equals( o2 ) ){
1597
               return false;
1598
            }
1599
         }else if( o1 instanceof JSONFunction && o2 instanceof JSONFunction ){
1600
            if( !o1.equals( o2 ) ){
1601
               return false;
1602
            }
1603
         }else{
1604
            if( o1 instanceof String ){
1605
               if( !o1.equals( String.valueOf( o2 ) ) ){
1606
                  return false;
1607
               }
1608
            }else if( o2 instanceof String ){
1609
               if( !o2.equals( String.valueOf( o1 ) ) ){
1610
                  return false;
1611
               }
1612
            }else{
1613
               Morpher m1 = JSONUtils.getMorpherRegistry()
1614
                     .getMorpherFor( o1.getClass() );
1615
               Morpher m2 = JSONUtils.getMorpherRegistry()
1616
                     .getMorpherFor( o2.getClass() );
1617
               if( m1 != null && m1 != IdentityObjectMorpher.getInstance() ){
1618
                  if( !o1.equals( JSONUtils.getMorpherRegistry()
1619
                        .morph( o1.getClass(), o2 ) ) ){
1620
                     return false;
1621
                  }
1622
               }else if( m2 != null && m2 != IdentityObjectMorpher.getInstance() ){
1623
                  if( !JSONUtils.getMorpherRegistry()
1624
                        .morph( o1.getClass(), o1 )
1625
                        .equals( o2 ) ){
1626
                     return false;
1627
                  }
1628
               }else{
1629
                  if( !o1.equals( o2 ) ){
1630
                     return false;
1631
                  }
1632
               }
1633
            }
1634
         }
1635
      }
1636
      return true;
1637
   }
1638
1639
   public Object get( Object key ) {
1640
      if( key instanceof String ){
1641
         return get( (String) key );
1642
      }
1643
      return null;
1644
   }

   
 Get the value object associated with a key.

 
 Parameters:key A key string. Returns:The object associated with the key. Throws:JSONException if this.isNull() returns true.
1652
1653
   public Object get( String key ) {
1654
      verifyIsNull();
1655
      return this.properties.get( key );
1656
   }

   
 Get the boolean value associated with a key.

 
 Parameters:key A key string. Returns:The truth. Throws:JSONException if the value is not a Boolean or the String "true"
         or "false".
1665
1666
   public boolean getBoolean( String key ) {
1667
      verifyIsNull();
1668
      Object o = get( key );
1669
      if( o != null ){
1670
         if( o.equals( Boolean.FALSE )
1671
               || (o instanceof String && ((String) o).equalsIgnoreCase( "false" )) ){
1672
            return false;
1673
         }else if( o.equals( Boolean.TRUE )
1674
               || (o instanceof String && ((String) o).equalsIgnoreCase( "true" )) ){
1675
            return true;
1676
         }
1677
      }
1678
      throw new JSONException( "JSONObject[" + JSONUtils.quote( key ) + "] is not a Boolean." );
1679
   }

   
 Get the double value associated with a key.

 
 Parameters:key A key string. Returns:The numeric value. Throws:JSONException if the key is not found or if the value is not a
         Number object and cannot be converted to a number.
1688
1689
   public double getDouble( String key ) {
1690
      verifyIsNull();
1691
      Object o = get( key );
1692
      if( o != null ){
1693
         try{
1694
            return o instanceof Number ? ((Number) o).doubleValue()
1695
                  : Double.parseDouble( (String) o );
1696
         }catch( Exception e ){
1697
            throw new JSONException( "JSONObject[" + JSONUtils.quote( key ) + "] is not a number." );
1698
         }
1699
      }
1700
      throw new JSONException( "JSONObject[" + JSONUtils.quote( key ) + "] is not a number." );
1701
   }

   
 Get the int value associated with a key. If the number value is too large
 for an int, it will be clipped.

 
 Parameters:key A key string. Returns:The integer value. Throws:JSONException if the key is not found or if the value cannot be
         converted to an integer.
1711
1712
   public int getInt( String key ) {
1713
      verifyIsNull();
1714
      Object o = get( key );
1715
      if( o != null ){
1716
         return o instanceof Number ? ((Number) o).intValue() : (int) getDouble( key );
1717
      }
1718
      throw new JSONException( "JSONObject[" + JSONUtils.quote( key ) + "] is not a number." );
1719
   }

   
 Get the JSONArray value associated with a key.

 
 Parameters:key A key string. Returns:A JSONArray which is the value. Throws:JSONException if the key is not found or if the value is not a
         JSONArray.
1728
1729
   public JSONArray getJSONArray( String key ) {
1730
      verifyIsNull();
1731
      Object o = get( key );
1732
      if( o != null && o instanceof JSONArray ){
1733
         return (JSONArray) o;
1734
      }
1735
      throw new JSONException( "JSONObject[" + JSONUtils.quote( key ) + "] is not a JSONArray." );
1736
   }

   
 Get the JSONObject value associated with a key.

 
 Parameters:key A key string. Returns:A JSONObject which is the value. Throws:JSONException if the key is not found or if the value is not a
         JSONObject.
1745
1746
   public JSONObject getJSONObject( String key ) {
1747
      verifyIsNull();
1748
      Object o = get( key );
1749
      if( JSONNull.getInstance()
1750
            .equals( o ) ){
1751
         return new JSONObject( true );
1752
      }else if( o instanceof JSONObject ){
1753
         return (JSONObject) o;
1754
      }
1755
      throw new JSONException( "JSONObject[" + JSONUtils.quote( key ) + "] is not a JSONObject." );
1756
   }

   
 Get the long value associated with a key. If the number value is too long
 for a long, it will be clipped.

 
 Parameters:key A key string. Returns:The long value. Throws:JSONException if the key is not found or if the value cannot be
         converted to a long.
1766
1767
   public long getLong( String key ) {
1768
      verifyIsNull();
1769
      Object o = get( key );
1770
      if( o != null ){
1771
         return o instanceof Number ? ((Number) o).longValue() : (long) getDouble( key );
1772
      }
1773
      throw new JSONException( "JSONObject[" + JSONUtils.quote( key ) + "] is not a number." );
1774
   }

   
 Get the string associated with a key.

 
 Parameters:key A key string. Returns:A string which is the value. Throws:JSONException if the key is not found.
1782
1783
   public String getString( String key ) {
1784
      verifyIsNull();
1785
      Object o = get( key );
1786
      if( o != null ){
1787
         return o.toString();
1788
      }
1789
      throw new JSONException( "JSONObject[" + JSONUtils.quote( key ) + "] not found." );
1790
   }

   
 Determine if the JSONObject contains a specific key.

 
 Parameters:key A key string. Returns:true if the key exists in the JSONObject.
1797
1798
   public boolean has( String key ) {
1799
      verifyIsNull();
1800
      return this.properties.containsKey( key );
1801
   }
1802
1803
   public int hashCode() {
1804
      int hashcode = 19;
1805
      if( isNullObject() ){
1806
         return hashcode + JSONNull.getInstance()
1807
               .hashCode();
1808
      }
1809
      for( Iterator entries = properties.entrySet()
1810
            .iterator(); entries.hasNext(); ){
1811
         Map.Entry entry = (Map.Entry) entries.next();
1812
         Object key = entry.getKey();
1813
         Object value = entry.getValue();
1814
         hashcode += key.hashCode() + JSONUtils.hashCode( value );
1815
      }
1816
      return hashcode;
1817
   }
1818
1819
   public boolean isArray() {
1820
      return false;
1821
   }
1822
1823
   public boolean isEmpty() {
1824
      verifyIsNull();
1825
      return this.properties.isEmpty();
1826
   }

   
 Returs if this object is a null JSONObject.
 
1830
1831
   public boolean isNullObject() {
1832
      return nullObject;
1833
   }

   
 Get an enumeration of the keys of the JSONObject.

 
 Returns:An iterator of the keys.
1839
1840
   public Iterator keys() {
1841
      verifyIsNull();
1842
      return this.properties.keySet()
1843
            .iterator();
1844
   }
1845
1846
   public Set keySet() {
1847
      return properties.keySet();
1848
   }

   
 Produce a JSONArray containing the names of the elements of this
 JSONObject.

 
 Returns:A JSONArray containing the key strings, or null if the JSONObject
         is empty.
1856
1857
   public JSONArray names() {
1858
      verifyIsNull();
1859
      JSONArray ja = new JSONArray();
1860
      Iterator keys = keys();
1861
      while( keys.hasNext() ){
1862
         ja.element( keys.next() );
1863
      }
1864
      return ja;
1865
   }

   
 Get an optional value associated with a key.

 
 Parameters:key A key string. Returns:An object which is the value, or null if there is no value.
1872
1873
   public Object opt( String key ) {
1874
      verifyIsNull();
1875
      return key == null ? null : this.properties.get( key );
1876
   }

   
 Get an optional boolean associated with a key. It returns false if there
 is no such key, or if the value is not Boolean.TRUE or the String "true".

 
 Parameters:key A key string. Returns:The truth.
1884
1885
   public boolean optBoolean( String key ) {
1886
      verifyIsNull();
1887
      return optBoolean( key, false );
1888
   }

   
 Get an optional boolean associated with a key. It returns the defaultValue
 if there is no such key, or if it is not a Boolean or the String "true" or
 "false" (case insensitive).

 
 Parameters:key A key string.defaultValue The default. Returns:The truth.
1898
1899
   public boolean optBoolean( String key, boolean defaultValue ) {
1900
      verifyIsNull();
1901
      try{
1902
         return getBoolean( key );
1903
      }catch( Exception e ){
1904
         return defaultValue;
1905
      }
1906
   }

   
 Get an optional double associated with a key, or NaN if there is no such
 key or if its value is not a number. If the value is a string, an attempt
 will be made to evaluate it as a number.

 
 Parameters:key A string which is the key. Returns:An object which is the value.
1915
1916
   public double optDouble( String key ) {
1917
      verifyIsNull();
1918
      return optDouble( key, Double.NaN );
1919
   }

   
 Get an optional double associated with a key, or the defaultValue if there
 is no such key or if its value is not a number. If the value is a string,
 an attempt will be made to evaluate it as a number.

 
 Parameters:key A key string.defaultValue The default. Returns:An object which is the value.
1929
1930
   public double optDouble( String key, double defaultValue ) {
1931
      verifyIsNull();
1932
      try{
1933
         Object o = opt( key );
1934
         return o instanceof Number ? ((Number) o).doubleValue()
1935
               : Double.parseDouble((String) o);
1936
      }catch( Exception e ){
1937
         return defaultValue;
1938
      }
1939
   }

   
 Get an optional int value associated with a key, or zero if there is no
 such key or if the value is not a number. If the value is a string, an
 attempt will be made to evaluate it as a number.

 
 Parameters:key A key string. Returns:An object which is the value.
1948
1949
   public int optInt( String key ) {
1950
      verifyIsNull();
1951
      return optInt( key, 0 );
1952
   }

   
 Get an optional int value associated with a key, or the default if there
 is no such key or if the value is not a number. If the value is a string,
 an attempt will be made to evaluate it as a number.

 
 Parameters:key A key string.defaultValue The default. Returns:An object which is the value.
1962
1963
   public int optInt( String key, int defaultValue ) {
1964
      verifyIsNull();
1965
      try{
1966
         return getInt( key );
1967
      }catch( Exception e ){
1968
         return defaultValue;
1969
      }
1970
   }

   
 Get an optional JSONArray associated with a key. It returns null if there
 is no such key, or if its value is not a JSONArray.

 
 Parameters:key A key string. Returns:A JSONArray which is the value.
1978
1979
   public JSONArray optJSONArray( String key ) {
1980
      verifyIsNull();
1981
      Object o = opt( key );
1982
      return o instanceof JSONArray ? (JSONArray) o : null;
1983
   }

   
 Get an optional JSONObject associated with a key. It returns null if there
 is no such key, or if its value is not a JSONObject.

 
 Parameters:key A key string. Returns:A JSONObject which is the value.
1991
1992
   public JSONObject optJSONObject( String key ) {
1993
      verifyIsNull();
1994
      Object o = opt( key );
1995
      return o instanceof JSONObject ? (JSONObject) o : null;
1996
   }

   
 Get an optional long value associated with a key, or zero if there is no
 such key or if the value is not a number. If the value is a string, an
 attempt will be made to evaluate it as a number.

 
 Parameters:key A key string. Returns:An object which is the value.
2005
2006
   public long optLong( String key ) {
2007
      verifyIsNull();
2008
      return optLong( key, 0 );
2009
   }

   
 Get an optional long value associated with a key, or the default if there
 is no such key or if the value is not a number. If the value is a string,
 an attempt will be made to evaluate it as a number.

 
 Parameters:key A key string.defaultValue The default. Returns:An object which is the value.
2019
2020
   public long optLong( String key, long defaultValue ) {
2021
      verifyIsNull();
2022
      try{
2023
         return getLong( key );
2024
      }catch( Exception e ){
2025
         return defaultValue;
2026
      }
2027
   }

   
 Get an optional string associated with a key. It returns an empty string
 if there is no such key. If the value is not a string and is not null,
 then it is coverted to a string.

 
 Parameters:key A key string. Returns:A string which is the value.
2036
2037
   public String optString( String key ) {
2038
      verifyIsNull();
2039
      return optString( key, "" );
2040
   }

   
 Get an optional string associated with a key. It returns the defaultValue
 if there is no such key.

 
 Parameters:key A key string.defaultValue The default. Returns:A string which is the value.
2049
2050
   public String optString( String key, String defaultValue ) {
2051
      verifyIsNull();
2052
      Object o = opt( key );
2053
      return o != null ? o.toString() : defaultValue;
2054
   }
2055
2056
   public Object put( String key, Object value ) {
2057
      if( key == null ){
2058
         throw new IllegalArgumentException( "key is null." );
2059
      }
2060
      Object previous = properties.get( key );
2061
      element( String.valueOf( key ), value );
2062
      return previous;
2063
   }
2064
2065
   public void putAll( Map map ) {
2066
      putAll( map, new JsonConfig() );
2067
   }
2068
2069
   public void putAll( Map map, JsonConfig jsonConfig ) {
2070
      if( map instanceof JSONObject ){
2071
         for( Iterator entries = map.entrySet()
2072
               .iterator(); entries.hasNext(); ){
2073
            Map.Entry entry = (Map.Entry) entries.next();
2074
            String key = (String) entry.getKey();
2075
            Object value = entry.getValue();
2076
            this.properties.put( key, value );
2077
         }
2078
      }else{
2079
         for( Iterator entries = map.entrySet()
2080
               .iterator(); entries.hasNext(); ){
2081
            Map.Entry entry = (Map.Entry) entries.next();
2082
            String key = String.valueOf( entry.getKey() );
2083
            Object value = entry.getValue();
2084
            element( key, value, jsonConfig );
2085
         }
2086
      }
2087
   }
2088
2089
   public Object remove( Object key ) {
2090
      return properties.remove( key );
2091
   }

   
 Remove a name and its value, if present.

 
 Parameters:key The name to be removed. Returns:The value that was associated with the name, or null if there was
         no value.
2099
2100
   public Object remove( String key ) {
2101
      verifyIsNull();
2102
      return this.properties.remove( key );
2103
   }

   
 Get the number of keys stored in the JSONObject.

 
 Returns:The number of keys in the JSONObject.
2109
2110
   public int size() {
2111
      verifyIsNull();
2112
      return this.properties.size();
2113
   }

   
 Produce a JSONArray containing the values of the members of this
 JSONObject.

 
 Parameters:names A JSONArray containing a list of key strings. This determines
        the sequence of the values in the result. Returns:A JSONArray of values. Throws:JSONException If any of the values are non-finite numbers.
2123
2124
   public JSONArray toJSONArray( JSONArray names ) {
2125
      verifyIsNull();
2126
      if( names == null || names.size() == 0 ){
2127
         return null;
2128
      }
2129
      JSONArray ja = new JSONArray();
2130
      for( int i = 0; i < names.size(); i += 1 ){
2131
         ja.element( this.opt( names.getString( i ) ) );
2132
      }
2133
      return ja;
2134
   }

   
 Make a JSON text of this JSONObject. For compactness, no whitespace is
 added. If this would not result in a syntactically correct JSON text, then
 null will be returned instead.
 
 Warning: This method assumes that the data structure is acyclical.

 
 Returns:a printable, displayable, portable, transmittable representation
         of the object, beginning with { (left
         brace) and ending with } (right
         brace).
2147
2148
   public String toString() {
2149
      if( isNullObject() ){
2150
         return JSONNull.getInstance()
2151
               .toString();
2152
      }
2153
      try{
2154
         Iterator keys = keys();
2155
         StringBuffer sb = new StringBuffer( "{" );
2156
2157
         while( keys.hasNext() ){
2158
            if( sb.length() > 1 ){
2159
               sb.append( ',' );
2160
            }
2161
            Object o = keys.next();
2162
            sb.append( JSONUtils.quote( o.toString() ) );
2163
            sb.append( ':' );
2164
            sb.append( JSONUtils.valueToString( this.properties.get( o ) ) );
2165
         }
2166
         sb.append( '}' );
2167
         return sb.toString();
2168
      }catch( Exception e ){
2169
         return null;
2170
      }
2171
   }

   
 Make a prettyprinted JSON text of this JSONObject.
 
 Warning: This method assumes that the data structure is acyclical.

 
 Parameters:indentFactor The number of spaces to add to each level of
        indentation. Returns:a printable, displayable, portable, transmittable representation
         of the object, beginning with { (left
         brace) and ending with } (right
         brace). Throws:JSONException If the object contains an invalid number.
2185
2186
   public String toString( int indentFactor ) {
2187
      if( isNullObject() ){
2188
         return JSONNull.getInstance()
2189
               .toString();
2190
      }
2191
      if( indentFactor == 0 ){
2192
         return this.toString();
2193
      }
2194
      return toString( indentFactor, 0 );
2195
   }

   
 Make a prettyprinted JSON text of this JSONObject.
 
 Warning: This method assumes that the data structure is acyclical.

 
 Parameters:indentFactor The number of spaces to add to each level of
        indentation.indent The indentation of the top level. Returns:a printable, displayable, transmittable representation of the
         object, beginning with { (left brace)
         and ending with } (right brace). Throws:JSONException If the object contains an invalid number.
2209
2210
   public String toString( int indentFactor, int indent ) {
2211
      if( isNullObject() ){
2212
         return JSONNull.getInstance()
2213
               .toString();
2214
      }
2215
      int i;
2216
      int n = size();
2217
      if( n == 0 ){
2218
         return "{}";
2219
      }
2220
      if( indentFactor == 0 ){
2221
         return this.toString();
2222
      }
2223
      Iterator keys = keys();
2224
      StringBuffer sb = new StringBuffer( "{" );
2225
      int newindent = indent + indentFactor;
2226
      Object o;
2227
      if( n == 1 ){
2228
         o = keys.next();
2229
         sb.append( JSONUtils.quote( o.toString() ) );
2230
         sb.append( ": " );
2231
         sb.append( JSONUtils.valueToString( this.properties.get( o ), indentFactor, indent ) );
2232
      }else{
2233
         while( keys.hasNext() ){
2234
            o = keys.next();
2235
            if( sb.length() > 1 ){
2236
               sb.append( ",\n" );
2237
            }else{
2238
               sb.append( '\n' );
2239
            }
2240
            for( i = 0; i < newindent; i += 1 ){
2241
               sb.append( ' ' );
2242
            }
2243
            sb.append( JSONUtils.quote( o.toString() ) );
2244
            sb.append( ": " );
2245
            sb.append( JSONUtils.valueToString( this.properties.get( o ), indentFactor, newindent ) );
2246
         }
2247
         if( sb.length() > 1 ){
2248
            sb.append( '\n' );
2249
            for( i = 0; i < indent; i += 1 ){
2250
               sb.append( ' ' );
2251
            }
2252
         }
2253
         for( i = 0; i < indent; i += 1 ){
2254
            sb.insert( 0, ' ' );
2255
         }
2256
      }
2257
      sb.append( '}' );
2258
      return sb.toString();
2259
   }
2260
2261
   public Collection values() {
2262
      return Collections.unmodifiableCollection( properties.values() );
2263
   }

   
 Write the contents of the JSONObject as JSON text to a writer. For
 compactness, no whitespace is added.
 
 Warning: This method assumes that the data structure is acyclical.

 
 Returns:The writer. Throws:JSONException
2273
2274
   protected void write( Writer writer, WritingVisitor visitor ) throws IOException {
2275
       if( isNullObject() ){
2276
          writer.write( JSONNull.getInstance().toString() );
2277
           return;
2278
       }
2279
2280
       boolean b = false;
2281
       Iterator keys = keys();
2282
       writer.write( '{' );
2283
2284
       while( keys.hasNext() ){
2285
          if( b ){
2286
             writer.write( ',' );
2287
          }
2288
          Object k = keys.next();
2289
          writer.write( JSONUtils.quote( k.toString() ) );
2290
          writer.write( ':' );
2291
          Object v = this.properties.get( k );
2292
          if( v instanceof JSON ){
2293
              visitor.on((JSON)v,writer);
2294
          }else{
2295
              visitor.on(v,writer);
2296
          }
2297
          b = true;
2298
       }
2299
       writer.write( '}' );
2300
   }
2301
2302
   private JSONObject _accumulate( String key, Object value, JsonConfig jsonConfig ) {
2303
      if( isNullObject() ){
2304
         throw new JSONException( "Can't accumulate on null object" );
2305
      }
2306
2307
      if( !has( key ) ){
2308
         setInternal( key, value, jsonConfig );
2309
      }else{
2310
         Object o = opt( key );
2311
         if( o instanceof JSONArray ){
2312
            ((JSONArray) o).element( value, jsonConfig );
2313
         }else{
2314
            setInternal( key, new JSONArray().element( o )
2315
                  .element( value, jsonConfig ), jsonConfig );
2316
         }
2317
      }
2318
2319
      return this;
2320
   }
2321
2322
   private Object _processValue( Object value, JsonConfig jsonConfig ) {
2323
      if( (value != null && Class.class.isAssignableFrom( value.getClass() ))
2324
            || value instanceof Class ){
2325
         return ((Class) value).getName();
2326
      }else if( value instanceof JSON ){
2327
         return JSONSerializer.toJSON( value, jsonConfig );
2328
      }else if( JSONUtils.isFunction( value ) ){
2329
         if( value instanceof String ){
2330
            value = JSONFunction.parse( (String) value );
2331
         }
2332
         return value;
2333
      }else if( value instanceof JSONString ){
2334
         return JSONSerializer.toJSON(value, jsonConfig );
2335
      }else if( JSONUtils.isArray( value ) ){
2336
         return JSONArray.fromObject( value, jsonConfig );
2337
      }else if( JSONUtils.isString( value ) ){
2338
         String str = String.valueOf( value );
2339
         if( value == null ){
2340
            return "";
2341
         }else{
2342
            return str;
2343
         }
2344
      }else if( JSONUtils.isNumber( value ) ){
2345
         JSONUtils.testValidity( value );
2346
         return JSONUtils.transformNumber( (Number) value );
2347
      }else if( JSONUtils.isBoolean( value ) ){
2348
         return value;
2349
      }else if( value != null && Enum.class.isAssignableFrom( value.getClass() ) ){
2350
         return String.valueOf(value);
2351
      }else{
2352
         return fromObject( value, jsonConfig );
2353
      }
2354
   }

   
 Put a key/value pair in the JSONObject.

 
 Parameters:key A key string.value An object which is the value. It should be of one of these
        types: Boolean, Double, Integer, JSONArray, JSONObject, Long,
        String, or the JSONNull object. Returns:this. Throws:JSONException If the value is non-finite number or if the key is
         null.
2366
2367
   private JSONObject _setInternal( String key, Object value, JsonConfig jsonConfig ) {
2368
      verifyIsNull();
2369
      if( key == null ){
2370
         throw new JSONException( "Null key." );
2371
      }
2372
2373
      this.properties.put( key, _processValue( value, jsonConfig ) );
2374
2375
      return this;
2376
   }
2377
2378
   private Object processValue( Object value, JsonConfig jsonConfig ) {
2379
      if( value != null ){
2380
         JsonValueProcessor processor = jsonConfig.findJsonValueProcessor( value.getClass() );
2381
         if( processor != null ){
2382
            value = processor.processObjectValue( null, value, jsonConfig );
2383
            if( !JsonVerifier.isValidJsonValue( value ) ){
2384
               throw new JSONException( "Value is not a valid JSON value. " + value );
2385
            }
2386
         }
2387
      }
2388
      return _processValue( value, jsonConfig );
2389
   }
2390
2391
   private Object processValue( String key, Object value, JsonConfig jsonConfig ) {
2392
      if( value != null ){
2393
         JsonValueProcessor processor = jsonConfig.findJsonValueProcessor( value.getClass(), key );
2394
         if( processor != null ){
2395
            value = processor.processObjectValue( null, value, jsonConfig );
2396
            if( !JsonVerifier.isValidJsonValue( value ) ){
2397
               throw new JSONException( "Value is not a valid JSON value. " + value );
2398
            }
2399
         }
2400
      }
2401
      return _processValue( value, jsonConfig );
2402
   }

   
 Put a key/value pair in the JSONObject.

 
 Parameters:key A key string.value An object which is the value. It should be of one of these
        types: Boolean, Double, Integer, JSONArray, JSONObject, Long,
        String, or the JSONNull object. Returns:this. Throws:JSONException If the value is non-finite number or if the key is
         null.
2414
2415
   private JSONObject setInternal( String key, Object value, JsonConfig jsonConfig ) {
2416
      return _setInternal( key, processValue( key, value, jsonConfig ), jsonConfig );
2417
   }

   
 Checks if this object is a "null" object.
 
2421
2422
   private void verifyIsNull() {
2423
      if( isNullObject() ){
2424
         throw new JSONException( "null object" );
2425
      }
2426
   }
2427
}