JSONObject 源码

/*
* Copyright 2002-2009 the original author or authors.
*
* Licensed under the Apache License,Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.sf.json;

import java.beans.PropertyDescriptor;
import java.io.IOException;
import java.io.Writer;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import net.sf.ezmorph.Morpher;
import net.sf.ezmorph.array.ObjectArrayMorpher;
import net.sf.ezmorph.bean.BeanMorpher;
import net.sf.ezmorph.object.IdentityObjectMorpher;
import net.sf.json.processors.JsonBeanProcessor;
import net.sf.json.processors.JsonValueProcessor;
import net.sf.json.processors.JsonVerifier;
import net.sf.json.processors.PropertyNameProcessor;
import net.sf.json.regexp.RegexpUtils;
import net.sf.json.util.CycleDetectionStrategy;
import net.sf.json.util.JSONTokener;
import net.sf.json.util.JSONUtils;
import net.sf.json.util.PropertyFilter;
import net.sf.json.util.PropertySetStrategy;

import org.apache.commons.beanutils.DynaBean;
import org.apache.commons.beanutils.DynaProperty;
import org.apache.commons.beanutils.PropertyUtils;
import org.apache.commons.collections.map.ListOrderedMap;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
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 <code>get</code> and <code>opt</code> methods for accessing
* the values by name,and <code>put</code> methods for adding or replacing
* values by name. The values can be any of these types: <code>Boolean</code>,
* <code>JSONArray</code>,<code>JSONObject</code>,<code>Number</code>,
* <code>String</code>,or the <code>JSONNull</code> 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 <code>get</code> and
* <code>opt</code> methods,or to convert values into a JSON text using the
* <code>element</code> and <code>toString</code> methods. A
* <code>get</code> method returns a value if one can be found,and throws an
* exception if one cannot be found. An <code>opt</code> method returns a
* default value instead of throwing an exception,and so is useful for
* obtaining optional values.
* 
* The generic <code>get()</code> and <code>opt()</code> methods return an
* object,which you can cast or query for type. There are also typed
* <code>get</code> and <code>opt</code> methods that do type checking and
* type coercion for you.
* 
* The <code>put</code> methods adds values to an object. For example,
*
* <pre>
* myString = new JSONObject().put("JSON","Hello,World!").toString();</pre>
*
* produces the string <code>{"JSON": "Hello,World"}</code>.
* 
* The texts produced by the <code>toString</code> methods strictly conform to
* the JSON Syntax rules. The constructors are more forgiving in the texts they
* will accept:
* <ul>
* <li>An extra <code>,</code> (comma) may appear just
* before the closing brace.</li>
* <li>Strings may be quoted with <code>'</code> (single quote).</li>
* <li>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:
* <code>{ } [ ] / \ :,= ; #</code> and if they do not look like numbers and
* if they are not the reserved words <code>true</code>,<code>false</code>,
* or <code>null</code>.</li>
* <li>Keys can be followed by <code>=</code> or <code>=></code> as well as
* by <code>:</code>.</li>
* <li>Values can be followed by <code>;</code> (semicolon)
* as well as by <code>,</code> (comma).</li>
* <li>Numbers may have the <code>0-</code> (octal) or
* <code>0x-</code> (hex) prefix.</li>
* <li>Comments written in the slashshlash,slashstar,and hash conventions
* will be ignored.</li>
* </ul>
*
* @author JSON.org
*/
public final class JSONObject extends AbstractJSON implements JSON,Map,Comparable {

private static final Log log = LogFactory.getLog( JSONObject.class );

/**
* Creates a JSONObject. 
* Inspects the object type to call the correct JSONObject factory method.
* Accepts JSON formatted strings,Maps,DynaBeans and JavaBeans.
*
* @param object
* @throws JSONException if the object can not be converted to a proper
* JSONObject.
*/

public static JSONObject fromObject( Object object ) {
return fromObject( object,new JsonConfig() );
}

/**
* Creates a JSONObject. 
* Inspects the object type to call the correct JSONObject factory method.
* Accepts JSON formatted strings,DynaBeans and JavaBeans.
*
* @param object
* @throws JSONException if the object can not be converted to a proper
* JSONObject.
*/
public static JSONObject fromObject( Object object,JsonConfig jsonConfig ) {
if( object == null || JSONUtils.isNull( object ) ){
return new JSONObject( true );
}else if( object instanceof JSONObject ){
return _fromJSONObject( (JSONObject) object,jsonConfig );
}else if( object instanceof DynaBean ){
return _fromDynaBean( (DynaBean) object,jsonConfig );
}else if( object instanceof JSONTokener ){
return _fromJSONTokener( (JSONTokener) object,jsonConfig );
}else if( object instanceof JSONString ){
return _fromJSONString( (JSONString) object,jsonConfig );
}else if( object instanceof Map ){
return _fromMap( (Map) object,jsonConfig );
}else if( object instanceof String ){
return _fromString( (String) object,jsonConfig );
}else if( JSONUtils.isNumber( object ) || JSONUtils.isBoolean( object )
|| JSONUtils.isString( object ) ){
return new JSONObject();
}else if( JSONUtils.isArray( object ) ){
throw new JSONException( "'object' is an array. Use JSONArray instead" );
}else{
return _fromBean( object,jsonConfig );
}
}

/**
* Creates a JSONDynaBean from a JSONObject.
*/
public static Object toBean( JSONObject jsonObject ) {
if( jsonObject == null || jsonObject.isNullObject() ){
return null;
}

DynaBean dynaBean = null;

JsonConfig jsonConfig = new JsonConfig();
Map props = JSONUtils.getProperties( jsonObject );
dynaBean = JSONUtils.newDynaBean( jsonObject,jsonConfig );
for( Iterator entries = jsonObject.names( jsonConfig )
.iterator(); entries.hasNext(); ){
String name = (String) entries.next();
String key = JSONUtils.convertToJavaIdentifier( name,jsonConfig );
Class type = (Class) props.get( name );
Object value = jsonObject.get( name );
try{
if( !JSONUtils.isNull( value ) ){
if( value instanceof JSONArray ){
dynaBean.set( key,JSONArray.toCollection( (JSONArray) value ) );
}else if( String.class.isAssignableFrom( type )
|| Boolean.class.isAssignableFrom( type ) || JSONUtils.isNumber( type )
|| Character.class.isAssignableFrom( type )
|| JSONFunction.class.isAssignableFrom( type ) ){
dynaBean.set( key,value );
}else{
dynaBean.set( key,toBean( (JSONObject) value ) );
}
}else{
if( type.isPrimitive() ){
// assume assigned default value
log.warn( "Tried to assign null value to " + key + ":" + type.getName() );
dynaBean.set( key,JSONUtils.getMorpherRegistry()
.morph( type,null ) );
}else{
dynaBean.set( key,null );
}
}
}catch( JSONException jsone ){
throw jsone;
}catch( Exception e ){
throw new JSONException( "Error while setting property=" + name + " type" + type,e );
}
}

return dynaBean;
}

/**
* Creates a bean from a JSONObject,with a specific target class. 
*/
public static Object toBean( JSONObject jsonObject,Class beanClass ) {
JsonConfig jsonConfig = new JsonConfig();
jsonConfig.setRootClass( beanClass );
return toBean( jsonObject,jsonConfig );
}

/**
* 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:
* <ul>
* <li>Every key must be an String.</li>
* <li>Every value must be a Class.</li>
* <li>A key may be a regular expression.</li>
* </ul>
*/
public static Object toBean( JSONObject jsonObject,Class beanClass,Map classMap ) {
JsonConfig jsonConfig = new JsonConfig();
jsonConfig.setRootClass( beanClass );
jsonConfig.setClassMap( classMap );
return toBean( jsonObject,with the specific configuration.
*/
public static Object toBean( JSONObject jsonObject,JsonConfig jsonConfig ) {
if( jsonObject == null || jsonObject.isNullObject() ){
return null;
}

Class beanClass = jsonConfig.getRootClass();
Map classMap = jsonConfig.getClassMap();

if( beanClass == null ){
return toBean( jsonObject );
}
if( classMap == null ){
classMap = Collections.EMPTY_MAP;
}

Object bean = null;
try{
if( beanClass.isInterface() ){
if( !Map.class.isAssignableFrom( beanClass ) ){
throw new JSONException( "beanClass is an interface. " + beanClass );
}else{
bean = new HashMap();
}
}else{
bean = jsonConfig.getNewBeanInstanceStrategy()
.newInstance( beanClass,jsonObject );
}
}catch( JSONException jsone ){
throw jsone;
}catch( Exception e ){
throw new JSONException( e );
}

Map props = JSONUtils.getProperties( jsonObject );
PropertyFilter javaPropertyFilter = jsonConfig.getJavaPropertyFilter();
for( Iterator entries = jsonObject.names( jsonConfig )
.iterator(); entries.hasNext(); ){
String name = (String) entries.next();
Class type = (Class) props.get( name );
Object value = jsonObject.get( name );
if( javaPropertyFilter != null && javaPropertyFilter.apply( bean,name,value ) ){
continue;
}
String key = Map.class.isAssignableFrom( beanClass )
&& jsonConfig.isSkipJavaIdentifierTransformationInMapKeys() ? name
: JSONUtils.convertToJavaIdentifier( name,jsonConfig );
PropertyNameProcessor propertyNameProcessor = jsonConfig.findJavaPropertyNameProcessor( beanClass );
if( propertyNameProcessor != null ){
key = propertyNameProcessor.processPropertyName( beanClass,key );
}
try{
if( Map.class.isAssignableFrom( beanClass ) ){
// no type info available for conversion
if( JSONUtils.isNull( value ) ){
setProperty( bean,key,value,jsonConfig );
}else if( value instanceof JSONArray ){
setProperty( bean,convertPropertyValueToCollection( key,jsonConfig,
classMap,List.class ),jsonConfig );
}else if( String.class.isAssignableFrom( type ) || JSONUtils.isBoolean( type )
|| JSONUtils.isNumber( type ) || JSONUtils.isString( type )
|| JSONFunction.class.isAssignableFrom( type ) ){
if( jsonConfig.isHandleJettisonEmptyElement() && "".equals( value ) ){
setProperty( bean,null,jsonConfig );
}else{
setProperty( bean,jsonConfig );
}
}else{
Class targetClass = findTargetClass( key,classMap );
targetClass = targetClass == null ? findTargetClass( name,classMap )
: targetClass;
JsonConfig jsc = jsonConfig.copy();
jsc.setRootClass( targetClass );
jsc.setClassMap( classMap );
if( targetClass != null ){
setProperty( bean,toBean( (JSONObject) value,jsc ),toBean( (JSONObject) value ),jsonConfig );
}
}
}else{
PropertyDescriptor pd = PropertyUtils.getPropertyDescriptor( bean,key );
if( pd != null && pd.getWriteMethod() == null ){
log.info( "Property '" + key + "' of "+ bean.getClass()+" has no write method. SKIPPED." );
continue;
}

if( pd != null ){
Class targetType = pd.getPropertyType();
if( !JSONUtils.isNull( value ) ){
if( value instanceof JSONArray ){
if( List.class.isAssignableFrom( pd.getPropertyType() ) ){
setProperty( bean,
jsonConfig,classMap,pd.getPropertyType() ),jsonConfig );
}else if( Set.class.isAssignableFrom( pd.getPropertyType() ) ){
setProperty( bean,convertPropertyValueToArray( key,
targetType,classMap ),jsonConfig );
}
}else if( String.class.isAssignableFrom( type ) || JSONUtils.isBoolean( type )
|| JSONUtils.isNumber( type ) || JSONUtils.isString( type )
|| JSONFunction.class.isAssignableFrom( type ) ){
if( pd != null ){
if( jsonConfig.isHandleJettisonEmptyElement() && "".equals( value ) ){
setProperty( bean,jsonConfig );
}else if( !targetType.isInstance( value ) ){
setProperty( bean,morPHPropertyValue( key,type,
targetType ),jsonConfig );
}
}else if( beanClass == null || bean instanceof Map ){
setProperty( bean,jsonConfig );
}else{
log.warn( "Tried to assign property " + key + ":" + type.getName()
+ " to bean of class " + bean.getClass()
.getName() );
}
}else{
if( jsonConfig.isHandleJettisonSingleElementArray() ){
JSONArray array = new JSONArray().element( value,jsonConfig );
Class newTargetClass = findTargetClass( key,classMap );
newTargetClass = newTargetClass == null ? findTargetClass( name,
classMap ) : newTargetClass;
JsonConfig jsc = jsonConfig.copy();
jsc.setRootClass( newTargetClass );
jsc.setClassMap( classMap );
if( targetType.isArray() ){
setProperty( bean,JSONArray.toArray( array,jsonConfig );
}else if( JSONArray.class.isAssignableFrom( targetType ) ){
setProperty( bean,array,jsonConfig );
}else if( List.class.isAssignableFrom( targetType )
|| Set.class.isAssignableFrom( targetType ) ){
jsc.setCollectionType( targetType );
setProperty( bean,JSONArray.toCollection( array,
jsonConfig );
}else{
setProperty( bean,jsonConfig );
}
}else{
if( targetType == Object.class || targetType.isInterface() ) {
Class targetTypeCopy = targetType;
targetType = findTargetClass( key,classMap );
targetType = targetType == null ? findTargetClass( name,classMap )
: targetType;
targetType = targetType == null && targetTypeCopy.isInterface() ? targetTypeCopy
: targetType;
}
JsonConfig jsc = jsonConfig.copy();
jsc.setRootClass( targetType );
jsc.setClassMap( classMap );
setProperty( bean,jsonConfig );
}
}
}else{
if( type.isPrimitive() ){
// assume assigned default value
log.warn( "Tried to assign null value to " + key + ":" + type.getName() );
setProperty( bean,null ),jsonConfig );
}
}
}else{
// pd is null
if( !JSONUtils.isNull( value ) ){
if( value instanceof JSONArray ){
setProperty( bean,jsonConfig );
}else if( String.class.isAssignableFrom( type ) || JSONUtils.isBoolean( type )
|| JSONUtils.isNumber( type ) || JSONUtils.isString( type )
|| JSONFunction.class.isAssignableFrom( type ) ){
if( beanClass == null || bean instanceof Map || jsonConfig.getPropertySetStrategy() != null ||
!jsonConfig.isIgnorePublicFields() ){
setProperty( bean,jsonConfig );
}else{
log.warn( "Tried to assign property " + key + ":" + type.getName()
+ " to bean of class " + bean.getClass()
.getName() );
}
}else{
if( jsonConfig.isHandleJettisonSingleElementArray() ){
Class newTargetClass = findTargetClass( key,
classMap ) : newTargetClass;
JsonConfig jsc = jsonConfig.copy();
jsc.setRootClass( newTargetClass );
jsc.setClassMap( classMap );
setProperty( bean,jsonConfig );
}
}
}
}
}catch( JSONException jsone ){
throw jsone;
}catch( Exception e ){
throw new JSONException( "Error while setting property=" + name + " type " + type,e );
}
}

return bean;
}

/**
* Creates a bean from a JSONObject,Object root,JsonConfig jsonConfig ) {
if( jsonObject == null || jsonObject.isNullObject() || root == null ){
return root;
}

Class rootClass = root.getClass();
if( rootClass.isInterface() ){
throw new JSONException( "Root bean is an interface. " + rootClass );
}

Map classMap = jsonConfig.getClassMap();
if( classMap == null ){
classMap = Collections.EMPTY_MAP;
}

if( !JSONUtils.isNull( value ) ){
if( value instanceof JSONArray ){
if( pd == null || List.class.isAssignableFrom( pd.getPropertyType() ) ){
Class targetClass = findTargetClass( key,classMap )
: targetClass;
Object newRoot = jsonConfig.getNewBeanInstanceStrategy()
.newInstance( targetClass,null );
List list = JSONArray.toList( (JSONArray) value,newRoot,jsonConfig );
setProperty( root,list,jsonConfig );
}else{
Class innerType = JSONUtils.getInnerComponentType( pd.getPropertyType() );
Class targetInnerType = findTargetClass( key,classMap );
if( innerType.equals( Object.class ) && targetInnerType != null
&& !targetInnerType.equals( Object.class ) ){
innerType = targetInnerType;
}
Object newRoot = jsonConfig.getNewBeanInstanceStrategy()
.newInstance( innerType,null );
Object array = JSONArray.toArray( (JSONArray) value,jsonConfig );
if( innerType.isPrimitive() || JSONUtils.isNumber( innerType )
|| Boolean.class.isAssignableFrom( innerType )
|| JSONUtils.isString( innerType ) ){
array = JSONUtils.getMorpherRegistry()
.morph( Array.newInstance( innerType,0 )
.getClass(),array );
}else if( !array.getClass()
.equals( pd.getPropertyType() ) ){
if( !pd.getPropertyType()
.equals( Object.class ) ){
Morpher morpher = JSONUtils.getMorpherRegistry()
.getMorpherFor( Array.newInstance( innerType,0 )
.getClass() );
if( IdentityObjectMorpher.getInstance()
.equals( morpher ) ){
ObjectArrayMorpher beanMorpher = new ObjectArrayMorpher(
new BeanMorpher( innerType,JSONUtils.getMorpherRegistry() ) );
JSONUtils.getMorpherRegistry()
.registerMorpher( beanMorpher );
}
array = JSONUtils.getMorpherRegistry()
.morph( Array.newInstance( innerType,array );
}
}
setProperty( root,jsonConfig );
}
}else if( String.class.isAssignableFrom( type ) || JSONUtils.isBoolean( type )
|| JSONUtils.isNumber( type ) || JSONUtils.isString( type )
|| JSONFunction.class.isAssignableFrom( type ) ){
if( pd != null ){
if( jsonConfig.isHandleJettisonEmptyElement() && "".equals( value ) ){
setProperty( root,jsonConfig );
}else if( !pd.getPropertyType()
.isInstance( value ) ){
Morpher morpher = JSONUtils.getMorpherRegistry()
.getMorpherFor( pd.getPropertyType() );
if( IdentityObjectMorpher.getInstance()
.equals( morpher ) ){
log.warn( "Can't transform property '" + key + "' from "
+ type.getName() + " into " + pd.getPropertyType()
.getName() + ". Will register a default BeanMorpher" );
JSONUtils.getMorpherRegistry()
.registerMorpher(
new BeanMorpher( pd.getPropertyType(),
JSONUtils.getMorpherRegistry() ) );
}
setProperty( root,JSONUtils.getMorpherRegistry()
.morph( pd.getPropertyType(),value ),jsonConfig );
}else{
setProperty( root,jsonConfig );
}
}else if( root instanceof Map ){
setProperty( root,jsonConfig );
}else{
log.warn( "Tried to assign property " + key + ":" + type.getName()
+ " to bean of class " + root.getClass()
.getName() );
}
}else{
if( pd != null ){
Class targetClass = pd.getPropertyType();
if( jsonConfig.isHandleJettisonSingleElementArray() ){
JSONArray array = new JSONArray().element( value,classMap )
: newTargetClass;
Object newRoot = jsonConfig.getNewBeanInstanceStrategy()
.newInstance( newTargetClass,null );
if( targetClass.isArray() ){
setProperty( root,jsonConfig ),
jsonConfig );
}else if( Collection.class.isAssignableFrom( targetClass ) ){
setProperty( root,JSONArray.toList( array,
jsonConfig );
}else if( JSONArray.class.isAssignableFrom( targetClass ) ){
setProperty( root,
toBean( (JSONObject) value,jsonConfig );
}
}else{
if( targetClass == Object.class ){
targetClass = findTargetClass( key,classMap )
: targetClass;
}
Object newRoot = jsonConfig.getNewBeanInstanceStrategy()
.newInstance( targetClass,null );
setProperty( root,
jsonConfig );
}
}else if( root instanceof Map ){
Class targetClass = findTargetClass( key,
jsonConfig );
}else{
log.warn( "Tried to assign property " + key + ":" + type.getName()
+ " to bean of class " + rootClass.getName() );
}
}
}else{
if( type.isPrimitive() ){
// assume assigned default value
log.warn( "Tried to assign null value to " + key + ":" + type.getName() );
setProperty( root,jsonConfig );
}
}
}catch( JSONException jsone ){
throw jsone;
}catch( Exception e ){
throw new JSONException( "Error while setting property=" + name + " type " + type,e );
}
}

return root;
}

/**
* Creates a JSONObject from a POJO. 
* Supports nested maps,POJOs,and arrays/collections.
*
* @param bean An object with POJO conventions
* @throws JSONException if the bean can not be converted to a proper
* JSONObject.
*/
private static JSONObject _fromBean( Object bean,JsonConfig jsonConfig ) {
if( !addInstance( bean ) ){
try{
return jsonConfig.getCycleDetectionStrategy()
.handleRepeatedReferenceAsObject( bean );
}catch( JSONException jsone ){
removeInstance( bean );
fireErrorEvent( jsone,jsonConfig );
throw jsone;
}catch( RuntimeException e ){
removeInstance( bean );
JSONException jsone = new JSONException( e );
fireErrorEvent( jsone,jsonConfig );
throw jsone;
}
}
fireObjectStartEvent( jsonConfig );

JsonBeanProcessor processor = jsonConfig.findJsonBeanProcessor( bean.getClass() );
if( processor != null ){
JSONObject json = null;
try{
json = processor.processBean( bean,jsonConfig );
if( json == null ){
json = (JSONObject) jsonConfig.findDefaultValueProcessor( bean.getClass() )
.getDefaultValue( bean.getClass() );
if( json == null ){
json = new JSONObject( true );
}
}
removeInstance( bean );
fireObjectEndEvent( jsonConfig );
}catch( JSONException jsone ){
removeInstance( bean );
fireErrorEvent( jsone,jsonConfig );
throw jsone;
}
return json;
}

Class beanClass = bean.getClass();
PropertyNameProcessor propertyNameProcessor = jsonConfig.findJsonPropertyNameProcessor( beanClass );
Collection exclusions = jsonConfig.getMergedExcludes( beanClass );
JSONObject jsonObject = new JSONObject();
try{
PropertyDescriptor[] pds = PropertyUtils.getPropertyDescriptors( bean );
PropertyFilter jsonPropertyFilter = jsonConfig.getJsonPropertyFilter();
for( int i = 0; i < pds.length; i++ ){
boolean bypass = false;
String key = pds[i].getName();
if( exclusions.contains( key ) ){
continue;
}

if( jsonConfig.isIgnoreTransientFields() && isTransientField( key,beanClass ) ){
continue;
}

Class type = pds[i].getPropertyType();
try { pds[i].getReadMethod(); }
catch( Exception e ) {
// bug 2565295
String warning = "Property '" + key + "' of "+ beanClass+" has no read method. SKIPPED";
fireWarnEvent( warning,jsonConfig );
log.info( warning );
continue;
}
if( pds[i].getReadMethod() != null ){
Object value = PropertyUtils.getProperty( bean,key );
if( jsonPropertyFilter != null && jsonPropertyFilter.apply( bean,value ) ){
continue;
}
JsonValueProcessor jsonValueProcessor = jsonConfig.findJsonValueProcessor(
beanClass,key );
if( jsonValueProcessor != null ){
value = jsonValueProcessor.processObjectValue( key,jsonConfig );
bypass = true;
if( !JsonVerifier.isValidJsonValue( value ) ){
throw new JSONException( "Value is not a valid JSON value. " + value );
}
}
if( propertyNameProcessor != null ){
key = propertyNameProcessor.processPropertyName( beanClass,key );
}
setValue( jsonObject,bypass );
}else{
String warning = "Property '" + key + "' of "+ beanClass+" has no read method. SKIPPED";
fireWarnEvent( warning,jsonConfig );
log.info( warning );
}
}
// inspect public fields,this operation may fail under
// a SecurityManager so we will eat all exceptions
try {
if( !jsonConfig.isIgnorePublicFields() ) {
Field[] fields = beanClass.getFields();
for( int i = 0; i < fields.length; i++ ) {
boolean bypass = false;
Field field = fields[i];
String key = field.getName();
if( exclusions.contains( key ) ) {
continue;
}

if( jsonConfig.isIgnoreTransientFields() && isTransientField( field ) ) {
continue;
}

Class type = field.getType();
Object value = field.get( bean );
if( jsonPropertyFilter != null && jsonPropertyFilter.apply( bean,value ) ) {
continue;
}
JsonValueProcessor jsonValueProcessor = jsonConfig.findJsonValueProcessor( beanClass,key );
if( jsonValueProcessor != null ) {
value = jsonValueProcessor.processObjectValue( key,jsonConfig );
bypass = true;
if( !JsonVerifier.isValidJsonValue( value ) ) {
throw new JSONException( "Value is not a valid JSON value. " + value );
}
}
if( propertyNameProcessor != null ) {
key = propertyNameProcessor.processPropertyName( beanClass,bypass );
}
}
}
catch( Exception e ){
log.trace( "Couldn't read public fields.",e );
}
}catch( JSONException jsone ){
removeInstance( bean );
fireErrorEvent( jsone,jsonConfig );
throw jsone;
}catch( Exception e ){
removeInstance( bean );
JSONException jsone = new JSONException( e );
fireErrorEvent( jsone,jsonConfig );
throw jsone;
}

removeInstance( bean );
fireObjectEndEvent( jsonConfig );
return jsonObject;
}

private static JSONObject _fromDynaBean( DynaBean bean,JsonConfig jsonConfig ) {
if( bean == null ){
fireObjectStartEvent( jsonConfig );
fireObjectEndEvent( jsonConfig );
return new JSONObject( true );
}

if( !addInstance( bean ) ){
try{
return jsonConfig.getCycleDetectionStrategy()
.handleRepeatedReferenceAsObject( bean );
}catch( JSONException jsone ){
removeInstance( bean );
fireErrorEvent( jsone,jsonConfig );
throw jsone;
}
}
fireObjectStartEvent( jsonConfig );

JSONObject jsonObject = new JSONObject();
try{
DynaProperty[] props = bean.getDynaClass()
.getDynaProperties();
Collection exclusions = jsonConfig.getMergedExcludes();
PropertyFilter jsonPropertyFilter = jsonConfig.getJsonPropertyFilter();
for( int i = 0; i < props.length; i++ ){
boolean bypass = false;
DynaProperty dynaProperty = props[i];
String key = dynaProperty.getName();
if( exclusions.contains( key ) ){
continue;
}
Class type = dynaProperty.getType();
Object value = bean.get( dynaProperty.getName() );
if( jsonPropertyFilter != null && jsonPropertyFilter.apply( bean,value ) ){
continue;
}
JsonValueProcessor jsonValueProcessor = jsonConfig.findJsonValueProcessor( type,jsonConfig );
bypass = true;
if( !JsonVerifier.isValidJsonValue( value ) ){
throw new JSONException( "Value is not a valid JSON value. " + value );
}
}
setValue( jsonObject,bypass );
}
}catch( JSONException jsone ){
removeInstance( bean );
fireErrorEvent( jsone,jsonConfig );
throw jsone;
}

removeInstance( bean );
fireObjectEndEvent( jsonConfig );
return jsonObject;
}

private static JSONObject _fromJSONObject( JSONObject object,JsonConfig jsonConfig ) {
if( object == null || object.isNullObject() ){
fireObjectStartEvent( jsonConfig );
fireObjectEndEvent( jsonConfig );
return new JSONObject( true );
}

if( !addInstance( object ) ){
try{
return jsonConfig.getCycleDetectionStrategy()
.handleRepeatedReferenceAsObject( object );
}catch( JSONException jsone ){
removeInstance( object );
fireErrorEvent( jsone,jsonConfig );
throw jsone;
}catch( RuntimeException e ){
removeInstance( object );
JSONException jsone = new JSONException( e );
fireErrorEvent( jsone,jsonConfig );
throw jsone;
}
}
fireObjectStartEvent( jsonConfig );

JSONArray sa = object.names(jsonConfig);
Collection exclusions = jsonConfig.getMergedExcludes();
JSONObject jsonObject = new JSONObject();
PropertyFilter jsonPropertyFilter = jsonConfig.getJsonPropertyFilter();
for( Iterator i = sa.iterator(); i.hasNext(); ){
Object k = i.next();
if( k == null ){
throw new JSONException("JSON keys cannot be null.");
}
if( !(k instanceof String) && !jsonConfig.isAllowNonStringKeys()) {
throw new ClassCastException("JSON keys must be strings.");
}
String key = String.valueOf( k );
if( "null".equals( key )){
throw new NullPointerException("JSON keys must not be null nor the 'null' string.");
}
if( exclusions.contains( key ) ){
continue;
}
Object value = object.opt( key );
if( jsonPropertyFilter != null && jsonPropertyFilter.apply( object,value ) ){
continue;
}
if( jsonObject.properties.containsKey( key ) ){
jsonObject.accumulate( key,jsonConfig );
firePropertySetEvent( key,true,jsonConfig );
}else{
jsonObject.setInternal( key,false,jsonConfig );
}
}

removeInstance( object );
fireObjectEndEvent( jsonConfig );
return jsonObject;
}

private static JSONObject _fromJSONString( JSONString string,JsonConfig jsonConfig ) {
return _fromJSONTokener( new JSONTokener( string.toJSONString() ),jsonConfig );
}

private static JSONObject _fromJSONTokener( JSONTokener tokener,JsonConfig jsonConfig ) {

try{
char c;
String key;
Object value;

if( tokener.matches( "null.*" ) ){
fireObjectStartEvent( jsonConfig );
fireObjectEndEvent( jsonConfig );
return new JSONObject( true );
}

if( tokener.nextClean() != '{' ){
throw tokener.SyntaxError( "A JSONObject text must begin with '{'" );
}
fireObjectStartEvent( jsonConfig );

Collection exclusions = jsonConfig.getMergedExcludes();
PropertyFilter jsonPropertyFilter = jsonConfig.getJsonPropertyFilter();
JSONObject jsonObject = new JSONObject();
for( ;; ){
c = tokener.nextClean();
switch( c ){
case 0:
throw tokener.SyntaxError( "A JSONObject text must end with '}'" );
case '}':
fireObjectEndEvent( jsonConfig );
return jsonObject;
default:
tokener.back();
key = tokener.nextValue( jsonConfig )
.toString();
}

/*
* The key is followed by ':'. We will also tolerate '=' or '=>'.
*/

c = tokener.nextClean();
if( c == '=' ){
if( tokener.next() != '>' ){
tokener.back();
}
}else if( c != ':' ){
throw tokener.SyntaxError( "Expected a ':' after a key" );
}

char peek = tokener.peek();
boolean quoted = peek == '"' || peek == '\'';
Object v = tokener.nextValue( jsonConfig );
if( quoted || !JSONUtils.isFunctionHeader( v ) ){
if( exclusions.contains( key ) ){
switch( tokener.nextClean() ){
case ';':
case ',':
if( tokener.nextClean() == '}' ){
fireObjectEndEvent( jsonConfig );
return jsonObject;
}
tokener.back();
break;
case '}':
fireObjectEndEvent( jsonConfig );
return jsonObject;
default:
throw tokener.SyntaxError( "Expected a ',' or '}'" );
}
continue;
}
if( jsonPropertyFilter == null || !jsonPropertyFilter.apply( tokener,v ) ){
if( quoted && v instanceof String && (JSONUtils.mayBeJSON( (String) v ) || JSONUtils.isFunction( v ))){
v = JSONUtils.DOUBLE_QUOTE + v + JSONUtils.DOUBLE_QUOTE;
}
if( jsonObject.properties.containsKey( key ) ){
jsonObject.accumulate( key,v,jsonConfig );
}else{
jsonObject.element( key,jsonConfig );
}
}
}else{
// read params if any
String params = JSONUtils.getFunctionParams( (String) v );
// read function text
int i = 0;
StringBuffer sb = new StringBuffer();
for( ;; ){
char ch = tokener.next();
if( ch == 0 ){
break;
}
if( ch == '{' ){
i++;
}
if( ch == '}' ){
i--;
}
sb.append( ch );
if( i == 0 ){
break;
}
}
if( i != 0 ){
throw tokener.SyntaxError( "Unbalanced '{' or '}' on prop: " + v );
}
// trim '{' at start and '}' at end
String text = sb.toString();
text = text.substring( 1,text.length() - 1 )
.trim();
value = new JSONFunction(
(params != null) ? StringUtils.split( params,"," ) : null,text );
if( jsonPropertyFilter == null || !jsonPropertyFilter.apply( tokener,value ) ){
if( jsonObject.properties.containsKey( key ) ){
jsonObject.accumulate( key,jsonConfig );
}
}
}

/*
* Pairs are separated by ','. We will also tolerate ';'.
*/

switch( tokener.nextClean() ){
case ';':
case ',' or '}'" );
}
}
}catch( JSONException jsone ){
fireErrorEvent( jsone,jsonConfig );
throw jsone;
}
}

private static JSONObject _fromMap( Map map,JsonConfig jsonConfig ) {
if( map == null ){
fireObjectStartEvent( jsonConfig );
fireObjectEndEvent( jsonConfig );
return new JSONObject( true );
}

if( !addInstance( map ) ){
try{
return jsonConfig.getCycleDetectionStrategy()
.handleRepeatedReferenceAsObject( map );
}catch( JSONException jsone ){
removeInstance( map );
fireErrorEvent( jsone,jsonConfig );
throw jsone;
}catch( RuntimeException e ){
removeInstance( map );
JSONException jsone = new JSONException( e );
fireErrorEvent( jsone,jsonConfig );
throw jsone;
}
}
fireObjectStartEvent( jsonConfig );

Collection exclusions = jsonConfig.getMergedExcludes();
JSONObject jsonObject = new JSONObject();
PropertyFilter jsonPropertyFilter = jsonConfig.getJsonPropertyFilter();
try{
for( Iterator entries = map.entrySet()
.iterator(); entries.hasNext(); ){
boolean bypass = false;
Map.Entry entry = (Map.Entry) entries.next();
Object k = entry.getKey();
if( k == null ){
throw new JSONException("JSON keys cannot be null.");
}
if( !(k instanceof String) && !jsonConfig.isAllowNonStringKeys() ) {
throw new ClassCastException("JSON keys must be strings.");
}
String key = String.valueOf( k );
if( "null".equals( key )){
throw new NullPointerException("JSON keys must not be null nor the 'null' string.");
}
if( exclusions.contains( key ) ){
continue;
}
Object value = entry.getValue();
if( jsonPropertyFilter != null && jsonPropertyFilter.apply( map,value ) ){
continue;
}
if( value != null ){
JsonValueProcessor jsonValueProcessor = jsonConfig.findJsonValueProcessor(
value.getClass(),value.getClass(),bypass );
}else{
if( jsonObject.properties.containsKey( key ) ){
jsonObject.accumulate( key,JSONNull.getInstance() );
firePropertySetEvent( key,JSONNull.getInstance(),jsonConfig );
}
}
}
}catch( JSONException jsone ){
removeInstance( map );
fireErrorEvent( jsone,jsonConfig );
throw jsone;
}

removeInstance( map );
fireObjectEndEvent( jsonConfig );
return jsonObject;
}

private static JSONObject _fromString( String str,JsonConfig jsonConfig ) {
if( str == null || "null".equals( str ) ){
fireObjectStartEvent( jsonConfig );
fireObjectEndEvent( jsonConfig );
return new JSONObject( true );
}
return _fromJSONTokener( new JSONTokener( str ),jsonConfig );
}

private static Object convertPropertyValueToArray( String key,Object value,Class targetType,
JsonConfig jsonConfig,Map classMap ) {
Class innerType = JSONUtils.getInnerComponentType( targetType );
Class targetInnerType = findTargetClass( key,classMap );
if( innerType.equals( Object.class ) && targetInnerType != null
&& !targetInnerType.equals( Object.class ) ){
innerType = targetInnerType;
}
JsonConfig jsc = jsonConfig.copy();
jsc.setRootClass( innerType );
jsc.setClassMap( classMap );
Object array = JSONArray.toArray( (JSONArray) value,jsc );
if( innerType.isPrimitive() || JSONUtils.isNumber( innerType )
|| Boolean.class.isAssignableFrom( innerType ) || JSONUtils.isString( innerType ) ){
array = JSONUtils.getMorpherRegistry()
.morph( Array.newInstance( innerType,array );
}else if( !array.getClass()
.equals( targetType ) ){
if( !targetType.equals( Object.class ) ){
Morpher morpher = JSONUtils.getMorpherRegistry()
.getMorpherFor( Array.newInstance( innerType,0 )
.getClass() );
if( IdentityObjectMorpher.getInstance()
.equals( morpher ) ){
ObjectArrayMorpher beanMorpher = new ObjectArrayMorpher( new BeanMorpher( innerType,
JSONUtils.getMorpherRegistry() ) );
JSONUtils.getMorpherRegistry()
.registerMorpher( beanMorpher );
}
array = JSONUtils.getMorpherRegistry()
.morph( Array.newInstance( innerType,array );
}
}
return array;
}

private static List convertPropertyValueToList( String key,JsonConfig jsonConfig,
String name,Map classMap ) {
Class targetClass = findTargetClass( key,classMap ) : targetClass;
JsonConfig jsc = jsonConfig.copy();
jsc.setRootClass( targetClass );
jsc.setClassMap( classMap );
List list = (List) JSONArray.toCollection( (JSONArray) value,jsc );
return list;
}

private static Collection convertPropertyValueToCollection( String key,Map classMap,Class collectionType ) {
Class targetClass = findTargetClass( key,classMap ) : targetClass;
JsonConfig jsc = jsonConfig.copy();
jsc.setRootClass( targetClass );
jsc.setClassMap( classMap );
jsc.setCollectionType( collectionType );
return JSONArray.toCollection( (JSONArray) value,jsc );
}

/**
* Locates a Class associated to a specifi key. 
* The key may be a regexp.
*/
private static Class findTargetClass( String key,Map classMap ) {
// try get first
Class targetClass = (Class) classMap.get( key );
if( targetClass == null ){
// try with regexp
// this will hit performance as it must iterate over all the keys
// and create a RegexpMatcher for each key
for( Iterator i = classMap.entrySet()
.iterator(); i.hasNext(); ){
Map.Entry entry = (Map.Entry) i.next();
if( RegexpUtils.getMatcher( (String) entry.getKey() )
.matches( key ) ){
targetClass = (Class) entry.getValue();
break;
}
}
}

return targetClass;
}

private static boolean isTransientField( String name,Class beanClass ) {
try{
return isTransientField(beanClass.getDeclaredField( name ));
}catch( Exception e ){
// swallow exception
}
return false;
}

private static boolean isTransientField( Field field ) {
return (field.getModifiers() & Modifier.TRANSIENT) == Modifier.TRANSIENT;
}

private static Object morPHPropertyValue( String key,Class type,Class targetType ) {
Morpher morpher = JSONUtils.getMorpherRegistry()
.getMorpherFor( targetType );
if( IdentityObjectMorpher.getInstance()
.equals( morpher ) ){
log.warn( "Can't transform property '" + key + "' from " + type.getName() + " into "
+ targetType.getName() + ". Will register a default BeanMorpher" );
JSONUtils.getMorpherRegistry()
.registerMorpher( new BeanMorpher( targetType,JSONUtils.getMorpherRegistry() ) );
}
value = JSONUtils.getMorpherRegistry()
.morph( targetType,value );
return value;
}

/**
* Sets a property on the target bean. 
* Bean may be a Map or a POJO.
*/
private static void setProperty( Object bean,String key,JsonConfig jsonConfig )
throws Exception {
PropertySetStrategy propertySetStrategy = jsonConfig.getPropertySetStrategy() != null ? jsonConfig.getPropertySetStrategy()
: PropertySetStrategy.DEFAULT;
propertySetStrategy.setProperty( bean,jsonConfig );
}

private static void setValue( JSONObject jsonObject,boolean bypass ) {
boolean accumulated = false;
if( value == null ){
value = jsonConfig.findDefaultValueProcessor( type )
.getDefaultValue( type );
if( !JsonVerifier.isValidJsonValue( value ) ){
throw new JSONException( "Value is not a valid JSON value. " + value );
}
}
if( jsonObject.properties.containsKey( key ) ){
if( String.class.isAssignableFrom( type ) ){
Object o = jsonObject.opt( key );
if( o instanceof JSONArray ){
((JSONArray) o).addString( (String) value );
}else{
jsonObject.properties.put( key,new JSONArray().element( o )
.addString( (String) value ) );
}
}else{
jsonObject.accumulate( key,jsonConfig );
}
accumulated = true;
}else{
if( bypass || String.class.isAssignableFrom( type ) ){
jsonObject.properties.put( key,value );
}else{
jsonObject.setInternal( key,jsonConfig );
}
}

value = jsonObject.opt( key );
if( accumulated ){
JSONArray array = (JSONArray) value;
value = array.get( array.size() - 1 );
}
firePropertySetEvent( key,accumulated,jsonConfig );
}

// ------------------------------------------------------

/** identifies this object as null */
private boolean nullObject;

/**
* The Map where the JSONObject's properties are kept.
*/
private Map properties;

/**
* Construct an empty JSONObject.
*/
public JSONObject() {
this.properties = new ListOrderedMap();
}

/**
* Creates a JSONObject that is null.
*/
public JSONObject( boolean isNull ) {
this();
this.nullObject = isNull;
}

/**
* 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.
*
* @param key A key string.
* @param value An object to be accumulated under the key.
* @return this.
* @throws JSONException If the value is an invalid number or if the key is
* null.
*/
public JSONObject accumulate( String key,boolean value ) {
return _accumulate( key,value ? Boolean.TRUE : Boolean.FALSE,new JsonConfig() );
}

/**
* 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,double value ) {
return _accumulate( key,new Double( value ),int value ) {
return _accumulate( key,new Integer( value ),long value ) {
return _accumulate( key,new Long( value ),Object value ) {
return _accumulate( key,JsonConfig jsonConfig ) {
return _accumulate( key,jsonConfig );
}

public void accumulateAll( Map map ) {
accumulateAll( map,new JsonConfig() );
}

public void accumulateAll( Map map,JsonConfig jsonConfig ) {
if( map instanceof JSONObject ){
for( Iterator entries = map.entrySet()
.iterator(); entries.hasNext(); ){
Map.Entry entry = (Map.Entry) entries.next();
String key = (String) entry.getKey();
Object value = entry.getValue();
accumulate( key,jsonConfig );
}
}else{
for( Iterator entries = map.entrySet()
.iterator(); entries.hasNext(); ){
Map.Entry entry = (Map.Entry) entries.next();
String key = String.valueOf( entry.getKey() );
Object value = entry.getValue();
accumulate( key,jsonConfig );
}
}
}

public void clear() {
properties.clear();
}

public int compareTo( Object obj ) {
if( obj != null && (obj instanceof JSONObject) ){
JSONObject other = (JSONObject) obj;
int size1 = size();
int size2 = other.size();
if( size1 < size2 ){
return -1;
}else if( size1 > size2 ){
return 1;
}else if( this.equals( other ) ){
return 0;
}
}
return -1;
}

public boolean containsKey( Object key ) {
return properties.containsKey( key );
}

public boolean containsValue( Object value ) {
return containsValue( value,new JsonConfig() );
}

public boolean containsValue( Object value,JsonConfig jsonConfig ) {
try{
value = processValue( value,jsonConfig );
}catch( JSONException e ){
return false;
}
return properties.containsValue( value );
}

/**
* Remove a name and its value,if present.
*
* @param key A key string.
* @return this.
*/
public JSONObject discard( String key ) {
verifyIsNull();
this.properties.remove( key );
return this;
}

/**
* Put a key/boolean pair in the JSONObject.
*
* @param key A key string.
* @param value A boolean which is the value.
* @return this.
* @throws JSONException If the key is null.
*/
public JSONObject element( String key,boolean value ) {
verifyIsNull();
return element( key,value ? Boolean.TRUE : Boolean.FALSE );
}

/**
* Put a key/value pair in the JSONObject,where the value will be a
* JSONArray which is produced from a Collection.
*
* @param key A key string.
* @param value A Collection value.
* @return this.
* @throws JSONException
*/
public JSONObject element( String key,Collection value ) {
return element( key,new JsonConfig() );
}

/**
* Put a key/value pair in the JSONObject,Collection value,JsonConfig jsonConfig ) {
verifyIsNull();
if( !(value instanceof JSONArray) ){
value = JSONArray.fromObject( value,jsonConfig );
}
return setInternal( key,jsonConfig );
}

/**
* Put a key/double pair in the JSONObject.
*
* @param key A key string.
* @param value A double which is the value.
* @return this.
* @throws JSONException If the key is null or if the number is invalid.
*/
public JSONObject element( String key,double value ) {
verifyIsNull();
Double d = new Double( value );
JSONUtils.testValidity( d );
return element( key,d );
}

/**
* Put a key/int pair in the JSONObject.
*
* @param key A key string.
* @param value An int which is the value.
* @return this.
* @throws JSONException If the key is null.
*/
public JSONObject element( String key,int value ) {
verifyIsNull();
return element( key,new Integer( value ) );
}

/**
* Put a key/long pair in the JSONObject.
*
* @param key A key string.
* @param value A long which is the value.
* @return this.
* @throws JSONException If the key is null.
*/
public JSONObject element( String key,long value ) {
verifyIsNull();
return element( key,new Long( value ) );
}

/**
* Put a key/value pair in the JSONObject,where the value will be a
* JSONObject which is produced from a Map.
*
* @param key A key string.
* @param value A Map value.
* @return this.
* @throws JSONException
*/
public JSONObject element( String key,Map value ) {
return element( key,Map value,JsonConfig jsonConfig ) {
verifyIsNull();
if( value instanceof JSONObject ){
return setInternal( key,jsonConfig );
}else{
return element( key,JSONObject.fromObject( value,jsonConfig );
}
}

/**
* 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.
*
* @param key A key string.
* @param 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.
* @return this.
* @throws JSONException If the value is non-finite number or if the key is
* null.
*/
public JSONObject element( String key,Object value ) {
return element( key,new JsonConfig() );
}

/**
* Put a key/value pair in the JSONObject. If the value is null,JsonConfig jsonConfig ) {
verifyIsNull();
if( key == null ){
throw new JSONException( "Null key." );
}
if( value != null ){
value = processValue( key,jsonConfig );
_setInternal( key,jsonConfig );
}else{
remove( key );
}
return this;
}

/**
* Put a key/value pair in the JSONObject,but only if the key and the value
* are both non-null.
*
* @param key A key string.
* @param value An object which is the value. It should be of one of these
* types: Boolean,or the JSONNull object.
* @return this.
* @throws JSONException If the value is a non-finite number.
*/
public JSONObject elementOpt( String key,Object value ) {
return elementOpt( key,JsonConfig jsonConfig ) {
verifyIsNull();
if( key != null && value != null ){
element( key,jsonConfig );
}
return this;
}

public Set entrySet() {
return Collections.unmodifiableSet( properties.entrySet() );
}

public boolean equals( Object obj ) {
if( obj == this ){
return true;
}
if( obj == null ){
return false;
}

if( !(obj instanceof JSONObject) ){
return false;
}

JSONObject other = (JSONObject) obj;

if( isNullObject() ){
if( other.isNullObject() ){
return true;
}else{
return false;
}
}else{
if( other.isNullObject() ){
return false;
}
}

if( other.size() != size() ){
return false;
}

for( Iterator keys = properties.keySet()
.iterator(); keys.hasNext(); ){
String key = (String) keys.next();
if( !other.properties.containsKey( key ) ){
return false;
}
Object o1 = properties.get( key );
Object o2 = other.properties.get( key );

if( JSONNull.getInstance()
.equals( o1 ) ){
if( JSONNull.getInstance()
.equals( o2 ) ){
continue;
}else{
return false;
}
}else{
if( JSONNull.getInstance()
.equals( o2 ) ){
return false;
}
}

if( o1 instanceof String && o2 instanceof JSONFunction ){
if( !o1.equals( String.valueOf( o2 ) ) ){
return false;
}
}else if( o1 instanceof JSONFunction && o2 instanceof String ){
if( !o2.equals( String.valueOf( o1 ) ) ){
return false;
}
}else if( o1 instanceof JSONObject && o2 instanceof JSONObject ){
if( !o1.equals( o2 ) ){
return false;
}
}else if( o1 instanceof JSONArray && o2 instanceof JSONArray ){
if( !o1.equals( o2 ) ){
return false;
}
}else if( o1 instanceof JSONFunction && o2 instanceof JSONFunction ){
if( !o1.equals( o2 ) ){
return false;
}
}else{
if( o1 instanceof String ){
if( !o1.equals( String.valueOf( o2 ) ) ){
return false;
}
}else if( o2 instanceof String ){
if( !o2.equals( String.valueOf( o1 ) ) ){
return false;
}
}else{
Morpher m1 = JSONUtils.getMorpherRegistry()
.getMorpherFor( o1.getClass() );
Morpher m2 = JSONUtils.getMorpherRegistry()
.getMorpherFor( o2.getClass() );
if( m1 != null && m1 != IdentityObjectMorpher.getInstance() ){
if( !o1.equals( JSONUtils.getMorpherRegistry()
.morph( o1.getClass(),o2 ) ) ){
return false;
}
}else if( m2 != null && m2 != IdentityObjectMorpher.getInstance() ){
if( !JSONUtils.getMorpherRegistry()
.morph( o1.getClass(),o1 )
.equals( o2 ) ){
return false;
}
}else{
if( !o1.equals( o2 ) ){
return false;
}
}
}
}
}
return true;
}

public Object get( Object key ) {
if( key instanceof String ){
return get( (String) key );
}
return null;
}

/**
* Get the value object associated with a key.
*
* @param key A key string.
* @return The object associated with the key.
* @throws JSONException if this.isNull() returns true.
*/
public Object get( String key ) {
verifyIsNull();
return this.properties.get( key );
}

/**
* Get the boolean value associated with a key.
*
* @param key A key string.
* @return The truth.
* @throws JSONException if the value is not a Boolean or the String "true"
* or "false".
*/
public boolean getBoolean( String key ) {
verifyIsNull();
Object o = get( key );
if( o != null ){
if( o.equals( Boolean.FALSE )
|| (o instanceof String && ((String) o).equalsIgnoreCase( "false" )) ){
return false;
}else if( o.equals( Boolean.TRUE )
|| (o instanceof String && ((String) o).equalsIgnoreCase( "true" )) ){
return true;
}
}
throw new JSONException( "JSONObject[" + JSONUtils.quote( key ) + "] is not a Boolean." );
}

/**
* Get the double value associated with a key.
*
* @param key A key string.
* @return 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.
*/
public double getDouble( String key ) {
verifyIsNull();
Object o = get( key );
if( o != null ){
try{
return o instanceof Number ? ((Number) o).doubleValue()
: Double.parseDouble( (String) o );
}catch( Exception e ){
throw new JSONException( "JSONObject[" + JSONUtils.quote( key ) + "] is not a number." );
}
}
throw new JSONException( "JSONObject[" + JSONUtils.quote( key ) + "] is not a number." );
}

/**
* Get the int value associated with a key. If the number value is too large
* for an int,it will be clipped.
*
* @param key A key string.
* @return The integer value.
* @throws JSONException if the key is not found or if the value cannot be
* converted to an integer.
*/
public int getInt( String key ) {
verifyIsNull();
Object o = get( key );
if( o != null ){
return o instanceof Number ? ((Number) o).intValue() : (int) getDouble( key );
}
throw new JSONException( "JSONObject[" + JSONUtils.quote( key ) + "] is not a number." );
}

/**
* Get the JSONArray value associated with a key.
*
* @param key A key string.
* @return A JSONArray which is the value.
* @throws JSONException if the key is not found or if the value is not a
* JSONArray.
*/
public JSONArray getJSONArray( String key ) {
verifyIsNull();
Object o = get( key );
if( o != null && o instanceof JSONArray ){
return (JSONArray) o;
}
throw new JSONException( "JSONObject[" + JSONUtils.quote( key ) + "] is not a JSONArray." );
}

/**
* Get the JSONObject value associated with a key.
*
* @param key A key string.
* @return A JSONObject which is the value.
* @throws JSONException if the key is not found or if the value is not a
* JSONObject.
*/
public JSONObject getJSONObject( String key ) {
verifyIsNull();
Object o = get( key );
if( JSONNull.getInstance()
.equals( o ) ){
return new JSONObject( true );
}else if( o instanceof JSONObject ){
return (JSONObject) o;
}
throw new JSONException( "JSONObject[" + JSONUtils.quote( key ) + "] is not a JSONObject." );
}

/**
* Get the long value associated with a key. If the number value is too long
* for a long,it will be clipped.
*
* @param key A key string.
* @return The long value.
* @throws JSONException if the key is not found or if the value cannot be
* converted to a long.
*/
public long getLong( String key ) {
verifyIsNull();
Object o = get( key );
if( o != null ){
return o instanceof Number ? ((Number) o).longValue() : (long) getDouble( key );
}
throw new JSONException( "JSONObject[" + JSONUtils.quote( key ) + "] is not a number." );
}

/**
* Get the string associated with a key.
*
* @param key A key string.
* @return A string which is the value.
* @throws JSONException if the key is not found.
*/
public String getString( String key ) {
verifyIsNull();
Object o = get( key );
if( o != null ){
return o.toString();
}
throw new JSONException( "JSONObject[" + JSONUtils.quote( key ) + "] not found." );
}

/**
* Determine if the JSONObject contains a specific key.
*
* @param key A key string.
* @return true if the key exists in the JSONObject.
*/
public boolean has( String key ) {
verifyIsNull();
return this.properties.containsKey( key );
}

public int hashCode() {
int hashcode = 19;
if( isNullObject() ){
return hashcode + JSONNull.getInstance()
.hashCode();
}
for( Iterator entries = properties.entrySet()
.iterator(); entries.hasNext(); ){
Map.Entry entry = (Map.Entry) entries.next();
Object key = entry.getKey();
Object value = entry.getValue();
hashcode += key.hashCode() + JSONUtils.hashCode( value );
}
return hashcode;
}

public boolean isArray() {
return false;
}

public boolean isEmpty() {
// verifyIsNull();
return this.properties.isEmpty();
}

/**
* Returs if this object is a null JSONObject.
*/
public boolean isNullObject() {
return nullObject;
}

/**
* Get an enumeration of the keys of the JSONObject.
*
* @return An iterator of the keys.
*/
public Iterator keys() {
verifyIsNull();
return keySet().iterator();
}

public Set keySet() {
return Collections.unmodifiableSet( properties.keySet() );
}

/**
* Produce a JSONArray containing the names of the elements of this
* JSONObject.
*
* @return A JSONArray containing the key strings,or null if the JSONObject
* is empty.
*/
public JSONArray names() {
return names( new JsonConfig() );
}

/**
* Produce a JSONArray containing the names of the elements of this
* JSONObject.
*
* @return A JSONArray containing the key strings,or null if the JSONObject
* is empty.
*/
public JSONArray names( JsonConfig jsonConfig ) {
verifyIsNull();
JSONArray ja = new JSONArray();
Iterator keys = keys();
while( keys.hasNext() ){
ja.element( keys.next(),jsonConfig );
}
return ja;
}

/**
* Get an optional value associated with a key.
*
* @param key A key string.
* @return An object which is the value,or null if there is no value.
*/
public Object opt( String key ) {
verifyIsNull();
return key == null ? null : this.properties.get( key );
}

/**
* 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".
*
* @param key A key string.
* @return The truth.
*/
public boolean optBoolean( String key ) {
verifyIsNull();
return optBoolean( key,false );
}

/**
* 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).
*
* @param key A key string.
* @param defaultValue The default.
* @return The truth.
*/
public boolean optBoolean( String key,boolean defaultValue ) {
verifyIsNull();
try{
return getBoolean( key );
}catch( Exception e ){
return defaultValue;
}
}

/**
* 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.
*
* @param key A string which is the key.
* @return An object which is the value.
*/
public double optDouble( String key ) {
verifyIsNull();
return optDouble( key,Double.NaN );
}

/**
* 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.
*
* @param key A key string.
* @param defaultValue The default.
* @return An object which is the value.
*/
public double optDouble( String key,double defaultValue ) {
verifyIsNull();
try{
Object o = opt( key );
return o instanceof Number ? ((Number) o).doubleValue()
: new Double( (String) o ).doubleValue();
}catch( Exception e ){
return defaultValue;
}
}

/**
* 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.
*
* @param key A key string.
* @return An object which is the value.
*/
public int optInt( String key ) {
verifyIsNull();
return optInt( key,0 );
}

/**
* 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.
*
* @param key A key string.
* @param defaultValue The default.
* @return An object which is the value.
*/
public int optInt( String key,int defaultValue ) {
verifyIsNull();
try{
return getInt( key );
}catch( Exception e ){
return defaultValue;
}
}

/**
* 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.
*
* @param key A key string.
* @return A JSONArray which is the value.
*/
public JSONArray optJSONArray( String key ) {
verifyIsNull();
Object o = opt( key );
return o instanceof JSONArray ? (JSONArray) o : null;
}

/**
* 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.
*
* @param key A key string.
* @return A JSONObject which is the value.
*/
public JSONObject optJSONObject( String key ) {
verifyIsNull();
Object o = opt( key );
return o instanceof JSONObject ? (JSONObject) o : null;
}

/**
* Get an optional long value associated with a key,an
* attempt will be made to evaluate it as a number.
*
* @param key A key string.
* @return An object which is the value.
*/
public long optLong( String key ) {
verifyIsNull();
return optLong( key,0 );
}

/**
* Get an optional long value associated with a key,
* an attempt will be made to evaluate it as a number.
*
* @param key A key string.
* @param defaultValue The default.
* @return An object which is the value.
*/
public long optLong( String key,long defaultValue ) {
verifyIsNull();
try{
return getLong( key );
}catch( Exception e ){
return defaultValue;
}
}

/**
* 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.
*
* @param key A key string.
* @return A string which is the value.
*/
public String optString( String key ) {
verifyIsNull();
return optString( key,"" );
}

/**
* Get an optional string associated with a key. It returns the defaultValue
* if there is no such key.
*
* @param key A key string.
* @param defaultValue The default.
* @return A string which is the value.
*/
public String optString( String key,String defaultValue ) {
verifyIsNull();
Object o = opt( key );
return o != null ? o.toString() : defaultValue;
}

public Object put( Object key,Object value ) {
if( key == null ){
throw new IllegalArgumentException( "key is null." );
}
Object prevIoUs = properties.get( key );
element( String.valueOf( key ),value );
return prevIoUs;
}

public void putAll( Map map ) {
putAll( map,new JsonConfig() );
}

public void putAll( Map map,JsonConfig jsonConfig ) {
if( map instanceof JSONObject ){
for( Iterator entries = map.entrySet()
.iterator(); entries.hasNext(); ){
Map.Entry entry = (Map.Entry) entries.next();
String key = (String) entry.getKey();
Object value = entry.getValue();
this.properties.put( key,value );
}
}else{
for( Iterator entries = map.entrySet()
.iterator(); entries.hasNext(); ){
Map.Entry entry = (Map.Entry) entries.next();
String key = String.valueOf( entry.getKey() );
Object value = entry.getValue();
element( key,jsonConfig );
}
}
}

public Object remove( Object key ) {
return properties.remove( key );
}

/**
* Remove a name and its value,if present.
*
* @param key The name to be removed.
* @return The value that was associated with the name,or null if there was
* no value.
*/
public Object remove( String key ) {
verifyIsNull();
return this.properties.remove( key );
}

/**
* Get the number of keys stored in the JSONObject.
*
* @return The number of keys in the JSONObject.
*/
public int size() {
// verifyIsNull();
return this.properties.size();
}

/**
* Produce a JSONArray containing the values of the members of this
* JSONObject.
*
* @param names A JSONArray containing a list of key strings. This determines
* the sequence of the values in the result.
* @return A JSONArray of values.
* @throws JSONException If any of the values are non-finite numbers.
*/
public JSONArray toJSONArray( JSONArray names ) {
verifyIsNull();
if( names == null || names.size() == 0 ){
return null;
}
JSONArray ja = new JSONArray();
for( int i = 0; i < names.size(); i += 1 ){
ja.element( this.opt( names.getString( i ) ) );
}
return ja;
}

/**
* 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.
*
* @return a printable,displayable,portable,transmittable representation
* of the object,beginning with <code>{</code> (left
* brace) and ending with <code>}</code> (right
* brace).
*/
public String toString() {
if( isNullObject() ){
return JSONNull.getInstance()
.toString();
}
try{
Iterator keys = keys();
StringBuffer sb = new StringBuffer( "{" );

while( keys.hasNext() ){
if( sb.length() > 1 ){
sb.append( ',' );
}
Object o = keys.next();
sb.append( JSONUtils.quote( o.toString() ) );
sb.append( ':' );
sb.append( JSONUtils.valueToString( this.properties.get( o ) ) );
}
sb.append( '}' );
return sb.toString();
}catch( Exception e ){
return null;
}
}

/**
* Make a prettyprinted JSON text of this JSONObject.
* 
* Warning: This method assumes that the data structure is acyclical.
*
* @param indentFactor The number of spaces to add to each level of
* indentation.
* @return a printable,beginning with <code>{</code> (left
* brace) and ending with <code>}</code> (right
* brace).
* @throws JSONException If the object contains an invalid number.
*/
public String toString( int indentFactor ) {
if( isNullObject() ){
return JSONNull.getInstance()
.toString();
}
if( indentFactor == 0 ){
return this.toString();
}
return toString( indentFactor,0 );
}

/**
* Make a prettyprinted JSON text of this JSONObject.
* 
* Warning: This method assumes that the data structure is acyclical.
*
* @param indentFactor The number of spaces to add to each level of
* indentation.
* @param indent The indentation of the top level.
* @return a printable,transmittable representation of the
* object,beginning with <code>{</code> (left brace)
* and ending with <code>}</code> (right brace).
* @throws JSONException If the object contains an invalid number.
*/
public String toString( int indentFactor,int indent ) {
if( isNullObject() ){
return JSONNull.getInstance()
.toString();
}
int i;
int n = size();
if( n == 0 ){
return "{}";
}
if( indentFactor == 0 ){
return this.toString();
}
Iterator keys = keys();
StringBuffer sb = new StringBuffer( "{" );
int newindent = indent + indentFactor;
Object o;
if( n == 1 ){
o = keys.next();
sb.append( JSONUtils.quote( o.toString() ) );
sb.append( ": " );
sb.append( JSONUtils.valueToString( this.properties.get( o ),indentFactor,indent ) );
}else{
while( keys.hasNext() ){
o = keys.next();
if( sb.length() > 1 ){
sb.append( ",\n" );
}else{
sb.append( '\n' );
}
for( i = 0; i < newindent; i += 1 ){
sb.append( ' ' );
}
sb.append( JSONUtils.quote( o.toString() ) );
sb.append( ": " );
sb.append( JSONUtils.valueToString( this.properties.get( o ),newindent ) );
}
if( sb.length() > 1 ){
sb.append( '\n' );
for( i = 0; i < indent; i += 1 ){
sb.append( ' ' );
}
}
for( i = 0; i < indent; i += 1 ){
sb.insert( 0,' ' );
}
}
sb.append( '}' );
return sb.toString();
}

public Collection values() {
return Collections.unmodifiableCollection( properties.values() );
}

/**
* 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.
*
* @return The writer.
* @throws JSONException
*/
public Writer write( Writer writer ) {
try{
if( isNullObject() ){
writer.write( JSONNull.getInstance()
.toString() );
return writer;
}

boolean b = false;
Iterator keys = keys();
writer.write( '{' );

while( keys.hasNext() ){
if( b ){
writer.write( ',' );
}
Object k = keys.next();
writer.write( JSONUtils.quote( k.toString() ) );
writer.write( ':' );
Object v = this.properties.get( k );
if( v instanceof JSONObject ){
((JSONObject) v).write( writer );
}else if( v instanceof JSONArray ){
((JSONArray) v).write( writer );
}else{
writer.write( JSONUtils.valueToString( v ) );
}
b = true;
}
writer.write( '}' );
return writer;
}catch( IOException e ){
throw new JSONException( e );
}
}

private JSONObject _accumulate( String key,JsonConfig jsonConfig ) {
if( isNullObject() ){
throw new JSONException( "Can't accumulate on null object" );
}

if( !has( key ) ){
setInternal( key,jsonConfig );
}else{
Object o = opt( key );
if( o instanceof JSONArray ){
((JSONArray) o).element( value,jsonConfig );
}else{
setInternal( key,new JSONArray().element( o )
.element( value,jsonConfig );
}
}

return this;
}

protected Object _processValue( Object value,JsonConfig jsonConfig ) {
if( value instanceof JSONTokener ) {
return _fromJSONTokener( (JSONTokener) value,jsonConfig );
}
return super._processValue( value,jsonConfig );
}

/**
* Put a key/value pair in the JSONObject.
*
* @param key A key string.
* @param value An object which is the value. It should be of one of these
* types: Boolean,or the JSONNull object.
* @return this.
* @throws JSONException If the value is non-finite number or if the key is
* null.
*/
private JSONObject _setInternal( String key,JsonConfig jsonConfig ) {
verifyIsNull();
if( key == null ){
throw new JSONException( "Null key." );
}

if( JSONUtils.isString( value ) && JSONUtils.mayBeJSON( String.valueOf( value ) ) ){
this.properties.put( key,value );
}else{
/*
Object jo = _processValue( value,jsonConfig );
if( CycleDetectionStrategy.IGNORE_PROPERTY_OBJ == jo
|| CycleDetectionStrategy.IGNORE_PROPERTY_ARR == jo ){
// do nothing
}else{
this.properties.put( key,jo );
}
*/
if( CycleDetectionStrategy.IGNORE_PROPERTY_OBJ == value
|| CycleDetectionStrategy.IGNORE_PROPERTY_ARR == value ){
// do nothing
}else{
this.properties.put( key,value );
}
}

return this;
}

private Object processValue( Object value,JsonConfig jsonConfig ) {
if( value != null ){
JsonValueProcessor processor = jsonConfig.findJsonValueProcessor( value.getClass() );
if( processor != null ){
value = processor.processObjectValue( null,jsonConfig );
if( !JsonVerifier.isValidJsonValue( value ) ){
throw new JSONException( "Value is not a valid JSON value. " + value );
}
}
}
return _processValue( value,jsonConfig );
}

private Object processValue( String key,JsonConfig jsonConfig ) {
if( value != null ){
JsonValueProcessor processor = jsonConfig.findJsonValueProcessor( value.getClass(),key );
if( processor != null ){
value = processor.processObjectValue( null,or the JSONNull object.
* @return this.
* @throws JSONException If the value is non-finite number or if the key is
* null.
*/
private JSONObject setInternal( String key,JsonConfig jsonConfig ) {
return _setInternal( key,processValue( key,jsonConfig );
}

/** * Checks if this object is a "null" object. */ private void verifyIsNull() { if( isNullObject() ){ throw new JSONException( "null object" ); } } }

原文链接：https://www.f2er.com/json/290724.html

猜你在找的Json相关文章