Open Source Repository

Home /json/json-lib-2.4-jdk13 | Repository Home



net/sf/json/JsonConfig.java
/*
 * 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.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import net.sf.json.processors.DefaultDefaultValueProcessor;
import net.sf.json.processors.DefaultValueProcessor;
import net.sf.json.processors.DefaultValueProcessorMatcher;
import net.sf.json.processors.JsonBeanProcessor;
import net.sf.json.processors.JsonBeanProcessorMatcher;
import net.sf.json.processors.JsonValueProcessor;
import net.sf.json.processors.JsonValueProcessorMatcher;
import net.sf.json.processors.PropertyNameProcessor;
import net.sf.json.processors.PropertyNameProcessorMatcher;
import net.sf.json.util.CycleDetectionStrategy;
import net.sf.json.util.JavaIdentifierTransformer;
import net.sf.json.util.JsonEventListener;
import net.sf.json.util.NewBeanInstanceStrategy;
import net.sf.json.util.PropertyExclusionClassMatcher;
import net.sf.json.util.PropertyFilter;
import net.sf.json.util.PropertySetStrategy;

import org.apache.commons.collections.map.MultiKeyMap;
import org.apache.commons.lang.StringUtils;

/**
 * Utility class that helps configuring the serialization process.
 
 @author Andres Almiray <[email protected]>
 */
public class JsonConfig {
   public static final DefaultValueProcessorMatcher DEFAULT_DEFAULT_VALUE_PROCESSOR_MATCHER = DefaultValueProcessorMatcher.DEFAULT;
   public static final JsonBeanProcessorMatcher DEFAULT_JSON_BEAN_PROCESSOR_MATCHER = JsonBeanProcessorMatcher.DEFAULT;
   public static final JsonValueProcessorMatcher DEFAULT_JSON_VALUE_PROCESSOR_MATCHER = JsonValueProcessorMatcher.DEFAULT;
   public static final NewBeanInstanceStrategy DEFAULT_NEW_BEAN_INSTANCE_STRATEGY = NewBeanInstanceStrategy.DEFAULT;
   public static final PropertyExclusionClassMatcher DEFAULT_PROPERTY_EXCLUSION_CLASS_MATCHER = PropertyExclusionClassMatcher.DEFAULT;
   public static final PropertyNameProcessorMatcher DEFAULT_PROPERTY_NAME_PROCESSOR_MATCHER = PropertyNameProcessorMatcher.DEFAULT;
   public static final int MODE_LIST = 1;
   public static final int MODE_OBJECT_ARRAY = 2;
   public static final int MODE_SET = 2;
   private static final Class DEFAULT_COLLECTION_TYPE = List.class;
   private static final CycleDetectionStrategy DEFAULT_CYCLE_DETECTION_STRATEGY = CycleDetectionStrategy.STRICT;
   private static final String[] DEFAULT_EXCLUDES = new String[] { "class""declaringClass""metaClass" };
   private static final JavaIdentifierTransformer DEFAULT_JAVA_IDENTIFIER_TRANSFORMER = JavaIdentifierTransformer.NOOP;
   private static final DefaultValueProcessor DEFAULT_VALUE_PROCESSOR = new DefaultDefaultValueProcessor();
   private static final String[] EMPTY_EXCLUDES = new String[0];

   /** Array conversion mode */
   private int arrayMode = MODE_LIST;
   private MultiKeyMap beanKeyMap = new MultiKeyMap();
   private Map beanProcessorMap = new HashMap();
   private MultiKeyMap beanTypeMap = new MultiKeyMap();
   /** Map of attribute/class */
   private Map classMap;
   private Class collectionType = DEFAULT_COLLECTION_TYPE;
   private CycleDetectionStrategy cycleDetectionStrategy = DEFAULT_CYCLE_DETECTION_STRATEGY;
   private Map defaultValueMap = new HashMap();
   private DefaultValueProcessorMatcher defaultValueProcessorMatcher = DEFAULT_DEFAULT_VALUE_PROCESSOR_MATCHER;
   private Class enclosedType;
   private List eventListeners = new ArrayList();
   private String[] excludes = EMPTY_EXCLUDES;
   private Map exclusionMap = new HashMap();
   private boolean handleJettisonEmptyElement;
   private boolean handleJettisonSingleElementArray;
   private boolean ignoreDefaultExcludes;
   //private boolean ignoreJPATransient;
   private boolean ignoreTransientFields;
   private boolean ignorePublicFields = true;
   private boolean javascriptCompliant;
   private JavaIdentifierTransformer javaIdentifierTransformer = DEFAULT_JAVA_IDENTIFIER_TRANSFORMER;
   private PropertyFilter javaPropertyFilter;
   private Map javaPropertyNameProcessorMap = new HashMap();
   private PropertyNameProcessorMatcher javaPropertyNameProcessorMatcher = DEFAULT_PROPERTY_NAME_PROCESSOR_MATCHER;
   private JsonBeanProcessorMatcher jsonBeanProcessorMatcher = DEFAULT_JSON_BEAN_PROCESSOR_MATCHER;
   private PropertyFilter jsonPropertyFilter;
   private Map jsonPropertyNameProcessorMap = new HashMap();
   private PropertyNameProcessorMatcher jsonPropertyNameProcessorMatcher = DEFAULT_PROPERTY_NAME_PROCESSOR_MATCHER;
   private JsonValueProcessorMatcher jsonValueProcessorMatcher = DEFAULT_JSON_VALUE_PROCESSOR_MATCHER;
   private Map keyMap = new HashMap();
   private NewBeanInstanceStrategy newBeanInstanceStrategy = DEFAULT_NEW_BEAN_INSTANCE_STRATEGY;
   private PropertyExclusionClassMatcher propertyExclusionClassMatcher = DEFAULT_PROPERTY_EXCLUSION_CLASS_MATCHER;
   private PropertySetStrategy propertySetStrategy;
   /** Root class used when converting to an specific bean */
   private Class rootClass;
   private boolean skipJavaIdentifierTransformationInMapKeys;
   private boolean triggerEvents;
   private Map typeMap = new HashMap();
   private List ignoreFieldAnnotations = new ArrayList();
   private boolean allowNonStringKeys = false;

   public JsonConfig() {
   }

   /**
    * Registers a listener for JSON events.<br>
    * The events will be triggered only when using the static builders and if event triggering is
    * enabled.<br>
    * [Java -&gt; JSON]
    
    @see #enableEventTriggering
    @see #disableEventTriggering
    @see #removeJsonEventListener(JsonEventListener)
    @param listener a listener for events
    */
   public synchronized void addJsonEventListenerJsonEventListener listener ) {
      if!eventListeners.containslistener ) ) {
         eventListeners.addlistener );
      }
   }

   /**
    * Removes all registered PropertyNameProcessors.<br>
    * [JSON -&gt; Java]
    */
   public void clearJavaPropertyNameProcessors() {
      javaPropertyNameProcessorMap.clear();
   }

   /**
    * Removes all registered JsonBeanProcessors.<br>
    * [Java -&gt; JSON]
    */
   public void clearJsonBeanProcessors() {
      beanProcessorMap.clear();
   }

   /**
    * Removes all registered listener for JSON Events.<br>
    * [Java -&gt; JSON]
    */
   public synchronized void clearJsonEventListeners() {
      eventListeners.clear();
   }

   /**
    * Removes all registered PropertyNameProcessors.<br>
    * [Java -&gt; JSON]
    */
   public void clearJsonPropertyNameProcessors() {
      jsonPropertyNameProcessorMap.clear();
   }   
   
   /**
    * Removes all registered JsonValueProcessors.<br>
    * [Java -&gt; JSON]
    */
   public void clearJsonValueProcessors() {
      beanKeyMap.clear();
      beanTypeMap.clear();
      keyMap.clear();
      typeMap.clear();
   }
   
   /**
    * Removes all property exclusions registered per class.<br>
    * [Java -&gt; JSON]
    */
   public void clearPropertyExclusions() {
      exclusionMap.clear();
   }

   /**
    * Removes all registered PropertyNameProcessors.<br>
    * [JSON -&gt; Java]
    
    @deprecated use clearJavaPropertyNameProcessors() instead
    */
   public void clearPropertyNameProcessors() {
      clearJavaPropertyNameProcessors();
   }

   public JsonConfig copy() {
      JsonConfig jsc = new JsonConfig();
      jsc.beanKeyMap.putAllbeanKeyMap );
      jsc.beanTypeMap.putAllbeanTypeMap );
      jsc.classMap = new HashMap();
      ifclassMap != null ) {
         jsc.classMap.putAllclassMap );
      }
      jsc.cycleDetectionStrategy = cycleDetectionStrategy;
      ifeventListeners != null ) {
         jsc.eventListeners.addAlleventListeners );
      }
      ifexcludes != null ) {
         jsc.excludes = new String[excludes.length];
         System.arraycopyexcludes, 0, jsc.excludes, 0, excludes.length );
      }
      jsc.handleJettisonEmptyElement = handleJettisonEmptyElement;
      jsc.handleJettisonSingleElementArray = handleJettisonSingleElementArray;
      jsc.ignoreDefaultExcludes = ignoreDefaultExcludes;
      jsc.ignoreTransientFields = ignoreTransientFields;
      jsc.ignorePublicFields = ignorePublicFields;
      jsc.javaIdentifierTransformer = javaIdentifierTransformer;
      jsc.javascriptCompliant = javascriptCompliant;
      jsc.keyMap.putAllkeyMap );
      jsc.beanProcessorMap.putAllbeanProcessorMap );
      jsc.rootClass = rootClass;
      jsc.skipJavaIdentifierTransformationInMapKeys = skipJavaIdentifierTransformationInMapKeys;
      jsc.triggerEvents = triggerEvents;
      jsc.typeMap.putAlltypeMap );
      jsc.jsonPropertyFilter = jsonPropertyFilter;
      jsc.javaPropertyFilter = javaPropertyFilter;
      jsc.jsonBeanProcessorMatcher = jsonBeanProcessorMatcher;
      jsc.newBeanInstanceStrategy = newBeanInstanceStrategy;
      jsc.defaultValueProcessorMatcher = defaultValueProcessorMatcher;
      jsc.defaultValueMap.putAlldefaultValueMap );
      jsc.propertySetStrategy = propertySetStrategy;
      //jsc.ignoreJPATransient = ignoreJPATransient;
      jsc.collectionType = collectionType;
      jsc.enclosedType = enclosedType;
      jsc.jsonValueProcessorMatcher = jsonValueProcessorMatcher;
      jsc.javaPropertyNameProcessorMatcher = javaPropertyNameProcessorMatcher;
      jsc.javaPropertyNameProcessorMap.putAlljavaPropertyNameProcessorMap );
      jsc.jsonPropertyNameProcessorMatcher = jsonPropertyNameProcessorMatcher;
      jsc.jsonPropertyNameProcessorMap.putAlljsonPropertyNameProcessorMap );
      jsc.propertyExclusionClassMatcher = propertyExclusionClassMatcher;
      jsc.exclusionMap.putAll(  exclusionMap );
      jsc.ignoreFieldAnnotations.addAllignoreFieldAnnotations );
      jsc.allowNonStringKeys = allowNonStringKeys;
      return jsc;
   }

   /**
    * Disables event triggering when building.<br>
    * [Java -&gt; JSON]
    */
   public void disableEventTriggering() {
      triggerEvents = false;
   }

   /**
    * Enables event triggering when building.<br>
    * [Java -&gt; JSON]
    */
   public void enableEventTriggering() {
      triggerEvents = true;
   }

   /**
    * Finds a DefaultValueProcessor registered to the target class.<br>
    * Returns null if none is registered.<br>
    * [Java -&gt; JSON]
    
    @param target a class used for searching a DefaultValueProcessor.
    */
   public DefaultValueProcessor findDefaultValueProcessorClass target ) {
      if!defaultValueMap.isEmpty() ) {
         Object key = defaultValueProcessorMatcher.getMatchtarget, defaultValueMap.keySet() );
         DefaultValueProcessor processor = (DefaultValueProcessordefaultValueMap.getkey );
         ifprocessor != null ) {
            return processor;
         }
      }
      return DEFAULT_VALUE_PROCESSOR;
   }

   /**
    * Finds a PropertyNameProcessor registered to the target class.<br>
    * Returns null if none is registered.<br>
    * [JSON -&gt; Java]
    
    @param propertyType a class used for searching a PropertyNameProcessor.
    */
   public PropertyNameProcessor findJavaPropertyNameProcessorClass beanClass ) {
      if!javaPropertyNameProcessorMap.isEmpty() ) {
         Object key = javaPropertyNameProcessorMatcher.getMatchbeanClass, javaPropertyNameProcessorMap.keySet() );
         return (PropertyNameProcessorjavaPropertyNameProcessorMap.getkey );

      }
      return null;
   }

   /**
    * Finds a JsonBeanProcessor registered to the target class.<br>
    * Returns null if none is registered.<br>
    * [Java -&gt; JSON]
    
    @param target a class used for searching a JsonBeanProcessor.
    */
   public JsonBeanProcessor findJsonBeanProcessorClass target ) {
      if!beanProcessorMap.isEmpty() ) {
         Object key = jsonBeanProcessorMatcher.getMatchtarget, beanProcessorMap.keySet() );
         return (JsonBeanProcessorbeanProcessorMap.getkey );
      }
      return null;
   }

   /**
    * Finds a PropertyNameProcessor registered to the target class.<br>
    * Returns null if none is registered.<br>
    * [Java -&gt; JSON]
    
    @param propertyType a class used for searching a PropertyNameProcessor.
    */
   public PropertyNameProcessor findJsonPropertyNameProcessorClass beanClass ) {
      if!jsonPropertyNameProcessorMap.isEmpty() ) {
         Object key = jsonPropertyNameProcessorMatcher.getMatchbeanClass, jsonPropertyNameProcessorMap.keySet() );
         return (PropertyNameProcessorjsonPropertyNameProcessorMap.getkey );

      }
      return null;
   }

   /**
    * Finds a JsonValueProcessor registered to the target type.<br>
    * Returns null if none is registered.<br>
    * [Java -&gt; JSON]
    
    @param propertyType a class used for searching a JsonValueProcessor.
    */
   public JsonValueProcessor findJsonValueProcessorClass propertyType ) {
      if!typeMap.isEmpty() ) {
         Object key = jsonValueProcessorMatcher.getMatchpropertyType, typeMap.keySet() );
         return (JsonValueProcessortypeMap.getkey );

      }
      return null;
   }

   /**
    * Finds a JsonValueProcessor.<br>
    * It will search the registered JsonValueProcessors in the following order:
    <ol>
    <li>beanClass, key</li>
    <li>beanClass, type</li>
    <li>key</li>
    <li>type</li>
    </ol>
    * Returns null if none is registered.<br>
    * [Java -&gt; JSON]
    
    @param beanClass the class to which the property may belong
    @param propertyType the type of the property
    @param key the name of the property which may belong to the target class
    */
   public JsonValueProcessor findJsonValueProcessorClass beanClass, Class propertyType, String key ) {
      JsonValueProcessor jsonValueProcessor = null;
      jsonValueProcessor = (JsonValueProcessorbeanKeyMap.getbeanClass, key );
      ifjsonValueProcessor != null ) {
         return jsonValueProcessor;
      }

      jsonValueProcessor = (JsonValueProcessorbeanTypeMap.getbeanClass, propertyType );
      ifjsonValueProcessor != null ) {
         return jsonValueProcessor;
      }

      jsonValueProcessor = (JsonValueProcessorkeyMap.getkey );
      ifjsonValueProcessor != null ) {
         return jsonValueProcessor;
      }

      Object tkey = jsonValueProcessorMatcher.getMatchpropertyType, typeMap.keySet() );
      jsonValueProcessor = (JsonValueProcessortypeMap.gettkey );
      ifjsonValueProcessor != null ) {
         return jsonValueProcessor;
      }

      return null;
   }

   /**
    * Finds a JsonValueProcessor.<br>
    * It will search the registered JsonValueProcessors in the following order:
    <ol>
    <li>key</li>
    <li>type</li>
    </ol>
    * Returns null if none is registered.<br>
    * [Java -&gt; JSON]
    
    @param propertyType the type of the property
    @param key the name of the property which may belong to the target class
    */
   public JsonValueProcessor findJsonValueProcessorClass propertyType, String key ) {
      JsonValueProcessor jsonValueProcessor = null;
      jsonValueProcessor = (JsonValueProcessorkeyMap.getkey );
      ifjsonValueProcessor != null ) {
         return jsonValueProcessor;
      }

      Object tkey = jsonValueProcessorMatcher.getMatchpropertyType, typeMap.keySet() );
      jsonValueProcessor = (JsonValueProcessortypeMap.gettkey );
      ifjsonValueProcessor != null ) {
         return jsonValueProcessor;
      }

      return null;
   }
   
   /**
    * Finds a PropertyNameProcessor registered to the target class.<br>
    * Returns null if none is registered. <br>
    * [JSON -&gt; Java]
    
    @param propertyType a class used for searching a PropertyNameProcessor.
    
    @deprecated use findJavaPropertyNameProcessor() instead
    */
   public PropertyNameProcessor findPropertyNameProcessorClass beanClass ) {
      return findJavaPropertyNameProcessorbeanClass );
   }   
   
   /**
    * Returns the current array mode conversion.<br>
    * [JSON -&gt; Java]
    
    @return MODE_OBJECT_ARRAY, MODE_LIST or MODE_SET
    */
   public int getArrayMode() {
      return arrayMode;
   }

   /**
    * Returns the current attribute/class Map.<br>
    * [JSON -&gt; Java]
    
    @return a Map of classes, every key identifies a property or a regexp
    */
   public Map getClassMap() {
      return classMap;
   }

   /**
    * Returns the current collection type used for collection transformations.<br>
    * [JSON -&gt; Java]
    
    @return the target collection class for conversion
    */
   public Class getCollectionType() {
      return collectionType;
   }

   /**
    * Returns the configured CycleDetectionStrategy.<br>
    * Default value is CycleDetectionStrategy.STRICT<br>
    * [Java -&gt; JSON]
    */
   public CycleDetectionStrategy getCycleDetectionStrategy() {
      return cycleDetectionStrategy;
   }

   /**
    * Returns the configured DefaultValueProcessorMatcher.<br>
    * Default value is DefaultValueProcessorMatcher.DEFAULT<br>
    * [Java -&gt; JSON]
    */
   public DefaultValueProcessorMatcher getDefaultValueProcessorMatcher() {
      return defaultValueProcessorMatcher;
   }

   /**
    * Returns the current enclosed type for generic collection transformations.<br>
    * [JSON -&gt; Java]
    
    @return the target type for conversion
    */
   public Class getEnclosedType() {
      return enclosedType;
   }

   /**
    * Returns the configured properties for exclusion. <br>
    * [Java -&gt; JSON]
    */
   public String[] getExcludes() {
      return excludes;
   }

   /**
    * Returns the configured JavaIdentifierTransformer. <br>
    * Default value is JavaIdentifierTransformer.NOOP<br>
    * [JSON -&gt; Java]
    */
   public JavaIdentifierTransformer getJavaIdentifierTransformer() {
      return javaIdentifierTransformer;
   }

   /**
    * Returns the configured property filter when serializing to Java.<br>
    * [JSON -&gt; Java]
    */
   public PropertyFilter getJavaPropertyFilter() {
      return javaPropertyFilter;
   }

   /**
    * Returns the configured PropertyNameProcessorMatcher.<br>
    * Default value is PropertyNameProcessorMatcher.DEFAULT<br>
    * [JSON -&gt; Java]
    */
   public PropertyNameProcessorMatcher getJavaPropertyNameProcessorMatcher() {
      return javaPropertyNameProcessorMatcher;
   }
   
   /**
    * Returns the configured JsonBeanProcessorMatcher.<br>
    * Default value is JsonBeanProcessorMatcher.DEFAULT<br>
    * [JSON -&gt; Java]
    */
   public JsonBeanProcessorMatcher getJsonBeanProcessorMatcher() {
      return jsonBeanProcessorMatcher;
   }

   /**
    * Returns a list of registered listeners for JSON events.<br>
    * [JSON -&gt; Java]
    */
   public synchronized List getJsonEventListeners() {
      return eventListeners;
   }

   /**
    * Returns the configured property filter when serializing to JSON.<br>
    * [Java -&gt; JSON]
    */
   public PropertyFilter getJsonPropertyFilter() {
      return jsonPropertyFilter;
   }

   /**
    * Returns the configured PropertyNameProcessorMatcher.<br>
    * Default value is PropertyNameProcessorMatcher.DEFAULT<br>
    * [Java -&gt; JSON]
    */
   public PropertyNameProcessorMatcher getJsonPropertyNameProcessorMatcher() {
      return javaPropertyNameProcessorMatcher;
   }

   /**
    * Returns the configured JsonValueProcessorMatcher.<br>
    * Default value is JsonValueProcessorMatcher.DEFAULT<br>
    * [Java -&gt; JSON]
    */
   public JsonValueProcessorMatcher getJsonValueProcessorMatcher() {
      return jsonValueProcessorMatcher;
   }

   /**
    * Returns a set of default excludes with user-defined excludes.<br>
    * [Java -&gt; JSON]
    */
   public Collection getMergedExcludes() {
      Collection exclusions = new HashSet();
      forint i = 0; i < excludes.length; i++ ) {
         String exclusion = excludes[i];
         if!StringUtils.isBlankexcludes[i] ) ) {
            exclusions.addexclusion.trim() );
         }
      }

      if!ignoreDefaultExcludes ) {
         forint i = 0; i < DEFAULT_EXCLUDES.length; i++ ) {
            if!exclusions.containsDEFAULT_EXCLUDES[i] ) ) {
               exclusions.addDEFAULT_EXCLUDES[i] );
            }
         }
      }

      return exclusions;
   }
   
   /**
    * Returns a set of default excludes with user-defined excludes.<br>
    * Takes into account any additional excludes per matching class.
    * [Java -&gt; JSON]
    */
   public Collection getMergedExcludesClass target ) {
      iftarget == null ) {
         return getMergedExcludes();
      }

      Collection exclusionSet = getMergedExcludes();
      if!exclusionMap.isEmpty() ) {
         Object key = propertyExclusionClassMatcher.getMatchtarget, exclusionMap.keySet() );
         Set set = (SetexclusionMap.getkey );
         ifset != null && !set.isEmpty() ) {
            forIterator i = set.iterator(); i.hasNext()) {
               Object e = i.next();
               if!exclusionSet.contains) ) {
                  exclusionSet.add);
               }
            }
         }
      }

      return exclusionSet;
   }

   /**
    * Returns the configured NewBeanInstanceStrategy.<br>
    * Default value is NewBeanInstanceStrategy.DEFAULT<br>
    * [JSON -&gt; Java]
    */
   public NewBeanInstanceStrategy getNewBeanInstanceStrategy() {
      return newBeanInstanceStrategy;
   }
   
   /**
    * Returns the configured PropertyExclusionClassMatcher.<br>
    * Default value is PropertyExclusionClassMatcher.DEFAULT<br>
    * [JSON -&gt; Java]
    */
   public PropertyExclusionClassMatcher getPropertyExclusionClassMatcher() {
      return propertyExclusionClassMatcher;
   }
   
   /**
    * Returns the configured PropertyNameProcessorMatcher.<br>
    * Default value is PropertyNameProcessorMatcher.DEFAULT<br>
    * [JSON -&gt; Java]
    
    @deprecated use getJavaPropertyNameProcessorMatcher() instead
    */
   public PropertyNameProcessorMatcher getPropertyNameProcessorMatcher() {
      return getJavaPropertyNameProcessorMatcher();
   }

   /**
    * Returns the configured PropertySetStrategy.<br>
    * Default value is PropertySetStrategy.DEFAULT<br>
    * [JSON -&gt; Java]
    */
   public PropertySetStrategy getPropertySetStrategy() {
      return propertySetStrategy;
   }

   /**
    * Returns the current root Class.<br>
    * [JSON -&gt; Java]
    
    @return the target class for conversion
    */
   public Class getRootClass() {
      return rootClass;
   }

   /**
    * Returns true if non-String keys are allowed on JSONObject.<br>
    * Default value is false<br>
    * [Java -&gt; JSON]
    */
   public boolean isAllowNonStringKeys() {
      return allowNonStringKeys;
   }
   
   /**
    * Returns true if event triggering is enabled during building.<br>
    * Default value is false<br>
    * [Java -&gt; JSON]
    */
   public boolean isEventTriggeringEnabled() {
      return triggerEvents;
   }

   /**
    * Returns true if this Jettison convention will be handled when converting to Java.<br>
    * Jettison assumes that "" (empty string) can be assigned to empty elements (objects), which
    * clearly violates the JSON spec.<br>
    * [JSON -&gt; Java]
    */
   public boolean isHandleJettisonEmptyElement() {
      return handleJettisonEmptyElement;
   }

   /**
    * Returns true if this jettison convention will be handled when converting to Java.<br>
    * Jettison states the following JSON {'media':{'title':'hello'}} can be set as a single element
    * JSONArray (media is the array).<br>
    * [JSON -&gt; Java]
    */
   public boolean isHandleJettisonSingleElementArray() {
      return handleJettisonSingleElementArray;
   }

   /**
    * Returns true if default excludes will not be used.<br>
    * Default value is false.<br>
    * [Java -&gt; JSON]
    */
   public boolean isIgnoreDefaultExcludes() {
      return ignoreDefaultExcludes;
   }

   /**
    * Returns true if JPA Transient annotated methods should be ignored.<br>
    * Default value is false.<br>
    * [Java -&gt; JSON]
    */
   public boolean isIgnoreJPATransient() {
      return ignoreFieldAnnotations.contains("javax.persistence.Transient");
   }

   /**
    * Returns true if transient fields of a bean will be ignored.<br>
    * Default value is false.<br>
    * [Java -&gt; JSON]
    */
   public boolean isIgnoreTransientFields() {
      return ignoreTransientFields;
   }
   
   /**
    * Returns true if public fields of a bean will be ignored.<br>
    * Default value is true.<br>
    * [Java -&gt; JSON]
    */
   public boolean isIgnorePublicFields() {
      return ignorePublicFields;
   }
   
   /**
    * Returns true if Javascript compatibility is turned on.<br>
    * Default value is false.<br>
    * [Java -&gt; JSON]
    */
   public boolean isJavascriptCompliant() {
      return javascriptCompliant;
   }

   /**
    * Returns true if map keys will not be transformed.<br>
    * Default value is false.<br>
    * [JSON -&gt; Java]
    */
   public boolean isSkipJavaIdentifierTransformationInMapKeys() {
      return skipJavaIdentifierTransformationInMapKeys;
   }

   /**
    * Registers a DefaultValueProcessor.<br>
    * [Java -&gt; JSON]
    
    @param target the class to use as key
    @param defaultValueProcessor the processor to register
    */
   public void registerDefaultValueProcessorClass target, DefaultValueProcessor defaultValueProcessor ) {
      iftarget != null && defaultValueProcessor != null ) {
         defaultValueMap.puttarget, defaultValueProcessor );
      }
   }

   /**
    * Registers a PropertyNameProcessor.<br>
    * [JSON -&gt; Java]
    
    @param target the class to use as key
    @param propertyNameProcessor the processor to register
    */
   public void registerJavaPropertyNameProcessorClass target, PropertyNameProcessor propertyNameProcessor ) {
      iftarget != null && propertyNameProcessor != null ) {
         javaPropertyNameProcessorMap.puttarget, propertyNameProcessor );
      }
   }
   
   /**
    * Registers a JsonBeanProcessor.<br>
    * [Java -&gt; JSON]
    
    @param target the class to use as key
    @param jsonBeanProcessor the processor to register
    */
   public void registerJsonBeanProcessorClass target, JsonBeanProcessor jsonBeanProcessor ) {
      iftarget != null && jsonBeanProcessor != null ) {
         beanProcessorMap.puttarget, jsonBeanProcessor );
      }
   }

   /**
    * Registers a PropertyNameProcessor.<br>
    * [Java -&gt; JSON]
    
    @param target the class to use as key
    @param propertyNameProcessor the processor to register
    */
   public void registerJsonPropertyNameProcessorClass target, PropertyNameProcessor propertyNameProcessor ) {
      iftarget != null && propertyNameProcessor != null ) {
         jsonPropertyNameProcessorMap.puttarget, propertyNameProcessor );
      }
   }

   /**
    * Registers a JsonValueProcessor.<br>
    * [Java -&gt; JSON]
    
    @param beanClass the class to use as key
    @param propertyType the property type to use as key
    @param jsonValueProcessor the processor to register
    */
   public void registerJsonValueProcessorClass beanClass, Class propertyType, JsonValueProcessor jsonValueProcessor ) {
      ifbeanClass != null && propertyType != null && jsonValueProcessor != null ) {
         beanTypeMap.putbeanClass, propertyType, jsonValueProcessor );
      }
   }

   /**
    * Registers a JsonValueProcessor.<br>
    * [Java -&gt; JSON]
    
    @param propertyType the property type to use as key
    @param jsonValueProcessor the processor to register
    */
   public void registerJsonValueProcessorClass propertyType, JsonValueProcessor jsonValueProcessor ) {
      ifpropertyType != null && jsonValueProcessor != null ) {
         typeMap.putpropertyType, jsonValueProcessor );
      }
   }

   /**
    * Registers a JsonValueProcessor.<br>
    * [Java -&gt; JSON]
    
    @param beanClass the class to use as key
    @param key the property name to use as key
    @param jsonValueProcessor the processor to register
    */
   public void registerJsonValueProcessorClass beanClass, String key, JsonValueProcessor jsonValueProcessor ) {
      ifbeanClass != null && key != null && jsonValueProcessor != null ) {
         beanKeyMap.putbeanClass, key, jsonValueProcessor );
      }
   }

   /**
    * Registers a JsonValueProcessor.<br>
    * [Java -&gt; JSON]
    
    @param key the property name to use as key
    @param jsonValueProcessor the processor to register
    */
   public void registerJsonValueProcessorString key, JsonValueProcessor jsonValueProcessor ) {
      ifkey != null && jsonValueProcessor != null ) {
         keyMap.putkey, jsonValueProcessor );
      }
   }
   
   /**
    * Registers a exclusion for a target class.<br>
    * [Java -&gt; JSON]
    
    @param target the class to use as key
    @param propertyName the property to be excluded
    */
   public void registerPropertyExclusionClass target, String propertyName ) {
      iftarget != null && propertyName != null ) {
         Set set = (SetexclusionMap.gettarget );
         ifset == null ){
            set = new HashSet();
            exclusionMap.put(  target, set );
         }
         if!set.containspropertyName )){
            set.add(propertyName );
         }
      }
   }
   
   /**
    * Registers exclusions for a target class.<br>
    * [Java -&gt; JSON]
    
    @param target the class to use as key
    @param properties the properties to be excluded
    */
   public void registerPropertyExclusionsClass target, String[] properties ) {
      iftarget != null && properties != null && properties.length > ) {
         Set set = (SetexclusionMap.gettarget );
         ifset == null ) {
            set = new HashSet();
            exclusionMap.puttarget, set );
         }
         forint i = 0; i < properties.length; i++ ) {
            if!set.containsproperties[i] ) ) {
               set.addproperties[i] );
            }
         }
      }
   }
   
   /**
    * Registers a PropertyNameProcessor.<br>
    * [JSON -&gt; Java]
    
    @param target the class to use as key
    @param propertyNameProcessor the processor to register
    
    @deprecated use registerJavaPropertyNameProcessor() instead
    */
   public void registerPropertyNameProcessorClass target, PropertyNameProcessor propertyNameProcessor ) {
      registerJavaPropertyNameProcessortarget, propertyNameProcessor );
   }

   /**
    * Removes a listener for JSON events.<br>
    * [Java -&gt; JSON]
    
    @see #addJsonEventListener(JsonEventListener)
    @param listener a listener for events
    */
   public synchronized void removeJsonEventListenerJsonEventListener listener ) {
      eventListeners.removelistener );
   }

   /**
    * Resets all values to its default state.
    */
   public void reset() {
      excludes = EMPTY_EXCLUDES;
      ignoreDefaultExcludes = false;
      ignoreTransientFields = false;
      ignorePublicFields = true;
      javascriptCompliant = false;
      javaIdentifierTransformer = DEFAULT_JAVA_IDENTIFIER_TRANSFORMER;
      cycleDetectionStrategy = DEFAULT_CYCLE_DETECTION_STRATEGY;
      skipJavaIdentifierTransformationInMapKeys = false;
      triggerEvents = false;
      handleJettisonEmptyElement = false;
      handleJettisonSingleElementArray = false;
      arrayMode = MODE_LIST;
      rootClass = null;
      classMap = null;
      keyMap.clear();
      typeMap.clear();
      beanKeyMap.clear();
      beanTypeMap.clear();
      jsonPropertyFilter = null;
      javaPropertyFilter = null;
      jsonBeanProcessorMatcher = DEFAULT_JSON_BEAN_PROCESSOR_MATCHER;
      newBeanInstanceStrategy = DEFAULT_NEW_BEAN_INSTANCE_STRATEGY;
      defaultValueProcessorMatcher = DEFAULT_DEFAULT_VALUE_PROCESSOR_MATCHER;
      defaultValueMap.clear();
      propertySetStrategy = null/* DEFAULT_PROPERTY_SET_STRATEGY */;
      //ignoreJPATransient = false;
      collectionType = DEFAULT_COLLECTION_TYPE;
      enclosedType = null;
      jsonValueProcessorMatcher = DEFAULT_JSON_VALUE_PROCESSOR_MATCHER;
      javaPropertyNameProcessorMap.clear();
      javaPropertyNameProcessorMatcher = DEFAULT_PROPERTY_NAME_PROCESSOR_MATCHER;
      jsonPropertyNameProcessorMap.clear();
      jsonPropertyNameProcessorMatcher = DEFAULT_PROPERTY_NAME_PROCESSOR_MATCHER;
      beanProcessorMap.clear();
      propertyExclusionClassMatcher = DEFAULT_PROPERTY_EXCLUSION_CLASS_MATCHER;
      exclusionMap.clear();
      ignoreFieldAnnotations.clear();
      allowNonStringKeys = false;
   }

   /**
    * Sets if non-String keys are allowed on JSONObject.<br>
    * [Java -&gt; JSON]
    */
   public void setAllowNonStringKeysboolean allowNonStringKeys ) {
      this.allowNonStringKeys = allowNonStringKeys;
   }
   
   /**
    * Sets the current array mode for conversion.<br>
    * If the value is not MODE_LIST, MODE_OBJECT_ARRAY nor MODE_SET, then MODE_LIST will be used.<br>
    * [JSON -&gt; Java]
    
    @param arrayMode array mode for conversion
    */
   public void setArrayModeint arrayMode ) {
      ifarrayMode == MODE_OBJECT_ARRAY ) {
         this.arrayMode = arrayMode;
      else ifarrayMode == MODE_SET ) {
         this.arrayMode = arrayMode;
         this.collectionType = Set.class;
      else {
         this.arrayMode = MODE_LIST;
         this.enclosedType = DEFAULT_COLLECTION_TYPE;
      }
   }

   /**
    * Sets the current attribute/Class Map<br>
    * [JSON -&gt; Java]
    
    @param classMap a Map of classes, every key identifies a property or a regexp
    */
   public void setClassMapMap classMap ) {
      this.classMap = classMap;
   }

   /**
    * Sets the current collection type used for collection transformations.<br>
    * [JSON -&gt; Java]
    
    @param collectionType the target collection class for conversion
    */
   public void setCollectionTypeClass collectionType ) {
      ifcollectionType != null ) {
         if!Collection.class.isAssignableFromcollectionType ) ) {
            throw new JSONException"The configured collectionType is not a Collection: " + collectionType.getName() );
         }
         this.collectionType = collectionType;
      else {
         collectionType = DEFAULT_COLLECTION_TYPE;
      }
   }

   /**
    * Sets a CycleDetectionStrategy to use.<br>
    * Will set default value (CycleDetectionStrategy.STRICT) if null.<br>
    * [Java -&gt; JSON]
    */
   public void setCycleDetectionStrategyCycleDetectionStrategy cycleDetectionStrategy ) {
      this.cycleDetectionStrategy = cycleDetectionStrategy == null ? DEFAULT_CYCLE_DETECTION_STRATEGY
            : cycleDetectionStrategy;
   }

   /**
    * Sets a DefaultValueProcessorMatcher to use.<br>
    * Will set default value (DefaultValueProcessorMatcher.DEFAULT) if null.<br>
    * [Java -&gt; JSON]
    */
   public void setDefaultValueProcessorMatcherDefaultValueProcessorMatcher defaultValueProcessorMatcher ) {
      this.defaultValueProcessorMatcher = defaultValueProcessorMatcher == null ? DEFAULT_DEFAULT_VALUE_PROCESSOR_MATCHER
            : defaultValueProcessorMatcher;
   }

   /**
    * Sets the current enclosed type for generic collection transformations.<br>
    * [JSON -&gt; Java]
    
    @param enclosedType the target type for conversion
    */
   public void setEnclosedTypeClass enclosedType ) {
      this.enclosedType = enclosedType;
   }

   /**
    * Sets the excludes to use.<br>
    * Will set default value ([]) if null.<br>
    * [Java -&gt; JSON]
    */
   public void setExcludesString[] excludes ) {
      this.excludes = excludes == null ? EMPTY_EXCLUDES : excludes;
   }

   /**
    * Activate/Deactivate handling this jettison convention when converting to Java.<br>
    * Jettison states that "" (empty string) can be assigned to empty elements (objects), which
    * clearly violates the JSON spec.<br>
    * [JSON -&gt; Java]
    */
   public void setHandleJettisonEmptyElementboolean handleJettisonEmptyElement ) {
      this.handleJettisonEmptyElement = handleJettisonEmptyElement;
   }

   /**
    * Activate/Deactivate handling this jettison convention when converting to Java.<br> * Jettison
    * states the following JSON {'media':{'title':'hello'}} can be set as a single element JSONArray
    * (media is the array).<br>
    * [JSON -&gt; Java]
    */
   public void setHandleJettisonSingleElementArrayboolean handleJettisonSingleElementArray ) {
      this.handleJettisonSingleElementArray = handleJettisonSingleElementArray;
   }

   /**
    * Sets if default excludes would be skipped when building.<br>
    * [Java -&gt; JSON]
    */
   public void setIgnoreDefaultExcludesboolean ignoreDefaultExcludes ) {
      this.ignoreDefaultExcludes = ignoreDefaultExcludes;
   }

   /**
    * Sets if JPA Transient annotated methods would be skipped when building.<br>
    * [Java -&gt; JSON]
    */
   public void setIgnoreJPATransientboolean ignoreJPATransient ) {
      if(ignoreJPATransient) {
         addIgnoreFieldAnnotation("javax.persistence.Transient");
      else {
         removeIgnoreFieldAnnotation("javax.persistence.Transient");
      }
   }
   
   /**
    * Adds an annotation that marks a field to be skipped when building.<br>
    * [Java -&gt; JSON]
    */
   public void addIgnoreFieldAnnotationString annotationClassName ) {
      ifannotationClassName != null && !ignoreFieldAnnotations.containsannotationClassName )) {
         ignoreFieldAnnotations.add(annotationClassName);
      }
   }
   
   /**
    * Adds an annotation that marks a field to be skipped when building.<br>
    * [Java -&gt; JSON]
    */
   public void removeIgnoreFieldAnnotationString annotationClassName ) {
      ifannotationClassName != null ignoreFieldAnnotations.remove(annotationClassName);
   }

   /**
    * Removes an annotation that marks a field to be skipped when building.<br>
    * [Java -&gt; JSON]
    */
   public void addIgnoreFieldAnnotationClass annotationClass ) {
      ifannotationClass != null && !ignoreFieldAnnotations.containsannotationClass.getName() )) {
         ignoreFieldAnnotations.add(annotationClass.getName());
      }
   }
   
   /**
    * Removes an annotation that marks a field to be skipped when building.<br>
    * [Java -&gt; JSON]
    */
   public void removeIgnoreFieldAnnotationClass annotationClass ) {
      ifannotationClass != null ignoreFieldAnnotations.remove(annotationClass.getName());
   }
   
   /**
    * Returns a List of all annotations that mark a field to be skipped when building.<br>
    * [Java -&gt; JSON]
    */
   public List getIgnoreFieldAnnotations() {
      return Collections.unmodifiableList(ignoreFieldAnnotations);
   }
   
   /**
    * Sets if transient fields would be skipped when building.<br>
    * [Java -&gt; JSON]
    */
   public void setIgnoreTransientFieldsboolean ignoreTransientFields ) {
      this.ignoreTransientFields = ignoreTransientFields;
   }

   /**
    * Sets if public fields would be skipped when building.<br>
    * [Java -&gt; JSON]
    */
   public void setIgnorePublicFieldsboolean ignorePublicFields ) {
      this.ignorePublicFields = ignorePublicFields;
   }
   
   /**
    * Sets if Javascript compatibility is enabled when building.<br>
    * [Java -&gt; JSON]
    */
   public void setJavascriptCompliantboolean javascriptCompliant ) {
      this.javascriptCompliant = javascriptCompliant;
   }
   
   /**
    * Sets the JavaIdentifierTransformer to use.<br>
    * Will set default value (JavaIdentifierTransformer.NOOP) if null.<br>
    * [JSON -&gt; Java]
    */
   public void setJavaIdentifierTransformerJavaIdentifierTransformer javaIdentifierTransformer ) {
      this.javaIdentifierTransformer = javaIdentifierTransformer == null ? DEFAULT_JAVA_IDENTIFIER_TRANSFORMER
            : javaIdentifierTransformer;
   }

   /**
    * Sets a property filter used when serializing to Java.<br>
    * [JSON -&gt; Java]
    
    @param javaPropertyFilter the property filter
    */
   public void setJavaPropertyFilterPropertyFilter javaPropertyFilter ) {
      this.javaPropertyFilter = javaPropertyFilter;
   }

   /**
    * Sets a PropertyNameProcessorMatcher to use.<br>
    * Will set default value (PropertyNameProcessorMatcher.DEFAULT) if null.<br>
    * [JSON -&gt; Java]
    */
   public void setJavaPropertyNameProcessorMatcherPropertyNameProcessorMatcher propertyNameProcessorMatcher ) {
      this.javaPropertyNameProcessorMatcher = propertyNameProcessorMatcher == null ? DEFAULT_PROPERTY_NAME_PROCESSOR_MATCHER
            : propertyNameProcessorMatcher;
   }

   /**
    * Sets a JsonBeanProcessorMatcher to use.<br>
    * Will set default value (JsonBeanProcessorMatcher.DEFAULT) if null.<br>
    * [Java -&gt; JSON]
    */
   public void setJsonBeanProcessorMatcherJsonBeanProcessorMatcher jsonBeanProcessorMatcher ) {
      this.jsonBeanProcessorMatcher = jsonBeanProcessorMatcher == null ? DEFAULT_JSON_BEAN_PROCESSOR_MATCHER
            : jsonBeanProcessorMatcher;
   }

   /**
    * Sets a property filter used when serializing to JSON.<br>
    * [Java -&gt; JSON]
    
    @param jsonPropertyFilter the property filter
    */
   public void setJsonPropertyFilterPropertyFilter jsonPropertyFilter ) {
      this.jsonPropertyFilter = jsonPropertyFilter;
   }

   /**
    * Sets a PropertyNameProcessorMatcher to use.<br>
    * Will set default value (PropertyNameProcessorMatcher.DEFAULT) if null.<br>
    * [Java -&gt; JSON]
    */
   public void setJsonPropertyNameProcessorMatcherPropertyNameProcessorMatcher propertyNameProcessorMatcher ) {
      this.jsonPropertyNameProcessorMatcher = propertyNameProcessorMatcher == null ? DEFAULT_PROPERTY_NAME_PROCESSOR_MATCHER
            : propertyNameProcessorMatcher;
   }

   /**
    * Sets a JsonValueProcessorMatcher to use.<br>
    * Will set default value (JsonValueProcessorMatcher.DEFAULT) if null.<br>
    * [Java -&gt; JSON]
    */
   public void setJsonValueProcessorMatcherJsonValueProcessorMatcher jsonValueProcessorMatcher ) {
      this.jsonValueProcessorMatcher = jsonValueProcessorMatcher == null ? DEFAULT_JSON_VALUE_PROCESSOR_MATCHER
            : jsonValueProcessorMatcher;
   }
   
   /**
    * Sets the NewBeanInstanceStrategy to use.<br>
    * Will set default value (NewBeanInstanceStrategy.DEFAULT) if null.<br>
    * [JSON -&gt; Java]
    */
   public void setNewBeanInstanceStrategyNewBeanInstanceStrategy newBeanInstanceStrategy ) {
      this.newBeanInstanceStrategy = newBeanInstanceStrategy == null ? DEFAULT_NEW_BEAN_INSTANCE_STRATEGY
            : newBeanInstanceStrategy;
   }
   
   /**
    * Sets a PropertyExclusionClassMatcher to use.<br>
    * Will set default value (PropertyExclusionClassMatcher.DEFAULT) if null.<br>
    * [Java -&gt; JSON]
    */
   public void setPropertyExclusionClassMatcherPropertyExclusionClassMatcher propertyExclusionClassMatcher ) {
      this.propertyExclusionClassMatcher = propertyExclusionClassMatcher == null ? DEFAULT_PROPERTY_EXCLUSION_CLASS_MATCHER
            : propertyExclusionClassMatcher;
   }
   
   /**
    * Sets a PropertyNameProcessorMatcher to use.<br>
    * Will set default value (PropertyNameProcessorMatcher.DEFAULT) if null.<br>
    * [JSON -&gt; Java]
    
    @deprecated use setJavaPropertyNameProcessorMatcher() instead
    */
   public void setPropertyNameProcessorMatcherPropertyNameProcessorMatcher propertyNameProcessorMatcher ) {
      setJavaPropertyNameProcessorMatcherpropertyNameProcessorMatcher );
   }

   /**
    * Sets a PropertySetStrategy to use.<br>
    * Will set default value (PropertySetStrategy.DEFAULT) if null.<br>
    * [JSON -&gt; Java]
    */
   public void setPropertySetStrategyPropertySetStrategy propertySetStrategy ) {
      this.propertySetStrategy = propertySetStrategy;
   }

   /**
    * Sets the current root Class.<br>
    * [JSON -&gt; Java]
    
    @param rootClass the target class for conversion
    */
   public void setRootClassClass rootClass ) {
      this.rootClass = rootClass;
   }

   /**
    * Sets if property name as JavaIndetifier transformations would be skipped.<br>
    * [JSON -&gt; Java]
    */
   public void setSkipJavaIdentifierTransformationInMapKeysboolean skipJavaIdentifierTransformationInMapKeys ) {
      this.skipJavaIdentifierTransformationInMapKeys = skipJavaIdentifierTransformationInMapKeys;
   }

   /**
    * Removes a DefaultValueProcessor.<br>
    * [Java -&gt; JSON]
    
    @param target a class used for searching a DefaultValueProcessor.
    */
   public void unregisterDefaultValueProcessorClass target ) {
      iftarget != null ) {
         defaultValueMap.removetarget );
      }
   }

   /**
    * Removes a PropertyNameProcessor.<br>
    * [JSON -&gt; Java]
    
    @param target a class used for searching a PropertyNameProcessor.
    */
   public void unregisterJavaPropertyNameProcessorClass target ) {
      iftarget != null ) {
         javaPropertyNameProcessorMap.removetarget );
      }
   }
   
   /**
    * Removes a JsonBeanProcessor.<br>
    * [Java -&gt; JSON]
    
    @param target a class used for searching a JsonBeanProcessor.
    */
   public void unregisterJsonBeanProcessorClass target ) {
      iftarget != null ) {
         beanProcessorMap.removetarget );
      }
   }

   /**
    * Removes a PropertyNameProcessor.<br>
    * [Java -&gt; JSON]
    
    @param target a class used for searching a PropertyNameProcessor.
    */
   public void unregisterJsonPropertyNameProcessorClass target ) {
      iftarget != null ) {
         jsonPropertyNameProcessorMap.removetarget );
      }
   }

   /**
    * Removes a JsonValueProcessor.<br>
    * [Java -&gt; JSON]
    
    @param propertyType a class used for searching a JsonValueProcessor.
    */
   public void unregisterJsonValueProcessorClass propertyType ) {
      ifpropertyType != null ) {
         typeMap.removepropertyType );
      }
   }

   /**
    * Removes a JsonValueProcessor.<br>
    * [Java -&gt; JSON]
    
    @param beanClass the class to which the property may belong
    @param propertyType the type of the property
    */
   public void unregisterJsonValueProcessorClass beanClass, Class propertyType ) {
      ifbeanClass != null && propertyType != null ) {
         beanTypeMap.removebeanClass, propertyType );
      }
   }

   /**
    * Removes a JsonValueProcessor.<br>
    * [Java -&gt; JSON]
    
    @param beanClass the class to which the property may belong
    @param key the name of the property which may belong to the target class
    */
   public void unregisterJsonValueProcessorClass beanClass, String key ) {
      ifbeanClass != null && key != null ) {
         beanKeyMap.removebeanClass, key );
      }
   }

   /**
    * Removes a JsonValueProcessor.<br>
    * [Java -&gt; JSON]
    
    @param key the name of the property which may belong to the target class
    */
   public void unregisterJsonValueProcessorString key ) {
      ifkey != null ) {
         keyMap.removekey );
      }
   }

   /**
    * Removes a property exclusion assigned to the target class.<br>
    * [Java -&gt; JSON]
    
    @param target a class used for searching property exclusions.
    @param propertyName the name of the property to be removed from the exclusion list.
    */
   public void unregisterPropertyExclusionClass target, String propertyName ) {
      iftarget != null && propertyName != null ) {
         Set set = (SetexclusionMap.gettarget );
         ifset == null ) {
            set = new HashSet();
            exclusionMap.puttarget, set );
         }
         set.removepropertyName );
      }
   }
   
   /**
    * Removes all property exclusions assigned to the target class.<br>
    * [Java -&gt; JSON]
    
    @param target a class used for searching property exclusions.
    */
   public void unregisterPropertyExclusionsClass target ) {
      iftarget != null ) {
         Set set = (SetexclusionMap.gettarget );
         ifset != null ) {
            set.clear();
         }
      }
   }
   
   /**
    * Removes a PropertyNameProcessor.<br>
    * [JSON -&gt; Java]
    
    @param target a class used for searching a PropertyNameProcessor.
    
    @deprecated use unregisterJavaPropertyNameProcessor() instead
    */
   public void unregisterPropertyNameProcessorClass target ) {
      unregisterJavaPropertyNameProcessortarget );
   }
}