package com.smtscript.utils;
/*
 * Copyright (C) 2011 Miami-Dade County.
 *
 * 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.
 * 
 * Note: this file incorporates source code from 3d party entities. Such code 
 * is copyrighted by those entities as indicated below.
 */

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.text.CharacterIterator;
import java.text.StringCharacterIterator;
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.Map.Entry;
import java.util.Properties;
import java.util.Set;
import java.util.UUID;
import java.util.regex.Matcher;
import java.util.regex.Pattern;



/**
 * 
 * <p>
 * Represents a JSON (JavaScript Object Notation) entity. For more information about JSON, please see
 * <a href="http://www.json.org" target="_">http://www.json.org</a>.  
 * </p>
 *
 * <p>
 * A JSON entity can be one of several things: an object (set of name/Json entity pairs), an array (a list of
 * other JSON entities), a string, a number, a boolean or null. All of those are represented as <code>Json</code>
 * instances. Each of the different types of entities supports a different set of operations. However, this class
 * unifies all operations into a single interface so in Java one is always dealing with a single object type: this class. 
 * The approach effectively amounts to dynamic typing where using an unsupported operation won't be detected at
 * compile time, but will throw a runtime {@link UnsupportedOperationException}. It simplifies working with JSON
 * structures considerably and it leads to shorter at cleaner Java code. It makes much easier to work
 * with JSON structure without the need to convert to "proper" Java representation in the form of
 * POJOs and the like. When traversing a JSON, there's no need to type-cast at each step because there's
 * only one type: <code>Json</code>.   
 * </p>
 * 
 * <p>
 * One can examine the concrete type of a <code>Json</code> with one of the <code>isXXX</code> methods: 
 * {@link #isObject()}, {@link #isArray()},{@link #isNumber()},{@link #isBoolean()},{@link #isString()},
 * {@link #isNull()}.
 * </p>
 * 
 * <p>
 * The underlying representation of a given <code>Json</code> instance can be obtained by calling
 * the generic {@link #getValue()} method or one of the <code>asXXX</code> methods such 
 * as {@link #asBoolean()} or {@link #asString()} etc. 
 * JSON objects are represented as Java {@link Map}s while JSON arrays are represented as Java
 * {@link List}s. Because those are mutable aggregate structures, there are two versions of the 
 * corresponding <code>asXXX</code> methods: {@link #asMap()} which performs a deep copy of the underlying
 * map, unwrapping every nested Json entity to its Java representation and {@link #asJsonMap()} which
 * simply return the map reference. Similarly there are {@link #asList()} and {@link #asJsonList()}. 
 * </p>
 * 
 * <h3>Constructing and Modifying JSON Structures</h3>
 * 
 * <p>
 * There are several static factory methods in this class that allow you to create new
 * <code>Json</code> instances:
 * </p>
 *  
 * <table>
 * <tr><td>{@link #read(String)}</td>
 * <td>Parse a JSON string and return the resulting <code>Json</code> instance. The syntax
 * recognized is as defined in <a href="http://www.json.org">http://www.json.org</a>.
 * </td> 
 * </tr>
 * <tr><td>{@link #make(Object)}</td>
 * <td>Creates a Json instance based on the concrete type of the parameter. The types
 * recognized are null, numbers, primitives, String, Map, Collection, Java arrays
 * and <code>Json</code> itself.</td>
 * </tr>
 * <tr><td>{@link #nil()}</td>
 * <td>Return a <code>Json</code> instance representing JSON <code>null</code>.</td>
 * </tr>
 * <tr><td>{@link #object()}</td>
 * <td>Create and return an empty JSON object.</td>
 * </tr>
 * <tr><td>{@link #object(Object...)}</td>
 * <td>Create and return a JSON object populated with the key/value pairs
 * passed as an argument sequence. Each even parameter becomes a key (via 
 * <code>toString</code>) and each odd parameter is converted to a <code>Json</code>
 * value.</td>
 * </tr>   
 * <tr><td>{@link #array()}</td>
 * <td>Create and return an empty JSON array.</td>
 * </tr> 
 * <tr><td>{@link #array(Object...)}</td>
 * <td>Create and return a JSON array from the list of arguments.</td>
 * </tr> 
 * </table>
 * 
 * <p>
 * To customize how Json elements are represented and to provide your own version of the
 * {@link #make(Object)} method, you create an implementation of the {@link Factory} interface
 * and configure it either globally with the {@link #setGlobalFactory(Factory)} method or
 * on a per-thread basis with the {@link #attachFactory(Factory)}/{@link #dettachFactory()} 
 * methods.
 * </p>
 * 
 * <p>
 * If a <code>Json</code> instance is an object, you can set its properties by
 * calling the {@link #set(String, Object)} method which will add a new property or replace an existing one.
 * Adding elements to an array <code>Json</code> is done with the {@link #add(Object)} method.
 * Removing elements by their index (or key) is done with the {@link #delAt(int)} (or
 * {@link #delAt(String)}) method. You can also remove an element from an array without
 * knowing its index with the {@link #remove(Object)} method. All these methods return the 
 * <code>Json</code> instance being manipulated so that method calls can be chained.
 * If you want to remove an element from an object or array and return the removed element
 * as a result of the operation, call {@link #atDel(int)} or {@link #atDel(String)} instead.  
 * </p>
 * 
 * <p>
 * If you want to add properties to an object in bulk or append a sequence of elements to array, 
 * use the {@link #with(Json)} method. When used on an object, this method expects another
 * object as its argument and it will copy all properties of that argument into itself. Similarly,
 * when called on array, the method expects another array and it will append all elements of its
 * argument to itself.
 * </p>
 * 
 * <p>
 * To make a clone of a Json object, use the {@link #dup()} method. This method will create a new 
 * object even for the immutable primitive Json types. Objects and arrays are cloned 
 * (i.e. duplicated) recursively.
 * </p>
 * 
 * <h3>Navigating JSON Structures</h3>
 * 
 * <p>
 * The {@link #at(int)} method returns the array element at the specified index and the
 * {@link #at(String)} method does the same for a property of an object instance. You can
 * use the {@link #at(String, Object)} version to create an object property with a default
 * value if it doesn't exist already.  
 * </p>
 * 
 * <p>
 * To test just whether a Json object has a given property, use the {@link #has(String)} method. To test
 * whether a given object property or an array elements is equal to a particular value, use the 
 * {@link #is(String, Object)} and {@link #is(int, Object)} methods respectively. Those methods return 
 * true if the given named property (or indexed element) is equal to the passed in Object as the second 
 * parameter. They return false if an object doesn't have the specified property or an index array is out 
 * of bounds. For example is(name, value) is equivalent to 'has(name) &amp;&amp; at(name).equals(make(value))'.
 * </p>
 * 
 * <p>
 * To help in navigating JSON structures, instances of this class contain a reference to the 
 * enclosing JSON entity (object or array) if any. The enclosing entity can be accessed 
 * with {@link #up()} method.
 * </p>
 * 
 * <p>
 * The combination of method chaining when modifying <code>Json</code> instances and
 * the ability to navigate "inside" a structure and then go back to the enclosing 
 * element lets one accomplish a lot in a single Java statement, without the need
 * of intermediary variables. Here for example how the following JSON structure can
 * be created in one statement using chained calls:
 * </p>
 * 
 * <pre><code>
 * {"menu": {
 * "id": "file",
 * "value": "File",
 * "popup": {
 *   "menuitem": [
 *     {"value": "New", "onclick": "CreateNewDoc()"},
 *     {"value": "Open", "onclick": "OpenDoc()"},
 *     {"value": "Close", "onclick": "CloseDoc()"}
 *   ]
 * }
 * "position": 0
 * }}
 * </code></pre>
 * 
 * <pre><code>
 * import mjson.Json;
 * import static mjson.Json.*;
 * ...
 * Json j = object()
 *  .at("menu", object())
 *    .set("id", "file") 
 *    .set("value", "File")
 *    .at("popup", object())
 *      .at("menuitem", array())
 *        .add(object("value", "New", "onclick", "CreateNewDoc()"))
 *        .add(object("value", "Open", "onclick", "OpenDoc()"))
 *        .add(object("value", "Close", "onclick", "CloseDoc()"))
 *        .up()
 *      .up()
 *    .set("position", 0)
 *  .up();       
 * ...
 * </code></pre>
 * 
 * <p>
 * If there's no danger of naming conflicts, a static import of the factory methods (<code>
 * import static json.Json.*;</code>) would reduce typing even further and make the code more
 * readable.
 * </p>
 *
 * <h3>Converting to String</h3>
 * 
 * <p>
 * To get a compact string representation, simply use the {@link #toString()} method. If you
 * want to wrap it in a JavaScript callback (for JSON with padding), use the {@link #pad(String)}
 * method.
 * </p>
 * 
 * @author Borislav Iordanov
 * @version 1.3
 */
public class Json
{
	public static String _jsonPathSplit = "|";
	
	/**
	 * <p>
	 * This interface defines how <code>Json</code> instances are constructed. There is a 
	 * default implementation for each kind of <code>Json</code> value, but you can provide
	 * your own implementation. For example, you might want a different representation of 
	 * an object than a regular <code>HashMap</code>. Or you might want string comparison to be
	 * case insensitive.
	 * </p>
	 *
	 * <p>
	 * In addition, the {@link #make(Object)} method allows you plug-in your own mapping
	 * of arbitrary Java objects to <code>Json</code> instances. You might want to implement
	 * a Java Beans to JSON mapping or any other JSON serialization that makes sense in your 
	 * project.
	 * </p>
	 * 
	 * <p>
	 * To avoid implementing all methods in that interface, you can extend the {@link DefaultFactory}
	 * default implementation and simply overwrite the ones you're interested in.
	 * </p>
	 * 
	 * <p>
	 * The factory implementation used by the <code>Json</code> classes is specified simply by calling
	 * the {@link #setGlobalFactory(Factory)} method. The factory is a static, global variable by default.
	 * If you need different factories in different areas of a single application, you may attach them
	 * to different threads of execution using the {@link #attachFactory(Factory)}. Recall a separate 
	 * copy of static variables is made per ClassLoader, so for example in a web application context, that
	 * global factory can be different for each web application (as Java web servers usually use a separate
	 * class loader per application). Thread-local factories are really a provision for special cases.
	 * </p>
	 * 
	 * @author Borislav Iordanov
	 *
	 */
    public static interface Factory 
    {
        Json nil();
        Json bool(boolean value);
        Json string(String value);
        Json number(Number value);
        Json object();
        Json array();
        Json make(Object anything);
    }
    
    public static class DefaultFactory implements Factory
    {
        public Json nil() { return Json.topnull; }
        public Json bool(boolean x) { return new BooleanJson(x ? Boolean.TRUE : Boolean.FALSE, null); }
        public Json string(String x) { return new StringJson(x, null); }
        public Json number(Number x) { return new NumberJson(x, null); }
        public Json array() { return new ArrayJson(); }
        public Json object() { return new ObjectJson(); }
        public Json make(Object anything) 
        { 
            if (anything == null)
                return topnull;
            else if (anything instanceof Json)
                return (Json)anything;
            else if (anything instanceof String)
                return factory().string((String)anything);
            else if (anything instanceof Collection<?>)
            {
                Json L = array();
                for (Object x : (Collection<?>)anything)
                    L.add(factory().make(x));
                return L;
            }
            else if (anything instanceof Map<?,?>)
            {
                Json O = object();
                for (Map.Entry<?,?> x : ((Map<?,?>)anything).entrySet())
                    O.set(x.getKey().toString(), factory().make(x.getValue()));
                return O;
            }
            else if (anything instanceof Boolean)
                return factory().bool((Boolean)anything);
            else if (anything instanceof Number)
                return factory().number((Number)anything);
            else if (anything.getClass().isArray())
            {
                Class<?> comp = anything.getClass().getComponentType();
                if (!comp.isPrimitive())
                    return Json.array((Object[])anything);
                Json A = array();
                if (boolean.class == comp)
                    for (boolean b : (boolean[])anything) A.add(b);
                else if (byte.class == comp)
                    for (byte b : (byte[])anything) A.add(b);
                else if (char.class == comp)
                    for (char b : (char[])anything) A.add(b);
                else if (short.class == comp)
                    for (short b : (short[])anything) A.add(b);
                else if (int.class == comp)
                    for (int b : (int[])anything) A.add(b);
                else if (long.class == comp)
                    for (long b : (long[])anything) A.add(b);
                else if (float.class == comp)
                    for (float b : (float[])anything) A.add(b);
                else if (double.class == comp)
                    for (double b : (double[])anything) A.add(b);
                return A;
            }
            else
                throw new IllegalArgumentException("Don't know how to convert to Json : " + anything);
        }  
    }
    
    public static final Factory defaultFactory = new DefaultFactory();
    
    private static Factory globalFactory = defaultFactory;
    
    // TODO1: maybe use initialValue thread-local method to attach global factory by default here... 
    private static ThreadLocal<Factory> threadFactory = new ThreadLocal<Factory>();
    
    public static Factory factory() 
    {
    	Factory f = threadFactory.get();
    	return f != null ? f : globalFactory;
    }
    
    /**
     * <p>
     * Specify a global Json {@link Factory} to be used by all threads that don't have a
     * specific thread-local factory attached to them. 
     * </p>
     * 
     * @param factory
     */
    public static void setGlobalFactory(Factory factory) { globalFactory = factory; }
    
    /**
     * <p>
     * Attach a thread-local Json {@link Factory} to be used specifically by this thread. Thread-local
     * Json factories are the only means to have different {@link Factory} implementations used simultaneously
     * in the same application (well, more accurately, the same ClassLoader). 
     * </p>
     * 
     * @param factory
     */
    public static void attachFactory(Factory factory) { threadFactory.set(factory); }
    
    /**
     * <p>
     * Clear the thread-local factory previously attached to this thread via the 
     * {@link #attachFactory(Factory)} method. The global factory takes effect after
     * a call to this method.
     * </p>
     */
    public static void dettachFactory() { threadFactory.remove(); }
    
	/**
	 * <p>
	 * Parse a JSON entity from its string representation. 
	 * </p>
	 * 
	 * @param jsonAsString A valid JSON representation as per the <a href="http://www.json.org">json.org</a>
	 * grammar. Cannot be <code>null</code>.
	 * @return The JSON entity parsed: an object, array, string, number or boolean, or null. Note that
	 * this method will never return the actual Java <code>null</code>.
	 * @ 
	 */
	public static Json read(String jsonAsString, IJsonParseExt propReader) throws RuntimeException {
		Reader rd = new Reader();
		return (Json)rd.read(jsonAsString, propReader);
	}
	
	public static Json read(InputStream stream) throws RuntimeException {
		Reader rd = new Reader();
		return (Json)rd.read(readJsonStream(stream), null);
	}
	
	public static Json read(String jsonAsString)
	{
		return read(jsonAsString, false);
	}
	
	public static Json read(String jsonAsString, boolean convert) throws RuntimeException {
		Reader rd = new Reader();
		return (Json)rd.read(convert ? convToJsonString(jsonAsString) : jsonAsString, null);
	}
	
	public static Json read(File file) 
	{
		return read(file, null, null);
	}
	
	public static Json read(File file, IJsonParseExt propReader, String[] defineMap) 
	{
		Reader rd = new Reader();
		if(defineMap != null && defineMap.length > 0)
			rd.importDefineMap(defineMap);
		return (Json)rd.read(file, propReader);
	}
	
	private static String readTextStream(InputStream inputStream)
	{
		InputStreamReader rd = null;
		
		try
		{
			StringBuilder sb = new StringBuilder();
			int size = 0;
			char[] data = new char[10240];
			rd=new InputStreamReader(inputStream, "UTF-8");
			while((size = rd.read(data)) > 0)
			{
				sb.append(data, 0, size);
			}
			return sb.toString();
		}
		catch(Exception ex)
		{
			throw new RuntimeException(ex);
		}
		finally
		{
			if(rd != null)
				try {
					rd.close();
				} catch (IOException e) {
				}
		}
	}

	
	public static String readJsonFile(File file) 
	{
		try
		{
			FileInputStream fi = new FileInputStream(file);
			try
			{
				return convToJsonString(readTextStream(fi));
			}
			finally
			{
				fi.close();
			}
		}
		catch(Exception ex)
		{
			throw new RuntimeException(String.format("read json file [%s] error", file.getAbsolutePath()), ex);
		}
	}

	public static String readTextFile(File file) 
	{
		try
		{
			FileInputStream fi = new FileInputStream(file);
			try
			{
				return readTextStream(fi).replace("\r", "");
			}
			finally
			{
				fi.close();
			}
		}
		catch(Exception ex)
		{
			throw new RuntimeException(String.format("read json file [%s] error", file.getAbsolutePath()), ex);
		}
	}
	
	public static String readJsonStream(InputStream inputStream) 
	{
		return convToJsonString(readTextStream(inputStream));
	}
	
	public static String splitJsonMapString(String jsonStr)
	{
		for(int pos = 0; pos < jsonStr.length(); pos ++)
		{
			if(jsonStr.charAt(pos) == '{')
			{
				jsonStr = jsonStr.substring(pos + 1);
				break;
			}
		}
		
		for(int pos = jsonStr.length() - 1; pos >= 0; pos --)
		{
			if(jsonStr.charAt(pos) == '}')
			{
				jsonStr = jsonStr.substring(0, pos);
				break;
			}
		}
		
		return jsonStr;
	}
	
	private static String convToJsonString(String jsonStr)
	{
		while(jsonStr.length() > 0 && jsonStr.charAt(0) >= 128)
			jsonStr = jsonStr.substring(1);
		
		for(int i = 0; i < jsonStr.length(); i ++)
		{
			char ch = jsonStr.charAt(i);
			if(ch == '[' || ch == '{' || ch =='\r' || ch == '\n')
			{
				jsonStr = jsonStr.substring(i);
				break;
			}
			if(ch == '=')
			{
				jsonStr = jsonStr.substring(i + 1);
				break;
			}
		}
		
		return jsonStr.replace("\r", "");
	}

	
	/**
	 * <p>
	 * Parse a JSON entity from a {@link CharacterIterator}. 
	 * </p>
	 * @see #read(String)
	 */
	public static Json read(JsonCharacterIterator it) { return (Json)new Reader().read(it); }
	/**
	 * <p>Return the <code>null Json</code> instance.</p> 
	 */
	public static Json nil() { return factory().nil(); }	
	/**
	 * <p>Return a newly constructed, empty JSON object.</p>
	 */
	public static Json object()	{ return factory().object();	}
	/**
	 * <p>Return a new JSON object initialized from the passed list of
	 * name/value pairs. The number of arguments must
	 * be even. Each argument at an even position is taken to be a name
	 * for the following value. The name arguments are normally of type
	 * Java String, but they can be of any other type having an appropriate
	 * <code>toString</code> method. Each value is first converted
	 * to a <code>Json</code> instance using the {@link #make(Object)} method.
	 * </p>
	 * @param args A sequence of name value pairs.   
	 */
	public static Json object(Object...args)
	{
		Json j = object();
		if (args.length % 2 != 0)
			throw new IllegalArgumentException("An even number of arguments is expected.");
		for (int i = 0; i < args.length; i++)
			j.set(args[i].toString(), factory().make(args[++i]));
		return j;
	}
	
	/**
	 * <p>Return a new constructed, empty JSON array.</p>
	 */
	public static Json array() { return factory().array(); }
	
	/**
	 * <p>Return a new JSON array filled up with the list of arguments.</p>
	 *  
	 * @param args The initial content of the array. 
	 */
	public static Json array(Object...args) 
	{
		Json A = array();
		for (Object x : args)
			A.add(factory().make(x));
		return A;
	}
	
	/**
	 * <p>
	 * Convert an arbitrary Java instance to a {@link Json} instance.   
	 * </p>
	 * 
	 * <p>
	 * Maps, Collections and arrays are recursively copied where each of 
	 * their elements concerted into <code>Json</code> instances as well. The keys
	 * of a {@link Map} parameter are normally strings, but anything with a meaningful
	 * <code>toString</code> implementation will work as well. 
	 * </p>
	 * 
	 * @param anything
	 * @return The <code>Json</code>. This method will never return <code>null</code>. It will
	 * throw an {@link IllegalArgumentException} if it doesn't know how to convert the argument
	 * to a <code>Json</code> instance.
	 * @throws IllegalArgumentException when the concrete type of the parameter is
	 * unknown.
	 */
	public static Json make(Object anything) 
	{
	    return factory().make(anything);
	}
		
	// end of static utility method section

	Json enclosing = null;
	
	protected Json() { }
	protected Json(Json enclosing) { this.enclosing = enclosing; }
	
	protected Json getLinkOneTail(Json jsonRoot)
	{
		return this;
	}

	public Map<String,Json> safeGetJsonMap(String key)
	{
		if(!this.has(key))
			return null;
		
		return at(key).asJsonMap();
	}

	public List<Json> safeGetJsonList(String key)
	{
		if(!this.has(key))
			return null;
		
		return at(key).asJsonList();
	}
	
	public Json safeGetJson(String key)
	{
		return at(key);
	}
	
	public Json getJsonPath(String path, boolean skipNFind) throws RuntimeException
	{
		try
		{
			Json jsonRoot = this; 
			
			String[] spPath = path.split(_jsonPathSplit.replace("\\", "\\\\").replace("|", "\\|"));
			for(int i = 0; i < spPath.length; i ++)
			{
				String subPath = spPath[i];
				if(subPath.length() == 0)
					continue;
				if(subPath.charAt(0) == '#')
				{
					int index = Integer.parseInt(subPath.substring(1));
					if(skipNFind && index >= jsonRoot.asJsonList().size())
						return null;
					jsonRoot = jsonRoot.at(index);
				}
				else
				{
					if(skipNFind && !jsonRoot.has(spPath[i]))
						return null;
					jsonRoot = jsonRoot.getJson(spPath[i]);
				}
			}
			
			return jsonRoot;
		}
		catch(Exception ex)
		{
			throw new RuntimeException(String.format("get json path [%s] error:[%s]", path, this.toString()), ex);
		}
	}
	
	public Json getJsonDefault(String key) throws RuntimeException
	{
		if(this.has(key))
			return this.at(key);

		return this.getJson("*default*");
	}
	
	public Json getJson(String key)
	{
		Json jsonRet = at(key);
		if(jsonRet == null)
			throw new RuntimeException(String.format("can't find json key [%s] for [%s]", key, this.toString()));
		return jsonRet;
	}

	
	public String safeGetStr(String key, String defValue)
	{
		if(!this.has(key))
			return defValue;
		
		return at(key).asString();
	}

	public int safeGetInt(String key, int defValue)
	{
		if(!this.has(key))
			return defValue;
		
		return at(key).asInteger();
	}

	public boolean safeGetBoolean(String key, boolean defValue)
	{
		if(!this.has(key))
			return defValue;
		
		return at(key).asBoolean();
	}
	
	/**
	 * <p>Explicitly set the parent of this element. The parent is presumably an array
	 * or an object. Normally, there's no need to call this method as the parent is
	 * automatically set by the framework. You may need to call it however, if you implement
	 * your own {@link Factory} with your own implementations of the Json types.
	 * </p>
	 *  
	 * @param enclosing The parent element.
	 */
	public void attachTo(Json enclosing) { this.enclosing = enclosing; }
	
	/**
	 * <p>Return the <code>Json</code> entity, if any, enclosing this 
	 * <code>Json</code>. The returned value can be <code>null</code> or
	 * a <code>Json</code> object or list, but not one of the primitive types.</p>
	 */
	public final Json up() { return enclosing; }
	
	/**
	 * <p>Return a clone (a duplicate) of this <code>Json</code> entity. Note that cloning
	 * is deep if array and objects. Primitives are also cloned, even though their values are immutable
	 * because the new enclosing entity (the result of the {@link #up()} method) may be different.
	 * since they are immutable.</p>
	 */
	public Json dup() { return this; }
	
	/**
	 * <p>Return the <code>Json</code> element at the specified index of this
	 * <code>Json</code> array. This method applies only to Json arrays.
	 * </p>
	 * 
	 * @param index The index of the desired element.
	 */
	public Json at(int index) { throw new UnsupportedOperationException(); }
	
	/**
	 * <p>
	 * Return the specified property of a <code>Json</code> object or <code>null</code>
	 * if there's no such property. This method applies only to Json objects.  
	 * </p>
	 */
	public Json at(String property)	{ throw new UnsupportedOperationException(); }
	
	/**
	 * <p>
	 * Return the specified property of a <code>Json</code> object if it exists.
	 * If it doesn't, then create a new property with value the <code>def</code> 
	 * parameter and return that parameter. 
	 * </p>
	 * 
	 * @param property The property to return.
	 * @param def The default value to set and return in case the property doesn't exist.
	 */
	public final Json at(String property, Json def)	
	{
		Json x = at(property);
		if (x == null)
		{
			set(property, def);
			return def;
		}
		else
			return x; 
	}	
	
	/**
	 * <p>
	 * Return the specified property of a <code>Json</code> object if it exists.
	 * If it doesn't, then create a new property with value the <code>def</code> 
	 * parameter and return that parameter. 
	 * </p>
	 * 
	 * @param property The property to return.
	 * @param def The default value to set and return in case the property doesn't exist.
	 */
	public final Json at(String property, Object def)
	{
		return at(property, make(def));
	}
	
	/**
	 * <p>
	 * Return true if this <code>Json</code> object has the specified property
	 * and false otherwise. 
	 * </p>
	 * 
	 * @param property The name of the property.
	 */
	public boolean has(String property)	{ throw new UnsupportedOperationException(); }
	
	/**
	 * <p>
	 * Return <code>true</code> if and only if this <code>Json</code> object has a property with
	 * the specified value. In particular, if the object has no such property <code>false</code> is returned. 
	 * </p>
	 * 
	 * @param property The property name.
	 * @param value The value to compare with. Comparison is done via the equals method. 
	 * If the value is not an instance of <code>Json</code>, it is first converted to
	 * such an instance. 
	 * @return
	 */
	public boolean is(String property, Object value) { throw new UnsupportedOperationException(); }

    /**
     * <p>
     * Return <code>true</code> if and only if this <code>Json</code> array has an element with
     * the specified value at the specified index. In particular, if the array has no element at
     * this index, <code>false</code> is returned. 
     * </p>
     * 
     * @param property The property name.
     * @param value The value to compare with. Comparison is done via the equals method. 
     * If the value is not an instance of <code>Json</code>, it is first converted to
     * such an instance. 
     * @return
     */
    public boolean is(int index, Object value) { throw new UnsupportedOperationException(); }
	
	/**
	 * <p>
	 * Add the specified <code>Json</code> element to this array. 
	 * </p>
	 * 
	 * @return this
	 */
	public Json add(Json el) { throw new UnsupportedOperationException(); }
	
	/**
	 * <p>
	 * Add an arbitrary Java object to this <code>Json</code> array. The object
	 * is first converted to a <code>Json</code> instance by calling the static
	 * {@link #make} method.
	 * </p>
	 * 
	 * @param anything Any Java object that can be converted to a Json instance.
	 * @return this
	 */
	public final Json add(Object anything) { return add(make(anything)); }
	
	/**
	 * <p>
	 * Remove the specified property from a <code>Json</code> object and return
	 * that property.
	 * </p>
	 * 
	 * @param property The property to be removed.
	 * @return The property value or <code>null</code> if the object didn't have such
	 * a property to begin with.
	 */
	public Json atDel(String property)	{ throw new UnsupportedOperationException(); }

	/**
	 * <p>
	 * Remove the element at the specified index from a <code>Json</code> array and return
	 * that element.
	 * </p>
	 * 
	 * @param index The index of the element to delete.
	 * @return The element value.
	 */
	public Json atDel(int index)	{ throw new UnsupportedOperationException(); }
	
	/**
	 * <p>
	 * Delete the specified property from a <code>Json</code> object.
	 * </p>
	 * 
	 * @param property The property to be removed.
	 * @return this
	 */
	public Json delAt(String property)	{ throw new UnsupportedOperationException(); }
	
	/**
	 * <p>
	 * Remove the element at the specified index from a <code>Json</code> array.
	 * </p>
	 * 
	 * @param index The index of the element to delete.
	 * @return this
	 */
	public Json delAt(int index) { throw new UnsupportedOperationException(); }
	
	/**
	 * <p>
	 * Remove the specified element from a <code>Json</code> array.
	 * </p>
	 * 
	 * @param el The element to delete.
	 * @return this
	 */
	public Json remove(Json el)	{ throw new UnsupportedOperationException(); }
	
	/**
	 * <p>
	 * Remove the specified Java object (converted to a Json instance) 
	 * from a <code>Json</code> array. This is equivalent to 
	 * <code>remove({@link #make(anything)})</code>.
	 * </p>
	 * 
	 * @param anything The object to delete.
	 * @return this
	 */
	public final Json remove(Object anything) { return remove(make(anything)); }
	
	/**
	 * <p>
	 * Set a <code>Json</code> objects's property.
	 * </p>
	 * 
	 * @param property The property name.
	 * @param value The value of the property.
	 * @return this
	 */
	public Json set(String property, Json value) { throw new UnsupportedOperationException();	}
	
	/**
	 * <p>
	 * Set a <code>Json</code> objects's property.
	 * </p>
	 * 
	 * @param property The property name.
	 * @param value The value of the property, converted to a <code>Json</code> representation
	 * with {@link #make}.
	 * @return this
	 */
	public final Json set(String property, Object value) { return set(property, make(value)); }
	
	/**
	 * <p>
	 * Combine this object or array with the passed in object or array. The types of 
	 * <code>this</code> and the <code>object</code> argument must match. If both are
	 * <code>Json</code> objects, all properties of the parameter are added to <code>this</code>.
	 * If both are arrays, all elements of the parameter are appended to <code>this</code> 
	 * </p>
	 * @param object The object or array whose properties or elements must be added to this
	 * Json object or array.
	 * @return this
	 */
	public Json with(Json object) { throw new UnsupportedOperationException(); }
	
	/**
	 * <p>Return the underlying value of this <code>Json</code> entity. The actual value will 
	 * be a Java Boolean, String, Number, Map, List or null. For complex entities (objects
	 * or arrays), the method will perform a deep copy and extra underlying values recursively 
	 * for all nested elements.</p>
	 */
	public Object getValue() { throw new UnsupportedOperationException(); }
	
	/**
	 * <p>Return the boolean value of a boolean <code>Json</code> instance. Call
	 * {@link #isBoolean()} first if you're not sure this instance is indeed a
	 * boolean.</p>
	 */
	public boolean asBoolean() { throw new UnsupportedOperationException(); }
	
	/**
	 * <p>Return the string value of a string <code>Json</code> instance. Call
	 * {@link #isString()} first if you're not sure this instance is indeed a
	 * string.</p>
	 */
	public String asString() { throw new UnsupportedOperationException(); }
	
	/**
	 * <p>Return the integer value of a number <code>Json</code> instance. Call
	 * {@link #isNumber()} first if you're not sure this instance is indeed a
	 * number.</p>
	 */
	public int asInteger() { throw new UnsupportedOperationException(); }

	/**
	 * <p>Return the float value of a float <code>Json</code> instance. Call
	 * {@link #isNumber()} first if you're not sure this instance is indeed a
	 * number.</p>
	 */
	public float asFloat() { throw new UnsupportedOperationException(); }

	/**
	 * <p>Return the double value of a number <code>Json</code> instance. Call
	 * {@link #isNumber()} first if you're not sure this instance is indeed a
	 * number.</p>
	 */
	public double asDouble() { throw new UnsupportedOperationException(); }

	/**
	 * <p>Return the long value of a number <code>Json</code> instance. Call
	 * {@link #isNumber()} first if you're not sure this instance is indeed a
	 * number.</p>
	 */
	public long asLong() { throw new UnsupportedOperationException(); }

	/**
	 * <p>Return the short value of a number <code>Json</code> instance. Call
	 * {@link #isNumber()} first if you're not sure this instance is indeed a
	 * number.</p>
	 */
	public short asShort() { throw new UnsupportedOperationException(); }

	/**
	 * <p>Return the byte value of a number <code>Json</code> instance. Call
	 * {@link #isNumber()} first if you're not sure this instance is indeed a
	 * number.</p>
	 */	
	public byte asByte() { throw new UnsupportedOperationException(); }

	/**
	 * <p>Return the first character of a string <code>Json</code> instance. Call
	 * {@link #isString()} first if you're not sure this instance is indeed a
	 * string.</p>
	 */	
	public char asChar() { throw new UnsupportedOperationException(); }		

	/**
	 * <p>Return a map of the properties of an object <code>Json</code> instance. The map
	 * is a clone of the object and can be modified safely without affecting it. Call
	 * {@link #isObject()} first if you're not sure this instance is indeed a
	 * <code>Json</code> object.</p>
	 */	
	public Map<String, Object> asMap() { throw new UnsupportedOperationException(); }
	
	/**
	 * <p>Return the underlying map of properties of a <code>Json</code> object. The returned
	 * map is the actual object representation so any modifications to it are modifications
	 * of the <code>Json</code> object itself. Call
	 * {@link #isObject()} first if you're not sure this instance is indeed a
	 * <code>Json</code> object.
	 * </p>
	 */
	public Map<String, Json> asJsonMap() { throw new UnsupportedOperationException(); }
	
	/**
	 * <p>Return a list of the elements of a <code>Json</code> array. The list is a clone
	 * of the array and can be modified safely without affecting it. Call
	 * {@link #isArray()} first if you're not sure this instance is indeed a
	 * <code>Json</code> array.
	 * </p>  
	 */
	public List<Object> asList()  { throw new UnsupportedOperationException(); }
	
	/**
	 * <p>Return the underlying {@link List} representation of a <code>Json</code> array.
	 * The returned list is the actual array representation so any modifications to it 
	 * are modifications of the <code>Json</code> array itself. Call
	 * {@link #isArray()} first if you're not sure this instance is indeed a
	 * <code>Json</code> array.
	 * </p>
	 */
	public List<Json> asJsonList() { throw new UnsupportedOperationException(); }

	/**
	 * <p>Return <code>true</code> if this is a <code>Json</code> null entity 
	 * and <code>false</code> otherwise.
	 * </p> 
	 */
	public boolean isNull() { return false; }
	/**
	 * <p>Return <code>true</code> if this is a <code>Json</code> string entity 
	 * and <code>false</code> otherwise.
	 * </p> 
	 */
	public boolean isString() { return false; }	
	/**
	 * <p>Return <code>true</code> if this is a <code>Json</code> number entity 
	 * and <code>false</code> otherwise.
	 * </p> 
	 */
	public boolean isNumber() { return false; }	
	/**
	 * <p>Return <code>true</code> if this is a <code>Json</code> boolean entity 
	 * and <code>false</code> otherwise.
	 * </p> 
	 */
	public boolean isBoolean() { return false;	}	
	/**
	 * <p>Return <code>true</code> if this is a <code>Json</code> array (i.e. list) entity 
	 * and <code>false</code> otherwise.
	 * </p> 
	 */
	public boolean isArray() { return false; }	
	/**
	 * <p>Return <code>true</code> if this is a <code>Json</code> object entity 
	 * and <code>false</code> otherwise.
	 * </p> 
	 */
	public boolean isObject(){ return false; }	
	/**
	 * <p>Return <code>true</code> if this is a <code>Json</code> primitive entity 
	 * (one of string, number or boolean) and <code>false</code> otherwise.
	 * </p> 
	 */
	public boolean isPrimitive() { return isString() || isNumber() || isBoolean(); }
	
	/**
	 * <p>
	 * Json-pad this object as an argument to a callback function.  
	 * </p>
	 * 
	 * @param callback The name of the callback function. Can be null or empty, 
	 * in which case no padding is done.
	 * @return The jsonpadded, stringified version of this object if the <code>callback</code>
	 * is not null or empty, or just the stringified version of the object. 
	 */
	public String pad(String callback)
	{
		return (callback != null && callback.length() > 0) 
			? callback + "(" + toString() + ");"
			: toString();		
	}
	
	//-------------------------------------------------------------------------
	// END OF PUBLIC INTERFACE
	//-------------------------------------------------------------------------
		
	static class NullJson extends Json
	{
		NullJson() {}
		NullJson(Json e) {super(e);}
		
		public Object getValue() { return null; }
		public Json dup() { return new NullJson(); }
		public boolean isNull() { return true; }
		public String toString() { return "null"; }
		public List<Object> asList() { return (List<Object>)Collections.singletonList(null); }
		
		public int hashCode() { return 0; }
		public boolean equals(Object x)
		{
			return x instanceof NullJson;
		}
	}
	
	static NullJson topnull = new NullJson();

    static abstract class WriteBackJson extends Json
    {
		protected String _link;
    	protected Json _parent;
    	protected Object _key;
		protected boolean _writed = false;
    	
		protected WriteBackJson(String link)
		{
			_link = link;
		}
		
    	protected abstract Json writeBack(Json rootJson, boolean throwDup);

    	protected void setWriteBackParent(Json parent, Object key)
    	{
    		_parent = parent; 
    		_key = key;
    	}
    	
    	protected boolean isDupWriteBack(boolean throwDup)
    	{
			if(_writed)
			{
				if(throwDup)
					throw new RuntimeException(String.format("dup writeBack for link [%s]", _link));
				else
					return true;
			}
			
    		_writed = true;
    		
    		return false;
    	}
    	
    	protected void repaceOneJson(Json jsonReplace, Json jsonRoot)
    	{
    		if(_parent == null)
    			return;
    		
    		jsonReplace = jsonReplace.getLinkOneTail(jsonRoot);
    		
    		if(_parent instanceof ArrayJson)
    			((ArrayJson)_parent).set((int)(Integer)_key, jsonReplace);
    		else if(_parent instanceof ObjectJson)
    			((ObjectJson)_parent).set(_key.toString(), jsonReplace);
    		else
    			throw new RuntimeException("unsupport parent json");
    	}
    	
    	protected void replaceJsonList(Json jsonList, Json jsonRoot)
    	{
    		if(_parent == null)
    			return;
    		
    		if(!(_parent instanceof ArrayJson))
    			throw new RuntimeException("parent json must be ArrayJson");
  		
    		jsonList = jsonList.getLinkOneTail(jsonRoot);
    		
    		if(!jsonList.isArray())
    			throw new RuntimeException("linked json must be ArrayJson");
    		
    		((ArrayJson)_parent).replaceLinkList((Integer)_key, jsonList.asJsonList(), jsonRoot);
    	}
    
    	protected void replaceJsonMap(Json jsonMap, char mode, Json jsonRoot, Pattern patFilter, String replaceFilter)
    	{
    		if(_parent == null)
    			return;
    		
    		if(!(_parent instanceof ObjectJson))
    			throw new RuntimeException("parent json must be ObjectJson");
  		
    		jsonMap = jsonMap.getLinkOneTail(jsonRoot);
    		
    		if(!jsonMap.isObject())
    			throw new RuntimeException("linked json must be ObjectJson");
    		
    		((ObjectJson)_parent).replaceLinkMap((String)_key, mode, jsonMap.asJsonMap(), jsonRoot, patFilter, replaceFilter);
    	}

    }
    
	static class LinkOneJson extends WriteBackJson
	{
		protected LinkOneJson(String link)
		{
			super(link);
		}

		@Override
		protected Json getLinkOneTail(Json rootJson)
		{
			Json json = writeBack(rootJson, true);
			
			return json;
		}
		
		@Override
		protected Json writeBack(Json jsonRoot, boolean throwDup)
    	{
			if(isDupWriteBack(throwDup))
				return null;
			
    		Json json = jsonRoot.getJsonPath(_link, false).getLinkOneTail(jsonRoot);
    		repaceOneJson(json, jsonRoot);
    		
    		return json;
    	}
		
		public String toString() { return "@one:" + _link; }
	}
	
	static class LinkListJson extends WriteBackJson
	{
		protected LinkListJson(String link)
		{
			super(link);
		}

		@Override
		protected Json getLinkOneTail(Json rootJson)
		{
			Json json = writeBack(rootJson, true);
			
			return json;
		}
		
		@Override
		protected Json writeBack(Json rootJson, boolean throwDup) throws RuntimeException
    	{
			if(isDupWriteBack(throwDup))
				return null;
			
    		Json json = rootJson.getJsonPath(_link, false);
    		replaceJsonList(json, rootJson);
    		return _parent;
    	}
		
		public String toString() { return "@list:" + _link; }
	}

	static class LinkMapJson extends WriteBackJson
	{
		private char _mode;
		private Pattern _patFilter;
		private String _replaceFilter;
		
		public LinkMapJson(String link, char mode, String regFilter, String replaceFilter)
		{
			super(link);
			_mode = mode;
			_patFilter = (regFilter == null || regFilter.length() == 0) ? null : Pattern.compile(regFilter);
			_replaceFilter = replaceFilter;
		}
		
		@Override
		protected Json getLinkOneTail(Json rootJson)
		{
			Json json = writeBack(rootJson, true);
			
			return json;
		}
		
		@Override
    	public Json writeBack(Json rootJson, boolean throwDup) throws RuntimeException
    	{
			if(isDupWriteBack(throwDup))
				return null;
			
    		Json json = rootJson.getJsonPath(_link, false);
    		replaceJsonMap(json, _mode, rootJson, _patFilter, _replaceFilter);
    		return _parent;
    	}
		
		public String toString() { return "@map:" + _link; }
	}
	
	
	static class BooleanJson extends Json
	{
		boolean val;
		BooleanJson() {}
		BooleanJson(Json e) {super(e);}
		BooleanJson(Boolean val, Json e) { super(e); this.val = val; }
		
		public Object getValue() { return val; }
        public Json dup() { return new BooleanJson(val, null); }		
		public boolean asBoolean() { return val; }		
		public boolean isBoolean() { return true;	}		
		public String toString() { return val ? "true" : "false"; }
		
		@SuppressWarnings("unchecked")
		public List<Object> asList() { return (List<Object>)(List<?>)Collections.singletonList(val); }
		public int hashCode() { return val ? 1 : 0; }
		public boolean equals(Object x)
		{
			return x instanceof BooleanJson && ((BooleanJson)x).val == val;
		}		
	}

	static class StringJson extends Json
	{
		String val;

		StringJson() {}
		StringJson(Json e) {super(e);}		
		StringJson(String val, Json e) { super(e); this.val = val; }
		
		public Json dup() { return new StringJson(val, null); }		
		public boolean isString() { return true; }
		public Object getValue() { return val; }
		public String asString() { return val; }
		public int asInteger() { return Integer.parseInt(val); }
		public float asFloat() { return Float.parseFloat(val); }
		public double asDouble() { return Double.parseDouble(val); }
		public long asLong() { return Long.parseLong(val); }
		public short asShort() { return Short.parseShort(val); }
		public byte asByte() { return Byte.parseByte(val); }
		public char asChar() { return val.charAt(0); }
		@SuppressWarnings("unchecked")
		public List<Object> asList() { return (List<Object>)(List<?>)Collections.singletonList(val); }
		
		public String toString()
		{
			return '"' + escaper.escapeJsonString(val) + '"'; 
		}
		
		public int hashCode() { return val.hashCode(); }
		public boolean equals(Object x)
		{			
			return x instanceof StringJson && ((StringJson)x).val.equals(val); 
		}		
	}

	static class NumberJson extends Json
	{
		Number val;

		NumberJson() {}
		NumberJson(Json e) {super(e);}		
		NumberJson(Number val, Json e) { super(e); this.val = val; }
		
		public Json dup() { return new NumberJson(val, null); }		
		public boolean isNumber() { return true; }		
		public Object getValue() { return val; }
		public String asString() { return val.toString(); }
		public int asInteger() { return val.intValue(); }
		public float asFloat() { return val.floatValue(); }
		public double asDouble() { return val.doubleValue(); }
		public long asLong() { return val.longValue(); }
		public short asShort() { return val.shortValue(); }
		public byte asByte() { return val.byteValue(); }

		@SuppressWarnings("unchecked")
		public List<Object> asList() { return (List<Object>)(List<?>)Collections.singletonList(val); }
		
		public String toString() { return SMTStatic.toString(val); }
		public int hashCode() { return val.hashCode(); }
		public boolean equals(Object x)
		{			
			return x instanceof NumberJson && ((NumberJson)x).val.equals(val); 
		}				
	}
	
	static class ArrayJson extends Json
	{
		List<Json> L = new ArrayList<Json>();
		
		ArrayJson() { }
		ArrayJson(Json e) { super(e); }
		

        public Json dup() 
        { 
            ArrayJson j = new ArrayJson();
            for (Json e : L)
            {
                Json v = e.dup();
                v.enclosing = j;
                j.L.add(v);
            }
            return j;
        }
		
		public List<Json> asJsonList() { return L; }
		public List<Object> asList() 
		{
			ArrayList<Object> A = new ArrayList<Object>();
			for (Json x: L)
				A.add(x.getValue());
			return A; 
		}
        public boolean is(int index, Object value) 
        { 
            if (index < 0 || index >= L.size())
                return false;
            else
                return L.get(index).equals(make(value));
        }       		
		public Object getValue() { return asList(); }
		public boolean isArray() { return true; }
		public Json at(int index) { return L.get(index); }
		public Json add(Json el) { L.add(el); el.enclosing = this; return this; }
		public Json remove(Json el) { L.remove(el); el.enclosing = null; return this; }
		
		public void set(int index, Json json)
		{
			L.set(index, json);
		}
		
		private Json[] copyList(List<Json> list)
		{
			Json[] jsonArr = new Json[list.size()];
			for(int i = 0; i < list.size(); i ++)
				jsonArr[i] = list.get(i);
			
			return jsonArr;
		}
		
		protected void replaceLinkList(int index, List<Json> list, Json jsonRoot)
		{
			L.remove(index);

			if(list.size() == 0)
				return;
			
			Json[] copyList = copyList(list);
			for(int i = 0; i < copyList.length; i ++)
				index = insertLinkItem(index, copyList[i], jsonRoot);
		}
		
		protected int insertLinkItem(int index, Json jsonValue, Json jsonRoot)
		{
			if(jsonValue instanceof LinkListJson)
			{
				List<Json> jsonList = jsonValue.getLinkOneTail(jsonRoot).asJsonList();
				Json[] copyList = copyList(jsonList);
				for(int i = 0; i < copyList.length; i ++)
					index = insertLinkItem(index, copyList[i], jsonRoot);

				return index;
			}
			else
			{
				L.add(index, jsonValue.getLinkOneTail(jsonRoot));
				return index + 1;
			}
		}
		
		public Json with(Json object) 
		{
			if (!object.isArray())
				throw new UnsupportedOperationException();
			// what about "enclosing" here? we don't have a provision where a Json 
			// element belongs to more than one enclosing elements...
			L.addAll(((ArrayJson)object).L);
			return this;
		}
		
		public Json atDel(int index) 
		{ 
			Json el = L.remove(index); 
			if (el != null) 
				el.enclosing = null; 
			return el; 
		}
		
		public Json delAt(int index) 
		{ 
			Json el = L.remove(index); 
			if (el != null) 
				el.enclosing = null; 
			return this; 
		}
		
		public String toString()
		{
			StringBuilder sb = new StringBuilder("[");
			for (Iterator<Json> i = L.iterator(); i.hasNext(); )
			{
				sb.append(i.next().toString());
				if (i.hasNext())
					sb.append(",");
			}
			sb.append("]");
			return sb.toString();
		}
		public int hashCode() { return L.hashCode(); }
		public boolean equals(Object x)
		{			
			return x instanceof ArrayJson && ((ArrayJson)x).L.equals(L); 
		}		
	}
	
	static class ObjectJson extends Json
	{
		Map<String, Json> object = new HashMap<String, Json>();
		
		ObjectJson() { }
		ObjectJson(Json e) { super(e); }

		public Json dup() 
		{ 
		    ObjectJson j = new ObjectJson();
		    for (Map.Entry<String, Json> e : object.entrySet())
		    {
		        Json v = e.getValue().dup();
		        v.enclosing = j;
		        j.object.put(e.getKey(), v);
		    }
		    return j;
		}
		
		public boolean has(String property)
		{
			return object.containsKey(property);
		}
		
		public boolean is(String property, Object value) 
		{ 
		    Json p = object.get(property);
		    if (p == null)
		        return false;
		    else
		        return p.equals(make(value));
		}		
		
		public Json at(String property)
		{
			return object.get(property);
		}

		public Json with(Json x)
		{
			if (!x.isObject())
				throw new UnsupportedOperationException();
			object.putAll(((ObjectJson)x).object);
			return this;
		}
		
		public Json set(String property, Json el)
		{
			if (property == null)
				throw new IllegalArgumentException("Null property names are not allowed, value is " + el);
			el.enclosing = this;
			object.put(property, el);
			return this;
		}
		
		public void replaceLinkMap(String key, char mode, Map<String, Json> jsonMap, Json jsonRoot, Pattern patFilter, String replaceFilter)
		{
			if(key.length() != 0)
				this.delAt(key);
			
			String[] entryKeys = new String[jsonMap.size()];
			Json[] entryValues = new Json[jsonMap.size()];
			int count = 0;
			for(Entry<String, Json> entry : jsonMap.entrySet())
			{
				entryKeys[count] = entry.getKey();
				entryValues[count] = entry.getValue();
				count ++;
			}
			
			for(int i = 0; i < count; i ++)
			{
				String key1 = entryKeys[i];
				
				// 如果存在复制前缀过滤，则首先对其进行过滤
				if(patFilter != null)
				{
					Matcher m = patFilter.matcher(key1);
					if(!m.find())
						continue;
					
					if(replaceFilter != null)
						key1 = m.replaceAll(replaceFilter);
				}
				
				if(this.has(key1))
				{
					if(mode == 'I')
						continue;
					else if(mode == 'E')
						throw new RuntimeException(String.format("key [%s] has been found in map", key));
				}
				
				Json value = entryValues[i];
				if(value instanceof LinkMapJson)
				{
					Map<String, Json> jsonMap1 = value.getLinkOneTail(jsonRoot).asJsonMap();
					replaceLinkMap(key1, mode, jsonMap1, jsonRoot, null, null);
				}
				else
				{
					this.set(key1, value.getLinkOneTail(jsonRoot));
				}
			}
		}

		public Json atDel(String property) 
		{
			Json el = object.remove(property);
			if (el != null)
				el.enclosing = null;
			return el;
		}
		
		public Json delAt(String property) 
		{
			Json el = object.remove(property);
			if (el != null)
				el.enclosing = null;
			return this;
		}
		
		public Object getValue() { return asMap(); }
		public boolean isObject() { return true; }
		public Map<String, Object> asMap() 
		{
			HashMap<String, Object> m = new HashMap<String, Object>();
			for (Map.Entry<String, Json> e : object.entrySet())
				m.put(e.getKey(), e.getValue().getValue());
			return m; 
		}
		@Override
		public Map<String, Json> asJsonMap() { return object; }
		
		public String toString()
		{
			StringBuilder sb = new StringBuilder("{");
			for (Iterator<Map.Entry<String, Json>> i = object.entrySet().iterator(); i.hasNext(); )
			{
				Map.Entry<String, Json> x  = i.next();
				sb.append('"');
				sb.append(escaper.escapeJsonString(x.getKey()));
				sb.append('"');
				sb.append(":");
				sb.append(x.getValue().toString());
				if (i.hasNext())
					sb.append(",");
			}
			sb.append("}");
			return sb.toString();
		}
		public int hashCode() { return object.hashCode(); }
		public boolean equals(Object x)
		{			
			return x instanceof ObjectJson && ((ObjectJson)x).object.equals(object); 
		}				
	}
	
	// ------------------------------------------------------------------------
	// Extra utilities, taken from around the internet:
	// ------------------------------------------------------------------------
	
	/*
	 * Copyright (C) 2008 Google Inc.
	 *
	 * 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.
	 */

	/**
	 * A utility class that is used to perform JSON escaping so that ", <, >, etc. characters are
	 * properly encoded in the JSON string representation before returning to the client code.
	 *
	 * <p>This class contains a single method to escape a passed in string value:
	 * <pre>
	 *   String jsonStringValue = "beforeQuote\"afterQuote";
	 *   String escapedValue = Escaper.escapeJsonString(jsonStringValue);
	 * </pre></p>
	 *
	 * @author Inderjeet Singh
	 * @author Joel Leitch
	 */
	static Escaper escaper = new Escaper(false);
	
	final static class Escaper {

	  private static final char[] HEX_CHARS = {
	    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
	  };

	  private static final Set<Character> JS_ESCAPE_CHARS;
	  private static final Set<Character> HTML_ESCAPE_CHARS;

	  static {
	    Set<Character> mandatoryEscapeSet = new HashSet<Character>();
	    mandatoryEscapeSet.add('"');
	    mandatoryEscapeSet.add('\\');
	    JS_ESCAPE_CHARS = Collections.unmodifiableSet(mandatoryEscapeSet);

	    Set<Character> htmlEscapeSet = new HashSet<Character>();
	    htmlEscapeSet.add('<');
	    htmlEscapeSet.add('>');
	    htmlEscapeSet.add('&');
	    htmlEscapeSet.add('=');
	    htmlEscapeSet.add('\'');
//	    htmlEscapeSet.add('/');  -- Removing slash for now since it causes some incompatibilities
	    HTML_ESCAPE_CHARS = Collections.unmodifiableSet(htmlEscapeSet);
	  }

	  private final boolean escapeHtmlCharacters;

	  Escaper(boolean escapeHtmlCharacters) {
	    this.escapeHtmlCharacters = escapeHtmlCharacters;
	  }

	  public String escapeJsonString(CharSequence plainText) {
	    StringBuilder escapedString = new StringBuilder(plainText.length() + 20);
	    try {
	      escapeJsonString(plainText, escapedString);
	    } catch (IOException e) {
	      throw new RuntimeException(e);
	    }
	    return escapedString.toString();
	  }

	  private void escapeJsonString(CharSequence plainText, StringBuilder out) throws IOException {
	    int pos = 0;  // Index just past the last char in plainText written to out.
	    int len = plainText.length();

	    for (int charCount, i = 0; i < len; i += charCount) {
	      int codePoint = Character.codePointAt(plainText, i);
	      charCount = Character.charCount(codePoint);

	       if (!isControlCharacter(codePoint) && !mustEscapeCharInJsString(codePoint)) {
	          continue;
	       }

	       out.append(plainText, pos, i);
	       pos = i + charCount;
	       switch (codePoint) {
	         case '\b':
	           out.append("\\b");
	           break;
	         case '\t':
	           out.append("\\t");
	           break;
	         case '\n':
	           out.append("\\n");
	           break;
	         case '\f':
	           out.append("\\f");
	           break;
	         case '\r':
	           out.append("\\r");
	           break;
	         case '\\':
	           out.append("\\\\");
	           break;
	         case '/':
	           out.append("\\/");
	           break;
	         case '"':
	           out.append("\\\"");
	           break;
	         default:
	           appendHexJavaScriptRepresentation(codePoint, out);
	           break;
	       }
	     }
	     out.append(plainText, pos, len);
	  }

	  private boolean mustEscapeCharInJsString(int codepoint) {
	    if (!Character.isSupplementaryCodePoint(codepoint)) {
	      char c = (char) codepoint;
	      return JS_ESCAPE_CHARS.contains(c)
	          || (escapeHtmlCharacters && HTML_ESCAPE_CHARS.contains(c));
	    }
	    return false;
	  }

	  private static boolean isControlCharacter(int codePoint) {
	    // JSON spec defines these code points as control characters, so they must be escaped
	    return codePoint < 0x20
	        || codePoint == 0x2028  // Line separator
	        || codePoint == 0x2029  // Paragraph separator
	        || (codePoint >= 0x7f && codePoint <= 0x9f);
	  }

	  private static void appendHexJavaScriptRepresentation(int codePoint, Appendable out)
	      throws IOException {
	    if (Character.isSupplementaryCodePoint(codePoint)) {
	      // Handle supplementary unicode values which are not representable in
	      // javascript.  We deal with these by escaping them as two 4B sequences
	      // so that they will round-trip properly when sent from java to javascript
	      // and back.
	      char[] surrogates = Character.toChars(codePoint);
	      appendHexJavaScriptRepresentation(surrogates[0], out);
	      appendHexJavaScriptRepresentation(surrogates[1], out);
	      return;
	    }
	    out.append("\\u")
	        .append(HEX_CHARS[(codePoint >>> 12) & 0xf])
	        .append(HEX_CHARS[(codePoint >>> 8) & 0xf])
	        .append(HEX_CHARS[(codePoint >>> 4) & 0xf])
	        .append(HEX_CHARS[codePoint & 0xf]);
	  }
	}	
	
	@SuppressWarnings("deprecation")
	public static class Reader
	{
	    private static final Object OBJECT_END = new Object();
	    private static final Object ARRAY_END = new Object();
	    private static final Object COLON = new Object();
	    private static final Object COMMA = new Object();
	    public static final int FIRST = 0;
	    public static final int CURRENT = 1;
	    public static final int NEXT = 2;

	    private static Map<Character, Character> escapes = new HashMap<Character, Character>();
	    static 
	    {
	    	escapes.put(new Character('\''), new Character('\''));
	        escapes.put(new Character('"'), new Character('"'));
	        escapes.put(new Character('\\'), new Character('\\'));
	        escapes.put(new Character('/'), new Character('/'));
	        escapes.put(new Character('b'), new Character('\b'));
	        escapes.put(new Character('f'), new Character('\f'));
	        escapes.put(new Character('n'), new Character('\n'));
	        escapes.put(new Character('r'), new Character('\r'));
	        escapes.put(new Character('t'), new Character('\t'));
	        escapes.put(new Character(','), new Character(','));
	    }

	    private String _rootPath;
	    private JsonCharacterIterator it;
	    private char c;
	    private Object token;
	    private StringBuffer buf = new StringBuffer();
	    private IJsonParseExt _jsonParseExt = null;
	    private Map<String, Properties> _propMap = null;
	    private Map<String, String> _defineMap = null;
	    private List<WriteBackJson> _writeBackList = null;
	    private List<String> _parsePath = new ArrayList<String>();

	    public void importDefineMap(String[] defineMap)
	    {
	    	if(_defineMap == null)
	    		_defineMap = new HashMap<String, String>();
	    	
	    	for(int i = 0; i < defineMap.length; i += 2)
	    	{
	    		String key = defineMap[i + 0];
	    		String value = defineMap[i + 1];
	    		
	    		_defineMap.put(key, value);
	    	}
	    }
	    
	    public void setRootPath(String rootPath)
	    {
	    	_rootPath = rootPath;
	    }
	    
	    private char next() 
	    {
	        if (it.getIndex() == it.getEndIndex())
	            throw new RuntimeException("Reached end of input at the " + 
	                                       it.getIndex() + "th character.");
	        c = it.next();
	        return c;
	    }

	    private char previous()
	    {
	    	c = it.previous();
	    	return c;
	    }
	    
	    private void skipWhiteSpace() 
	    {
	        do
	        {
	        	if (Character.isWhitespace(c))
	        		;
	        	else if (c == '/')
	        	{
	        		next();
	        		if (c == '*')
	        		{
	        			// skip multiline comments
	        			while (c != CharacterIterator.DONE)
	        				if (next() == '*' && next() == '/')
	        						break;
	        			if (c == CharacterIterator.DONE)
	        				throw new RuntimeException("Unterminated comment while parsing JSON string.");
	        		}
	        		else if (c == '/')
	        			while (c != '\n' && c != CharacterIterator.DONE)
	        				next();
	        		else
	        		{
	        			previous();
	        			break;
	        		}
	        	}
	        	else
	        		break;
	        } while (next() != CharacterIterator.DONE);
	    }

	    private Object read(JsonCharacterIterator ci, int start) 
	    {
	        it = ci;
	        switch (start) 
	        {
	        	case FIRST:
	        		c = it.first();
	        		break;
	        	case CURRENT:
	        		c = it.current();
	        		break;
	        	case NEXT:
	        		c = it.next();
	        		break;
	        }
	        return read();
	    }

	    private Object read(JsonCharacterIterator it) 
	    {
	        return read(it, NEXT);
	    }
	    
	    public Object read(File file, IJsonParseExt jsonParseExt)
	    {
			String jsonStr = readJsonFile(file);
			
			String rootPath = file.getAbsolutePath();
			rootPath = rootPath.substring(0, rootPath.length() - file.getName().length());
			this.setRootPath(rootPath);
			
			return this.read(jsonStr, jsonParseExt);
	    }

	    public Object read(String string, IJsonParseExt jsonParseExt) 
	    {
	    	try
	    	{
		    	this._jsonParseExt = jsonParseExt;
		        Object ret = read(new JsonCharacterIterator(string), FIRST);
		        
		        if(_writeBackList != null)
		        {
		        	for(int i = _writeBackList.size() - 1; i >= 0 ; i --)
		        	{
		        		WriteBackJson json = _writeBackList.get(i);
		        		json.writeBack((Json)ret, false);
		        	}
		        }
		        return ret;
	    	}
	    	catch(Exception ex)
	    	{
	    		throw new RuntimeException(String.format("parse error [%s]\n", ex.getMessage()) + it.getErrorLine(),ex);
	    	}
	    }
	    
	    public void writeBackList(Object ret)
	    {
	    }

	    @SuppressWarnings("unchecked")
		private <T> T read() 
	    {
	        skipWhiteSpace();
	        char ch = c;
	        next();
	        switch (ch) 
	        {
	        	case '(': token = readLargeString();break; 
	        	case '\'':token = readMacro();break; 
	            case '"': token = readString(); break;
	            case '[': token = readArray(); break;
	            case ']': token = ARRAY_END; break;
	            case ',': token = COMMA; break;
	            case '{': token = readObject(); break;
	            case '}': token = OBJECT_END; break;
	            case ':': token = COLON; break;
	            case 't':
	                if (c != 'r' || next() != 'u' || next() != 'e')
	                	throw new RuntimeException("Invalid JSON token: expected 'true' keyword.");
	                next();
	                token = factory().bool(Boolean.TRUE);
	                break;
	            case'f':
	                if (c != 'a' || next() != 'l' || next() != 's' || next() != 'e')
	                	throw new RuntimeException("Invalid JSON token: expected 'false' keyword.");
	                next();
	                token = factory().bool(Boolean.FALSE);
	                break;
	            case 'n':
	                if (c != 'u' || next() != 'l' || next() != 'l')
	                	throw new RuntimeException("Invalid JSON token: expected 'null' keyword.");
	                next();
	                token = nil();
	                break;
	            default:
	                c = it.previous();
	                if (Character.isDigit(c) || c == '-') {
	                    token = readNumber();
	                }
	                else throw new RuntimeException("Invalid JSON near position: " + it.getIndex());
	        }
	        //System.out.println("token: " + token); // TODO1 enable this line to see the token stream
	        return (T)token;
	    }
	    
	    private String readObjectKey()
	    {
	    	Object key = read();
	    	if (key == null)
                throw new RuntimeException(
                        "Missing object key (don't forget to put quotes!).");
	    	else if (key != OBJECT_END)
	    		return ((Json)key).asString();
	    	else
	    		return key.toString();
	    }
	    
	    private Json readObject() 
	    {
	        Json ret = object();
	        String key = readObjectKey();
        	this._parsePath.add(0, key);
	        while (token != OBJECT_END) 
	        {
	            read(); // should be a colon
	            if (token != OBJECT_END) 
	            {
	            	Json value = read();
            		
	            	if(value instanceof WriteBackJson)
	            	{
	            		if(key.length() == 0)
	            			key = UUID.randomUUID().toString();
            			((WriteBackJson)value).setWriteBackParent(ret, key);
	            	}
	            	
		        	if((this._jsonParseExt == null || this._jsonParseExt.beforeAddMap(this, key, value)) && key.length() > 0)
		        		ret.set(key, value);

            		if (read() == COMMA) {
	                    key = readObjectKey();
	                    this._parsePath.set(0, key);
	                }
	            }
	        }
	        
        	if(this._jsonParseExt != null)
        		this._jsonParseExt.finishAddMap(this);

	        this._parsePath.remove(0);

	        return ret;
	    }

	    private Json readArray() 
	    {
	        Json ret = array();
	        this._parsePath.add(0, String.format("#%d", ret.asJsonList().size()));
	        Object value = read();
	        while (token != ARRAY_END) 
	        {
	        	if(value instanceof WriteBackJson)
	        		((WriteBackJson)value).setWriteBackParent(ret, ret.asJsonList().size());

	        	if(this._jsonParseExt == null || this._jsonParseExt.beforeAddArray(this, value))
	        		ret.add((Json)value);
	        	
	            if (read() == COMMA)
	            {
	            	this._parsePath.set(0, String.format("#%d", ret.asJsonList().size()));
	            	value = read();
	            }
	            else if (token != ARRAY_END)
	                throw new RuntimeException("Unexpected token in array " + token);
	        }
	        
	        if(this._jsonParseExt != null)
	        	this._jsonParseExt.finishAddArray(this);
	        
	        this._parsePath.remove(0);
	        return ret;
	    }

	    private Json readNumber() 
	    {
	        int length = 0;
	        boolean isFloatingPoint = false;
	        buf.setLength(0);
	        
	        if (c == '-') 
	        {
	            add();
	        }
	        length += addDigits();
	        if (c == '.') 
	        {
	            add();
	            length += addDigits();
	            isFloatingPoint = true;
	        }
	        if (c == 'e' || c == 'E') 
	        {
	            add();
	            if (c == '+' || c == '-') 
	            {
	                add();
	            }
	            addDigits();
	            isFloatingPoint = true;
	        }
	 
	        String s = buf.toString();
	        Number n = isFloatingPoint 
	            ? (length < 17) ? Double.valueOf(s) : new BigDecimal(s)
	            : (length < 20) ? Long.valueOf(s) : new BigInteger(s);
	        return factory().number(n);
	    }
	 
	    private int addDigits() 
	    {
	        int ret;
	        for (ret = 0; Character.isDigit(c); ++ret) 
	        {
	            add();
	        }
	        return ret;
	    }
	    
	    public String getRooPath()
	    {
	    	if(_rootPath == null)
	    		throw new RuntimeException("root json is not file mode");
	    	return _rootPath;
	    }
	    
	    public void addWriteBackJson(WriteBackJson jsonWB)
	    {
        	if(_writeBackList == null)
        		_writeBackList = new ArrayList<WriteBackJson>();
        	_writeBackList.add(jsonWB);
	    }
	    
	    private Object readLargeString()
	    {
	        buf.setLength(0);
	        while(true)
	        {
		        if(c != '\"')
		        	throw new RuntimeException("string start char must be '\"'");
		        next();
		        while (c != '"') 
		        {
		            if (c == '\\') 
		            {
		                next();
		                if (c == 'u') 
		                {
		                    add(unicode());
		                } 
		                else 
		                {
		                    Object value = escapes.get(new Character(c));
		                    if (value != null) 
		                    {
		                        add(((Character) value).charValue());
		                    }
		                }
		            } 
		            else 
		            {
		                add();
		            }
		        }
		        next();
		        skipWhiteSpace();
		        if(c == ')')
		        	break;
		        if(c != '+')
		        	throw new RuntimeException("string join char must be '+'");
		        next();
		        skipWhiteSpace();

	        }
	        next();
	        return factory().string(buf.toString());
	    }
	    
	    private Object readMacro()
	    {
	    	List<String> list = new ArrayList<String>();
	        buf.setLength(0);
	        while (c != '\'') 
	        {
	            if (c == '\\') 
	            {
	                next();
	                if (c == 'u') 
	                {
	                    add(unicode());
	                } 
	                else 
	                {
	                    Object value = escapes.get(new Character(c));
	                    if (value != null) 
	                    {
	                        add(((Character) value).charValue());
	                    }
	                }
	            } 
	            else if(c == ',')
	            {
	            	list.add(buf.toString());
	            	buf.setLength(0);
	            	next();
	            }
	            else
	            {
	                add();
	            }
	        }
	        list.add(buf.toString());
	        next();
	        
	        
	        boolean extParsed = false;
	        if(this._jsonParseExt != null)
	        {
	        	Object ret = this._jsonParseExt.parseMacro(this, list);
	        	
	        	if(ret == null)
	        		extParsed = false;
	        	else if(ret instanceof WriteBackJson)
	        	{
	        		addWriteBackJson((WriteBackJson)ret);
		        	return (WriteBackJson)ret;
	        	}
	        	else if(ret instanceof Json)
	        		return (Json)ret;
	        	else if(ret instanceof Boolean)
	        		extParsed = (Boolean)ret;
	        	else if(ret instanceof String)
	        	{
	        		this.insertJsonText((String)ret);
	        		extParsed = true;
	        	}
	        	else
	        		throw new RuntimeException("unknow extend property return type for command:" + list.get(0));
	        }
	        
	        String cmd = list.get(0);
	        // if ext parsed this macro then skip inner macro
	        if(extParsed)
	        {
	        }
	        else if(cmd.charAt(0) == '@')
	        {
	        	String defName = cmd.substring(1);
	        	if(_defineMap == null || !_defineMap.containsKey(defName))
	        		throw new RuntimeException(String.format("unknow define name [%s]", defName));
	        	
	        	Object[] args = new Object[list.size() - 1];
	        	for(int i = 1; i < list.size(); i ++)
	        	{
	        		args[i - 1] = list.get(i);
	        	}
	        	return insertJsonText(SMTStatic.stringFormat(_defineMap.get(defName), args));
	        }
	        // load text file to buufer for parse it
	        // '#include_file,[file name],[json,array,map]?'
	        else if("#include_file".equals(cmd))
	        {
	        	String fileName = convFileName(list.get(1));
	        	try
	        	{
	        		// 对返回的字符串做转换
	        		String mode = "J";
	        		if(list.size() > 2)
	        			mode = list.get(2).toUpperCase();
	        		
	        		// 需要对数据做处理
	        		if(mode.charAt(0) != 'J')
	        		{
	    				String text = readTextFileForJson(new File(fileName), null, mode, null);
	        			return this.insertJsonText("null," + text);
	        		}
	        		else
	        		{
		        		String text = Json.readJsonFile(new File(fileName));
	        			return this.insertJsonText(text);
	        		}
	        	}
	        	catch(Exception ex)
	        	{
	        		throw new RuntimeException(String.format("read json file [%s] error", fileName), ex);
	        	}
	        }
	        // search fold json file
	        // '#search_file,[root path],[file regex],[tranBase Key],[json,array,map]'
	        else if("#search_file".equals(cmd))
	        {
	        	File rootPath = new File(convFileName(list.get(1)));
	        	Pattern patFile = Pattern.compile(list.get(2));
	        	String mode = list.get(3);
	        	
	        	// 取出后面的宏定义列表
	        	String[] tranKeyList = null;
	        	if(list.size() > 4)
	        	{
		        	tranKeyList = new String[list.size() - 4];
		        	for(int i = 0; i < tranKeyList.length; i ++)
		        	{
		        		tranKeyList[i] = list.get(i + 4);
		        	}
	        	}
	        	
	        	StringBuilder sbInsert = new StringBuilder();
	        	searchTextFileWithFold(rootPath, rootPath.getAbsolutePath(), patFile, mode, sbInsert, tranKeyList);
	        	if(sbInsert.length() > 0)
	        		return insertJsonText("null," + sbInsert.toString());
	        	else
	        		return insertJsonText("null");
	        	
	        }
	        // load file to buufer for parse it
	        // '#nick_prop,[property file name],[property nick]?'
	        else if("#nick_prop".equals(cmd))
	        {
	        	String fileName = convFileName(list.get(1));
        		String fileNick = (list.size() < 3) ? fileName : list.get(2);
	        	try
	        	{
	    			Properties prop = new Properties();
	    			prop.load(new InputStreamReader(new FileInputStream(fileName),"UTF-8"));

		        	if(_propMap == null)
		        		_propMap = new HashMap<String, Properties>();
		        	_propMap.put(fileNick, prop);
		        	
		        	return insertJsonText("null");
	        	}
	        	catch(Exception ex)
	        	{
	        		throw new RuntimeException(String.format("read json file [%s] error", fileName), ex);
	        	}
	        }
	        // get value from property object and insert as json
	        // '#prop_value, [[property_nick],[property key],[default value]?'
	        else if("#prop_value".equals(cmd))
	        {
	        	String nick = list.get(1);
	        	if(_propMap == null || !_propMap.containsKey(nick))
	        		throw new RuntimeException(String.format("read json property [%s] error", nick));
	        	
	        	String key = list.get(2);
	        	
	        	String value = list.size() > 3 ? _propMap.get(nick).getProperty(key, list.get(3)) : _propMap.get(nick).getProperty(key);
	        	if(value == null)
	        		throw new RuntimeException(String.format("read json include property key [%s] error", key));
	        	return insertJsonText(value);
	        }
	        // get value from property string and insert as json
	        // '#prop_value, [[property_nick],[property key],[default value]?'
	        else if("#prop_string".equals(cmd))
	        {
	        	String nick = list.get(1);
	        	if(_propMap == null || !_propMap.containsKey(nick))
	        		throw new RuntimeException(String.format("read json property [%s] error", nick));
	        	
	        	String key = list.get(2);
	        	
	        	String value = list.size() > 3 ? _propMap.get(nick).getProperty(key, list.get(3)) : _propMap.get(nick).getProperty(key);
	        	if(value == null)
	        		throw new RuntimeException(String.format("read json include property key [%s] error", key));
	        	return insertJsonText(String.format("\"%s\"", SMTStatic.toCStr(value)));
	        }
	        // replace current node to linked node
	        // '#link, [link path]'
	        else if("#link".equals(cmd))
	        {
	        	String link = getJsonFullPath(list.get(1));
	        	
	        	if(_writeBackList == null)
	        		_writeBackList = new ArrayList<WriteBackJson>();
	        	
	        	LinkOneJson json =  new LinkOneJson(link);
	        	_writeBackList.add(json);
	        	return json;
	        }
	        // replac current node to linked node list 
	        // '#link_list, [link path]'
	        else if("#link_list".equals(cmd))
	        {
	        	String link = getJsonFullPath(list.get(1));
	        	
	        	LinkListJson json =  new LinkListJson(link);
        		addWriteBackJson(json);

	        	return json;
	        }
	        // replac current node to linked node map 
	        // '#link_map, [link path], [overwrite|ignore|error]?, [regex for filter]?, [replace for filter]?'
	        else if("#link_map".equals(cmd))
	        {
	        	String link = getJsonFullPath(list.get(1));
	        	char mode = 'I';
	        	
	        	if(list.size() > 2)
	        	{
		        	mode = list.get(2).toUpperCase().charAt(0);
	        		if(mode != 'O' && mode != 'I' && mode != 'E')
	        			throw new RuntimeException(String.format("unknow link_map mode [%s]", list.get(2)));
	        	}
	        	
        		String regFilter = (list.size() > 3) ? list.get(3) : null;
        		String repFilter = (list.size() > 4) ? list.get(4) : null;
        		
	        	LinkMapJson json =  new LinkMapJson(link, mode, regFilter, repFilter);
        		addWriteBackJson(json);

	        	return json;
	        }
	        // define new macro 
	        // '#define, [define_name], [define string]'
	        else if("#define".equals(cmd))
	        {
	        	if(_defineMap == null)
	        		_defineMap = new HashMap<String, String>();
	        	
	        	_defineMap.put(list.get(1), list.get(2));
	        	
	        	return Json.nil();
	        }
	        else
	        {
	        	throw new RuntimeException(String.format("unknow json macro [%s]", cmd));
	        }
	        
	        return this.read();
	    }

	    private void searchTextFileWithFold(File fold, String rootPath, Pattern patFile, String mode, StringBuilder sbOut, String[] tranKeyList)
	    {
	    	if(!fold.exists() || !fold.isDirectory())
	    		return;
	    	
	    	for(File file : fold.listFiles())
	    	{
	    		if(file.isDirectory())
	    		{
	    			searchTextFileWithFold(file, rootPath, patFile, mode, sbOut, tranKeyList);
	    		}
	    		else if(file.isFile())
	    		{
	    			if(patFile.matcher(file.getName()).find())
	    			{
	    				String text = readTextFileForJson(file, rootPath, mode, tranKeyList);
	    				boolean onlySpace = true;
	    				for(int i = 0; i < text.length(); i ++)
	    				{
	    					char ch = text.charAt(i);
	    					if(ch == '\r' || ch == '\n' || ch == '\t' || ch == ' ')
	    						continue;
	    					
	    					onlySpace = false;
	    					break;
	    				}
	    				
	    				if(!onlySpace)
	    				{
		    				if(sbOut.length() > 0)
		    					sbOut.append(",");
		    				sbOut.append(text);
	    				}
	    			}
	    		}
	    	}
	    }
	    
	    private String readTextFileForJson(File file, String rootPath, String mode, String[] tranKeyList)
	    {
    		// 对返回的字符串做转换
    		String text = Json.readJsonFile(file);
    		
    		// 需要对数据做处理
    		if(mode.charAt(0) != 'J')
    		{
    			int index;
    			
    			// 去掉头部的'{'
				for(index = 0; index < text.length(); index ++)
				{
					char ch = text.charAt(index);
					if(ch == '\r' || ch == '\n' || ch == '\t' || ch == ' ')
						continue;
					if(ch == '{' || ch == '[')
						break;
				}
				if(index >= text.length())
					throw new RuntimeException(String.format("file [%s] is not mode start json file", file.getAbsoluteFile()));
    			if(index > 0)
    				text = text.substring(index + 1);
    			else if(index == 0 && text.length() > 0 && text.charAt(0) == '{' || text.charAt(0) == '[')
    				text = text.substring(1);
				
    			// 去掉尾部的'}'
    			for(index = text.length() - 1; index >= 0; index --)
    			{
					char ch = text.charAt(index);
					if(ch == '\r' || ch == '\n' || ch == '\t' || ch == ' ')
						continue;
					if(ch == ']' || ch == '}')
						break;
    			}
				if(index >= text.length())
					throw new RuntimeException(String.format("file [%s] is not mode end json file", file.getAbsoluteFile()));
    			if(index > 0)
    				text = text.substring(0, index);
    			
    			// 去掉尾部的逗号
    			for(index = text.length() - 1; index >= 0; index --)
    			{
					char ch = text.charAt(index);
					if(ch == '\r' || ch == '\n' || ch == '\t' || ch == ' ')
						continue;
					
					if(ch == ',')
        				text = text.substring(0, index);

					break;
    			}
    			
				
    			if(tranKeyList != null)
				{
					String fname = file.getName();
					int pos = fname.lastIndexOf(".");
					if(pos > 0)
						fname = fname.substring(0, pos);
					
					String fpath = file.getAbsolutePath().substring(rootPath.length()).substring(1).replace("\\", "/");
					pos = fpath.lastIndexOf(".");
					if(pos > 0)
						fpath = fpath.substring(0, pos);
					
					for(int i = 0; i < tranKeyList.length; i += 2)
					{
						text = text.replace(tranKeyList[i + 0], tranKeyList[i + 1]
								.replace("${JSP_NAME}", fname)
								.replace("${JSP_PATH}", fpath));
					}
				}
        	}
			return text;
    	}
	    
	    public String getJsonFullPath(String path)
	    {
	    	// 切分路径
	    	String[] sp = path.split("/");
	    	
	    	// 如果第一个路径是"."或"..", 则将基本路径复制过来
	    	List<String> fullPath = null;
	    	if(".".equals(sp[0]) || "..".equals(sp[0]))
	    	{
	    		// 如果是当前目录需要回退到倒数第二个，因为最后一个路径是map或索引本身
	    		// 所以回退位置和长度正巧一致
	    		int endPos = sp[0].length(); 
	    		fullPath = new ArrayList<String>();
	    		for(int i = this._parsePath.size() - 1; i >= endPos; i --)
	    		{
	    			fullPath.add(this._parsePath.get(i));
	    		}
	    	}
	    	// 如果第一个路径不是"."或".."，则此路径为全路径
	    	else
	    	{
	    		return path;
	    	}
	    	
	    	// 计算以后的路径
	    	for(int i = 1; i < sp.length; i ++)
	    	{
	    		if(".".equals(sp[i]))
	    			continue;
	    		else if("..".equals(sp[i]))
	    		{
	    			if(fullPath.size() == 0)
	    				throw new RuntimeException(String.format("can't calculate path [%s]", path));
	    			fullPath.remove(fullPath.size() - 1);
	    		}
	    		else
	    		{
	    			fullPath.add(sp[i]);
	    		}
	    	}
	    	
	    	StringBuilder sb = new StringBuilder();
	    	for(int i = 0; i < fullPath.size(); i ++)
	    	{
	    		if(sb.length() > 0)
	    			sb.append("/");
	    		sb.append(fullPath.get(i));
	    	}
	    	
	    	return sb.toString();
	    }
	    
	    public String convFileName(String fileName)
	    {
        	if(fileName.charAt(0) == '*')
        		fileName = fileName.substring(1);
        	else
        		fileName = getRooPath() + fileName;
        	return fileName;
	    }
	    
	    public Json insertJsonText(String text)
	    {
    		it.insertText(text);
    		c = it.current();
    		return this.read();
	    }
	    
	    private Json readString() 
	    {
	        buf.setLength(0);
	        while (c != '"') 
	        {
	            if (c == '\\') 
	            {
	                next();
	                if (c == 'u') 
	                {
	                    add(unicode());
	                } 
	                else 
	                {
	                    Object value = escapes.get(new Character(c));
	                    if (value != null) 
	                    {
	                        add(((Character) value).charValue());
	                    }
	                }
	            } 
	            else 
	            {
	                add();
	            }
	        }
	        next();
	        return factory().string(buf.toString());
	    }

	    private void add(char cc) 
	    {
	        buf.append(cc);
	        next();
	    }

	    private void add() 
	    {
	        add(c);
	    }

	    private char unicode() 
	    {
	        int value = 0;
	        for (int i = 0; i < 4; ++i) 
	        {
	            switch (next()) 
	            {
	            	case '0': case '1': case '2': case '3': case '4': 
	            	case '5': case '6': case '7': case '8': case '9':
	            		value = (value << 4) + c - '0';
	            		break;
	            	case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
	            		value = (value << 4) + (c - 'a') + 10;
	            		break;
	            	case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
	            		value = (value << 4) + (c - 'A') + 10;
	            		break;
	            }
	        }
	        return (char) value;
	    }
	}
	// END Reader
/*	
	public static void main(String [] argv)
	{
		 Json j = object()
		  .at("menu", object())
		    .set("id", "file") 
		    .set("value", "File")
		    .at("popup", object())
		      .at("menuitem", array())
		        .add(object("value", "New", "onclick", "CreateNewDoc()"))
		        .add(object("value", "Open", "onclick", "OpenDoc()"))
		        .add(object("value", "Close", "onclick", "CloseDoc()"))
		        .up()
		      .up()
		    .set("position", 0);
		 System.out.println(j);
	}
	*/

//	public static void main(String[] args) 
//    {	
//		Json j = Json.object("label", "Does CTRL+Q show an \"OPEN\" Bulky Work Order number?");
//	    String evilJson = j.toString();	 
//	    System.out.println("To string: " + evilJson);
//        System.out.println("Parsed: " + Json.read(evilJson)); 
//    }
	
	private static class JsonCharacterIterator implements CharacterIterator
	{
	    private String text;
	    private int begin;
	    private int end;
	    // invariant: begin <= pos <= end
	    private int pos;

	    /**
	     * Constructs an iterator with an initial index of 0.
	     */
	    public JsonCharacterIterator(String text)
	    {
	        this(text, 0);
	    }

	    /**
	     * Constructs an iterator with the specified initial index.
	     *
	     * @param  text   The String to be iterated over
	     * @param  pos    Initial iterator position
	     */
	    public JsonCharacterIterator(String text, int pos)
	    {
	    this(text, 0, text.length(), pos);
	    }

	    /**
	     * Constructs an iterator over the given range of the given string, with the
	     * index set at the specified position.
	     *
	     * @param  text   The String to be iterated over
	     * @param  begin  Index of the first character
	     * @param  end    Index of the character following the last character
	     * @param  pos    Initial iterator position
	     */
	    public JsonCharacterIterator(String text, int begin, int end, int pos) {
	        if (text == null)
	            throw new NullPointerException();
	        this.text = text;

	        if (begin < 0 || begin > end || end > text.length())
	            throw new IllegalArgumentException("Invalid substring range");

	        if (pos < begin || pos > end)
	            throw new IllegalArgumentException("Invalid position");

	        this.begin = begin;
	        this.end = end;
	        this.pos = pos;
	    }

	    /**
	     * Reset this iterator to point to a new string.  This package-visible
	     * method is used by other java.text classes that want to avoid allocating
	     * new StringCharacterIterator objects every time their setText method
	     * is called.
	     *
	     * @param  text   The String to be iterated over
	     * @since 1.2
	     */
	    public void insertText(String text) {
	        if (text == null)
	            throw new NullPointerException();
	        this.text = this.text.substring(0, pos) + text + this.text.substring(pos);
	        this.end += text.length();
	    }

	    /**
	     * Implements CharacterIterator.first() for String.
	     * @see CharacterIterator#first
	     */
	    public char first()
	    {
	        pos = begin;
	        return current();
	    }

	    /**
	     * Implements CharacterIterator.last() for String.
	     * @see CharacterIterator#last
	     */
	    public char last()
	    {
	        if (end != begin) {
	            pos = end - 1;
	        } else {
	            pos = end;
	        }
	        return current();
	     }

	    /**
	     * Implements CharacterIterator.setIndex() for String.
	     * @see CharacterIterator#setIndex
	     */
	    public char setIndex(int p)
	    {
	    if (p < begin || p > end)
	            throw new IllegalArgumentException("Invalid index");
	        pos = p;
	        return current();
	    }

	    /**
	     * Implements CharacterIterator.current() for String.
	     * @see CharacterIterator#current
	     */
	    public char current()
	    {
	        if (pos >= begin && pos < end) {
	            return text.charAt(pos);
	        }
	        else {
	            return DONE;
	        }
	    }

	    /**
	     * Implements CharacterIterator.next() for String.
	     * @see CharacterIterator#next
	     */
	    public char next()
	    {
	        if (pos < end - 1) {
	            pos++;
	            return text.charAt(pos);
	        }
	        else {
	            pos = end;
	            return DONE;
	        }
	    }

	    /**
	     * Implements CharacterIterator.previous() for String.
	     * @see CharacterIterator#previous
	     */
	    public char previous()
	    {
	        if (pos > begin) {
	            pos--;
	            return text.charAt(pos);
	        }
	        else {
	            return DONE;
	        }
	    }

	    /**
	     * Implements CharacterIterator.getBeginIndex() for String.
	     * @see CharacterIterator#getBeginIndex
	     */
	    public int getBeginIndex()
	    {
	        return begin;
	    }

	    /**
	     * Implements CharacterIterator.getEndIndex() for String.
	     * @see CharacterIterator#getEndIndex
	     */
	    public int getEndIndex()
	    {
	        return end;
	    }

	    /**
	     * Implements CharacterIterator.getIndex() for String.
	     * @see CharacterIterator#getIndex
	     */
	    public int getIndex()
	    {
	        return pos;
	    }

	    /**
	     * Compares the equality of two StringCharacterIterator objects.
	     * @param obj the StringCharacterIterator object to be compared with.
	     * @return true if the given obj is the same as this
	     * StringCharacterIterator object; false otherwise.
	     */
	    public boolean equals(Object obj)
	    {
	        if (this == obj)
	            return true;
	        if (!(obj instanceof StringCharacterIterator))
	            return false;

	        JsonCharacterIterator that = (JsonCharacterIterator) obj;

	        if (hashCode() != that.hashCode())
	            return false;
	        if (!text.equals(that.text))
	            return false;
	        if (pos != that.pos || begin != that.begin || end != that.end)
	            return false;
	        return true;
	    }

	    /**
	     * Computes a hashcode for this iterator.
	     * @return A hash code
	     */
	    public int hashCode()
	    {
	        return text.hashCode() ^ pos ^ begin ^ end;
	    }

	    /**
	     * Creates a copy of this iterator.
	     * @return A copy of this
	     */
	    public Object clone()
	    {
	        try {
	            StringCharacterIterator other
	            = (StringCharacterIterator) super.clone();
	            return other;
	        }
	        catch (CloneNotSupportedException e) {
	            throw new InternalError();
	        }
	    }

	    public String getErrorLine()
	    {
	    	return this.text.substring(0, pos) + "\n ======== ERROR ========= \n" + text.substring(pos);
	    }
	}
	
	public interface IJsonParseExt
	{
		public Object parseMacro(Reader reader, List<String> list);
		public boolean beforeAddArray(Reader reader, Object value);
		public boolean beforeAddMap(Reader reader, String key, Json child);
		public void finishAddArray(Reader reader);
		public void finishAddMap(Reader reader);
	}
}