X-Git-Url: https://gerrit.onap.org/r/gitweb?a=blobdiff_plain;f=datarouter-prov%2Fsrc%2Fmain%2Fjava%2Forg%2Fonap%2Fdmaap%2Fdatarouter%2Fprovisioning%2Futils%2FLOGJSONObject.java;h=0f95523406bef9a7ec62a22d5754c2339510fef1;hb=381d4ebc5e83d5fd5b62fff7e5a6fa6d582149d9;hp=cbe87da848a9533aad3d348df5188df023c6fbf7;hpb=070b01cc6eb66cec5c8131b2f3d6f2d50879754f;p=dmaap%2Fdatarouter.git

diff --git a/datarouter-prov/src/main/java/org/onap/dmaap/datarouter/provisioning/utils/LOGJSONObject.java b/datarouter-prov/src/main/java/org/onap/dmaap/datarouter/provisioning/utils/LOGJSONObject.java
index cbe87da8..0f955234 100644
--- a/datarouter-prov/src/main/java/org/onap/dmaap/datarouter/provisioning/utils/LOGJSONObject.java
+++ b/datarouter-prov/src/main/java/org/onap/dmaap/datarouter/provisioning/utils/LOGJSONObject.java
@@ -9,9 +9,9 @@ package org.onap.dmaap.datarouter.provisioning.utils;
  * * 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.
@@ -23,21 +23,19 @@ package org.onap.dmaap.datarouter.provisioning.utils;
  * *
  ******************************************************************************/
 
+import com.att.eelf.configuration.EELFLogger;
+import com.att.eelf.configuration.EELFManager;
 import java.io.IOException;
 import java.io.StringWriter;
 import java.io.Writer;
-import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.util.Collection;
-import java.util.Enumeration;
-import java.util.LinkedHashMap;
+import java.util.HashMap;
 import java.util.Iterator;
-import java.util.Locale;
+import java.util.LinkedHashMap;
 import java.util.Map;
-import java.util.ResourceBundle;
 import java.util.Set;
-
 import org.json.JSONArray;
 import org.json.JSONException;
 import org.json.JSONString;
@@ -59,22 +57,22 @@ import org.json.JSONTokener;
  * 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
+ *
+ * <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. The opt methods differ from the get methods in that they do
  * not throw. Instead, they return a specified value, such as null.
- * <p>
- * The <code>put</code> methods add or replace values in an object. For example,
+ *
+ * <p>The <code>put</code> methods add or replace values in an object. For example,
  *
  * <pre>
  * myString = new JSONObject().put(&quot;JSON&quot;, &quot;Hello, World!&quot;).toString();
  * </pre>
  *
- * produces the string <code>{"JSON": "Hello, World"}</code>.
- * <p>
- * The texts produced by the <code>toString</code> methods strictly conform to
+ * <p>* 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>
@@ -97,31 +95,38 @@ import org.json.JSONTokener;
  * @author JSON.org
  * @version 2012-12-01
  */
+
 public class LOGJSONObject {
+
     /**
      * The maximum number of keys in the key pool.
      */
-     private static final int keyPoolSize = 100;
+    private static final int KEY_POOL_SIZE = 100;
+    private static final String USING_DEFAULT_VALUE = "Using defaultValue: ";
+    private static final String JSON_OBJECT_CONST = "JSONObject[";
 
-   /**
+    /**
      * Key pooling is like string interning, but without permanently tying up
      * memory. To help conserve memory, storage of duplicated key strings in
      * JSONObjects will be avoided by using a key pool to manage unique key
      * string objects. This is used by JSONObject.put(string, object).
      */
-     private static Map<String,Object> keyPool = new LinkedHashMap<String,Object>(keyPoolSize);
+    private static Map<String, Object> keyPool = new LinkedHashMap<>(KEY_POOL_SIZE);
+
+    private static final EELFLogger intlogger = EELFManager.getInstance().getLogger("InternalLog");
 
     /**
      * JSONObject.NULL is equivalent to the value that JavaScript calls null,
      * whilst Java's null is equivalent to the value that JavaScript calls
      * undefined.
      */
-     private static final class Null {
+    private static final class Null {
 
         /**
          * There is only intended to be a single instance of the NULL object,
          * so the clone method returns itself.
-         * @return     NULL.
+         *
+         * @return NULL.
          */
         protected final Object clone() {
             return this;
@@ -129,16 +134,58 @@ public class LOGJSONObject {
 
         /**
          * A Null object is equal to the null value and to itself.
-         * @param object    An object to test for nullness.
+         *
+         * @param object An object to test for nullness.
          * @return true if the object parameter is the JSONObject.NULL object
-         *  or null.
+         * or null.
          */
         public boolean equals(Object object) {
             return object == null || object == this;
         }
 
+        /**
+         * Returns a hash code value for the object. This method is
+         * supported for the benefit of hash tables such as those provided by
+         * {@link HashMap}.
+         *
+         * <p>* The general contract of {@code hashCode} is:
+         * <ul>
+         * <li>Whenever it is invoked on the same object more than once during
+         * an execution of a Java application, the {@code hashCode} method
+         * must consistently return the same integer, provided no information
+         * used in {@code equals} comparisons on the object is modified.
+         * This integer need not remain consistent from one execution of an
+         * application to another execution of the same application.
+         * <li>If two objects are equal according to the {@code equals(Object)}
+         * method, then calling the {@code hashCode} method on each of
+         * the two objects must produce the same integer result.
+         * <li>It is <em>not</em> required that if two objects are unequal
+         * according to the {@link Object#equals(Object)}
+         * method, then calling the {@code hashCode} method on each of the
+         * two objects must produce distinct integer results.  However, the
+         * programmer should be aware that producing distinct integer results
+         * for unequal objects may improve the performance of hash tables.
+         * </ul>
+         *
+         * <p>* As much as is reasonably practical, the hashCode method defined by
+         * class {@code Object} does return distinct integers for distinct
+         * objects. (This is typically implemented by converting the internal
+         * address of the object into an integer, but this implementation
+         * technique is not required by the
+         * Java&trade; programming language.)
+         *
+         * @return a hash code value for this object.
+         * @see Object#equals(Object)
+         * @see System#identityHashCode
+         */
+        @Override
+        public int hashCode() {
+            return super.hashCode();
+        }
+
         /**
          * Get the "null" string value.
+         *
          * @return The string "null".
          */
         public String toString() {
@@ -146,12 +193,10 @@ public class LOGJSONObject {
         }
     }
 
-
     /**
      * The map where the JSONObject's properties are kept.
      */
-    private final Map<String,Object> map;
-
+    private final Map<String, Object> map;
 
     /**
      * It is sometimes more convenient and less ambiguous to have a
@@ -159,25 +204,22 @@ public class LOGJSONObject {
      * <code>JSONObject.NULL.equals(null)</code> returns <code>true</code>.
      * <code>JSONObject.NULL.toString()</code> returns <code>"null"</code>.
      */
-    public static final Object NULL = new Null();
-
+    private static final Object NULL = new Null();
 
     /**
      * Construct an empty JSONObject.
      */
     public LOGJSONObject() {
-        this.map = new LinkedHashMap<String,Object>();
+        this.map = new LinkedHashMap<>();
     }
 
-
     /**
      * Construct a JSONObject from a subset of another JSONObject.
      * An array of strings is used to identify the keys that should be copied.
      * Missing keys are ignored.
-     * @param jo A JSONObject.
+     *
+     * @param jo    A JSONObject.
      * @param names An array of strings.
-     * @throws JSONException
-     * @exception JSONException If a value is a non-finite number or if a name is duplicated.
      */
     public LOGJSONObject(LOGJSONObject jo, String[] names) {
         this();
@@ -185,90 +227,89 @@ public class LOGJSONObject {
             try {
                 this.putOnce(names[i], jo.opt(names[i]));
             } catch (Exception ignore) {
+                intlogger.error("PROV0001 LOGJSONObject: " + ignore.getMessage(), ignore);
             }
         }
     }
 
-
     /**
      * Construct a JSONObject from a JSONTokener.
-     * @param x A JSONTokener object containing the source string.
+     *
+     * @param tokener A JSONTokener object containing the source string.
      * @throws JSONException If there is a syntax error in the source string
-     *  or a duplicated key.
+     *                       or a duplicated key.
      */
-    public LOGJSONObject(JSONTokener x) throws JSONException {
+    public LOGJSONObject(JSONTokener tokener) {
         this();
-        char c;
+        char chr;
         String key;
 
-        if (x.nextClean() != '{') {
-            throw x.syntaxError("A JSONObject text must begin with '{'");
+        if (tokener.nextClean() != '{') {
+            throw tokener.syntaxError("A JSONObject text must begin with '{'");
         }
-        for (;;) {
-            c = x.nextClean();
-            switch (c) {
-            case 0:
-                throw x.syntaxError("A JSONObject text must end with '}'");
-            case '}':
-                return;
-            default:
-                x.back();
-                key = x.nextValue().toString();
+        for (; ; ) {
+            chr = tokener.nextClean();
+            switch (chr) {
+                case 0:
+                    throw tokener.syntaxError("A JSONObject text must end with '}'");
+                case '}':
+                    return;
+                default:
+                    tokener.back();
+                    key = tokener.nextValue().toString();
             }
 
-// The key is followed by ':'. We will also tolerate '=' or '=>'.
+            // The key is followed by ':'. We will also tolerate '=' or '=>'.
 
-            c = x.nextClean();
-            if (c == '=') {
-                if (x.next() != '>') {
-                    x.back();
+            chr = tokener.nextClean();
+            if (chr == '=') {
+                if (tokener.next() != '>') {
+                    tokener.back();
                 }
-            } else if (c != ':') {
-                throw x.syntaxError("Expected a ':' after a key");
+            } else if (chr != ':') {
+                throw tokener.syntaxError("Expected a ':' after a key");
             }
-            this.putOnce(key, x.nextValue());
+            this.putOnce(key, tokener.nextValue());
 
-// Pairs are separated by ','. We will also tolerate ';'.
+            // Pairs are separated by ','. We will also tolerate ';'.
 
-            switch (x.nextClean()) {
-            case ';':
-            case ',':
-                if (x.nextClean() == '}') {
+            switch (tokener.nextClean()) {
+                case ';':
+                case ',':
+                    if (tokener.nextClean() == '}') {
+                        return;
+                    }
+                    tokener.back();
+                    break;
+                case '}':
                     return;
-                }
-                x.back();
-                break;
-            case '}':
-                return;
-            default:
-                throw x.syntaxError("Expected a ',' or '}'");
+                default:
+                    throw tokener.syntaxError("Expected a ',' or '}'");
             }
         }
     }
 
-
     /**
      * Construct a JSONObject from a Map.
      *
      * @param map A map object that can be used to initialize the contents of
-     *  the JSONObject.
-     * @throws JSONException
+     *            the JSONObject.
+     * @throws JSONException json exception
      */
-    public LOGJSONObject(Map<String,Object> map) {
-        this.map = new LinkedHashMap<String,Object>();
+    public LOGJSONObject(Map<String, Object> map) {
+        this.map = new LinkedHashMap<>();
         if (map != null) {
-            Iterator<Map.Entry<String,Object>> i = map.entrySet().iterator();
-            while (i.hasNext()) {
-                Map.Entry<String,Object> e = i.next();
-                Object value = e.getValue();
+            Iterator<Map.Entry<String, Object>> iterator = map.entrySet().iterator();
+            while (iterator.hasNext()) {
+                Map.Entry<String, Object> entry = iterator.next();
+                Object value = entry.getValue();
                 if (value != null) {
-                    this.map.put(e.getKey(), wrap(value));
+                    this.map.put(entry.getKey(), wrap(value));
                 }
             }
         }
     }
 
-
     /**
      * Construct a JSONObject from an Object using bean getters.
      * It reflects on all of the public methods of the object.
@@ -277,101 +318,22 @@ public class LOGJSONObject {
      * the method is invoked, and a key and the value returned from the getter method
      * are put into the new JSONObject.
      *
-     * The key is formed by removing the <code>"get"</code> or <code>"is"</code> prefix.
+     * <p>* The key is formed by removing the <code>"get"</code> or <code>"is"</code> prefix.
      * If the second remaining character is not upper case, then the first
      * character is converted to lower case.
      *
-     * For example, if an object has a method named <code>"getName"</code>, and
+     * <p>* For example, if an object has a method named <code>"getName"</code>, and
      * if the result of calling <code>object.getName()</code> is <code>"Larry Fine"</code>,
      * then the JSONObject will contain <code>"name": "Larry Fine"</code>.
      *
      * @param bean An object that has getter methods that should be used
-     * to make a JSONObject.
+     *             to make a JSONObject.
      */
     public LOGJSONObject(Object bean) {
         this();
         this.populateMap(bean);
     }
 
-
-    /**
-     * Construct a JSONObject from an Object, using reflection to find the
-     * public members. The resulting JSONObject's keys will be the strings
-     * from the names array, and the values will be the field values associated
-     * with those keys in the object. If a key is not found or not visible,
-     * then it will not be copied into the new JSONObject.
-     * @param object An object that has fields that should be used to make a
-     * JSONObject.
-     * @param names An array of strings, the names of the fields to be obtained
-     * from the object.
-     */
-    public LOGJSONObject(Object object, String names[]) {
-        this();
-        Class<? extends Object> c = object.getClass();
-        for (int i = 0; i < names.length; i += 1) {
-            String name = names[i];
-            try {
-                this.putOpt(name, c.getField(name).get(object));
-            } catch (Exception ignore) {
-            }
-        }
-    }
-
-
-    /**
-     * Construct a JSONObject from a source JSON text string.
-     * This is the most commonly used JSONObject constructor.
-     * @param source    A string beginning
-     *  with <code>{</code>&nbsp;<small>(left brace)</small> and ending
-     *  with <code>}</code>&nbsp;<small>(right brace)</small>.
-     * @exception JSONException If there is a syntax error in the source
-     *  string or a duplicated key.
-     */
-    public LOGJSONObject(String source) throws JSONException {
-        this(new JSONTokener(source));
-    }
-
-
-    /**
-     * Construct a JSONObject from a ResourceBundle.
-     * @param baseName The ResourceBundle base name.
-     * @param locale The Locale to load the ResourceBundle for.
-     * @throws JSONException If any JSONExceptions are detected.
-     */
-    public LOGJSONObject(String baseName, Locale locale) throws JSONException {
-        this();
-        ResourceBundle bundle = ResourceBundle.getBundle(baseName, locale,
-                Thread.currentThread().getContextClassLoader());
-
-// Iterate through the keys in the bundle.
-
-        Enumeration<?> keys = bundle.getKeys();
-        while (keys.hasMoreElements()) {
-            Object key = keys.nextElement();
-            if (key instanceof String) {
-
-// Go through the path, ensuring that there is a nested JSONObject for each
-// segment except the last. Add the value using the last segment's name into
-// the deepest nested JSONObject.
-
-                String[] path = ((String)key).split("\\.");
-                int last = path.length - 1;
-                LOGJSONObject target = this;
-                for (int i = 0; i < last; i += 1) {
-                    String segment = path[i];
-                    LOGJSONObject nextTarget = target.optJSONObject(segment);
-                    if (nextTarget == null) {
-                        nextTarget = new LOGJSONObject();
-                        target.put(segment, nextTarget);
-                    }
-                    target = nextTarget;
-                }
-                target.put(path[last], bundle.getString((String)key));
-            }
-        }
-    }
-
-
     /**
      * Accumulate values under a key. It is similar to the put method except
      * that if there is already an object stored under the key then a
@@ -379,76 +341,77 @@ public class LOGJSONObject {
      * If there is already a JSONArray, then the new value is appended to it.
      * In contrast, the put method replaces the previous value.
      *
-     * If only one value is accumulated that is not a JSONArray, then the
+     * <p>* If only one value is accumulated that is not a JSONArray, then the
      * result will be the same as using put. But if multiple values are
      * accumulated, then the result will be like append.
+     *
      * @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.
+     *                       or if the key is null.
      */
     public LOGJSONObject accumulate(
         String key,
         Object value
-    ) throws JSONException {
+    ) {
         testValidity(value);
         Object object = this.opt(key);
         if (object == null) {
             this.put(key, value instanceof JSONArray
-                    ? new JSONArray().put(value)
-                    : value);
+                ? new JSONArray().put(value)
+                : value);
         } else if (object instanceof JSONArray) {
-            ((JSONArray)object).put(value);
+            ((JSONArray) object).put(value);
         } else {
             this.put(key, new JSONArray().put(object).put(value));
         }
         return this;
     }
 
-
     /**
      * Append values to the array under a key. If the key does not exist in the
      * JSONObject, then the key is put in the JSONObject with its value being a
      * JSONArray containing the value parameter. If the key was already
      * associated with a JSONArray, then the value parameter is appended to it.
+     *
      * @param key   A key string.
      * @param value An object to be accumulated under the key.
      * @return this.
      * @throws JSONException If the key is null or if the current value
-     *  associated with the key is not a JSONArray.
+     *                       associated with the key is not a JSONArray.
      */
-    public LOGJSONObject append(String key, Object value) throws JSONException {
+    public LOGJSONObject append(String key, Object value) {
         testValidity(value);
         Object object = this.opt(key);
         if (object == null) {
             this.put(key, new JSONArray().put(value));
         } else if (object instanceof JSONArray) {
-            this.put(key, ((JSONArray)object).put(value));
+            this.put(key, ((JSONArray) object).put(value));
         } else {
-            throw new JSONException("JSONObject[" + key +
-                    "] is not a JSONArray.");
+            throw new JSONException(JSON_OBJECT_CONST + key
+                + "] is not a JSONArray.");
         }
         return this;
     }
 
-
     /**
      * Produce a string from a double. The string "null" will be returned if
      * the number is not finite.
-     * @param  d A double.
+     *
+     * @param dub A double.
      * @return A String.
      */
-    public static String doubleToString(double d) {
-        if (Double.isInfinite(d) || Double.isNaN(d)) {
+    public static String doubleToString(double dub) {
+        if (Double.isInfinite(dub) || Double.isNaN(dub)) {
             return "null";
         }
 
-// Shave off trailing zeros and decimal point, if possible.
+        // Shave off trailing zeros and decimal point, if possible.
 
-        String string = Double.toString(d);
-        if (string.indexOf('.') > 0 && string.indexOf('e') < 0 &&
-                string.indexOf('E') < 0) {
+        String string = Double.toString(dub);
+        if (string.indexOf('.') > 0 && string.indexOf('e') < 0
+            && string.indexOf('E') < 0) {
             while (string.endsWith("0")) {
                 string = string.substring(0, string.length() - 1);
             }
@@ -459,149 +422,141 @@ public class LOGJSONObject {
         return string;
     }
 
-
     /**
      * Get the value object associated with a key.
      *
-     * @param key   A key string.
-     * @return      The object associated with the key.
-     * @throws      JSONException if the key is not found.
+     * @param key A key string.
+     * @return The object associated with the key.
+     * @throws JSONException if the key is not found.
      */
-    public Object get(String key) throws JSONException {
+    public Object get(String key) {
         if (key == null) {
             throw new JSONException("Null key.");
         }
         Object object = this.opt(key);
         if (object == null) {
-            throw new JSONException("JSONObject[" + quote(key) +
-                    "] not found.");
+            throw new JSONException(JSON_OBJECT_CONST + quote(key)
+                + "] not found.");
         }
         return object;
     }
 
-
     /**
      * 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".
+     * @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) throws JSONException {
+    public boolean getBoolean(String key) {
         Object object = this.get(key);
-        if (object.equals(Boolean.FALSE) ||
-                (object instanceof String &&
-                ((String)object).equalsIgnoreCase("false"))) {
+        if (object.equals(Boolean.FALSE)
+            || (object instanceof String
+            && "false".equalsIgnoreCase((String) object))) {
             return false;
-        } else if (object.equals(Boolean.TRUE) ||
-                (object instanceof String &&
-                ((String)object).equalsIgnoreCase("true"))) {
+        } else if (object.equals(Boolean.TRUE)
+            || (object instanceof String
+                && "true".equalsIgnoreCase((String) object))) {
             return true;
         }
-        throw new JSONException("JSONObject[" + quote(key) +
-                "] is not a Boolean.");
+        throw new JSONException(JSON_OBJECT_CONST + quote(key)
+            + "] is not a Boolean.");
     }
 
-
     /**
      * Get the double value associated with a key.
-     * @param key   A key string.
-     * @return      The numeric value.
+     *
+     * @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.
+     *                       if the value is not a Number object and cannot be converted to a number.
      */
-    public double getDouble(String key) throws JSONException {
+    public double getDouble(String key) {
         Object object = this.get(key);
         try {
             return object instanceof Number
-                ? ((Number)object).doubleValue()
-                : Double.parseDouble((String)object);
+                ? ((Number) object).doubleValue()
+                : Double.parseDouble((String) object);
         } catch (Exception e) {
-            throw new JSONException("JSONObject[" + quote(key) +
-                "] is not a number.");
+            intlogger.error(JSON_OBJECT_CONST + quote(key) + "] is not a number.", e);
+            throw new JSONException(JSON_OBJECT_CONST + quote(key) + "] is not a number.");
         }
     }
 
-
     /**
      * Get the int value associated with a key.
      *
-     * @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.
+     * @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) throws JSONException {
+    public int getInt(String key) {
         Object object = this.get(key);
         try {
             return object instanceof Number
-                ? ((Number)object).intValue()
-                : Integer.parseInt((String)object);
+                ? ((Number) object).intValue()
+                : Integer.parseInt((String) object);
         } catch (Exception e) {
-            throw new JSONException("JSONObject[" + quote(key) +
-                "] is not an int.");
+            intlogger.error(JSON_OBJECT_CONST + quote(key) + "] is not an int.", e);
+            throw new JSONException(JSON_OBJECT_CONST + quote(key) + "] is not an int.");
         }
     }
 
-
     /**
      * 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.
+     * @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) throws JSONException {
+    public JSONArray getJSONArray(String key) {
         Object object = this.get(key);
         if (object instanceof JSONArray) {
-            return (JSONArray)object;
+            return (JSONArray) object;
         }
-        throw new JSONException("JSONObject[" + quote(key) +
-                "] is not a JSONArray.");
+        throw new JSONException(JSON_OBJECT_CONST + 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.
+     * @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 LOGJSONObject getJSONObject(String key) throws JSONException {
+    public LOGJSONObject getJSONObject(String key) {
         Object object = this.get(key);
         if (object instanceof LOGJSONObject) {
-            return (LOGJSONObject)object;
+            return (LOGJSONObject) object;
         }
-        throw new JSONException("JSONObject[" + quote(key) +
-                "] is not a JSONObject.");
+        throw new JSONException(JSON_OBJECT_CONST + quote(key)
+            + "] is not a JSONObject.");
     }
 
-
     /**
      * Get the long value associated with a key.
      *
-     * @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.
+     * @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) throws JSONException {
+    public long getLong(String key) {
         Object object = this.get(key);
         try {
             return object instanceof Number
-                ? ((Number)object).longValue()
-                : Long.parseLong((String)object);
+                ? ((Number) object).longValue()
+                : Long.parseLong((String) object);
         } catch (Exception e) {
-            throw new JSONException("JSONObject[" + quote(key) +
-                "] is not a long.");
+            intlogger.error(JSON_OBJECT_CONST + quote(key) + "] is not a long.", e);
+            throw new JSONException(JSON_OBJECT_CONST + quote(key) + "] is not a long.");
         }
     }
 
-
     /**
      * Get an array of field names from a JSONObject.
      *
@@ -610,109 +565,72 @@ public class LOGJSONObject {
     public static String[] getNames(LOGJSONObject jo) {
         int length = jo.length();
         if (length == 0) {
-            return null;
+            return new String[]{};
         }
         Iterator<String> iterator = jo.keys();
         String[] names = new String[length];
-        int i = 0;
+        int iter = 0;
         while (iterator.hasNext()) {
-            names[i] = iterator.next();
-            i += 1;
-        }
-        return names;
-    }
-
-
-    /**
-     * Get an array of field names from an Object.
-     *
-     * @return An array of field names, or null if there are no names.
-     */
-    public static String[] getNames(Object object) {
-        if (object == null) {
-            return null;
-        }
-        Class<? extends Object> klass = object.getClass();
-        Field[] fields = klass.getFields();
-        int length = fields.length;
-        if (length == 0) {
-            return null;
-        }
-        String[] names = new String[length];
-        for (int i = 0; i < length; i += 1) {
-            names[i] = fields[i].getName();
+            names[iter] = iterator.next();
+            iter += 1;
         }
         return names;
     }
 
-
     /**
      * Get the string associated with a key.
      *
-     * @param key   A key string.
-     * @return      A string which is the value.
-     * @throws   JSONException if there is no string value for the key.
+     * @param key A key string.
+     * @return A string which is the value.
+     * @throws JSONException if there is no string value for the key.
      */
-    public String getString(String key) throws JSONException {
+    public String getString(String key) {
         Object object = this.get(key);
         if (object instanceof String) {
-            return (String)object;
+            return (String) object;
         }
-        throw new JSONException("JSONObject[" + quote(key) +
-            "] not a string.");
+        throw new JSONException(JSON_OBJECT_CONST + quote(key)
+            + "] not a string.");
     }
 
-
     /**
      * Determine if the JSONObject contains a specific key.
-     * @param key   A key string.
-     * @return      true if the key exists in the JSONObject.
+     *
+     * @param key A key string.
+     * @return true if the key exists in the JSONObject.
      */
     public boolean has(String key) {
         return this.map.containsKey(key);
     }
 
-
     /**
      * Increment a property of a JSONObject. If there is no such property,
      * create one with a value of 1. If there is such a property, and if
      * it is an Integer, Long, Double, or Float, then add one to it.
-     * @param key  A key string.
+     *
+     * @param key A key string.
      * @return this.
      * @throws JSONException If there is already a property with this name
-     * that is not an Integer, Long, Double, or Float.
+     *                       that is not an Integer, Long, Double, or Float.
      */
-    public LOGJSONObject increment(String key) throws JSONException {
+    public LOGJSONObject increment(String key) {
         Object value = this.opt(key);
         if (value == null) {
             this.put(key, 1);
         } else if (value instanceof Integer) {
-            this.put(key, ((Integer)value).intValue() + 1);
+            this.put(key, ((Integer) value).intValue() + 1);
         } else if (value instanceof Long) {
-            this.put(key, ((Long)value).longValue() + 1);
+            this.put(key, ((Long) value).longValue() + 1);
         } else if (value instanceof Double) {
-            this.put(key, ((Double)value).doubleValue() + 1);
+            this.put(key, ((Double) value).doubleValue() + 1);
         } else if (value instanceof Float) {
-            this.put(key, ((Float)value).floatValue() + 1);
+            this.put(key, ((Float) value).floatValue() + 1);
         } else {
             throw new JSONException("Unable to increment [" + quote(key) + "].");
         }
         return this;
     }
 
-
-    /**
-     * Determine if the value associated with the key is null or if there is
-     *  no value.
-     * @param key   A key string.
-     * @return      true if there is no value associated with the key or if
-     *  the value is the JSONObject.NULL object.
-     */
-    public boolean isNull(String key) {
-        return LOGJSONObject.NULL.equals(this.opt(key));
-    }
-
-
     /**
      * Get an enumeration of the keys of the JSONObject.
      *
@@ -722,7 +640,6 @@ public class LOGJSONObject {
         return this.keySet().iterator();
     }
 
-
     /**
      * Get a set of keys of the JSONObject.
      *
@@ -732,7 +649,6 @@ public class LOGJSONObject {
         return this.map.keySet();
     }
 
-
     /**
      * Get the number of keys stored in the JSONObject.
      *
@@ -742,10 +658,10 @@ public class LOGJSONObject {
         return this.map.size();
     }
 
-
     /**
      * 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.
      */
@@ -760,22 +676,22 @@ public class LOGJSONObject {
 
     /**
      * Produce a string from a Number.
-     * @param  number A Number
+     *
+     * @param number A Number
      * @return A String.
      * @throws JSONException If n is a non-finite number.
      */
-    public static String numberToString(Number number)
-            throws JSONException {
+    public static String numberToString(Number number) {
         if (number == null) {
             throw new JSONException("Null pointer");
         }
         testValidity(number);
 
-// Shave off trailing zeros and decimal point, if possible.
+        // Shave off trailing zeros and decimal point, if possible.
 
         String string = number.toString();
-        if (string.indexOf('.') > 0 && string.indexOf('e') < 0 &&
-                string.indexOf('E') < 0) {
+        if (string.indexOf('.') > 0 && string.indexOf('e') < 0
+            && string.indexOf('E') < 0) {
             while (string.endsWith("0")) {
                 string = string.substring(0, string.length() - 1);
             }
@@ -786,156 +702,73 @@ public class LOGJSONObject {
         return string;
     }
 
-
     /**
      * 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.
+     *
+     * @param key A key string.
+     * @return An object which is the value, or null if there is no value.
      */
     public Object opt(String key) {
         return key == null ? null : this.map.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) {
-        return this.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.
+     * @param key          A key string.
+     * @param defaultValue The default.
+     * @return The truth.
      */
     public boolean optBoolean(String key, boolean defaultValue) {
         try {
             return this.getBoolean(key);
         } catch (Exception e) {
+            intlogger.trace(USING_DEFAULT_VALUE + defaultValue, 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) {
-        return this.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.
+     * @param key          A key string.
+     * @param defaultValue The default.
+     * @return An object which is the value.
      */
     public double optDouble(String key, double defaultValue) {
         try {
             return this.getDouble(key);
         } catch (Exception e) {
+            intlogger.trace(USING_DEFAULT_VALUE + defaultValue, 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) {
-        return this.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.
+     * @param key          A key string.
+     * @param defaultValue The default.
+     * @return An object which is the value.
      */
     public int optInt(String key, int defaultValue) {
         try {
             return this.getInt(key);
         } catch (Exception e) {
+            intlogger.trace(USING_DEFAULT_VALUE + defaultValue, 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) {
-        Object o = this.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 LOGJSONObject optJSONObject(String key) {
-        Object object = this.opt(key);
-        return object instanceof LOGJSONObject ? (LOGJSONObject)object : 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) {
-        return this.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.
@@ -944,7 +777,7 @@ public class LOGJSONObject {
      *
      * @param key          A key string.
      * @param defaultValue The default.
-     * @return             An object which is the value.
+     * @return An object which is the value.
      */
     public long optLong(String key, long defaultValue) {
         try {
@@ -954,44 +787,29 @@ public class LOGJSONObject {
         }
     }
 
-
-    /**
-     * 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 converted to a string.
-     *
-     * @param key   A key string.
-     * @return      A string which is the value.
-     */
-    public String optString(String key) {
-        return this.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.
+     * @param key          A key string.
+     * @param defaultValue The default.
+     * @return A string which is the value.
      */
     public String optString(String key, String defaultValue) {
         Object object = this.opt(key);
         return NULL.equals(object) ? defaultValue : object.toString();
     }
 
-
     private void populateMap(Object bean) {
-        Class<? extends Object> klass = bean.getClass();
+        Class<?> klass = bean.getClass();
 
-// If klass is a System class then set includeSuperClass to false.
+        // If klass is a System class then set includeSuperClass to false.
 
         boolean includeSuperClass = klass.getClassLoader() != null;
 
         Method[] methods = includeSuperClass
-                ? klass.getMethods()
-                : klass.getDeclaredMethods();
+            ? klass.getMethods()
+            : klass.getDeclaredMethods();
         for (int i = 0; i < methods.length; i += 1) {
             try {
                 Method method = methods[i];
@@ -999,8 +817,8 @@ public class LOGJSONObject {
                     String name = method.getName();
                     String key = "";
                     if (name.startsWith("get")) {
-                        if ("getClass".equals(name) ||
-                                "getDeclaringClass".equals(name)) {
+                        if ("getClass".equals(name)
+                            || "getDeclaringClass".equals(name)) {
                             key = "";
                         } else {
                             key = name.substring(3);
@@ -1008,56 +826,28 @@ public class LOGJSONObject {
                     } else if (name.startsWith("is")) {
                         key = name.substring(2);
                     }
-                    if (key.length() > 0 &&
-                            Character.isUpperCase(key.charAt(0)) &&
-                            method.getParameterTypes().length == 0) {
+                    if (key.length() > 0
+                        && Character.isUpperCase(key.charAt(0))
+                        && method.getParameterTypes().length == 0) {
                         if (key.length() == 1) {
                             key = key.toLowerCase();
                         } else if (!Character.isUpperCase(key.charAt(1))) {
-                            key = key.substring(0, 1).toLowerCase() +
-                                key.substring(1);
+                            key = key.substring(0, 1).toLowerCase()
+                                + key.substring(1);
                         }
 
-                        Object result = method.invoke(bean, (Object[])null);
+                        Object result = method.invoke(bean, (Object[]) null);
                         if (result != null) {
                             this.map.put(key, wrap(result));
                         }
                     }
                 }
             } catch (Exception ignore) {
+                intlogger.trace("populateMap: " + ignore.getMessage(), ignore);
             }
         }
     }
 
-
-    /**
-     * 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 LOGJSONObject put(String key, boolean value) throws JSONException {
-        this.put(key, value ? Boolean.TRUE : Boolean.FALSE);
-        return this;
-    }
-
-
-    /**
-     * 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 LOGJSONObject put(String key, Collection<Object> value) throws JSONException {
-        this.put(key, new JSONArray(value));
-        return this;
-    }
-
-
     /**
      * Put a key/double pair in the JSONObject.
      *
@@ -1066,12 +856,11 @@ public class LOGJSONObject {
      * @return this.
      * @throws JSONException If the key is null or if the number is invalid.
      */
-    public LOGJSONObject put(String key, double value) throws JSONException {
+    public LOGJSONObject put(String key, double value) {
         this.put(key, new Double(value));
         return this;
     }
 
-
     /**
      * Put a key/int pair in the JSONObject.
      *
@@ -1080,12 +869,11 @@ public class LOGJSONObject {
      * @return this.
      * @throws JSONException If the key is null.
      */
-    public LOGJSONObject put(String key, int value) throws JSONException {
+    public LOGJSONObject put(String key, int value) {
         this.put(key, new Integer(value));
         return this;
     }
 
-
     /**
      * Put a key/long pair in the JSONObject.
      *
@@ -1094,48 +882,34 @@ public class LOGJSONObject {
      * @return this.
      * @throws JSONException If the key is null.
      */
-    public LOGJSONObject put(String key, long value) throws JSONException {
+    public LOGJSONObject put(String key, long value) {
         this.put(key, new Long(value));
         return this;
     }
 
-
-    /**
-     * 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 LOGJSONObject put(String key, Map<String, Object> value) throws JSONException {
-        this.put(key, new LOGJSONObject(value));
-        return this;
-    }
-
-
     /**
      * 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.
+     *
      * @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 JSONObject.NULL object.
+     *              types: Boolean, Double, Integer, JSONArray, JSONObject, Long, String,
+     *              or the JSONObject.NULL object.
      * @return this.
      * @throws JSONException If the value is non-finite number
-     *  or if the key is null.
+     *                       or if the key is null.
      */
-    public LOGJSONObject put(String key, Object value) throws JSONException {
+    public LOGJSONObject put(String key, Object value) {
         String pooled;
         if (key == null) {
             throw new JSONException("Null key.");
         }
         if (value != null) {
             testValidity(value);
-            pooled = (String)keyPool.get(key);
+            pooled = (String) keyPool.get(key);
             if (pooled == null) {
-                if (keyPool.size() >= keyPoolSize) {
-                    keyPool = new LinkedHashMap<String, Object>(keyPoolSize);
+                if (keyPool.size() >= KEY_POOL_SIZE) {
+                    keyPool = new LinkedHashMap<>(KEY_POOL_SIZE);
                 }
                 keyPool.put(key, key);
             } else {
@@ -1148,17 +922,17 @@ public class LOGJSONObject {
         return this;
     }
 
-
     /**
      * Put a key/value pair in the JSONObject, but only if the key and the
      * value are both non-null, and only if there is not already a member
      * with that name.
-     * @param key
-     * @param value
-     * @return his.
+     *
+     * @param key string key
+     * @param value obj value
+     * @return this LOGJSONObject
      * @throws JSONException if the key is a duplicate
      */
-    public LOGJSONObject putOnce(String key, Object value) throws JSONException {
+    public LOGJSONObject putOnce(String key, Object value) {
         if (key != null && value != null) {
             if (this.opt(key) != null) {
                 throw new JSONException("Duplicate key \"" + key + "\"");
@@ -1168,106 +942,94 @@ public class LOGJSONObject {
         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 JSONObject.NULL object.
-     * @return this.
-     * @throws JSONException If the value is a non-finite number.
-     */
-    public LOGJSONObject putOpt(String key, Object value) throws JSONException {
-        if (key != null && value != null) {
-            this.put(key, value);
-        }
-        return this;
-    }
-
-
     /**
      * Produce a string in double quotes with backslash sequences in all the
-     * right places. A backslash will be inserted within </, producing <\/,
-     * allowing JSON text to be delivered in HTML. In JSON text, a string
+     * right places. In JSON text, a string
      * cannot contain a control character or an unescaped quote or backslash.
+     *
      * @param string A String
-     * @return  A String correctly formatted for insertion in a JSON text.
+     * @return A String correctly formatted for insertion in a JSON text.
      */
     public static String quote(String string) {
         StringWriter sw = new StringWriter();
         synchronized (sw.getBuffer()) {
             try {
                 return quote(string, sw).toString();
-            } catch (IOException ignored) {
-                // will never happen - we are writing to a string writer
+            } catch (IOException e) {
+                intlogger.trace("Ignore Exception message: ", e);
                 return "";
             }
         }
     }
 
-    public static Writer quote(String string, Writer w) throws IOException {
+    /**
+     * Writer method.
+     * @param string string
+     * @param writer writer
+     * @return A writer
+     * @throws IOException input/output exception
+     */
+    public static Writer quote(String string, Writer writer) throws IOException {
         if (string == null || string.length() == 0) {
-            w.write("\"\"");
-            return w;
+            writer.write("\"\"");
+            return writer;
         }
 
-        char b;
-        char c = 0;
+        char char1;
+        char char2 = 0;
         String hhhh;
-        int i;
         int len = string.length();
 
-        w.write('"');
-        for (i = 0; i < len; i += 1) {
-            b = c;
-            c = string.charAt(i);
-            switch (c) {
-            case '\\':
-            case '"':
-                w.write('\\');
-                w.write(c);
-                break;
-            case '/':
-                if (b == '<') {
-                    w.write('\\');
-                }
-                w.write(c);
-                break;
-            case '\b':
-                w.write("\\b");
-                break;
-            case '\t':
-                w.write("\\t");
-                break;
-            case '\n':
-                w.write("\\n");
-                break;
-            case '\f':
-                w.write("\\f");
-                break;
-            case '\r':
-                w.write("\\r");
-                break;
-            default:
-                if (c < ' ' || (c >= '\u0080' && c < '\u00a0')
-                        || (c >= '\u2000' && c < '\u2100')) {
-                    w.write("\\u");
-                    hhhh = Integer.toHexString(c);
-                    w.write("0000", 0, 4 - hhhh.length());
-                    w.write(hhhh);
-                } else {
-                    w.write(c);
-                }
+        writer.write('"');
+        for (int i = 0; i < len; i += 1) {
+            char1 = char2;
+            char2 = string.charAt(i);
+            switch (char2) {
+                case '\\':
+                case '"':
+                    writer.write('\\');
+                    writer.write(char2);
+                    break;
+                case '/':
+                    if (char1 == '<') {
+                        writer.write('\\');
+                    }
+                    writer.write(char2);
+                    break;
+                case '\b':
+                    writer.write("\\b");
+                    break;
+                case '\t':
+                    writer.write("\\t");
+                    break;
+                case '\n':
+                    writer.write("\\n");
+                    break;
+                case '\f':
+                    writer.write("\\f");
+                    break;
+                case '\r':
+                    writer.write("\\r");
+                    break;
+                default:
+                    if (char2 < ' ' || (char2 >= '\u0080' && char2 < '\u00a0')
+                        || (char2 >= '\u2000' && char2 < '\u2100')) {
+                        writer.write("\\u");
+                        hhhh = Integer.toHexString(char2);
+                        writer.write("0000", 0, 4 - hhhh.length());
+                        writer.write(hhhh);
+                    } else {
+                        writer.write(char2);
+                    }
             }
         }
-        w.write('"');
-        return w;
+        writer.write('"');
+        return writer;
     }
 
     /**
      * 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.
@@ -1279,21 +1041,22 @@ public class LOGJSONObject {
     /**
      * Try to convert a string into a number, boolean, or null. If the string
      * can't be converted, return the string.
+     *
      * @param string A String.
      * @return A simple JSON value.
      */
     public static Object stringToValue(String string) {
-        Double d;
-        if (string.equals("")) {
+        Double dub;
+        if ("".equals(string)) {
             return string;
         }
-        if (string.equalsIgnoreCase("true")) {
+        if ("true".equalsIgnoreCase(string)) {
             return Boolean.TRUE;
         }
-        if (string.equalsIgnoreCase("false")) {
+        if ("false".equalsIgnoreCase(string)) {
             return Boolean.FALSE;
         }
-        if (string.equalsIgnoreCase("null")) {
+        if ("null".equalsIgnoreCase(string)) {
             return LOGJSONObject.NULL;
         }
 
@@ -1305,61 +1068,60 @@ public class LOGJSONObject {
          * non-JSON forms as long as it accepts all correct JSON forms.
          */
 
-        char b = string.charAt(0);
-        if ((b >= '0' && b <= '9') || b == '.' || b == '-' || b == '+') {
+        char chr = string.charAt(0);
+        if ((chr >= '0' && chr <= '9') || chr == '.' || chr == '-' || chr == '+') {
             try {
-                if (string.indexOf('.') > -1 ||
-                        string.indexOf('e') > -1 || string.indexOf('E') > -1) {
-                    d = Double.valueOf(string);
-                    if (!d.isInfinite() && !d.isNaN()) {
-                        return d;
+                if (string.indexOf('.') > -1 || string.indexOf('e') > -1
+                    || string.indexOf('E') > -1) {
+                    dub = Double.valueOf(string);
+                    if (!dub.isInfinite() && !dub.isNaN()) {
+                        return dub;
                     }
                 } else {
                     Long myLong = new Long(string);
-                    if (myLong.longValue() == myLong.intValue()) {
-                        return new Integer(myLong.intValue());
+                    if (myLong == myLong.intValue()) {
+                        return myLong.intValue();
                     } else {
                         return myLong;
                     }
                 }
-            }  catch (Exception ignore) {
+            } catch (Exception e) {
+                intlogger.trace("Ignore Exception message: ", e);
             }
         }
         return string;
     }
 
-
     /**
      * Throw an exception if the object is a NaN or infinite number.
-     * @param o The object to test.
+     *
+     * @param obj The object to test.
      * @throws JSONException If o is a non-finite number.
      */
-    public static void testValidity(Object o) throws JSONException {
-        if (o != null) {
-            if (o instanceof Double) {
-                if (((Double)o).isInfinite() || ((Double)o).isNaN()) {
-                    throw new JSONException(
-                        "JSON does not allow non-finite numbers.");
-                }
-            } else if (o instanceof Float) {
-                if (((Float)o).isInfinite() || ((Float)o).isNaN()) {
+    public static void testValidity(Object obj) {
+        if (obj != null) {
+            if (obj instanceof Double) {
+                if (((Double) obj).isInfinite() || ((Double) obj).isNaN()) {
                     throw new JSONException(
                         "JSON does not allow non-finite numbers.");
                 }
+            } else if (obj instanceof Float && (((Float) obj).isInfinite() || ((Float) obj).isNaN())) {
+                throw new JSONException(
+                    "JSON does not allow non-finite numbers.");
             }
         }
     }
 
-
     /**
      * 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.
+     *              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) throws JSONException {
+    public JSONArray toJSONArray(JSONArray names) {
         if (names == null || names.length() == 0) {
             return null;
         }
@@ -1374,39 +1136,40 @@ public class LOGJSONObject {
      * 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.
+     *
+     * <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>&nbsp;<small>(left brace)</small> and ending
-     *  with <code>}</code>&nbsp;<small>(right brace)</small>.
+     * representation of the object, beginning
+     * with <code>{</code>&nbsp;<small>(left brace)</small> and ending
+     * with <code>}</code>&nbsp;<small>(right brace)</small>.
      */
     public String toString() {
         try {
             return this.toString(0);
         } catch (Exception e) {
-            return null;
+            intlogger.trace("Exception: ", e);
+            return "";
         }
     }
 
-
     /**
      * Make a prettyprinted JSON text of this JSONObject.
-     * <p>
-     * Warning: This method assumes that the data structure is acyclical.
+     *
+     * <p>* Warning: This method assumes that the data structure is acyclical.
+     *
      * @param indentFactor The number of spaces to add to each level of
-     *  indentation.
+     *                     indentation.
      * @return a printable, displayable, portable, transmittable
-     *  representation of the object, beginning
-     *  with <code>{</code>&nbsp;<small>(left brace)</small> and ending
-     *  with <code>}</code>&nbsp;<small>(right brace)</small>.
+     * representation of the object, beginning
+     * with <code>{</code>&nbsp;<small>(left brace)</small> and ending
+     * with <code>}</code>&nbsp;<small>(right brace)</small>.
      * @throws JSONException If the object contains an invalid number.
      */
-    public String toString(int indentFactor) throws JSONException {
-        StringWriter w = new StringWriter();
-        synchronized (w.getBuffer()) {
-            return this.write(w, indentFactor, 0).toString();
+    public String toString(int indentFactor) {
+        StringWriter writer = new StringWriter();
+        synchronized (writer.getBuffer()) {
+            return this.write(writer, indentFactor, 0).toString();
         }
     }
 
@@ -1422,44 +1185,44 @@ public class LOGJSONObject {
      * from it and its toJSONString method will be called. Otherwise, the
      * value's toString method will be called, and the result will be quoted.
      *
-     * <p>
-     * Warning: This method assumes that the data structure is acyclical.
+     * <p>* Warning: This method assumes that the data structure is acyclical.
+     *
      * @param value The value to be serialized.
      * @return a printable, displayable, transmittable
-     *  representation of the object, beginning
-     *  with <code>{</code>&nbsp;<small>(left brace)</small> and ending
-     *  with <code>}</code>&nbsp;<small>(right brace)</small>.
+     * representation of the object, beginning
+     * with <code>{</code>&nbsp;<small>(left brace)</small> and ending
+     * with <code>}</code>&nbsp;<small>(right brace)</small>.
      * @throws JSONException If the value is or contains an invalid number.
      */
     @SuppressWarnings("unchecked")
-	public static String valueToString(Object value) throws JSONException {
-        if (value == null || value.equals(null)) {
+    public static String valueToString(Object value) {
+        if (value == null) {
             return "null";
         }
         if (value instanceof JSONString) {
-            Object object;
+            String object;
             try {
-                object = ((JSONString)value).toJSONString();
+                object = ((JSONString) value).toJSONString();
             } catch (Exception e) {
                 throw new JSONException(e);
             }
-            if (object instanceof String) {
-                return (String)object;
+            if (object != null) {
+                return object;
             }
             throw new JSONException("Bad value from toJSONString: " + object);
         }
         if (value instanceof Number) {
             return numberToString((Number) value);
         }
-        if (value instanceof Boolean || value instanceof LOGJSONObject ||
-                value instanceof JSONArray) {
+        if (value instanceof Boolean || value instanceof LOGJSONObject
+            || value instanceof JSONArray) {
             return value.toString();
         }
         if (value instanceof Map) {
-            return new LOGJSONObject((Map<String, Object>)value).toString();
+            return new LOGJSONObject((Map<String, Object>) value).toString();
         }
         if (value instanceof Collection) {
-            return new JSONArray((Collection<Object>)value).toString();
+            return new JSONArray((Collection<Object>) value).toString();
         }
         if (value.getClass().isArray()) {
             return new JSONArray(value).toString();
@@ -1467,79 +1230,64 @@ public class LOGJSONObject {
         return quote(value.toString());
     }
 
-     /**
-      * Wrap an object, if necessary. If the object is null, return the NULL
-      * object. If it is an array or collection, wrap it in a JSONArray. If
-      * it is a map, wrap it in a JSONObject. If it is a standard property
-      * (Double, String, et al) then it is already wrapped. Otherwise, if it
-      * comes from one of the java packages, turn it into a string. And if
-      * it doesn't, try to wrap it in a JSONObject. If the wrapping fails,
-      * then null is returned.
-      *
-      * @param object The object to wrap
-      * @return The wrapped value
-      */
-     @SuppressWarnings("unchecked")
-	public static Object wrap(Object object) {
-         try {
-             if (object == null) {
-                 return NULL;
-             }
-             if (object instanceof LOGJSONObject || object instanceof JSONArray  ||
-                     NULL.equals(object)      || object instanceof JSONString ||
-                     object instanceof Byte   || object instanceof Character  ||
-                     object instanceof Short  || object instanceof Integer    ||
-                     object instanceof Long   || object instanceof Boolean    ||
-                     object instanceof Float  || object instanceof Double     ||
-                     object instanceof String) {
-                 return object;
-             }
-
-             if (object instanceof Collection) {
-                 return new JSONArray((Collection<Object>)object);
-             }
-             if (object.getClass().isArray()) {
-                 return new JSONArray(object);
-             }
-             if (object instanceof Map) {
-                 return new LOGJSONObject((Map<String, Object>)object);
-             }
-             Package objectPackage = object.getClass().getPackage();
-             String objectPackageName = objectPackage != null
-                 ? objectPackage.getName()
-                 : "";
-             if (
-                 objectPackageName.startsWith("java.") ||
-                 objectPackageName.startsWith("javax.") ||
-                 object.getClass().getClassLoader() == null
-             ) {
-                 return object.toString();
-             }
-             return new LOGJSONObject(object);
-         } catch(Exception exception) {
-             return null;
-         }
-     }
-
-
-     /**
-      * 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
-      */
-     public Writer write(Writer writer) throws JSONException {
-        return this.write(writer, 0, 0);
-    }
+    /**
+     * Wrap an object, if necessary. If the object is null, return the NULL
+     * object. If it is an array or collection, wrap it in a JSONArray. If
+     * it is a map, wrap it in a JSONObject. If it is a standard property
+     * (Double, String, et al) then it is already wrapped. Otherwise, if it
+     * comes from one of the java packages, turn it into a string. And if
+     * it doesn't, try to wrap it in a JSONObject. If the wrapping fails,
+     * then null is returned.
+     *
+     * @param object The object to wrap
+     * @return The wrapped value
+     */
+    @SuppressWarnings("unchecked")
+    public static Object wrap(Object object) {
+        try {
+            if (object == null) {
+                return NULL;
+            }
+            if (object instanceof LOGJSONObject || object instanceof JSONArray
+                || NULL.equals(object) || object instanceof JSONString
+                || object instanceof Byte || object instanceof Character
+                || object instanceof Short || object instanceof Integer
+                || object instanceof Long || object instanceof Boolean
+                || object instanceof Float || object instanceof Double
+                || object instanceof String) {
+                return object;
+            }
 
+            if (object instanceof Collection) {
+                return new JSONArray((Collection<Object>) object);
+            }
+            if (object.getClass().isArray()) {
+                return new JSONArray(object);
+            }
+            if (object instanceof Map) {
+                return new LOGJSONObject((Map<String, Object>) object);
+            }
+            Package objectPackage = object.getClass().getPackage();
+            String objectPackageName = objectPackage != null
+                ? objectPackage.getName()
+                : "";
+            if (
+                objectPackageName.startsWith("java.")
+                    || objectPackageName.startsWith("javax.")
+                    || object.getClass().getClassLoader() == null
+            ) {
+                return object.toString();
+            }
+            return new LOGJSONObject(object);
+        } catch (Exception exception) {
+            intlogger.trace("Exception: ", exception);
+            return null;
+        }
+    }
 
     @SuppressWarnings("unchecked")
-	static final Writer writeValue(Writer writer, Object value,
-            int indentFactor, int indent) throws JSONException, IOException {
-        if (value == null || value.equals(null)) {
+    static Writer writeValue(Writer writer, Object value, int indentFactor, int indent) throws IOException {
+        if (value == null) {
             writer.write("null");
         } else if (value instanceof LOGJSONObject) {
             ((LOGJSONObject) value).write(writer, indentFactor, indent);
@@ -1548,8 +1296,7 @@ public class LOGJSONObject {
         } else if (value instanceof Map) {
             new LOGJSONObject((Map<String, Object>) value).write(writer, indentFactor, indent);
         } else if (value instanceof Collection) {
-            new JSONArray((Collection<Object>) value).write(writer, indentFactor,
-                    indent);
+            new JSONArray((Collection<Object>) value).write(writer, indentFactor, indent);
         } else if (value.getClass().isArray()) {
             new JSONArray(value).write(writer, indentFactor, indent);
         } else if (value instanceof Number) {
@@ -1557,20 +1304,20 @@ public class LOGJSONObject {
         } else if (value instanceof Boolean) {
             writer.write(value.toString());
         } else if (value instanceof JSONString) {
-            Object o;
+            Object obj;
             try {
-                o = ((JSONString) value).toJSONString();
+                obj = ((JSONString) value).toJSONString();
             } catch (Exception e) {
                 throw new JSONException(e);
             }
-            writer.write(o != null ? o.toString() : quote(value.toString()));
+            writer.write(obj != null ? obj.toString() : quote(value.toString()));
         } else {
             quote(value.toString(), writer);
         }
         return writer;
     }
 
-    static final void indent(Writer writer, int indent) throws IOException {
+    private static void indent(Writer writer, int indent) throws IOException {
         for (int i = 0; i < indent; i += 1) {
             writer.write(' ');
         }
@@ -1579,14 +1326,13 @@ public class LOGJSONObject {
     /**
      * 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.
+     *
+     * <p>* Warning: This method assumes that the data structure is acyclical.
      *
      * @return The writer.
-     * @throws JSONException
+     * @throws JSONException JSON exception
      */
-    Writer write(Writer writer, int indentFactor, int indent)
-            throws JSONException {
+    Writer write(Writer writer, int indentFactor, int indent) {
         try {
             boolean commanate = false;
             final int length = this.length();
@@ -1604,7 +1350,6 @@ public class LOGJSONObject {
             } else if (length != 0) {
                 final int newindent = indent + indentFactor;
                 while (keys.hasNext()) {
-                    Object key = keys.next();
                     if (commanate) {
                         writer.write(',');
                     }
@@ -1612,13 +1357,14 @@ public class LOGJSONObject {
                         writer.write('\n');
                     }
                     indent(writer, newindent);
+                    Object key = keys.next();
                     writer.write(quote(key.toString()));
                     writer.write(':');
                     if (indentFactor > 0) {
                         writer.write(' ');
                     }
                     writeValue(writer, this.map.get(key), indentFactor,
-                            newindent);
+                        newindent);
                     commanate = true;
                 }
                 if (indentFactor > 0) {
@@ -1631,5 +1377,5 @@ public class LOGJSONObject {
         } catch (IOException exception) {
             throw new JSONException(exception);
         }
-     }
+    }
 }