Java tutorial
/* * 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.annotation.Annotation; import java.lang.reflect.Array; import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Modifier; import java.util.ArrayList; import java.lang.reflect.AnnotatedElement; import java.util.Collection; import java.util.Collections; import java.util.HashMap; import java.util.Iterator; import java.util.LinkedHashMap; import java.util.LinkedHashSet; import java.util.List; import java.util.Map; import java.util.Set; import java.util.TreeMap; 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.JSONObject; import net.sf.json.JsonConfig; 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.EnumMorpher; 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. * <p> * 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. * <p> * 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>. * <p> * 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> <small>(comma)</small> may appear just * before the closing brace.</li> * <li>Strings may be quoted with <code>'</code> <small>(single quote)</small>.</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> <small>(semicolon)</small> * as well as by <code>,</code> <small>(comma)</small>.</li> * <li>Numbers may have the <code>0-</code> <small>(octal)</small> or * <code>0x-</code> <small>(hex)</small> 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<String, Object>, Comparable { private static final Log log = LogFactory.getLog(JSONObject.class); /** * Creates a JSONObject.<br> * 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.<br> * 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, JsonConfig jsonConfig) { if (object == null || JSONUtils.isNull(object)) { return new JSONObject(true); } else if (object instanceof Enum) { throw new JSONException("'object' is an Enum. Use JSONArray instead"); } else if (object instanceof Annotation || (object != null && object.getClass().isAnnotation())) { throw new JSONException("'object' is an Annotation."); } 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.<br> */ 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.<br> * 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.<br> * 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, jsonConfig); } /** * Creates a bean from a 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, key, convertPropertyValueToCollection(key, value, jsonConfig, name, 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, key, null, jsonConfig); } else { setProperty(bean, key, value, jsonConfig); } } else { Class targetClass = resolveClass(classMap, key, name, type); JsonConfig jsc = jsonConfig.copy(); jsc.setRootClass(targetClass); jsc.setClassMap(classMap); if (targetClass != null) { setProperty(bean, key, toBean((JSONObject) value, jsc), jsonConfig); } else { setProperty(bean, key, 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, key, convertPropertyValueToCollection(key, value, jsonConfig, name, classMap, pd.getPropertyType()), jsonConfig); } else if (Set.class.isAssignableFrom(pd.getPropertyType())) { setProperty(bean, key, convertPropertyValueToCollection(key, value, jsonConfig, name, classMap, pd.getPropertyType()), jsonConfig); } else { setProperty(bean, key, convertPropertyValueToArray(key, value, targetType, jsonConfig, 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, key, null, jsonConfig); } else if (!targetType.isInstance(value)) { setProperty(bean, key, morphPropertyValue(key, value, type, targetType), jsonConfig); } else { setProperty(bean, key, value, jsonConfig); } } else if (beanClass == null || bean instanceof Map) { setProperty(bean, key, value, 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 = resolveClass(classMap, key, name, type); JsonConfig jsc = jsonConfig.copy(); jsc.setRootClass(newTargetClass); jsc.setClassMap(classMap); if (targetType.isArray()) { setProperty(bean, key, JSONArray.toArray(array, jsc), jsonConfig); } else if (JSONArray.class.isAssignableFrom(targetType)) { setProperty(bean, key, array, jsonConfig); } else if (List.class.isAssignableFrom(targetType) || Set.class.isAssignableFrom(targetType)) { jsc.setCollectionType(targetType); setProperty(bean, key, JSONArray.toCollection(array, jsc), jsonConfig); } else { setProperty(bean, key, toBean((JSONObject) value, jsc), 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, key, toBean((JSONObject) value, jsc), jsonConfig); } } } else { if (type.isPrimitive()) { // assume assigned default value log.warn("Tried to assign null value to " + key + ":" + type.getName()); setProperty(bean, key, JSONUtils.getMorpherRegistry().morph(type, null), jsonConfig); } else { setProperty(bean, key, null, jsonConfig); } } } else { if (!JSONUtils.isNull(value)) { if (value instanceof JSONArray) { setProperty(bean, key, convertPropertyValueToCollection(key, value, jsonConfig, name, classMap, List.class), 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, key, value, jsonConfig); } else { log.warn("Tried to assign property " + key + ":" + type.getName() + " to bean of class " + bean.getClass().getName()); } } else { if (jsonConfig.isHandleJettisonSingleElementArray()) { Class newTargetClass = resolveClass(classMap, key, name, type); JsonConfig jsc = jsonConfig.copy(); jsc.setRootClass(newTargetClass); jsc.setClassMap(classMap); setProperty(bean, key, toBean((JSONObject) value, jsc), jsonConfig); } else { setProperty(bean, key, value, jsonConfig); } } } else { if (type.isPrimitive()) { // assume assigned default value log.warn("Tried to assign null value to " + key + ":" + type.getName()); setProperty(bean, key, JSONUtils.getMorpherRegistry().morph(type, null), jsonConfig); } else { setProperty(bean, key, null, 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, with the specific configuration. */ public static Object toBean(JSONObject 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; } 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(root, name, value)) { continue; } String key = JSONUtils.convertToJavaIdentifier(name, jsonConfig); try { PropertyDescriptor pd = PropertyUtils.getPropertyDescriptor(root, key); if (pd != null && pd.getWriteMethod() == null) { log.info("Property '" + key + "' of " + root.getClass() + " has no write method. SKIPPED."); continue; } if (!JSONUtils.isNull(value)) { if (value instanceof JSONArray) { if (pd == null || List.class.isAssignableFrom(pd.getPropertyType())) { Class targetClass = resolveClass(classMap, key, name, type); Object newRoot = jsonConfig.getNewBeanInstanceStrategy().newInstance(targetClass, null); List list = JSONArray.toList((JSONArray) value, newRoot, jsonConfig); setProperty(root, key, 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, newRoot, 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, 0).getClass(), array); } } setProperty(root, key, array, 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, key, null, 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, key, JSONUtils.getMorpherRegistry().morph(pd.getPropertyType(), value), jsonConfig); } else { setProperty(root, key, value, jsonConfig); } } else if (root instanceof Map) { setProperty(root, key, value, 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, jsonConfig); Class newTargetClass = resolveClass(classMap, key, name, type); Object newRoot = jsonConfig.getNewBeanInstanceStrategy().newInstance(newTargetClass, (JSONObject) value); if (targetClass.isArray()) { setProperty(root, key, JSONArray.toArray(array, newRoot, jsonConfig), jsonConfig); } else if (Collection.class.isAssignableFrom(targetClass)) { setProperty(root, key, JSONArray.toList(array, newRoot, jsonConfig), jsonConfig); } else if (JSONArray.class.isAssignableFrom(targetClass)) { setProperty(root, key, array, jsonConfig); } else { setProperty(root, key, toBean((JSONObject) value, newRoot, jsonConfig), jsonConfig); } } else { if (targetClass == Object.class) { targetClass = resolveClass(classMap, key, name, type); if (targetClass == null) { targetClass = Object.class; } } Object newRoot = jsonConfig.getNewBeanInstanceStrategy().newInstance(targetClass, (JSONObject) value); setProperty(root, key, toBean((JSONObject) value, newRoot, jsonConfig), jsonConfig); } } else if (root instanceof Map) { Class targetClass = findTargetClass(key, classMap); targetClass = targetClass == null ? findTargetClass(name, classMap) : targetClass; Object newRoot = jsonConfig.getNewBeanInstanceStrategy().newInstance(targetClass, null); setProperty(root, key, toBean((JSONObject) value, newRoot, jsonConfig), 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, key, JSONUtils.getMorpherRegistry().morph(type, null), jsonConfig); } else { setProperty(root, key, null, 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.<br> * 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; } catch (RuntimeException e) { removeInstance(bean); JSONException jsone = new JSONException(e); fireErrorEvent(jsone, jsonConfig); throw jsone; } return json; } JSONObject jsonObject = defaultBeanProcessing(bean, jsonConfig); removeInstance(bean); fireObjectEndEvent(jsonConfig); return jsonObject; } private static JSONObject defaultBeanProcessing(Object bean, JsonConfig jsonConfig) { 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, jsonConfig)) { 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) { /* if( jsonConfig.isIgnoreJPATransient() ){ try{ Class transientClass = Class.forName( "javax.persistence.Transient" ); if( pds[i].getReadMethod() .getAnnotation( transientClass ) != null ){ continue; } }catch( ClassNotFoundException cnfe ){ // ignore } } */ if (isTransient(pds[i].getReadMethod(), jsonConfig)) continue; Object value = PropertyUtils.getProperty(bean, key); if (jsonPropertyFilter != null && jsonPropertyFilter.apply(bean, key, value)) { continue; } JsonValueProcessor jsonValueProcessor = jsonConfig.findJsonValueProcessor(beanClass, type, key); if (jsonValueProcessor != null) { value = jsonValueProcessor.processObjectValue(key, value, 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, key, value, type, jsonConfig, 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() && isTransient(field, jsonConfig)) { continue; } Class type = field.getType(); Object value = field.get(bean); if (jsonPropertyFilter != null && jsonPropertyFilter.apply(bean, key, value)) { continue; } JsonValueProcessor jsonValueProcessor = jsonConfig.findJsonValueProcessor(beanClass, type, key); if (jsonValueProcessor != null) { value = jsonValueProcessor.processObjectValue(key, value, 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, key, value, type, jsonConfig, 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; } 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; } catch (RuntimeException e) { removeInstance(bean); JSONException jsone = new JSONException(e); 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, key, value)) { continue; } JsonValueProcessor jsonValueProcessor = jsonConfig.findJsonValueProcessor(type, key); if (jsonValueProcessor != null) { value = jsonValueProcessor.processObjectValue(key, value, jsonConfig); bypass = true; if (!JsonVerifier.isValidJsonValue(value)) { throw new JSONException("Value is not a valid JSON value. " + value); } } setValue(jsonObject, key, value, type, jsonConfig, bypass); } } 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; } 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, key, value)) { continue; } if (jsonObject.properties.containsKey(key)) { jsonObject.accumulate(key, value, jsonConfig); firePropertySetEvent(key, value, true, jsonConfig); } else { jsonObject.setInternal(key, value, jsonConfig); firePropertySetEvent(key, value, 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, key, 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); firePropertySetEvent(key, v, true, jsonConfig); } else { jsonObject.element(key, v, jsonConfig); firePropertySetEvent(key, v, false, 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, key, value)) { if (jsonObject.properties.containsKey(key)) { jsonObject.accumulate(key, value, jsonConfig); firePropertySetEvent(key, value, true, jsonConfig); } else { jsonObject.element(key, value, jsonConfig); firePropertySetEvent(key, value, false, jsonConfig); } } } /* * Pairs are separated by ','. We will also tolerate ';'. */ 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 '}'"); } } } 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, key, value)) { continue; } if (value != null) { JsonValueProcessor jsonValueProcessor = jsonConfig.findJsonValueProcessor(value.getClass(), key); if (jsonValueProcessor != null) { value = jsonValueProcessor.processObjectValue(key, value, jsonConfig); bypass = true; if (!JsonVerifier.isValidJsonValue(value)) { throw new JSONException("Value is not a valid JSON value. " + value); } } setValue(jsonObject, key, value, value.getClass(), jsonConfig, bypass); } else { if (jsonObject.properties.containsKey(key)) { jsonObject.accumulate(key, JSONNull.getInstance()); firePropertySetEvent(key, JSONNull.getInstance(), true, jsonConfig); } else { jsonObject.element(key, JSONNull.getInstance()); firePropertySetEvent(key, JSONNull.getInstance(), false, jsonConfig); } } } } 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; } 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, 0).getClass(), 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, 0).getClass(), array); } } return array; } private static List convertPropertyValueToList(String key, Object value, JsonConfig jsonConfig, String name, Map classMap) { Class targetClass = findTargetClass(key, classMap); targetClass = targetClass == null ? findTargetClass(name, 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, Object value, JsonConfig jsonConfig, String name, Map classMap, Class collectionType) { Class targetClass = findTargetClass(key, classMap); targetClass = targetClass == null ? findTargetClass(name, classMap) : targetClass; JsonConfig jsc = jsonConfig.copy(); jsc.setRootClass(targetClass); jsc.setClassMap(classMap); jsc.setCollectionType(collectionType); return JSONArray.toCollection((JSONArray) value, jsc); } /* private static Collection convertPropertyValueToCollection( String key, Object value, JsonConfig jsonConfig, String name, Map classMap, Object bean ) { Class targetClass = findTargetClass( key, classMap ); targetClass = targetClass == null ? findTargetClass( name, classMap ) : targetClass; PropertyDescriptor pd; try{ pd = PropertyUtils.getPropertyDescriptor( bean, key ); }catch( IllegalAccessException e ){ throw new JSONException( e ); }catch( InvocationTargetException e ){ throw new JSONException( e ); }catch( NoSuchMethodException e ){ throw new JSONException( e ); } if( null == targetClass ){ Class[] cType = JSONArray.getCollectionType( pd, false ); if( null != cType && cType.length == 1 ){ targetClass = cType[0]; } } JsonConfig jsc = jsonConfig.copy(); jsc.setRootClass( targetClass ); jsc.setClassMap( classMap ); jsc.setCollectionType( pd.getPropertyType() ); jsc.setEnclosedType( targetClass ); Collection collection = JSONArray.toCollection( (JSONArray) value, jsonConfig ); return collection; } */ private static Class resolveClass(Map classMap, String key, String name, Class type) { Class targetClass = findTargetClass(key, classMap); if (targetClass == null) { targetClass = findTargetClass(name, classMap); } if (targetClass == null && type != null) { if (List.class.equals(type)) { targetClass = ArrayList.class; } else if (Map.class.equals(type)) { targetClass = LinkedHashMap.class; } else if (Set.class.equals(type)) { targetClass = LinkedHashSet.class; } else if (!type.isInterface() && !Object.class.equals(type)) { targetClass = type; } } return targetClass; } /** * Locates a Class associated to a specifi key.<br> * 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, JsonConfig jsonConfig) { try { Field field = beanClass.getDeclaredField(name); if ((field.getModifiers() & Modifier.TRANSIENT) == Modifier.TRANSIENT) return true; return isTransient(field, jsonConfig); } catch (Exception e) { log.info("Error while inspecting field " + beanClass + "." + name + " for transient status.", e); } return false; } private static boolean isTransient(AnnotatedElement element, JsonConfig jsonConfig) { for (Iterator annotations = jsonConfig.getIgnoreFieldAnnotations().iterator(); annotations.hasNext();) { try { String annotationClassName = (String) annotations.next(); if (element.getAnnotation((Class) Class.forName(annotationClassName)) != null) return true; } catch (Exception e) { log.info("Error while inspecting " + element + " for transient status.", e); } } return false; } private static Object morphPropertyValue(String key, Object value, 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 Morpher"); if (Enum.class.isAssignableFrom(targetType)) { JSONUtils.getMorpherRegistry().registerMorpher(new EnumMorpher(targetType)); } else { JSONUtils.getMorpherRegistry() .registerMorpher(new BeanMorpher(targetType, JSONUtils.getMorpherRegistry())); } } value = JSONUtils.getMorpherRegistry().morph(targetType, value); return value; } /** * Sets a property on the target bean.<br> * Bean may be a Map or a POJO. */ private static void setProperty(Object bean, String key, Object value, JsonConfig jsonConfig) throws Exception { PropertySetStrategy propertySetStrategy = jsonConfig.getPropertySetStrategy() != null ? jsonConfig.getPropertySetStrategy() : PropertySetStrategy.DEFAULT; propertySetStrategy.setProperty(bean, key, value, jsonConfig); } private static void setValue(JSONObject jsonObject, String key, Object value, Class type, JsonConfig jsonConfig, 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, value, jsonConfig); } accumulated = true; } else { if (bypass || String.class.isAssignableFrom(type)) { jsonObject.properties.put(key, value); } else { jsonObject.setInternal(key, value, jsonConfig); } } value = jsonObject.opt(key); if (accumulated) { JSONArray array = (JSONArray) value; value = array.get(array.size() - 1); } firePropertySetEvent(key, value, 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, 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, double value) { return _accumulate(key, Double.valueOf(value), 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, 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, int value) { return _accumulate(key, Integer.valueOf(value), 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, 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, long value) { return _accumulate(key, Long.valueOf(value), 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, 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, Object value) { return _accumulate(key, value, 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, 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, Object value, JsonConfig jsonConfig) { return _accumulate(key, value, 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, value, 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, value, 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, value, new JsonConfig()); } /** * 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, JsonConfig jsonConfig) { if (!(value instanceof JSONArray)) { value = JSONArray.fromObject(value, jsonConfig); } return setInternal(key, value, 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, value, new JsonConfig()); } /** * 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, JsonConfig jsonConfig) { verifyIsNull(); if (value instanceof JSONObject) { return setInternal(key, value, jsonConfig); } else { return element(key, JSONObject.fromObject(value, jsonConfig), 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.<br> * 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, value, new 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.<br> * 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, JsonConfig jsonConfig) { verifyIsNull(); if (key == null) { throw new JSONException("Null key."); } if (value != null) { value = processValue(key, value, jsonConfig); _setInternal(key, value, 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, Double, Integer, JSONArray, JSONObject, Long, * String, 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, value, new JsonConfig()); } /** * 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, Double, Integer, JSONArray, JSONObject, Long, * String, or the JSONNull object. * @return this. * @throws JSONException If the value is a non-finite number. */ public JSONObject elementOpt(String key, Object value, JsonConfig jsonConfig) { verifyIsNull(); if (key != null && value != null) { element(key, value, 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() { verifyIsNull(); JSONArray ja = new JSONArray(); Iterator keys = keys(); while (keys.hasNext()) { ja.element(keys.next()); } return ja; } /** * 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, 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 long optLong(String key) { verifyIsNull(); return optLong(key, 0); } /** * 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. * * @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(String 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, value, 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. * <p> * Warning: This method assumes that the data structure is acyclical. * * @return a printable, displayable, portable, transmittable representation * of the object, beginning with <code>{</code> <small>(left * brace)</small> and ending with <code>}</code> <small>(right * brace)</small>. */ 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. * <p> * 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, displayable, portable, transmittable representation * of the object, beginning with <code>{</code> <small>(left * brace)</small> and ending with <code>}</code> <small>(right * brace)</small>. * @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. * <p> * 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, displayable, transmittable representation of the * object, beginning with <code>{</code> <small>(left brace)</small> * and ending with <code>}</code> <small>(right brace)</small>. * @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), indentFactor, 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. * <p> * Warning: This method assumes that the data structure is acyclical. * * @return The writer. * @throws JSONException */ protected void write(Writer writer, WritingVisitor visitor) throws IOException { try { if (isNullObject()) { writer.write(JSONNull.getInstance().toString()); } boolean b = false; Iterator keys = visitor.keySet(this).iterator(); 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 JSON) { visitor.on((JSON) v, writer); } else { visitor.on(v, writer); } b = true; } writer.write('}'); } catch (IOException e) { throw new JSONException(e); } } private JSONObject _accumulate(String key, Object value, JsonConfig jsonConfig) { if (isNullObject()) { throw new JSONException("Can't accumulate on null object"); } if (!has(key)) { setInternal(key, value, 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), jsonConfig); } } return this; } protected Object _processValue(Object value, JsonConfig jsonConfig) { if (value instanceof JSONTokener) { return _fromJSONTokener((JSONTokener) value, jsonConfig); } else if (value != null && Enum.class.isAssignableFrom(value.getClass())) { return ((Enum) value).name(); } 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, 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. */ private JSONObject _setInternal(String key, Object value, 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, value, 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, Object value, JsonConfig jsonConfig) { if (value != null) { JsonValueProcessor processor = jsonConfig.findJsonValueProcessor(value.getClass(), key); if (processor != null) { value = processor.processObjectValue(null, value, jsonConfig); if (!JsonVerifier.isValidJsonValue(value)) { throw new JSONException("Value is not a valid JSON value. " + value); } } } return _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, 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. */ private JSONObject setInternal(String key, Object value, JsonConfig jsonConfig) { return _setInternal(key, processValue(key, value, jsonConfig), jsonConfig); } /** * Checks if this object is a "null" object. */ private void verifyIsNull() { if (isNullObject()) { throw new JSONException("null object"); } } }