+ * Each row of text represents a row in a table or a data record. Each row + * ends with a NEWLINE character. Each row contains one or more values. + * Values are separated by commas. A value can contain any character except + * for comma, unless is is wrapped in single quotes or double quotes. + *
+ * The first row usually contains the names of the columns. + *
+ * A comma delimited list can be converted into a JSONArray of JSONObjects.
+ * The names for the elements in the JSONObjects can be taken from the names
+ * in the first row.
+ * @author JSON.org
+ * @version 2012-11-13
+ */
+public class CDL {
+
+ /**
+ * Get the next value. The value can be wrapped in quotes. The value can
+ * be empty.
+ * @param x A JSONTokener of the source text.
+ * @return The value string, or null if empty.
+ * @throws JSONException if the quoted string is badly formed.
+ */
+ private static String getValue(JSONTokener x) throws JSONException {
+ char c;
+ char q;
+ StringBuffer sb;
+ do {
+ c = x.next();
+ } while (c == ' ' || c == '\t');
+ switch (c) {
+ case 0:
+ return null;
+ case '"':
+ case '\'':
+ q = c;
+ sb = new StringBuffer();
+ for (;;) {
+ c = x.next();
+ if (c == q) {
+ break;
+ }
+ if (c == 0 || c == '\n' || c == '\r') {
+ throw x.syntaxError("Missing close quote '" + q + "'.");
+ }
+ sb.append(c);
+ }
+ return sb.toString();
+ case ',':
+ x.back();
+ return "";
+ default:
+ x.back();
+ return x.nextTo(',');
+ }
+ }
+
+ /**
+ * Produce a JSONArray of strings from a row of comma delimited values.
+ * @param x A JSONTokener of the source text.
+ * @return A JSONArray of strings.
+ * @throws JSONException
+ */
+ public static JSONArray rowToJSONArray(JSONTokener x) throws JSONException {
+ JSONArray ja = new JSONArray();
+ for (;;) {
+ String value = getValue(x);
+ char c = x.next();
+ if (value == null ||
+ (ja.length() == 0 && value.length() == 0 && c != ',')) {
+ return null;
+ }
+ ja.put(value);
+ for (;;) {
+ if (c == ',') {
+ break;
+ }
+ if (c != ' ') {
+ if (c == '\n' || c == '\r' || c == 0) {
+ return ja;
+ }
+ throw x.syntaxError("Bad character '" + c + "' (" +
+ (int)c + ").");
+ }
+ c = x.next();
+ }
+ }
+ }
+
+ /**
+ * Produce a JSONObject from a row of comma delimited text, using a
+ * parallel JSONArray of strings to provides the names of the elements.
+ * @param names A JSONArray of names. This is commonly obtained from the
+ * first row of a comma delimited text file using the rowToJSONArray
+ * method.
+ * @param x A JSONTokener of the source text.
+ * @return A JSONObject combining the names and values.
+ * @throws JSONException
+ */
+ public static JSONObject rowToJSONObject(JSONArray names, JSONTokener x)
+ throws JSONException {
+ JSONArray ja = rowToJSONArray(x);
+ return ja != null ? ja.toJSONObject(names) : null;
+ }
+
+ /**
+ * Produce a comma delimited text row from a JSONArray. Values containing
+ * the comma character will be quoted. Troublesome characters may be
+ * removed.
+ * @param ja A JSONArray of strings.
+ * @return A string ending in NEWLINE.
+ */
+ public static String rowToString(JSONArray ja) {
+ StringBuffer sb = new StringBuffer();
+ for (int i = 0; i < ja.length(); i += 1) {
+ if (i > 0) {
+ sb.append(',');
+ }
+ Object object = ja.opt(i);
+ if (object != null) {
+ String string = object.toString();
+ if (string.length() > 0 && (string.indexOf(',') >= 0 ||
+ string.indexOf('\n') >= 0 || string.indexOf('\r') >= 0 ||
+ string.indexOf(0) >= 0 || string.charAt(0) == '"')) {
+ sb.append('"');
+ int length = string.length();
+ for (int j = 0; j < length; j += 1) {
+ char c = string.charAt(j);
+ if (c >= ' ' && c != '"') {
+ sb.append(c);
+ }
+ }
+ sb.append('"');
+ } else {
+ sb.append(string);
+ }
+ }
+ }
+ sb.append('\n');
+ return sb.toString();
+ }
+
+ /**
+ * Produce a JSONArray of JSONObjects from a comma delimited text string,
+ * using the first row as a source of names.
+ * @param string The comma delimited text.
+ * @return A JSONArray of JSONObjects.
+ * @throws JSONException
+ */
+ public static JSONArray toJSONArray(String string) throws JSONException {
+ return toJSONArray(new JSONTokener(string));
+ }
+
+ /**
+ * Produce a JSONArray of JSONObjects from a comma delimited text string,
+ * using the first row as a source of names.
+ * @param x The JSONTokener containing the comma delimited text.
+ * @return A JSONArray of JSONObjects.
+ * @throws JSONException
+ */
+ public static JSONArray toJSONArray(JSONTokener x) throws JSONException {
+ return toJSONArray(rowToJSONArray(x), x);
+ }
+
+ /**
+ * Produce a JSONArray of JSONObjects from a comma delimited text string
+ * using a supplied JSONArray as the source of element names.
+ * @param names A JSONArray of strings.
+ * @param string The comma delimited text.
+ * @return A JSONArray of JSONObjects.
+ * @throws JSONException
+ */
+ public static JSONArray toJSONArray(JSONArray names, String string)
+ throws JSONException {
+ return toJSONArray(names, new JSONTokener(string));
+ }
+
+ /**
+ * Produce a JSONArray of JSONObjects from a comma delimited text string
+ * using a supplied JSONArray as the source of element names.
+ * @param names A JSONArray of strings.
+ * @param x A JSONTokener of the source text.
+ * @return A JSONArray of JSONObjects.
+ * @throws JSONException
+ */
+ public static JSONArray toJSONArray(JSONArray names, JSONTokener x)
+ throws JSONException {
+ if (names == null || names.length() == 0) {
+ return null;
+ }
+ JSONArray ja = new JSONArray();
+ for (;;) {
+ JSONObject jo = rowToJSONObject(names, x);
+ if (jo == null) {
+ break;
+ }
+ ja.put(jo);
+ }
+ if (ja.length() == 0) {
+ return null;
+ }
+ return ja;
+ }
+
+
+ /**
+ * Produce a comma delimited text from a JSONArray of JSONObjects. The
+ * first row will be a list of names obtained by inspecting the first
+ * JSONObject.
+ * @param ja A JSONArray of JSONObjects.
+ * @return A comma delimited text.
+ * @throws JSONException
+ */
+ public static String toString(JSONArray ja) throws JSONException {
+ JSONObject jo = ja.optJSONObject(0);
+ if (jo != null) {
+ JSONArray names = jo.names();
+ if (names != null) {
+ return rowToString(names) + toString(names, ja);
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Produce a comma delimited text from a JSONArray of JSONObjects using
+ * a provided list of names. The list of names is not included in the
+ * output.
+ * @param names A JSONArray of strings.
+ * @param ja A JSONArray of JSONObjects.
+ * @return A comma delimited text.
+ * @throws JSONException
+ */
+ public static String toString(JSONArray names, JSONArray ja)
+ throws JSONException {
+ if (names == null || names.length() == 0) {
+ return null;
+ }
+ StringBuffer sb = new StringBuffer();
+ for (int i = 0; i < ja.length(); i += 1) {
+ JSONObject jo = ja.optJSONObject(i);
+ if (jo != null) {
+ sb.append(rowToString(jo.toJSONArray(names)));
+ }
+ }
+ return sb.toString();
+ }
+}
diff --git a/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/Cookie.java b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/Cookie.java
new file mode 100644
index 000000000..8c6691ead
--- /dev/null
+++ b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/Cookie.java
@@ -0,0 +1,169 @@
+package org.springframework.ide.eclipse.org.json;
+
+/*
+Copyright (c) 2002 JSON.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+The Software shall be used for Good, not Evil.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+/**
+ * Convert a web browser cookie specification to a JSONObject and back.
+ * JSON and Cookies are both notations for name/value pairs.
+ * @author JSON.org
+ * @version 2010-12-24
+ */
+public class Cookie {
+
+ /**
+ * Produce a copy of a string in which the characters '+', '%', '=', ';'
+ * and control characters are replaced with "%hh". This is a gentle form
+ * of URL encoding, attempting to cause as little distortion to the
+ * string as possible. The characters '=' and ';' are meta characters in
+ * cookies. By convention, they are escaped using the URL-encoding. This is
+ * only a convention, not a standard. Often, cookies are expected to have
+ * encoded values. We encode '=' and ';' because we must. We encode '%' and
+ * '+' because they are meta characters in URL encoding.
+ * @param string The source string.
+ * @return The escaped result.
+ */
+ public static String escape(String string) {
+ char c;
+ String s = string.trim();
+ StringBuffer sb = new StringBuffer();
+ int length = s.length();
+ for (int i = 0; i < length; i += 1) {
+ c = s.charAt(i);
+ if (c < ' ' || c == '+' || c == '%' || c == '=' || c == ';') {
+ sb.append('%');
+ sb.append(Character.forDigit((char)((c >>> 4) & 0x0f), 16));
+ sb.append(Character.forDigit((char)(c & 0x0f), 16));
+ } else {
+ sb.append(c);
+ }
+ }
+ return sb.toString();
+ }
+
+
+ /**
+ * Convert a cookie specification string into a JSONObject. The string
+ * will contain a name value pair separated by '='. The name and the value
+ * will be unescaped, possibly converting '+' and '%' sequences. The
+ * cookie properties may follow, separated by ';', also represented as
+ * name=value (except the secure property, which does not have a value).
+ * The name will be stored under the key "name", and the value will be
+ * stored under the key "value". This method does not do checking or
+ * validation of the parameters. It only converts the cookie string into
+ * a JSONObject.
+ * @param string The cookie specification string.
+ * @return A JSONObject containing "name", "value", and possibly other
+ * members.
+ * @throws JSONException
+ */
+ public static JSONObject toJSONObject(String string) throws JSONException {
+ String name;
+ JSONObject jo = new JSONObject();
+ Object value;
+ JSONTokener x = new JSONTokener(string);
+ jo.put("name", x.nextTo('='));
+ x.next('=');
+ jo.put("value", x.nextTo(';'));
+ x.next();
+ while (x.more()) {
+ name = unescape(x.nextTo("=;"));
+ if (x.next() != '=') {
+ if (name.equals("secure")) {
+ value = Boolean.TRUE;
+ } else {
+ throw x.syntaxError("Missing '=' in cookie parameter.");
+ }
+ } else {
+ value = unescape(x.nextTo(';'));
+ x.next();
+ }
+ jo.put(name, value);
+ }
+ return jo;
+ }
+
+
+ /**
+ * Convert a JSONObject into a cookie specification string. The JSONObject
+ * must contain "name" and "value" members.
+ * If the JSONObject contains "expires", "domain", "path", or "secure"
+ * members, they will be appended to the cookie specification string.
+ * All other members are ignored.
+ * @param jo A JSONObject
+ * @return A cookie specification string
+ * @throws JSONException
+ */
+ public static String toString(JSONObject jo) throws JSONException {
+ StringBuffer sb = new StringBuffer();
+
+ sb.append(escape(jo.getString("name")));
+ sb.append("=");
+ sb.append(escape(jo.getString("value")));
+ if (jo.has("expires")) {
+ sb.append(";expires=");
+ sb.append(jo.getString("expires"));
+ }
+ if (jo.has("domain")) {
+ sb.append(";domain=");
+ sb.append(escape(jo.getString("domain")));
+ }
+ if (jo.has("path")) {
+ sb.append(";path=");
+ sb.append(escape(jo.getString("path")));
+ }
+ if (jo.optBoolean("secure")) {
+ sb.append(";secure");
+ }
+ return sb.toString();
+ }
+
+ /**
+ * Convert %hh sequences to single characters, and
+ * convert plus to space.
+ * @param string A string that may contain
+ * + (plus) and
+ * %hh sequences.
+ * @return The unescaped string.
+ */
+ public static String unescape(String string) {
+ int length = string.length();
+ StringBuffer sb = new StringBuffer();
+ for (int i = 0; i < length; ++i) {
+ char c = string.charAt(i);
+ if (c == '+') {
+ c = ' ';
+ } else if (c == '%' && i + 2 < length) {
+ int d = JSONTokener.dehexchar(string.charAt(i + 1));
+ int e = JSONTokener.dehexchar(string.charAt(i + 2));
+ if (d >= 0 && e >= 0) {
+ c = (char)(d * 16 + e);
+ i += 2;
+ }
+ }
+ sb.append(c);
+ }
+ return sb.toString();
+ }
+}
diff --git a/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/CookieList.java b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/CookieList.java
new file mode 100644
index 000000000..87353b19b
--- /dev/null
+++ b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/CookieList.java
@@ -0,0 +1,90 @@
+package org.springframework.ide.eclipse.org.json;
+
+/*
+Copyright (c) 2002 JSON.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+The Software shall be used for Good, not Evil.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+import java.util.Iterator;
+
+/**
+ * Convert a web browser cookie list string to a JSONObject and back.
+ * @author JSON.org
+ * @version 2010-12-24
+ */
+public class CookieList {
+
+ /**
+ * Convert a cookie list into a JSONObject. A cookie list is a sequence
+ * of name/value pairs. The names are separated from the values by '='.
+ * The pairs are separated by ';'. The names and the values
+ * will be unescaped, possibly converting '+' and '%' sequences.
+ *
+ * To add a cookie to a cooklist,
+ * cookielistJSONObject.put(cookieJSONObject.getString("name"),
+ * cookieJSONObject.getString("value"));
+ * @param string A cookie list string
+ * @return A JSONObject
+ * @throws JSONException
+ */
+ public static JSONObject toJSONObject(String string) throws JSONException {
+ JSONObject jo = new JSONObject();
+ JSONTokener x = new JSONTokener(string);
+ while (x.more()) {
+ String name = Cookie.unescape(x.nextTo('='));
+ x.next('=');
+ jo.put(name, Cookie.unescape(x.nextTo(';')));
+ x.next();
+ }
+ return jo;
+ }
+
+
+ /**
+ * Convert a JSONObject into a cookie list. A cookie list is a sequence
+ * of name/value pairs. The names are separated from the values by '='.
+ * The pairs are separated by ';'. The characters '%', '+', '=', and ';'
+ * in the names and values are replaced by "%hh".
+ * @param jo A JSONObject
+ * @return A cookie list string
+ * @throws JSONException
+ */
+ public static String toString(JSONObject jo) throws JSONException {
+ boolean b = false;
+ Iterator keys = jo.keys();
+ String string;
+ StringBuffer sb = new StringBuffer();
+ while (keys.hasNext()) {
+ string = keys.next().toString();
+ if (!jo.isNull(string)) {
+ if (b) {
+ sb.append(';');
+ }
+ sb.append(Cookie.escape(string));
+ sb.append("=");
+ sb.append(Cookie.escape(jo.getString(string)));
+ b = true;
+ }
+ }
+ return sb.toString();
+ }
+}
diff --git a/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/HTTP.java b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/HTTP.java
new file mode 100644
index 000000000..8c477fea5
--- /dev/null
+++ b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/HTTP.java
@@ -0,0 +1,163 @@
+package org.springframework.ide.eclipse.org.json;
+
+/*
+Copyright (c) 2002 JSON.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+The Software shall be used for Good, not Evil.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+import java.util.Iterator;
+
+/**
+ * Convert an HTTP header to a JSONObject and back.
+ * @author JSON.org
+ * @version 2010-12-24
+ */
+public class HTTP {
+
+ /** Carriage return/line feed. */
+ public static final String CRLF = "\r\n";
+
+ /**
+ * Convert an HTTP header string into a JSONObject. It can be a request
+ * header or a response header. A request header will contain
+ *
{
+ * Method: "POST" (for example),
+ * "Request-URI": "/" (for example),
+ * "HTTP-Version": "HTTP/1.1" (for example)
+ * }
+ * A response header will contain
+ * {
+ * "HTTP-Version": "HTTP/1.1" (for example),
+ * "Status-Code": "200" (for example),
+ * "Reason-Phrase": "OK" (for example)
+ * }
+ * In addition, the other parameters in the header will be captured, using
+ * the HTTP field names as JSON names, so that + * Date: Sun, 26 May 2002 18:06:04 GMT + * Cookie: Q=q2=PPEAsg--; B=677gi6ouf29bn&b=2&f=s + * Cache-Control: no-cache+ * become + *
{...
+ * Date: "Sun, 26 May 2002 18:06:04 GMT",
+ * Cookie: "Q=q2=PPEAsg--; B=677gi6ouf29bn&b=2&f=s",
+ * "Cache-Control": "no-cache",
+ * ...}
+ * It does no further checking or conversion. It does not parse dates.
+ * It does not do '%' transforms on URLs.
+ * @param string An HTTP header string.
+ * @return A JSONObject containing the elements and attributes
+ * of the XML string.
+ * @throws JSONException
+ */
+ public static JSONObject toJSONObject(String string) throws JSONException {
+ JSONObject jo = new JSONObject();
+ HTTPTokener x = new HTTPTokener(string);
+ String token;
+
+ token = x.nextToken();
+ if (token.toUpperCase().startsWith("HTTP")) {
+
+// Response
+
+ jo.put("HTTP-Version", token);
+ jo.put("Status-Code", x.nextToken());
+ jo.put("Reason-Phrase", x.nextTo('\0'));
+ x.next();
+
+ } else {
+
+// Request
+
+ jo.put("Method", token);
+ jo.put("Request-URI", x.nextToken());
+ jo.put("HTTP-Version", x.nextToken());
+ }
+
+// Fields
+
+ while (x.more()) {
+ String name = x.nextTo(':');
+ x.next(':');
+ jo.put(name, x.nextTo('\0'));
+ x.next();
+ }
+ return jo;
+ }
+
+
+ /**
+ * Convert a JSONObject into an HTTP header. A request header must contain
+ * {
+ * Method: "POST" (for example),
+ * "Request-URI": "/" (for example),
+ * "HTTP-Version": "HTTP/1.1" (for example)
+ * }
+ * A response header must contain
+ * {
+ * "HTTP-Version": "HTTP/1.1" (for example),
+ * "Status-Code": "200" (for example),
+ * "Reason-Phrase": "OK" (for example)
+ * }
+ * Any other members of the JSONObject will be output as HTTP fields.
+ * The result will end with two CRLF pairs.
+ * @param jo A JSONObject
+ * @return An HTTP header string.
+ * @throws JSONException if the object does not contain enough
+ * information.
+ */
+ public static String toString(JSONObject jo) throws JSONException {
+ Iterator keys = jo.keys();
+ String string;
+ StringBuffer sb = new StringBuffer();
+ if (jo.has("Status-Code") && jo.has("Reason-Phrase")) {
+ sb.append(jo.getString("HTTP-Version"));
+ sb.append(' ');
+ sb.append(jo.getString("Status-Code"));
+ sb.append(' ');
+ sb.append(jo.getString("Reason-Phrase"));
+ } else if (jo.has("Method") && jo.has("Request-URI")) {
+ sb.append(jo.getString("Method"));
+ sb.append(' ');
+ sb.append('"');
+ sb.append(jo.getString("Request-URI"));
+ sb.append('"');
+ sb.append(' ');
+ sb.append(jo.getString("HTTP-Version"));
+ } else {
+ throw new JSONException("Not enough material for an HTTP header.");
+ }
+ sb.append(CRLF);
+ while (keys.hasNext()) {
+ string = keys.next().toString();
+ if (!"HTTP-Version".equals(string) && !"Status-Code".equals(string) &&
+ !"Reason-Phrase".equals(string) && !"Method".equals(string) &&
+ !"Request-URI".equals(string) && !jo.isNull(string)) {
+ sb.append(string);
+ sb.append(": ");
+ sb.append(jo.getString(string));
+ sb.append(CRLF);
+ }
+ }
+ sb.append(CRLF);
+ return sb.toString();
+ }
+}
diff --git a/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/HTTPTokener.java b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/HTTPTokener.java
new file mode 100644
index 000000000..ef7246735
--- /dev/null
+++ b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/HTTPTokener.java
@@ -0,0 +1,77 @@
+package org.springframework.ide.eclipse.org.json;
+
+/*
+Copyright (c) 2002 JSON.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+The Software shall be used for Good, not Evil.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+/**
+ * The HTTPTokener extends the JSONTokener to provide additional methods
+ * for the parsing of HTTP headers.
+ * @author JSON.org
+ * @version 2012-11-13
+ */
+public class HTTPTokener extends JSONTokener {
+
+ /**
+ * Construct an HTTPTokener from a string.
+ * @param string A source string.
+ */
+ public HTTPTokener(String string) {
+ super(string);
+ }
+
+
+ /**
+ * Get the next token or string. This is used in parsing HTTP headers.
+ * @throws JSONException
+ * @return A String.
+ */
+ public String nextToken() throws JSONException {
+ char c;
+ char q;
+ StringBuffer sb = new StringBuffer();
+ do {
+ c = next();
+ } while (Character.isWhitespace(c));
+ if (c == '"' || c == '\'') {
+ q = c;
+ for (;;) {
+ c = next();
+ if (c < ' ') {
+ throw syntaxError("Unterminated string.");
+ }
+ if (c == q) {
+ return sb.toString();
+ }
+ sb.append(c);
+ }
+ }
+ for (;;) {
+ if (c == 0 || Character.isWhitespace(c)) {
+ return sb.toString();
+ }
+ sb.append(c);
+ c = next();
+ }
+ }
+}
diff --git a/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/JSONArray.java b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/JSONArray.java
new file mode 100644
index 000000000..b9ebb177f
--- /dev/null
+++ b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/JSONArray.java
@@ -0,0 +1,944 @@
+package org.springframework.ide.eclipse.org.json;
+
+/*
+ Copyright (c) 2002 JSON.org
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ The Software shall be used for Good, not Evil.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+ */
+
+import java.io.IOException;
+import java.io.StringWriter;
+import java.io.Writer;
+import java.lang.reflect.Array;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Map;
+
+/**
+ * A JSONArray is an ordered sequence of values. Its external text form is a
+ * string wrapped in square brackets with commas separating the values. The
+ * internal form is an object having get and opt
+ * methods for accessing the values by index, and put methods for
+ * adding or replacing values. The values can be any of these types:
+ * Boolean, JSONArray, JSONObject,
+ * Number, String, or the
+ * JSONObject.NULL object.
+ *
+ * The constructor can convert a JSON text into a Java object. The
+ * toString method converts to JSON text.
+ *
+ * A get method returns a value if one can be found, and throws an
+ * exception if one cannot be found. An opt method returns a
+ * default value instead of throwing an exception, and so is useful for
+ * obtaining optional values.
+ *
+ * The generic get() and opt() methods return an
+ * object which you can cast or query for type. There are also typed
+ * get and opt methods that do type checking and type
+ * coercion for you.
+ *
+ * The texts produced by the toString methods strictly conform to
+ * JSON syntax rules. The constructors are more forgiving in the texts they will
+ * accept:
+ *
, (comma) may appear just
+ * before the closing bracket.null value will be inserted when there is ,
+ * (comma) elision.' (single
+ * quote).{ } [ ] / \ : , # and if they do not look like numbers and
+ * if they are not the reserved words true, false, or
+ * null.[ (left
+ * bracket) and ends with ]
+ * (right bracket).
+ * @throws JSONException
+ * If there is a syntax error.
+ */
+ public JSONArray(String source) throws JSONException {
+ this(new JSONTokener(source));
+ }
+
+ /**
+ * Construct a JSONArray from a Collection.
+ *
+ * @param collection
+ * A Collection.
+ */
+ public JSONArray(Collection collection) {
+ this.myArrayList = new ArrayList();
+ if (collection != null) {
+ Iterator iter = collection.iterator();
+ while (iter.hasNext()) {
+ this.myArrayList.add(JSONObject.wrap(iter.next()));
+ }
+ }
+ }
+
+ /**
+ * Construct a JSONArray from an array
+ *
+ * @throws JSONException
+ * If not an array.
+ */
+ public JSONArray(Object array) throws JSONException {
+ this();
+ if (array.getClass().isArray()) {
+ int length = Array.getLength(array);
+ for (int i = 0; i < length; i += 1) {
+ this.put(JSONObject.wrap(Array.get(array, i)));
+ }
+ } else {
+ throw new JSONException(
+ "JSONArray initial value should be a string or collection or array.");
+ }
+ }
+
+ /**
+ * Get the object value associated with an index.
+ *
+ * @param index
+ * The index must be between 0 and length() - 1.
+ * @return An object value.
+ * @throws JSONException
+ * If there is no value for the index.
+ */
+ public Object get(int index) throws JSONException {
+ Object object = this.opt(index);
+ if (object == null) {
+ throw new JSONException("JSONArray[" + index + "] not found.");
+ }
+ return object;
+ }
+
+ /**
+ * Get the boolean value associated with an index. The string values "true"
+ * and "false" are converted to boolean.
+ *
+ * @param index
+ * The index must be between 0 and length() - 1.
+ * @return The truth.
+ * @throws JSONException
+ * If there is no value for the index or if the value is not
+ * convertible to boolean.
+ */
+ public boolean getBoolean(int index) throws JSONException {
+ Object object = this.get(index);
+ if (object.equals(Boolean.FALSE)
+ || (object instanceof String && ((String) object)
+ .equalsIgnoreCase("false"))) {
+ return false;
+ } else if (object.equals(Boolean.TRUE)
+ || (object instanceof String && ((String) object)
+ .equalsIgnoreCase("true"))) {
+ return true;
+ }
+ throw new JSONException("JSONArray[" + index + "] is not a boolean.");
+ }
+
+ /**
+ * Get the double value associated with an index.
+ *
+ * @param index
+ * The index must be between 0 and length() - 1.
+ * @return The value.
+ * @throws JSONException
+ * If the key is not found or if the value cannot be converted
+ * to a number.
+ */
+ public double getDouble(int index) throws JSONException {
+ Object object = this.get(index);
+ try {
+ return object instanceof Number ? ((Number) object).doubleValue()
+ : Double.parseDouble((String) object);
+ } catch (Exception e) {
+ throw new JSONException("JSONArray[" + index + "] is not a number.");
+ }
+ }
+
+ /**
+ * Get the int value associated with an index.
+ *
+ * @param index
+ * The index must be between 0 and length() - 1.
+ * @return The value.
+ * @throws JSONException
+ * If the key is not found or if the value is not a number.
+ */
+ public int getInt(int index) throws JSONException {
+ Object object = this.get(index);
+ try {
+ return object instanceof Number ? ((Number) object).intValue()
+ : Integer.parseInt((String) object);
+ } catch (Exception e) {
+ throw new JSONException("JSONArray[" + index + "] is not a number.");
+ }
+ }
+
+ /**
+ * Get the JSONArray associated with an index.
+ *
+ * @param index
+ * The index must be between 0 and length() - 1.
+ * @return A JSONArray value.
+ * @throws JSONException
+ * If there is no value for the index. or if the value is not a
+ * JSONArray
+ */
+ public JSONArray getJSONArray(int index) throws JSONException {
+ Object object = this.get(index);
+ if (object instanceof JSONArray) {
+ return (JSONArray) object;
+ }
+ throw new JSONException("JSONArray[" + index + "] is not a JSONArray.");
+ }
+
+ /**
+ * Get the JSONObject associated with an index.
+ *
+ * @param index
+ * subscript
+ * @return A JSONObject value.
+ * @throws JSONException
+ * If there is no value for the index or if the value is not a
+ * JSONObject
+ */
+ public JSONObject getJSONObject(int index) throws JSONException {
+ Object object = this.get(index);
+ if (object instanceof JSONObject) {
+ return (JSONObject) object;
+ }
+ throw new JSONException("JSONArray[" + index + "] is not a JSONObject.");
+ }
+
+ /**
+ * Get the long value associated with an index.
+ *
+ * @param index
+ * The index must be between 0 and length() - 1.
+ * @return The value.
+ * @throws JSONException
+ * If the key is not found or if the value cannot be converted
+ * to a number.
+ */
+ public long getLong(int index) throws JSONException {
+ Object object = this.get(index);
+ try {
+ return object instanceof Number ? ((Number) object).longValue()
+ : Long.parseLong((String) object);
+ } catch (Exception e) {
+ throw new JSONException("JSONArray[" + index + "] is not a number.");
+ }
+ }
+
+ /**
+ * Get the string associated with an index.
+ *
+ * @param index
+ * The index must be between 0 and length() - 1.
+ * @return A string value.
+ * @throws JSONException
+ * If there is no string value for the index.
+ */
+ public String getString(int index) throws JSONException {
+ Object object = this.get(index);
+ if (object instanceof String) {
+ return (String) object;
+ }
+ throw new JSONException("JSONArray[" + index + "] not a string.");
+ }
+
+ /**
+ * Determine if the value is null.
+ *
+ * @param index
+ * The index must be between 0 and length() - 1.
+ * @return true if the value at the index is null, or if there is no value.
+ */
+ public boolean isNull(int index) {
+ return JSONObject.NULL.equals(this.opt(index));
+ }
+
+ /**
+ * Make a string from the contents of this JSONArray. The
+ * separator string is inserted between each element. Warning:
+ * This method assumes that the data structure is acyclical.
+ *
+ * @param separator
+ * A string that will be inserted between the elements.
+ * @return a string.
+ * @throws JSONException
+ * If the array contains an invalid number.
+ */
+ public String join(String separator) throws JSONException {
+ int len = this.length();
+ StringBuffer sb = new StringBuffer();
+
+ for (int i = 0; i < len; i += 1) {
+ if (i > 0) {
+ sb.append(separator);
+ }
+ sb.append(JSONObject.valueToString(this.myArrayList.get(i)));
+ }
+ return sb.toString();
+ }
+
+ /**
+ * Get the number of elements in the JSONArray, included nulls.
+ *
+ * @return The length (or size).
+ */
+ public int length() {
+ return this.myArrayList.size();
+ }
+
+ /**
+ * Get the optional object value associated with an index.
+ *
+ * @param index
+ * The index must be between 0 and length() - 1.
+ * @return An object value, or null if there is no object at that index.
+ */
+ public Object opt(int index) {
+ return (index < 0 || index >= this.length()) ? null : this.myArrayList
+ .get(index);
+ }
+
+ /**
+ * Get the optional boolean value associated with an index. It returns false
+ * if there is no value at that index, or if the value is not Boolean.TRUE
+ * or the String "true".
+ *
+ * @param index
+ * The index must be between 0 and length() - 1.
+ * @return The truth.
+ */
+ public boolean optBoolean(int index) {
+ return this.optBoolean(index, false);
+ }
+
+ /**
+ * Get the optional boolean value associated with an index. It returns the
+ * defaultValue if there is no value at that index or if it is not a Boolean
+ * or the String "true" or "false" (case insensitive).
+ *
+ * @param index
+ * The index must be between 0 and length() - 1.
+ * @param defaultValue
+ * A boolean default.
+ * @return The truth.
+ */
+ public boolean optBoolean(int index, boolean defaultValue) {
+ try {
+ return this.getBoolean(index);
+ } catch (Exception e) {
+ return defaultValue;
+ }
+ }
+
+ /**
+ * Get the optional double value associated with an index. NaN is returned
+ * if there is no value for the index, or if the value is not a number and
+ * cannot be converted to a number.
+ *
+ * @param index
+ * The index must be between 0 and length() - 1.
+ * @return The value.
+ */
+ public double optDouble(int index) {
+ return this.optDouble(index, Double.NaN);
+ }
+
+ /**
+ * Get the optional double value associated with an index. The defaultValue
+ * is returned if there is no value for the index, or if the value is not a
+ * number and cannot be converted to a number.
+ *
+ * @param index
+ * subscript
+ * @param defaultValue
+ * The default value.
+ * @return The value.
+ */
+ public double optDouble(int index, double defaultValue) {
+ try {
+ return this.getDouble(index);
+ } catch (Exception e) {
+ return defaultValue;
+ }
+ }
+
+ /**
+ * Get the optional int value associated with an index. Zero is returned if
+ * there is no value for the index, or if the value is not a number and
+ * cannot be converted to a number.
+ *
+ * @param index
+ * The index must be between 0 and length() - 1.
+ * @return The value.
+ */
+ public int optInt(int index) {
+ return this.optInt(index, 0);
+ }
+
+ /**
+ * Get the optional int value associated with an index. The defaultValue is
+ * returned if there is no value for the index, or if the value is not a
+ * number and cannot be converted to a number.
+ *
+ * @param index
+ * The index must be between 0 and length() - 1.
+ * @param defaultValue
+ * The default value.
+ * @return The value.
+ */
+ public int optInt(int index, int defaultValue) {
+ try {
+ return this.getInt(index);
+ } catch (Exception e) {
+ return defaultValue;
+ }
+ }
+
+ /**
+ * Get the optional JSONArray associated with an index.
+ *
+ * @param index
+ * subscript
+ * @return A JSONArray value, or null if the index has no value, or if the
+ * value is not a JSONArray.
+ */
+ public JSONArray optJSONArray(int index) {
+ Object o = this.opt(index);
+ return o instanceof JSONArray ? (JSONArray) o : null;
+ }
+
+ /**
+ * Get the optional JSONObject associated with an index. Null is returned if
+ * the key is not found, or null if the index has no value, or if the value
+ * is not a JSONObject.
+ *
+ * @param index
+ * The index must be between 0 and length() - 1.
+ * @return A JSONObject value.
+ */
+ public JSONObject optJSONObject(int index) {
+ Object o = this.opt(index);
+ return o instanceof JSONObject ? (JSONObject) o : null;
+ }
+
+ /**
+ * Get the optional long value associated with an index. Zero is returned if
+ * there is no value for the index, or if the value is not a number and
+ * cannot be converted to a number.
+ *
+ * @param index
+ * The index must be between 0 and length() - 1.
+ * @return The value.
+ */
+ public long optLong(int index) {
+ return this.optLong(index, 0);
+ }
+
+ /**
+ * Get the optional long value associated with an index. The defaultValue is
+ * returned if there is no value for the index, or if the value is not a
+ * number and cannot be converted to a number.
+ *
+ * @param index
+ * The index must be between 0 and length() - 1.
+ * @param defaultValue
+ * The default value.
+ * @return The value.
+ */
+ public long optLong(int index, long defaultValue) {
+ try {
+ return this.getLong(index);
+ } catch (Exception e) {
+ return defaultValue;
+ }
+ }
+
+ /**
+ * Get the optional string value associated with an index. It returns an
+ * empty string if there is no value at that index. If the value is not a
+ * string and is not null, then it is coverted to a string.
+ *
+ * @param index
+ * The index must be between 0 and length() - 1.
+ * @return A String value.
+ */
+ public String optString(int index) {
+ return this.optString(index, "");
+ }
+
+ /**
+ * Get the optional string associated with an index. The defaultValue is
+ * returned if the key is not found.
+ *
+ * @param index
+ * The index must be between 0 and length() - 1.
+ * @param defaultValue
+ * The default value.
+ * @return A String value.
+ */
+ public String optString(int index, String defaultValue) {
+ Object object = this.opt(index);
+ return JSONObject.NULL.equals(object) ? defaultValue : object
+ .toString();
+ }
+
+ /**
+ * Append a boolean value. This increases the array's length by one.
+ *
+ * @param value
+ * A boolean value.
+ * @return this.
+ */
+ public JSONArray put(boolean value) {
+ this.put(value ? Boolean.TRUE : Boolean.FALSE);
+ return this;
+ }
+
+ /**
+ * Put a value in the JSONArray, where the value will be a JSONArray which
+ * is produced from a Collection.
+ *
+ * @param value
+ * A Collection value.
+ * @return this.
+ */
+ public JSONArray put(Collection value) {
+ this.put(new JSONArray(value));
+ return this;
+ }
+
+ /**
+ * Append a double value. This increases the array's length by one.
+ *
+ * @param value
+ * A double value.
+ * @throws JSONException
+ * if the value is not finite.
+ * @return this.
+ */
+ public JSONArray put(double value) throws JSONException {
+ Double d = new Double(value);
+ JSONObject.testValidity(d);
+ this.put(d);
+ return this;
+ }
+
+ /**
+ * Append an int value. This increases the array's length by one.
+ *
+ * @param value
+ * An int value.
+ * @return this.
+ */
+ public JSONArray put(int value) {
+ this.put(new Integer(value));
+ return this;
+ }
+
+ /**
+ * Append an long value. This increases the array's length by one.
+ *
+ * @param value
+ * A long value.
+ * @return this.
+ */
+ public JSONArray put(long value) {
+ this.put(new Long(value));
+ return this;
+ }
+
+ /**
+ * Put a value in the JSONArray, where the value will be a JSONObject which
+ * is produced from a Map.
+ *
+ * @param value
+ * A Map value.
+ * @return this.
+ */
+ public JSONArray put(Map value) {
+ this.put(new JSONObject(value));
+ return this;
+ }
+
+ /**
+ * Append an object value. This increases the array's length by one.
+ *
+ * @param value
+ * An object value. The value should be a Boolean, Double,
+ * Integer, JSONArray, JSONObject, Long, or String, or the
+ * JSONObject.NULL object.
+ * @return this.
+ */
+ public JSONArray put(Object value) {
+ this.myArrayList.add(value);
+ return this;
+ }
+
+ /**
+ * Put or replace a boolean value in the JSONArray. If the index is greater
+ * than the length of the JSONArray, then null elements will be added as
+ * necessary to pad it out.
+ *
+ * @param index
+ * The subscript.
+ * @param value
+ * A boolean value.
+ * @return this.
+ * @throws JSONException
+ * If the index is negative.
+ */
+ public JSONArray put(int index, boolean value) throws JSONException {
+ this.put(index, value ? Boolean.TRUE : Boolean.FALSE);
+ return this;
+ }
+
+ /**
+ * Put a value in the JSONArray, where the value will be a JSONArray which
+ * is produced from a Collection.
+ *
+ * @param index
+ * The subscript.
+ * @param value
+ * A Collection value.
+ * @return this.
+ * @throws JSONException
+ * If the index is negative or if the value is not finite.
+ */
+ public JSONArray put(int index, Collection value) throws JSONException {
+ this.put(index, new JSONArray(value));
+ return this;
+ }
+
+ /**
+ * Put or replace a double value. If the index is greater than the length of
+ * the JSONArray, then null elements will be added as necessary to pad it
+ * out.
+ *
+ * @param index
+ * The subscript.
+ * @param value
+ * A double value.
+ * @return this.
+ * @throws JSONException
+ * If the index is negative or if the value is not finite.
+ */
+ public JSONArray put(int index, double value) throws JSONException {
+ this.put(index, new Double(value));
+ return this;
+ }
+
+ /**
+ * Put or replace an int value. If the index is greater than the length of
+ * the JSONArray, then null elements will be added as necessary to pad it
+ * out.
+ *
+ * @param index
+ * The subscript.
+ * @param value
+ * An int value.
+ * @return this.
+ * @throws JSONException
+ * If the index is negative.
+ */
+ public JSONArray put(int index, int value) throws JSONException {
+ this.put(index, new Integer(value));
+ return this;
+ }
+
+ /**
+ * Put or replace a long value. If the index is greater than the length of
+ * the JSONArray, then null elements will be added as necessary to pad it
+ * out.
+ *
+ * @param index
+ * The subscript.
+ * @param value
+ * A long value.
+ * @return this.
+ * @throws JSONException
+ * If the index is negative.
+ */
+ public JSONArray put(int index, long value) throws JSONException {
+ this.put(index, new Long(value));
+ return this;
+ }
+
+ /**
+ * Put a value in the JSONArray, where the value will be a JSONObject that
+ * is produced from a Map.
+ *
+ * @param index
+ * The subscript.
+ * @param value
+ * The Map value.
+ * @return this.
+ * @throws JSONException
+ * If the index is negative or if the the value is an invalid
+ * number.
+ */
+ public JSONArray put(int index, Map value) throws JSONException {
+ this.put(index, new JSONObject(value));
+ return this;
+ }
+
+ /**
+ * Put or replace an object value in the JSONArray. If the index is greater
+ * than the length of the JSONArray, then null elements will be added as
+ * necessary to pad it out.
+ *
+ * @param index
+ * The subscript.
+ * @param value
+ * The value to put into the array. The value should be a
+ * Boolean, Double, Integer, JSONArray, JSONObject, Long, or
+ * String, or the JSONObject.NULL object.
+ * @return this.
+ * @throws JSONException
+ * If the index is negative or if the the value is an invalid
+ * number.
+ */
+ public JSONArray put(int index, Object value) throws JSONException {
+ JSONObject.testValidity(value);
+ if (index < 0) {
+ throw new JSONException("JSONArray[" + index + "] not found.");
+ }
+ if (index < this.length()) {
+ this.myArrayList.set(index, value);
+ } else {
+ while (index != this.length()) {
+ this.put(JSONObject.NULL);
+ }
+ this.put(value);
+ }
+ return this;
+ }
+
+ /**
+ * Remove an index and close the hole.
+ *
+ * @param index
+ * The index of the element to be removed.
+ * @return The value that was associated with the index, or null if there
+ * was no value.
+ */
+ public Object remove(int index) {
+ Object o = this.opt(index);
+ this.myArrayList.remove(index);
+ return o;
+ }
+
+ /**
+ * Produce a JSONObject by combining a JSONArray of names with the values of
+ * this JSONArray.
+ *
+ * @param names
+ * A JSONArray containing a list of key strings. These will be
+ * paired with the values.
+ * @return A JSONObject, or null if there are no names or if this JSONArray
+ * has no values.
+ * @throws JSONException
+ * If any of the names are null.
+ */
+ public JSONObject toJSONObject(JSONArray names) throws JSONException {
+ if (names == null || names.length() == 0 || this.length() == 0) {
+ return null;
+ }
+ JSONObject jo = new JSONObject();
+ for (int i = 0; i < names.length(); i += 1) {
+ jo.put(names.getString(i), this.opt(i));
+ }
+ return jo;
+ }
+
+ /**
+ * Make a JSON text of this JSONArray. For compactness, no unnecessary
+ * whitespace is added. If it is not possible to produce a syntactically
+ * correct JSON text then null will be returned instead. This could occur if
+ * the array contains an invalid number.
+ *
+ * Warning: This method assumes that the data structure is acyclical.
+ *
+ * @return a printable, displayable, transmittable representation of the
+ * array.
+ */
+ public String toString() {
+ try {
+ return this.toString(0);
+ } catch (Exception e) {
+ return null;
+ }
+ }
+
+ /**
+ * Make a prettyprinted JSON text of this JSONArray. Warning: This method
+ * assumes that the data structure is acyclical.
+ *
+ * @param indentFactor
+ * The number of spaces to add to each level of indentation.
+ * @return a printable, displayable, transmittable representation of the
+ * object, beginning with [ (left
+ * bracket) and ending with ]
+ * (right bracket).
+ * @throws JSONException
+ */
+ public String toString(int indentFactor) throws JSONException {
+ StringWriter sw = new StringWriter();
+ synchronized (sw.getBuffer()) {
+ return this.write(sw, indentFactor, 0).toString();
+ }
+ }
+
+ /**
+ * Write the contents of the JSONArray as JSON text to a writer. For
+ * compactness, no whitespace is added.
+ *
+ * Warning: This method assumes that the data structure is acyclical. + * + * @return The writer. + * @throws JSONException + */ + public Writer write(Writer writer) throws JSONException { + return this.write(writer, 0, 0); + } + + /** + * Write the contents of the JSONArray as JSON text to a writer. For + * compactness, no whitespace is added. + *
+ * Warning: This method assumes that the data structure is acyclical.
+ *
+ * @param indentFactor
+ * The number of spaces to add to each level of indentation.
+ * @param indent
+ * The indention of the top level.
+ * @return The writer.
+ * @throws JSONException
+ */
+ Writer write(Writer writer, int indentFactor, int indent)
+ throws JSONException {
+ try {
+ boolean commanate = false;
+ int length = this.length();
+ writer.write('[');
+
+ if (length == 1) {
+ JSONObject.writeValue(writer, this.myArrayList.get(0),
+ indentFactor, indent);
+ } else if (length != 0) {
+ final int newindent = indent + indentFactor;
+
+ for (int i = 0; i < length; i += 1) {
+ if (commanate) {
+ writer.write(',');
+ }
+ if (indentFactor > 0) {
+ writer.write('\n');
+ }
+ JSONObject.indent(writer, newindent);
+ JSONObject.writeValue(writer, this.myArrayList.get(i),
+ indentFactor, newindent);
+ commanate = true;
+ }
+ if (indentFactor > 0) {
+ writer.write('\n');
+ }
+ JSONObject.indent(writer, indent);
+ }
+ writer.write(']');
+ return writer;
+ } catch (IOException e) {
+ throw new JSONException(e);
+ }
+ }
+}
diff --git a/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/JSONException.java b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/JSONException.java
new file mode 100644
index 000000000..3b73decd7
--- /dev/null
+++ b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/JSONException.java
@@ -0,0 +1,41 @@
+package org.springframework.ide.eclipse.org.json;
+
+/**
+ * The JSONException is thrown by the JSON.org classes when things are amiss.
+ *
+ * @author JSON.org
+ * @version 2013-02-10
+ */
+public class JSONException extends RuntimeException {
+ private static final long serialVersionUID = 0;
+ private Throwable cause;
+
+ /**
+ * Constructs a JSONException with an explanatory message.
+ *
+ * @param message
+ * Detail about the reason for the exception.
+ */
+ public JSONException(String message) {
+ super(message);
+ }
+
+ /**
+ * Constructs a new JSONException with the specified cause.
+ */
+ public JSONException(Throwable cause) {
+ super(cause.getMessage());
+ this.cause = cause;
+ }
+
+ /**
+ * Returns the cause of this exception or null if the cause is nonexistent
+ * or unknown.
+ *
+ * @returns the cause of this exception or null if the cause is nonexistent
+ * or unknown.
+ */
+ public Throwable getCause() {
+ return this.cause;
+ }
+}
diff --git a/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/JSONML.java b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/JSONML.java
new file mode 100644
index 000000000..5d86115c6
--- /dev/null
+++ b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/JSONML.java
@@ -0,0 +1,467 @@
+package org.springframework.ide.eclipse.org.json;
+
+/*
+Copyright (c) 2008 JSON.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+The Software shall be used for Good, not Evil.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+import java.util.Iterator;
+
+
+/**
+ * This provides static methods to convert an XML text into a JSONArray or
+ * JSONObject, and to covert a JSONArray or JSONObject into an XML text using
+ * the JsonML transform.
+ *
+ * @author JSON.org
+ * @version 2012-03-28
+ */
+public class JSONML {
+
+ /**
+ * Parse XML values and store them in a JSONArray.
+ * @param x The XMLTokener containing the source string.
+ * @param arrayForm true if array form, false if object form.
+ * @param ja The JSONArray that is containing the current tag or null
+ * if we are at the outermost level.
+ * @return A JSONArray if the value is the outermost tag, otherwise null.
+ * @throws JSONException
+ */
+ private static Object parse(
+ XMLTokener x,
+ boolean arrayForm,
+ JSONArray ja
+ ) throws JSONException {
+ String attribute;
+ char c;
+ String closeTag = null;
+ int i;
+ JSONArray newja = null;
+ JSONObject newjo = null;
+ Object token;
+ String tagName = null;
+
+// Test for and skip past these forms:
+//
+//
+//
+//
+
+ while (true) {
+ if (!x.more()) {
+ throw x.syntaxError("Bad XML");
+ }
+ token = x.nextContent();
+ if (token == XML.LT) {
+ token = x.nextToken();
+ if (token instanceof Character) {
+ if (token == XML.SLASH) {
+
+// Close tag ");
+ } else {
+ x.back();
+ }
+ } else if (c == '[') {
+ token = x.nextToken();
+ if (token.equals("CDATA") && x.next() == '[') {
+ if (ja != null) {
+ ja.put(x.nextCDATA());
+ }
+ } else {
+ throw x.syntaxError("Expected 'CDATA['");
+ }
+ } else {
+ i = 1;
+ do {
+ token = x.nextMeta();
+ if (token == null) {
+ throw x.syntaxError("Missing '>' after ' 0);
+ }
+ } else if (token == XML.QUEST) {
+
+// ");
+ } else {
+ throw x.syntaxError("Misshaped tag");
+ }
+
+// Open tag <
+
+ } else {
+ if (!(token instanceof String)) {
+ throw x.syntaxError("Bad tagName '" + token + "'.");
+ }
+ tagName = (String)token;
+ newja = new JSONArray();
+ newjo = new JSONObject();
+ if (arrayForm) {
+ newja.put(tagName);
+ if (ja != null) {
+ ja.put(newja);
+ }
+ } else {
+ newjo.put("tagName", tagName);
+ if (ja != null) {
+ ja.put(newjo);
+ }
+ }
+ token = null;
+ for (;;) {
+ if (token == null) {
+ token = x.nextToken();
+ }
+ if (token == null) {
+ throw x.syntaxError("Misshaped tag");
+ }
+ if (!(token instanceof String)) {
+ break;
+ }
+
+// attribute = value
+
+ attribute = (String)token;
+ if (!arrayForm && ("tagName".equals(attribute) || "childNode".equals(attribute))) {
+ throw x.syntaxError("Reserved attribute.");
+ }
+ token = x.nextToken();
+ if (token == XML.EQ) {
+ token = x.nextToken();
+ if (!(token instanceof String)) {
+ throw x.syntaxError("Missing value");
+ }
+ newjo.accumulate(attribute, XML.stringToValue((String)token));
+ token = null;
+ } else {
+ newjo.accumulate(attribute, "");
+ }
+ }
+ if (arrayForm && newjo.length() > 0) {
+ newja.put(newjo);
+ }
+
+// Empty tag <.../>
+
+ if (token == XML.SLASH) {
+ if (x.nextToken() != XML.GT) {
+ throw x.syntaxError("Misshaped tag");
+ }
+ if (ja == null) {
+ if (arrayForm) {
+ return newja;
+ } else {
+ return newjo;
+ }
+ }
+
+// Content, between <...> and
+
+ } else {
+ if (token != XML.GT) {
+ throw x.syntaxError("Misshaped tag");
+ }
+ closeTag = (String)parse(x, arrayForm, newja);
+ if (closeTag != null) {
+ if (!closeTag.equals(tagName)) {
+ throw x.syntaxError("Mismatched '" + tagName +
+ "' and '" + closeTag + "'");
+ }
+ tagName = null;
+ if (!arrayForm && newja.length() > 0) {
+ newjo.put("childNodes", newja);
+ }
+ if (ja == null) {
+ if (arrayForm) {
+ return newja;
+ } else {
+ return newjo;
+ }
+ }
+ }
+ }
+ }
+ } else {
+ if (ja != null) {
+ ja.put(token instanceof String
+ ? XML.stringToValue((String)token)
+ : token);
+ }
+ }
+ }
+ }
+
+
+ /**
+ * Convert a well-formed (but not necessarily valid) XML string into a
+ * JSONArray using the JsonML transform. Each XML tag is represented as
+ * a JSONArray in which the first element is the tag name. If the tag has
+ * attributes, then the second element will be JSONObject containing the
+ * name/value pairs. If the tag contains children, then strings and
+ * JSONArrays will represent the child tags.
+ * Comments, prologs, DTDs, and
+ * The generic
+ * The
+ * The texts produced by the
+ * Warning: This method assumes that the data structure is acyclical.
+ *
+ * @return a printable, displayable, portable, transmittable representation
+ * of the object, beginning with
+ * Warning: This method assumes that the data structure is acyclical.
+ *
+ * @param indentFactor
+ * The number of spaces to add to each level of indentation.
+ * @return a printable, displayable, portable, transmittable representation
+ * of the object, beginning with
+ * Warning: This method assumes that the data structure is acyclical.
+ *
+ * @param value
+ * The value to be serialized.
+ * @return a printable, displayable, transmittable representation of the
+ * object, beginning with
+ * Warning: This method assumes that the data structure is acyclical.
+ *
+ * @return The writer.
+ * @throws JSONException
+ */
+ public Writer write(Writer writer) throws JSONException {
+ return this.write(writer, 0, 0);
+ }
+
+ static final Writer writeValue(Writer writer, Object value,
+ int indentFactor, int indent) throws JSONException, IOException {
+ if (value == null || value.equals(null)) {
+ writer.write("null");
+ } else if (value instanceof JSONObject) {
+ ((JSONObject) value).write(writer, indentFactor, indent);
+ } else if (value instanceof JSONArray) {
+ ((JSONArray) value).write(writer, indentFactor, indent);
+ } else if (value instanceof Map) {
+ new JSONObject((Map) value).write(writer, indentFactor, indent);
+ } else if (value instanceof Collection) {
+ new JSONArray((Collection) value).write(writer, indentFactor,
+ indent);
+ } else if (value.getClass().isArray()) {
+ new JSONArray(value).write(writer, indentFactor, indent);
+ } else if (value instanceof Number) {
+ writer.write(numberToString((Number) value));
+ } else if (value instanceof Boolean) {
+ writer.write(value.toString());
+ } else if (value instanceof JSONString) {
+ Object o;
+ try {
+ o = ((JSONString) value).toJSONString();
+ } catch (Exception e) {
+ throw new JSONException(e);
+ }
+ writer.write(o != null ? o.toString() : quote(value.toString()));
+ } else {
+ quote(value.toString(), writer);
+ }
+ return writer;
+ }
+
+ static final void indent(Writer writer, int indent) throws IOException {
+ for (int i = 0; i < indent; i += 1) {
+ writer.write(' ');
+ }
+ }
+
+ /**
+ * Write the contents of the JSONObject as JSON text to a writer. For
+ * compactness, no whitespace is added.
+ *
+ * Warning: This method assumes that the data structure is acyclical.
+ *
+ * @return The writer.
+ * @throws JSONException
+ */
+ Writer write(Writer writer, int indentFactor, int indent)
+ throws JSONException {
+ try {
+ boolean commanate = false;
+ final int length = this.length();
+ Iterator keys = this.keys();
+ writer.write('{');
+
+ if (length == 1) {
+ Object key = keys.next();
+ writer.write(quote(key.toString()));
+ writer.write(':');
+ if (indentFactor > 0) {
+ writer.write(' ');
+ }
+ writeValue(writer, this.map.get(key), indentFactor, indent);
+ } else if (length != 0) {
+ final int newindent = indent + indentFactor;
+ while (keys.hasNext()) {
+ Object key = keys.next();
+ if (commanate) {
+ writer.write(',');
+ }
+ if (indentFactor > 0) {
+ writer.write('\n');
+ }
+ indent(writer, newindent);
+ writer.write(quote(key.toString()));
+ writer.write(':');
+ if (indentFactor > 0) {
+ writer.write(' ');
+ }
+ writeValue(writer, this.map.get(key), indentFactor,
+ newindent);
+ commanate = true;
+ }
+ if (indentFactor > 0) {
+ writer.write('\n');
+ }
+ indent(writer, indent);
+ }
+ writer.write('}');
+ return writer;
+ } catch (IOException exception) {
+ throw new JSONException(exception);
+ }
+ }
+}
diff --git a/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/JSONString.java b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/JSONString.java
new file mode 100644
index 000000000..e7fc3b0ab
--- /dev/null
+++ b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/JSONString.java
@@ -0,0 +1,18 @@
+package org.springframework.ide.eclipse.org.json;
+/**
+ * The
+ * A JSONStringer instance provides a
+ * The first method called must be
+ * This can sometimes be easier than using a JSONObject to build a string.
+ * @author JSON.org
+ * @version 2008-09-18
+ */
+public class JSONStringer extends JSONWriter {
+ /**
+ * Make a fresh JSONStringer. It can be used to build one JSON text.
+ */
+ public JSONStringer() {
+ super(new StringWriter());
+ }
+
+ /**
+ * Return the JSON text. This method is used to obtain the product of the
+ * JSONStringer instance. It will return
+ * A JSONWriter instance provides a
+ * The first method called must be
+ * This can sometimes be easier than using a JSONObject to build a string.
+ * @author JSON.org
+ * @version 2011-11-24
+ */
+public class JSONWriter {
+ private static final int maxdepth = 200;
+
+ /**
+ * The comma flag determines if a comma should be output before the next
+ * value.
+ */
+ private boolean comma;
+
+ /**
+ * The current mode. Values:
+ * 'a' (array),
+ * 'd' (done),
+ * 'i' (initial),
+ * 'k' (key),
+ * 'o' (object).
+ */
+ protected char mode;
+
+ /**
+ * The object/array stack.
+ */
+ private final JSONObject stack[];
+
+ /**
+ * The stack top index. A value of 0 indicates that the stack is empty.
+ */
+ private int top;
+
+ /**
+ * The writer that will receive the output.
+ */
+ protected Writer writer;
+
+ /**
+ * Make a fresh JSONWriter. It can be used to build one JSON text.
+ */
+ public JSONWriter(Writer w) {
+ this.comma = false;
+ this.mode = 'i';
+ this.stack = new JSONObject[maxdepth];
+ this.top = 0;
+ this.writer = w;
+ }
+
+ /**
+ * Append a value.
+ * @param string A string value.
+ * @return this
+ * @throws JSONException If the value is out of sequence.
+ */
+ private JSONWriter append(String string) throws JSONException {
+ if (string == null) {
+ throw new JSONException("Null pointer");
+ }
+ if (this.mode == 'o' || this.mode == 'a') {
+ try {
+ if (this.comma && this.mode == 'a') {
+ this.writer.write(',');
+ }
+ this.writer.write(string);
+ } catch (IOException e) {
+ throw new JSONException(e);
+ }
+ if (this.mode == 'o') {
+ this.mode = 'k';
+ }
+ this.comma = true;
+ return this;
+ }
+ throw new JSONException("Value out of sequence.");
+ }
+
+ /**
+ * Begin appending a new array. All values until the balancing
+ * <[ [ ]]> are ignored.
+ * @param string The source string.
+ * @return A JSONArray containing the structured data from the XML string.
+ * @throws JSONException
+ */
+ public static JSONArray toJSONArray(String string) throws JSONException {
+ return toJSONArray(new XMLTokener(string));
+ }
+
+
+ /**
+ * Convert a well-formed (but not necessarily valid) XML string into a
+ * JSONArray using the JsonML transform. Each XML tag is represented as
+ * a JSONArray in which the first element is the tag name. If the tag has
+ * attributes, then the second element will be JSONObject containing the
+ * name/value pairs. If the tag contains children, then strings and
+ * JSONArrays will represent the child content and tags.
+ * Comments, prologs, DTDs, and <[ [ ]]> are ignored.
+ * @param x An XMLTokener.
+ * @return A JSONArray containing the structured data from the XML string.
+ * @throws JSONException
+ */
+ public static JSONArray toJSONArray(XMLTokener x) throws JSONException {
+ return (JSONArray)parse(x, true, null);
+ }
+
+
+ /**
+ * Convert a well-formed (but not necessarily valid) XML string into a
+ * JSONObject using the JsonML transform. Each XML tag is represented as
+ * a JSONObject with a "tagName" property. If the tag has attributes, then
+ * the attributes will be in the JSONObject as properties. If the tag
+ * contains children, the object will have a "childNodes" property which
+ * will be an array of strings and JsonML JSONObjects.
+
+ * Comments, prologs, DTDs, and <[ [ ]]> are ignored.
+ * @param x An XMLTokener of the XML source text.
+ * @return A JSONObject containing the structured data from the XML string.
+ * @throws JSONException
+ */
+ public static JSONObject toJSONObject(XMLTokener x) throws JSONException {
+ return (JSONObject)parse(x, false, null);
+ }
+
+
+ /**
+ * Convert a well-formed (but not necessarily valid) XML string into a
+ * JSONObject using the JsonML transform. Each XML tag is represented as
+ * a JSONObject with a "tagName" property. If the tag has attributes, then
+ * the attributes will be in the JSONObject as properties. If the tag
+ * contains children, the object will have a "childNodes" property which
+ * will be an array of strings and JsonML JSONObjects.
+
+ * Comments, prologs, DTDs, and <[ [ ]]> are ignored.
+ * @param string The XML source text.
+ * @return A JSONObject containing the structured data from the XML string.
+ * @throws JSONException
+ */
+ public static JSONObject toJSONObject(String string) throws JSONException {
+ return toJSONObject(new XMLTokener(string));
+ }
+
+
+ /**
+ * Reverse the JSONML transformation, making an XML text from a JSONArray.
+ * @param ja A JSONArray.
+ * @return An XML string.
+ * @throws JSONException
+ */
+ public static String toString(JSONArray ja) throws JSONException {
+ int i;
+ JSONObject jo;
+ String key;
+ Iterator keys;
+ int length;
+ Object object;
+ StringBuffer sb = new StringBuffer();
+ String tagName;
+ String value;
+
+// Emit get and opt methods for accessing
+ * the values by name, and put methods for adding or replacing
+ * values by name. The values can be any of these types: Boolean,
+ * JSONArray, JSONObject, Number,
+ * String, or the JSONObject.NULL object. A
+ * JSONObject constructor can be used to convert an external form JSON text
+ * into an internal form whose values can be retrieved with the
+ * get and opt methods, or to convert values into a
+ * JSON text using the put and toString methods. A
+ * get method returns a value if one can be found, and throws an
+ * exception if one cannot be found. An opt method returns a
+ * default value instead of throwing an exception, and so is useful for
+ * obtaining optional values.
+ * get() and opt() methods return an
+ * object, which you can cast or query for type. There are also typed
+ * get and opt methods that do type checking and type
+ * coercion for you. The opt methods differ from the get methods in that they
+ * do not throw. Instead, they return a specified value, such as null.
+ * put methods add or replace values in an object. For
+ * example,
+ *
+ *
+ * myString = new JSONObject()
+ * .put("JSON", "Hello, World!").toString();
+ *
+ *
+ * produces the string {"JSON": "Hello, World"}.
+ * toString methods strictly conform to
+ * the JSON syntax rules. The constructors are more forgiving in the texts they
+ * will accept:
+ *
+ *
+ *
+ * @author JSON.org
+ * @version 2013-06-17
+ */
+public class JSONObject {
+ /**
+ * JSONObject.NULL is equivalent to the value that JavaScript calls null,
+ * whilst Java's null is equivalent to the value that JavaScript calls
+ * undefined.
+ */
+ private static final class Null {
+
+ /**
+ * There is only intended to be a single instance of the NULL object,
+ * so the clone method returns itself.
+ *
+ * @return NULL.
+ */
+ protected final Object clone() {
+ return this;
+ }
+
+ /**
+ * A Null object is equal to the null value and to itself.
+ *
+ * @param object
+ * An object to test for nullness.
+ * @return true if the object parameter is the JSONObject.NULL object or
+ * null.
+ */
+ public boolean equals(Object object) {
+ return object == null || object == this;
+ }
+
+ /**
+ * Get the "null" string value.
+ *
+ * @return The string "null".
+ */
+ public String toString() {
+ return "null";
+ }
+ }
+
+ /**
+ * The map where the JSONObject's properties are kept.
+ */
+ private final Map map;
+
+ /**
+ * It is sometimes more convenient and less ambiguous to have a
+ * , (comma) may appear just
+ * before the closing brace.' (single
+ * quote).{ } [ ] / \ : , # and if they do not look like numbers and
+ * if they are not the reserved words true, false,
+ * or null.NULL object than to use Java's null value.
+ * JSONObject.NULL.equals(null) returns true.
+ * JSONObject.NULL.toString() returns "null".
+ */
+ public static final Object NULL = new Null();
+
+ /**
+ * Construct an empty JSONObject.
+ */
+ public JSONObject() {
+ this.map = new HashMap();
+ }
+
+ /**
+ * Construct a JSONObject from a subset of another JSONObject. An array of
+ * strings is used to identify the keys that should be copied. Missing keys
+ * are ignored.
+ *
+ * @param jo
+ * A JSONObject.
+ * @param names
+ * An array of strings.
+ * @throws JSONException
+ * @exception JSONException
+ * If a value is a non-finite number or if a name is
+ * duplicated.
+ */
+ public JSONObject(JSONObject jo, String[] names) {
+ this();
+ for (int i = 0; i < names.length; i += 1) {
+ try {
+ this.putOnce(names[i], jo.opt(names[i]));
+ } catch (Exception ignore) {
+ }
+ }
+ }
+
+ /**
+ * Construct a JSONObject from a JSONTokener.
+ *
+ * @param x
+ * A JSONTokener object containing the source string.
+ * @throws JSONException
+ * If there is a syntax error in the source string or a
+ * duplicated key.
+ */
+ public JSONObject(JSONTokener x) throws JSONException {
+ this();
+ char c;
+ String key;
+
+ if (x.nextClean() != '{') {
+ throw x.syntaxError("A JSONObject text must begin with '{'");
+ }
+ for (;;) {
+ c = x.nextClean();
+ switch (c) {
+ case 0:
+ throw x.syntaxError("A JSONObject text must end with '}'");
+ case '}':
+ return;
+ default:
+ x.back();
+ key = x.nextValue().toString();
+ }
+
+// The key is followed by ':'.
+
+ c = x.nextClean();
+ if (c != ':') {
+ throw x.syntaxError("Expected a ':' after a key");
+ }
+ this.putOnce(key, x.nextValue());
+
+// Pairs are separated by ','.
+
+ switch (x.nextClean()) {
+ case ';':
+ case ',':
+ if (x.nextClean() == '}') {
+ return;
+ }
+ x.back();
+ break;
+ case '}':
+ return;
+ default:
+ throw x.syntaxError("Expected a ',' or '}'");
+ }
+ }
+ }
+
+ /**
+ * Construct a JSONObject from a Map.
+ *
+ * @param map
+ * A map object that can be used to initialize the contents of
+ * the JSONObject.
+ * @throws JSONException
+ */
+ public JSONObject(Map map) {
+ this.map = new HashMap();
+ if (map != null) {
+ Iterator i = map.entrySet().iterator();
+ while (i.hasNext()) {
+ Map.Entry e = (Map.Entry) i.next();
+ Object value = e.getValue();
+ if (value != null) {
+ this.map.put(e.getKey(), wrap(value));
+ }
+ }
+ }
+ }
+
+ /**
+ * Construct a JSONObject from an Object using bean getters. It reflects on
+ * all of the public methods of the object. For each of the methods with no
+ * parameters and a name starting with "get" or
+ * "is" followed by an uppercase letter, the method is invoked,
+ * and a key and the value returned from the getter method are put into the
+ * new JSONObject.
+ *
+ * The key is formed by removing the "get" or "is"
+ * prefix. If the second remaining character is not upper case, then the
+ * first character is converted to lower case.
+ *
+ * For example, if an object has a method named "getName", and
+ * if the result of calling object.getName() is
+ * "Larry Fine", then the JSONObject will contain
+ * "name": "Larry Fine".
+ *
+ * @param bean
+ * An object that has getter methods that should be used to make
+ * a JSONObject.
+ */
+ public JSONObject(Object bean) {
+ this();
+ this.populateMap(bean);
+ }
+
+ /**
+ * Construct a JSONObject from an Object, using reflection to find the
+ * public members. The resulting JSONObject's keys will be the strings from
+ * the names array, and the values will be the field values associated with
+ * those keys in the object. If a key is not found or not visible, then it
+ * will not be copied into the new JSONObject.
+ *
+ * @param object
+ * An object that has fields that should be used to make a
+ * JSONObject.
+ * @param names
+ * An array of strings, the names of the fields to be obtained
+ * from the object.
+ */
+ public JSONObject(Object object, String names[]) {
+ this();
+ Class c = object.getClass();
+ for (int i = 0; i < names.length; i += 1) {
+ String name = names[i];
+ try {
+ this.putOpt(name, c.getField(name).get(object));
+ } catch (Exception ignore) {
+ }
+ }
+ }
+
+ /**
+ * Construct a JSONObject from a source JSON text string. This is the most
+ * commonly used JSONObject constructor.
+ *
+ * @param source
+ * A string beginning with { (left
+ * brace) and ending with }
+ * (right brace).
+ * @exception JSONException
+ * If there is a syntax error in the source string or a
+ * duplicated key.
+ */
+ public JSONObject(String source) throws JSONException {
+ this(new JSONTokener(source));
+ }
+
+ /**
+ * Construct a JSONObject from a ResourceBundle.
+ *
+ * @param baseName
+ * The ResourceBundle base name.
+ * @param locale
+ * The Locale to load the ResourceBundle for.
+ * @throws JSONException
+ * If any JSONExceptions are detected.
+ */
+ public JSONObject(String baseName, Locale locale) throws JSONException {
+ this();
+ ResourceBundle bundle = ResourceBundle.getBundle(baseName, locale,
+ Thread.currentThread().getContextClassLoader());
+
+// Iterate through the keys in the bundle.
+
+ Enumeration keys = bundle.getKeys();
+ while (keys.hasMoreElements()) {
+ Object key = keys.nextElement();
+ if (key instanceof String) {
+
+// Go through the path, ensuring that there is a nested JSONObject for each
+// segment except the last. Add the value using the last segment's name into
+// the deepest nested JSONObject.
+
+ String[] path = ((String) key).split("\\.");
+ int last = path.length - 1;
+ JSONObject target = this;
+ for (int i = 0; i < last; i += 1) {
+ String segment = path[i];
+ JSONObject nextTarget = target.optJSONObject(segment);
+ if (nextTarget == null) {
+ nextTarget = new JSONObject();
+ target.put(segment, nextTarget);
+ }
+ target = nextTarget;
+ }
+ target.put(path[last], bundle.getString((String) key));
+ }
+ }
+ }
+
+ /**
+ * Accumulate values under a key. It is similar to the put method except
+ * that if there is already an object stored under the key then a JSONArray
+ * is stored under the key to hold all of the accumulated values. If there
+ * is already a JSONArray, then the new value is appended to it. In
+ * contrast, the put method replaces the previous value.
+ *
+ * If only one value is accumulated that is not a JSONArray, then the result
+ * will be the same as using put. But if multiple values are accumulated,
+ * then the result will be like append.
+ *
+ * @param key
+ * A key string.
+ * @param value
+ * An object to be accumulated under the key.
+ * @return this.
+ * @throws JSONException
+ * If the value is an invalid number or if the key is null.
+ */
+ public JSONObject accumulate(String key, Object value) throws JSONException {
+ testValidity(value);
+ Object object = this.opt(key);
+ if (object == null) {
+ this.put(key,
+ value instanceof JSONArray ? new JSONArray().put(value)
+ : value);
+ } else if (object instanceof JSONArray) {
+ ((JSONArray) object).put(value);
+ } else {
+ this.put(key, new JSONArray().put(object).put(value));
+ }
+ return this;
+ }
+
+ /**
+ * Append values to the array under a key. If the key does not exist in the
+ * JSONObject, then the key is put in the JSONObject with its value being a
+ * JSONArray containing the value parameter. If the key was already
+ * associated with a JSONArray, then the value parameter is appended to it.
+ *
+ * @param key
+ * A key string.
+ * @param value
+ * An object to be accumulated under the key.
+ * @return this.
+ * @throws JSONException
+ * If the key is null or if the current value associated with
+ * the key is not a JSONArray.
+ */
+ public JSONObject append(String key, Object value) throws JSONException {
+ testValidity(value);
+ Object object = this.opt(key);
+ if (object == null) {
+ this.put(key, new JSONArray().put(value));
+ } else if (object instanceof JSONArray) {
+ this.put(key, ((JSONArray) object).put(value));
+ } else {
+ throw new JSONException("JSONObject[" + key
+ + "] is not a JSONArray.");
+ }
+ return this;
+ }
+
+ /**
+ * Produce a string from a double. The string "null" will be returned if the
+ * number is not finite.
+ *
+ * @param d
+ * A double.
+ * @return A String.
+ */
+ public static String doubleToString(double d) {
+ if (Double.isInfinite(d) || Double.isNaN(d)) {
+ return "null";
+ }
+
+// Shave off trailing zeros and decimal point, if possible.
+
+ String string = Double.toString(d);
+ if (string.indexOf('.') > 0 && string.indexOf('e') < 0
+ && string.indexOf('E') < 0) {
+ while (string.endsWith("0")) {
+ string = string.substring(0, string.length() - 1);
+ }
+ if (string.endsWith(".")) {
+ string = string.substring(0, string.length() - 1);
+ }
+ }
+ return string;
+ }
+
+ /**
+ * Get the value object associated with a key.
+ *
+ * @param key
+ * A key string.
+ * @return The object associated with the key.
+ * @throws JSONException
+ * if the key is not found.
+ */
+ public Object get(String key) throws JSONException {
+ if (key == null) {
+ throw new JSONException("Null key.");
+ }
+ Object object = this.opt(key);
+ if (object == null) {
+ throw new JSONException("JSONObject[" + quote(key) + "] not found.");
+ }
+ return object;
+ }
+
+ /**
+ * Get the boolean value associated with a key.
+ *
+ * @param key
+ * A key string.
+ * @return The truth.
+ * @throws JSONException
+ * if the value is not a Boolean or the String "true" or
+ * "false".
+ */
+ public boolean getBoolean(String key) throws JSONException {
+ Object object = this.get(key);
+ if (object.equals(Boolean.FALSE)
+ || (object instanceof String && ((String) object)
+ .equalsIgnoreCase("false"))) {
+ return false;
+ } else if (object.equals(Boolean.TRUE)
+ || (object instanceof String && ((String) object)
+ .equalsIgnoreCase("true"))) {
+ return true;
+ }
+ throw new JSONException("JSONObject[" + quote(key)
+ + "] is not a Boolean.");
+ }
+
+ /**
+ * Get the double value associated with a key.
+ *
+ * @param key
+ * A key string.
+ * @return The numeric value.
+ * @throws JSONException
+ * if the key is not found or if the value is not a Number
+ * object and cannot be converted to a number.
+ */
+ public double getDouble(String key) throws JSONException {
+ Object object = this.get(key);
+ try {
+ return object instanceof Number ? ((Number) object).doubleValue()
+ : Double.parseDouble((String) object);
+ } catch (Exception e) {
+ throw new JSONException("JSONObject[" + quote(key)
+ + "] is not a number.");
+ }
+ }
+
+ /**
+ * Get the int value associated with a key.
+ *
+ * @param key
+ * A key string.
+ * @return The integer value.
+ * @throws JSONException
+ * if the key is not found or if the value cannot be converted
+ * to an integer.
+ */
+ public int getInt(String key) throws JSONException {
+ Object object = this.get(key);
+ try {
+ return object instanceof Number ? ((Number) object).intValue()
+ : Integer.parseInt((String) object);
+ } catch (Exception e) {
+ throw new JSONException("JSONObject[" + quote(key)
+ + "] is not an int.");
+ }
+ }
+
+ /**
+ * Get the JSONArray value associated with a key.
+ *
+ * @param key
+ * A key string.
+ * @return A JSONArray which is the value.
+ * @throws JSONException
+ * if the key is not found or if the value is not a JSONArray.
+ */
+ public JSONArray getJSONArray(String key) throws JSONException {
+ Object object = this.get(key);
+ if (object instanceof JSONArray) {
+ return (JSONArray) object;
+ }
+ throw new JSONException("JSONObject[" + quote(key)
+ + "] is not a JSONArray.");
+ }
+
+ /**
+ * Get the JSONObject value associated with a key.
+ *
+ * @param key
+ * A key string.
+ * @return A JSONObject which is the value.
+ * @throws JSONException
+ * if the key is not found or if the value is not a JSONObject.
+ */
+ public JSONObject getJSONObject(String key) throws JSONException {
+ Object object = this.get(key);
+ if (object instanceof JSONObject) {
+ return (JSONObject) object;
+ }
+ throw new JSONException("JSONObject[" + quote(key)
+ + "] is not a JSONObject.");
+ }
+
+ /**
+ * Get the long value associated with a key.
+ *
+ * @param key
+ * A key string.
+ * @return The long value.
+ * @throws JSONException
+ * if the key is not found or if the value cannot be converted
+ * to a long.
+ */
+ public long getLong(String key) throws JSONException {
+ Object object = this.get(key);
+ try {
+ return object instanceof Number ? ((Number) object).longValue()
+ : Long.parseLong((String) object);
+ } catch (Exception e) {
+ throw new JSONException("JSONObject[" + quote(key)
+ + "] is not a long.");
+ }
+ }
+
+ /**
+ * Get an array of field names from a JSONObject.
+ *
+ * @return An array of field names, or null if there are no names.
+ */
+ public static String[] getNames(JSONObject jo) {
+ int length = jo.length();
+ if (length == 0) {
+ return null;
+ }
+ Iterator iterator = jo.keys();
+ String[] names = new String[length];
+ int i = 0;
+ while (iterator.hasNext()) {
+ names[i] = (String) iterator.next();
+ i += 1;
+ }
+ return names;
+ }
+
+ /**
+ * Get an array of field names from an Object.
+ *
+ * @return An array of field names, or null if there are no names.
+ */
+ public static String[] getNames(Object object) {
+ if (object == null) {
+ return null;
+ }
+ Class klass = object.getClass();
+ Field[] fields = klass.getFields();
+ int length = fields.length;
+ if (length == 0) {
+ return null;
+ }
+ String[] names = new String[length];
+ for (int i = 0; i < length; i += 1) {
+ names[i] = fields[i].getName();
+ }
+ return names;
+ }
+
+ /**
+ * Get the string associated with a key.
+ *
+ * @param key
+ * A key string.
+ * @return A string which is the value.
+ * @throws JSONException
+ * if there is no string value for the key.
+ */
+ public String getString(String key) throws JSONException {
+ Object object = this.get(key);
+ if (object instanceof String) {
+ return (String) object;
+ }
+ throw new JSONException("JSONObject[" + quote(key) + "] not a string.");
+ }
+
+ /**
+ * Determine if the JSONObject contains a specific key.
+ *
+ * @param key
+ * A key string.
+ * @return true if the key exists in the JSONObject.
+ */
+ public boolean has(String key) {
+ return this.map.containsKey(key);
+ }
+
+ /**
+ * Increment a property of a JSONObject. If there is no such property,
+ * create one with a value of 1. If there is such a property, and if it is
+ * an Integer, Long, Double, or Float, then add one to it.
+ *
+ * @param key
+ * A key string.
+ * @return this.
+ * @throws JSONException
+ * If there is already a property with this name that is not an
+ * Integer, Long, Double, or Float.
+ */
+ public JSONObject increment(String key) throws JSONException {
+ Object value = this.opt(key);
+ if (value == null) {
+ this.put(key, 1);
+ } else if (value instanceof Integer) {
+ this.put(key, ((Integer) value).intValue() + 1);
+ } else if (value instanceof Long) {
+ this.put(key, ((Long) value).longValue() + 1);
+ } else if (value instanceof Double) {
+ this.put(key, ((Double) value).doubleValue() + 1);
+ } else if (value instanceof Float) {
+ this.put(key, ((Float) value).floatValue() + 1);
+ } else {
+ throw new JSONException("Unable to increment [" + quote(key) + "].");
+ }
+ return this;
+ }
+
+ /**
+ * Determine if the value associated with the key is null or if there is no
+ * value.
+ *
+ * @param key
+ * A key string.
+ * @return true if there is no value associated with the key or if the value
+ * is the JSONObject.NULL object.
+ */
+ public boolean isNull(String key) {
+ return JSONObject.NULL.equals(this.opt(key));
+ }
+
+ /**
+ * Get an enumeration of the keys of the JSONObject.
+ *
+ * @return An iterator of the keys.
+ */
+ public Iterator keys() {
+ return this.keySet().iterator();
+ }
+
+ /**
+ * Get a set of keys of the JSONObject.
+ *
+ * @return A keySet.
+ */
+ public Set keySet() {
+ return this.map.keySet();
+ }
+
+ /**
+ * Get the number of keys stored in the JSONObject.
+ *
+ * @return The number of keys in the JSONObject.
+ */
+ public int length() {
+ return this.map.size();
+ }
+
+ /**
+ * Produce a JSONArray containing the names of the elements of this
+ * JSONObject.
+ *
+ * @return A JSONArray containing the key strings, or null if the JSONObject
+ * is empty.
+ */
+ public JSONArray names() {
+ JSONArray ja = new JSONArray();
+ Iterator keys = this.keys();
+ while (keys.hasNext()) {
+ ja.put(keys.next());
+ }
+ return ja.length() == 0 ? null : ja;
+ }
+
+ /**
+ * Produce a string from a Number.
+ *
+ * @param number
+ * A Number
+ * @return A String.
+ * @throws JSONException
+ * If n is a non-finite number.
+ */
+ public static String numberToString(Number number) throws JSONException {
+ if (number == null) {
+ throw new JSONException("Null pointer");
+ }
+ testValidity(number);
+
+// Shave off trailing zeros and decimal point, if possible.
+
+ String string = number.toString();
+ if (string.indexOf('.') > 0 && string.indexOf('e') < 0
+ && string.indexOf('E') < 0) {
+ while (string.endsWith("0")) {
+ string = string.substring(0, string.length() - 1);
+ }
+ if (string.endsWith(".")) {
+ string = string.substring(0, string.length() - 1);
+ }
+ }
+ return string;
+ }
+
+ /**
+ * Get an optional value associated with a key.
+ *
+ * @param key
+ * A key string.
+ * @return An object which is the value, or null if there is no value.
+ */
+ public Object opt(String key) {
+ return key == null ? null : this.map.get(key);
+ }
+
+ /**
+ * Get an optional boolean associated with a key. It returns false if there
+ * is no such key, or if the value is not Boolean.TRUE or the String "true".
+ *
+ * @param key
+ * A key string.
+ * @return The truth.
+ */
+ public boolean optBoolean(String key) {
+ return this.optBoolean(key, false);
+ }
+
+ /**
+ * Get an optional boolean associated with a key. It returns the
+ * defaultValue if there is no such key, or if it is not a Boolean or the
+ * String "true" or "false" (case insensitive).
+ *
+ * @param key
+ * A key string.
+ * @param defaultValue
+ * The default.
+ * @return The truth.
+ */
+ public boolean optBoolean(String key, boolean defaultValue) {
+ try {
+ return this.getBoolean(key);
+ } catch (Exception e) {
+ return defaultValue;
+ }
+ }
+
+ /**
+ * Get an optional double associated with a key, or NaN if there is no such
+ * key or if its value is not a number. If the value is a string, an attempt
+ * will be made to evaluate it as a number.
+ *
+ * @param key
+ * A string which is the key.
+ * @return An object which is the value.
+ */
+ public double optDouble(String key) {
+ return this.optDouble(key, Double.NaN);
+ }
+
+ /**
+ * Get an optional double associated with a key, or the defaultValue if
+ * there is no such key or if its value is not a number. If the value is a
+ * string, an attempt will be made to evaluate it as a number.
+ *
+ * @param key
+ * A key string.
+ * @param defaultValue
+ * The default.
+ * @return An object which is the value.
+ */
+ public double optDouble(String key, double defaultValue) {
+ try {
+ return this.getDouble(key);
+ } catch (Exception e) {
+ return defaultValue;
+ }
+ }
+
+ /**
+ * Get an optional int value associated with a key, or zero if there is no
+ * such key or if the value is not a number. If the value is a string, an
+ * attempt will be made to evaluate it as a number.
+ *
+ * @param key
+ * A key string.
+ * @return An object which is the value.
+ */
+ public int optInt(String key) {
+ return this.optInt(key, 0);
+ }
+
+ /**
+ * Get an optional int value associated with a key, or the default if there
+ * is no such key or if the value is not a number. If the value is a string,
+ * an attempt will be made to evaluate it as a number.
+ *
+ * @param key
+ * A key string.
+ * @param defaultValue
+ * The default.
+ * @return An object which is the value.
+ */
+ public int optInt(String key, int defaultValue) {
+ try {
+ return this.getInt(key);
+ } catch (Exception e) {
+ return defaultValue;
+ }
+ }
+
+ /**
+ * Get an optional JSONArray associated with a key. It returns null if there
+ * is no such key, or if its value is not a JSONArray.
+ *
+ * @param key
+ * A key string.
+ * @return A JSONArray which is the value.
+ */
+ public JSONArray optJSONArray(String key) {
+ Object o = this.opt(key);
+ return o instanceof JSONArray ? (JSONArray) o : null;
+ }
+
+ /**
+ * Get an optional JSONObject associated with a key. It returns null if
+ * there is no such key, or if its value is not a JSONObject.
+ *
+ * @param key
+ * A key string.
+ * @return A JSONObject which is the value.
+ */
+ public JSONObject optJSONObject(String key) {
+ Object object = this.opt(key);
+ return object instanceof JSONObject ? (JSONObject) object : null;
+ }
+
+ /**
+ * Get an optional long value associated with a key, or zero if there is no
+ * such key or if the value is not a number. If the value is a string, an
+ * attempt will be made to evaluate it as a number.
+ *
+ * @param key
+ * A key string.
+ * @return An object which is the value.
+ */
+ public long optLong(String key) {
+ return this.optLong(key, 0);
+ }
+
+ /**
+ * Get an optional long value associated with a key, or the default if there
+ * is no such key or if the value is not a number. If the value is a string,
+ * an attempt will be made to evaluate it as a number.
+ *
+ * @param key
+ * A key string.
+ * @param defaultValue
+ * The default.
+ * @return An object which is the value.
+ */
+ public long optLong(String key, long defaultValue) {
+ try {
+ return this.getLong(key);
+ } catch (Exception e) {
+ return defaultValue;
+ }
+ }
+
+ /**
+ * Get an optional string associated with a key. It returns an empty string
+ * if there is no such key. If the value is not a string and is not null,
+ * then it is converted to a string.
+ *
+ * @param key
+ * A key string.
+ * @return A string which is the value.
+ */
+ public String optString(String key) {
+ return this.optString(key, "");
+ }
+
+ /**
+ * Get an optional string associated with a key. It returns the defaultValue
+ * if there is no such key.
+ *
+ * @param key
+ * A key string.
+ * @param defaultValue
+ * The default.
+ * @return A string which is the value.
+ */
+ public String optString(String key, String defaultValue) {
+ Object object = this.opt(key);
+ return NULL.equals(object) ? defaultValue : object.toString();
+ }
+
+ private void populateMap(Object bean) {
+ Class klass = bean.getClass();
+
+// If klass is a System class then set includeSuperClass to false.
+
+ boolean includeSuperClass = klass.getClassLoader() != null;
+
+ Method[] methods = includeSuperClass ? klass.getMethods() : klass
+ .getDeclaredMethods();
+ for (int i = 0; i < methods.length; i += 1) {
+ try {
+ Method method = methods[i];
+ if (Modifier.isPublic(method.getModifiers())) {
+ String name = method.getName();
+ String key = "";
+ if (name.startsWith("get")) {
+ if ("getClass".equals(name)
+ || "getDeclaringClass".equals(name)) {
+ key = "";
+ } else {
+ key = name.substring(3);
+ }
+ } else if (name.startsWith("is")) {
+ key = name.substring(2);
+ }
+ if (key.length() > 0
+ && Character.isUpperCase(key.charAt(0))
+ && method.getParameterTypes().length == 0) {
+ if (key.length() == 1) {
+ key = key.toLowerCase();
+ } else if (!Character.isUpperCase(key.charAt(1))) {
+ key = key.substring(0, 1).toLowerCase()
+ + key.substring(1);
+ }
+
+ Object result = method.invoke(bean, (Object[]) null);
+ if (result != null) {
+ this.map.put(key, wrap(result));
+ }
+ }
+ }
+ } catch (Exception ignore) {
+ }
+ }
+ }
+
+ /**
+ * Put a key/boolean pair in the JSONObject.
+ *
+ * @param key
+ * A key string.
+ * @param value
+ * A boolean which is the value.
+ * @return this.
+ * @throws JSONException
+ * If the key is null.
+ */
+ public JSONObject put(String key, boolean value) throws JSONException {
+ this.put(key, value ? Boolean.TRUE : Boolean.FALSE);
+ return this;
+ }
+
+ /**
+ * Put a key/value pair in the JSONObject, where the value will be a
+ * JSONArray which is produced from a Collection.
+ *
+ * @param key
+ * A key string.
+ * @param value
+ * A Collection value.
+ * @return this.
+ * @throws JSONException
+ */
+ public JSONObject put(String key, Collection value) throws JSONException {
+ this.put(key, new JSONArray(value));
+ return this;
+ }
+
+ /**
+ * Put a key/double pair in the JSONObject.
+ *
+ * @param key
+ * A key string.
+ * @param value
+ * A double which is the value.
+ * @return this.
+ * @throws JSONException
+ * If the key is null or if the number is invalid.
+ */
+ public JSONObject put(String key, double value) throws JSONException {
+ this.put(key, new Double(value));
+ return this;
+ }
+
+ /**
+ * Put a key/int pair in the JSONObject.
+ *
+ * @param key
+ * A key string.
+ * @param value
+ * An int which is the value.
+ * @return this.
+ * @throws JSONException
+ * If the key is null.
+ */
+ public JSONObject put(String key, int value) throws JSONException {
+ this.put(key, new Integer(value));
+ return this;
+ }
+
+ /**
+ * Put a key/long pair in the JSONObject.
+ *
+ * @param key
+ * A key string.
+ * @param value
+ * A long which is the value.
+ * @return this.
+ * @throws JSONException
+ * If the key is null.
+ */
+ public JSONObject put(String key, long value) throws JSONException {
+ this.put(key, new Long(value));
+ return this;
+ }
+
+ /**
+ * Put a key/value pair in the JSONObject, where the value will be a
+ * JSONObject which is produced from a Map.
+ *
+ * @param key
+ * A key string.
+ * @param value
+ * A Map value.
+ * @return this.
+ * @throws JSONException
+ */
+ public JSONObject put(String key, Map value) throws JSONException {
+ this.put(key, new JSONObject(value));
+ return this;
+ }
+
+ /**
+ * Put a key/value pair in the JSONObject. If the value is null, then the
+ * key will be removed from the JSONObject if it is present.
+ *
+ * @param key
+ * A key string.
+ * @param value
+ * An object which is the value. It should be of one of these
+ * types: Boolean, Double, Integer, JSONArray, JSONObject, Long,
+ * String, or the JSONObject.NULL object.
+ * @return this.
+ * @throws JSONException
+ * If the value is non-finite number or if the key is null.
+ */
+ public JSONObject put(String key, Object value) throws JSONException {
+ if (key == null) {
+ throw new NullPointerException("Null key.");
+ }
+ if (value != null) {
+ testValidity(value);
+ this.map.put(key, value);
+ } else {
+ this.remove(key);
+ }
+ return this;
+ }
+
+ /**
+ * Put a key/value pair in the JSONObject, but only if the key and the value
+ * are both non-null, and only if there is not already a member with that
+ * name.
+ *
+ * @param key
+ * @param value
+ * @return his.
+ * @throws JSONException
+ * if the key is a duplicate
+ */
+ public JSONObject putOnce(String key, Object value) throws JSONException {
+ if (key != null && value != null) {
+ if (this.opt(key) != null) {
+ throw new JSONException("Duplicate key \"" + key + "\"");
+ }
+ this.put(key, value);
+ }
+ return this;
+ }
+
+ /**
+ * Put a key/value pair in the JSONObject, but only if the key and the value
+ * are both non-null.
+ *
+ * @param key
+ * A key string.
+ * @param value
+ * An object which is the value. It should be of one of these
+ * types: Boolean, Double, Integer, JSONArray, JSONObject, Long,
+ * String, or the JSONObject.NULL object.
+ * @return this.
+ * @throws JSONException
+ * If the value is a non-finite number.
+ */
+ public JSONObject putOpt(String key, Object value) throws JSONException {
+ if (key != null && value != null) {
+ this.put(key, value);
+ }
+ return this;
+ }
+
+ /**
+ * Produce a string in double quotes with backslash sequences in all the
+ * right places. A backslash will be inserted within = '\u0080' && c < '\u00a0')
+ || (c >= '\u2000' && c < '\u2100')) {
+ w.write("\\u");
+ hhhh = Integer.toHexString(c);
+ w.write("0000", 0, 4 - hhhh.length());
+ w.write(hhhh);
+ } else {
+ w.write(c);
+ }
+ }
+ }
+ w.write('"');
+ return w;
+ }
+
+ /**
+ * Remove a name and its value, if present.
+ *
+ * @param key
+ * The name to be removed.
+ * @return The value that was associated with the name, or null if there was
+ * no value.
+ */
+ public Object remove(String key) {
+ return this.map.remove(key);
+ }
+
+ /**
+ * Try to convert a string into a number, boolean, or null. If the string
+ * can't be converted, return the string.
+ *
+ * @param string
+ * A String.
+ * @return A simple JSON value.
+ */
+ public static Object stringToValue(String string) {
+ Double d;
+ if (string.equals("")) {
+ return string;
+ }
+ if (string.equalsIgnoreCase("true")) {
+ return Boolean.TRUE;
+ }
+ if (string.equalsIgnoreCase("false")) {
+ return Boolean.FALSE;
+ }
+ if (string.equalsIgnoreCase("null")) {
+ return JSONObject.NULL;
+ }
+
+ /*
+ * If it might be a number, try converting it. If a number cannot be
+ * produced, then the value will just be a string.
+ */
+
+ char b = string.charAt(0);
+ if ((b >= '0' && b <= '9') || b == '-') {
+ try {
+ if (string.indexOf('.') > -1 || string.indexOf('e') > -1
+ || string.indexOf('E') > -1) {
+ d = Double.valueOf(string);
+ if (!d.isInfinite() && !d.isNaN()) {
+ return d;
+ }
+ } else {
+ Long myLong = new Long(string);
+ if (string.equals(myLong.toString())) {
+ if (myLong.longValue() == myLong.intValue()) {
+ return new Integer(myLong.intValue());
+ } else {
+ return myLong;
+ }
+ }
+ }
+ } catch (Exception ignore) {
+ }
+ }
+ return string;
+ }
+
+ /**
+ * Throw an exception if the object is a NaN or infinite number.
+ *
+ * @param o
+ * The object to test.
+ * @throws JSONException
+ * If o is a non-finite number.
+ */
+ public static void testValidity(Object o) throws JSONException {
+ if (o != null) {
+ if (o instanceof Double) {
+ if (((Double) o).isInfinite() || ((Double) o).isNaN()) {
+ throw new JSONException(
+ "JSON does not allow non-finite numbers.");
+ }
+ } else if (o instanceof Float) {
+ if (((Float) o).isInfinite() || ((Float) o).isNaN()) {
+ throw new JSONException(
+ "JSON does not allow non-finite numbers.");
+ }
+ }
+ }
+ }
+
+ /**
+ * Produce a JSONArray containing the values of the members of this
+ * JSONObject.
+ *
+ * @param names
+ * A JSONArray containing a list of key strings. This determines
+ * the sequence of the values in the result.
+ * @return A JSONArray of values.
+ * @throws JSONException
+ * If any of the values are non-finite numbers.
+ */
+ public JSONArray toJSONArray(JSONArray names) throws JSONException {
+ if (names == null || names.length() == 0) {
+ return null;
+ }
+ JSONArray ja = new JSONArray();
+ for (int i = 0; i < names.length(); i += 1) {
+ ja.put(this.opt(names.getString(i)));
+ }
+ return ja;
+ }
+
+ /**
+ * Make a JSON text of this JSONObject. For compactness, no whitespace is
+ * added. If this would not result in a syntactically correct JSON text,
+ * then null will be returned instead.
+ * { (left
+ * brace) and ending with } (right
+ * brace).
+ */
+ public String toString() {
+ try {
+ return this.toString(0);
+ } catch (Exception e) {
+ return null;
+ }
+ }
+
+ /**
+ * Make a prettyprinted JSON text of this JSONObject.
+ * { (left
+ * brace) and ending with } (right
+ * brace).
+ * @throws JSONException
+ * If the object contains an invalid number.
+ */
+ public String toString(int indentFactor) throws JSONException {
+ StringWriter w = new StringWriter();
+ synchronized (w.getBuffer()) {
+ return this.write(w, indentFactor, 0).toString();
+ }
+ }
+
+ /**
+ * Make a JSON text of an Object value. If the object has an
+ * value.toJSONString() method, then that method will be used to produce the
+ * JSON text. The method is required to produce a strictly conforming text.
+ * If the object does not contain a toJSONString method (which is the most
+ * common case), then a text will be produced by other means. If the value
+ * is an array or Collection, then a JSONArray will be made from it and its
+ * toJSONString method will be called. If the value is a MAP, then a
+ * JSONObject will be made from it and its toJSONString method will be
+ * called. Otherwise, the value's toString method will be called, and the
+ * result will be quoted.
+ *
+ * { (left
+ * brace) and ending with } (right
+ * brace).
+ * @throws JSONException
+ * If the value is or contains an invalid number.
+ */
+ public static String valueToString(Object value) throws JSONException {
+ if (value == null || value.equals(null)) {
+ return "null";
+ }
+ if (value instanceof JSONString) {
+ Object object;
+ try {
+ object = ((JSONString) value).toJSONString();
+ } catch (Exception e) {
+ throw new JSONException(e);
+ }
+ if (object instanceof String) {
+ return (String) object;
+ }
+ throw new JSONException("Bad value from toJSONString: " + object);
+ }
+ if (value instanceof Number) {
+ return numberToString((Number) value);
+ }
+ if (value instanceof Boolean || value instanceof JSONObject
+ || value instanceof JSONArray) {
+ return value.toString();
+ }
+ if (value instanceof Map) {
+ return new JSONObject((Map) value).toString();
+ }
+ if (value instanceof Collection) {
+ return new JSONArray((Collection) value).toString();
+ }
+ if (value.getClass().isArray()) {
+ return new JSONArray(value).toString();
+ }
+ return quote(value.toString());
+ }
+
+ /**
+ * Wrap an object, if necessary. If the object is null, return the NULL
+ * object. If it is an array or collection, wrap it in a JSONArray. If it is
+ * a map, wrap it in a JSONObject. If it is a standard property (Double,
+ * String, et al) then it is already wrapped. Otherwise, if it comes from
+ * one of the java packages, turn it into a string. And if it doesn't, try
+ * to wrap it in a JSONObject. If the wrapping fails, then null is returned.
+ *
+ * @param object
+ * The object to wrap
+ * @return The wrapped value
+ */
+ public static Object wrap(Object object) {
+ try {
+ if (object == null) {
+ return NULL;
+ }
+ if (object instanceof JSONObject || object instanceof JSONArray
+ || NULL.equals(object) || object instanceof JSONString
+ || object instanceof Byte || object instanceof Character
+ || object instanceof Short || object instanceof Integer
+ || object instanceof Long || object instanceof Boolean
+ || object instanceof Float || object instanceof Double
+ || object instanceof String) {
+ return object;
+ }
+
+ if (object instanceof Collection) {
+ return new JSONArray((Collection) object);
+ }
+ if (object.getClass().isArray()) {
+ return new JSONArray(object);
+ }
+ if (object instanceof Map) {
+ return new JSONObject((Map) object);
+ }
+ Package objectPackage = object.getClass().getPackage();
+ String objectPackageName = objectPackage != null ? objectPackage
+ .getName() : "";
+ if (objectPackageName.startsWith("java.")
+ || objectPackageName.startsWith("javax.")
+ || object.getClass().getClassLoader() == null) {
+ return object.toString();
+ }
+ return new JSONObject(object);
+ } catch (Exception exception) {
+ return null;
+ }
+ }
+
+ /**
+ * Write the contents of the JSONObject as JSON text to a writer. For
+ * compactness, no whitespace is added.
+ * JSONString interface allows a toJSONString()
+ * method so that a class can change the behavior of
+ * JSONObject.toString(), JSONArray.toString(),
+ * and JSONWriter.value(Object). The
+ * toJSONString method will be used instead of the default behavior
+ * of using the Object's toString() method and quoting the result.
+ */
+public interface JSONString {
+ /**
+ * The toJSONString method allows a class to produce its own JSON
+ * serialization.
+ *
+ * @return A strictly syntactically correct JSON text.
+ */
+ public String toJSONString();
+}
diff --git a/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/JSONStringer.java b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/JSONStringer.java
new file mode 100644
index 000000000..aa84ffc09
--- /dev/null
+++ b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/JSONStringer.java
@@ -0,0 +1,78 @@
+package org.springframework.ide.eclipse.org.json;
+
+/*
+Copyright (c) 2006 JSON.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+The Software shall be used for Good, not Evil.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+import java.io.StringWriter;
+
+/**
+ * JSONStringer provides a quick and convenient way of producing JSON text.
+ * The texts produced strictly conform to JSON syntax rules. No whitespace is
+ * added, so the results are ready for transmission or storage. Each instance of
+ * JSONStringer can produce one JSON text.
+ * value method for appending
+ * values to the
+ * text, and a key
+ * method for adding keys before values in objects. There are array
+ * and endArray methods that make and bound array values, and
+ * object and endObject methods which make and bound
+ * object values. All of these methods return the JSONWriter instance,
+ * permitting cascade style. For example,
+ * myString = new JSONStringer()
+ * .object()
+ * .key("JSON")
+ * .value("Hello, World!")
+ * .endObject()
+ * .toString(); which produces the string
+ * {"JSON":"Hello, World!"}
+ * array or object.
+ * There are no methods for adding commas or colons. JSONStringer adds them for
+ * you. Objects and arrays can be nested up to 20 levels deep.
+ * null if there was a
+ * problem in the construction of the JSON text (such as the calls to
+ * array were not properly balanced with calls to
+ * endArray).
+ * @return The JSON text.
+ */
+ public String toString() {
+ return this.mode == 'd' ? this.writer.toString() : null;
+ }
+}
diff --git a/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/JSONTokener.java b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/JSONTokener.java
new file mode 100644
index 000000000..6c0da0a05
--- /dev/null
+++ b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/JSONTokener.java
@@ -0,0 +1,446 @@
+package org.springframework.ide.eclipse.org.json;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.Reader;
+import java.io.StringReader;
+
+/*
+Copyright (c) 2002 JSON.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+The Software shall be used for Good, not Evil.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+/**
+ * A JSONTokener takes a source string and extracts characters and tokens from
+ * it. It is used by the JSONObject and JSONArray constructors to parse
+ * JSON source strings.
+ * @author JSON.org
+ * @version 2012-02-16
+ */
+public class JSONTokener {
+
+ private long character;
+ private boolean eof;
+ private long index;
+ private long line;
+ private char previous;
+ private Reader reader;
+ private boolean usePrevious;
+
+
+ /**
+ * Construct a JSONTokener from a Reader.
+ *
+ * @param reader A reader.
+ */
+ public JSONTokener(Reader reader) {
+ this.reader = reader.markSupported()
+ ? reader
+ : new BufferedReader(reader);
+ this.eof = false;
+ this.usePrevious = false;
+ this.previous = 0;
+ this.index = 0;
+ this.character = 1;
+ this.line = 1;
+ }
+
+
+ /**
+ * Construct a JSONTokener from an InputStream.
+ */
+ public JSONTokener(InputStream inputStream) throws JSONException {
+ this(new InputStreamReader(inputStream));
+ }
+
+
+ /**
+ * Construct a JSONTokener from a string.
+ *
+ * @param s A source string.
+ */
+ public JSONTokener(String s) {
+ this(new StringReader(s));
+ }
+
+
+ /**
+ * Back up one character. This provides a sort of lookahead capability,
+ * so that you can test for a digit or letter before attempting to parse
+ * the next number or identifier.
+ */
+ public void back() throws JSONException {
+ if (this.usePrevious || this.index <= 0) {
+ throw new JSONException("Stepping back two steps is not supported");
+ }
+ this.index -= 1;
+ this.character -= 1;
+ this.usePrevious = true;
+ this.eof = false;
+ }
+
+
+ /**
+ * Get the hex value of a character (base16).
+ * @param c A character between '0' and '9' or between 'A' and 'F' or
+ * between 'a' and 'f'.
+ * @return An int between 0 and 15, or -1 if c was not a hex digit.
+ */
+ public static int dehexchar(char c) {
+ if (c >= '0' && c <= '9') {
+ return c - '0';
+ }
+ if (c >= 'A' && c <= 'F') {
+ return c - ('A' - 10);
+ }
+ if (c >= 'a' && c <= 'f') {
+ return c - ('a' - 10);
+ }
+ return -1;
+ }
+
+ public boolean end() {
+ return this.eof && !this.usePrevious;
+ }
+
+
+ /**
+ * Determine if the source string still contains characters that next()
+ * can consume.
+ * @return true if not yet at the end of the source.
+ */
+ public boolean more() throws JSONException {
+ this.next();
+ if (this.end()) {
+ return false;
+ }
+ this.back();
+ return true;
+ }
+
+
+ /**
+ * Get the next character in the source string.
+ *
+ * @return The next character, or 0 if past the end of the source string.
+ */
+ public char next() throws JSONException {
+ int c;
+ if (this.usePrevious) {
+ this.usePrevious = false;
+ c = this.previous;
+ } else {
+ try {
+ c = this.reader.read();
+ } catch (IOException exception) {
+ throw new JSONException(exception);
+ }
+
+ if (c <= 0) { // End of stream
+ this.eof = true;
+ c = 0;
+ }
+ }
+ this.index += 1;
+ if (this.previous == '\r') {
+ this.line += 1;
+ this.character = c == '\n' ? 0 : 1;
+ } else if (c == '\n') {
+ this.line += 1;
+ this.character = 0;
+ } else {
+ this.character += 1;
+ }
+ this.previous = (char) c;
+ return this.previous;
+ }
+
+
+ /**
+ * Consume the next character, and check that it matches a specified
+ * character.
+ * @param c The character to match.
+ * @return The character.
+ * @throws JSONException if the character does not match.
+ */
+ public char next(char c) throws JSONException {
+ char n = this.next();
+ if (n != c) {
+ throw this.syntaxError("Expected '" + c + "' and instead saw '" +
+ n + "'");
+ }
+ return n;
+ }
+
+
+ /**
+ * Get the next n characters.
+ *
+ * @param n The number of characters to take.
+ * @return A string of n characters.
+ * @throws JSONException
+ * Substring bounds error if there are not
+ * n characters remaining in the source string.
+ */
+ public String next(int n) throws JSONException {
+ if (n == 0) {
+ return "";
+ }
+
+ char[] chars = new char[n];
+ int pos = 0;
+
+ while (pos < n) {
+ chars[pos] = this.next();
+ if (this.end()) {
+ throw this.syntaxError("Substring bounds error");
+ }
+ pos += 1;
+ }
+ return new String(chars);
+ }
+
+
+ /**
+ * Get the next char in the string, skipping whitespace.
+ * @throws JSONException
+ * @return A character, or 0 if there are no more characters.
+ */
+ public char nextClean() throws JSONException {
+ for (;;) {
+ char c = this.next();
+ if (c == 0 || c > ' ') {
+ return c;
+ }
+ }
+ }
+
+
+ /**
+ * Return the characters up to the next close quote character.
+ * Backslash processing is done. The formal JSON format does not
+ * allow strings in single quotes, but an implementation is allowed to
+ * accept them.
+ * @param quote The quoting character, either
+ * " (double quote) or
+ * ' (single quote).
+ * @return A String.
+ * @throws JSONException Unterminated string.
+ */
+ public String nextString(char quote) throws JSONException {
+ char c;
+ StringBuffer sb = new StringBuffer();
+ for (;;) {
+ c = this.next();
+ switch (c) {
+ case 0:
+ case '\n':
+ case '\r':
+ throw this.syntaxError("Unterminated string");
+ case '\\':
+ c = this.next();
+ switch (c) {
+ case 'b':
+ sb.append('\b');
+ break;
+ case 't':
+ sb.append('\t');
+ break;
+ case 'n':
+ sb.append('\n');
+ break;
+ case 'f':
+ sb.append('\f');
+ break;
+ case 'r':
+ sb.append('\r');
+ break;
+ case 'u':
+ sb.append((char)Integer.parseInt(this.next(4), 16));
+ break;
+ case '"':
+ case '\'':
+ case '\\':
+ case '/':
+ sb.append(c);
+ break;
+ default:
+ throw this.syntaxError("Illegal escape.");
+ }
+ break;
+ default:
+ if (c == quote) {
+ return sb.toString();
+ }
+ sb.append(c);
+ }
+ }
+ }
+
+
+ /**
+ * Get the text up but not including the specified character or the
+ * end of line, whichever comes first.
+ * @param delimiter A delimiter character.
+ * @return A string.
+ */
+ public String nextTo(char delimiter) throws JSONException {
+ StringBuffer sb = new StringBuffer();
+ for (;;) {
+ char c = this.next();
+ if (c == delimiter || c == 0 || c == '\n' || c == '\r') {
+ if (c != 0) {
+ this.back();
+ }
+ return sb.toString().trim();
+ }
+ sb.append(c);
+ }
+ }
+
+
+ /**
+ * Get the text up but not including one of the specified delimiter
+ * characters or the end of line, whichever comes first.
+ * @param delimiters A set of delimiter characters.
+ * @return A string, trimmed.
+ */
+ public String nextTo(String delimiters) throws JSONException {
+ char c;
+ StringBuffer sb = new StringBuffer();
+ for (;;) {
+ c = this.next();
+ if (delimiters.indexOf(c) >= 0 || c == 0 ||
+ c == '\n' || c == '\r') {
+ if (c != 0) {
+ this.back();
+ }
+ return sb.toString().trim();
+ }
+ sb.append(c);
+ }
+ }
+
+
+ /**
+ * Get the next value. The value can be a Boolean, Double, Integer,
+ * JSONArray, JSONObject, Long, or String, or the JSONObject.NULL object.
+ * @throws JSONException If syntax error.
+ *
+ * @return An object.
+ */
+ public Object nextValue() throws JSONException {
+ char c = this.nextClean();
+ String string;
+
+ switch (c) {
+ case '"':
+ case '\'':
+ return this.nextString(c);
+ case '{':
+ this.back();
+ return new JSONObject(this);
+ case '[':
+ this.back();
+ return new JSONArray(this);
+ }
+
+ /*
+ * Handle unquoted text. This could be the values true, false, or
+ * null, or it can be a number. An implementation (such as this one)
+ * is allowed to also accept non-standard forms.
+ *
+ * Accumulate characters until we reach the end of the text or a
+ * formatting character.
+ */
+
+ StringBuffer sb = new StringBuffer();
+ while (c >= ' ' && ",:]}/\\\"[{;=#".indexOf(c) < 0) {
+ sb.append(c);
+ c = this.next();
+ }
+ this.back();
+
+ string = sb.toString().trim();
+ if ("".equals(string)) {
+ throw this.syntaxError("Missing value");
+ }
+ return JSONObject.stringToValue(string);
+ }
+
+
+ /**
+ * Skip characters until the next character is the requested character.
+ * If the requested character is not found, no characters are skipped.
+ * @param to A character to skip to.
+ * @return The requested character, or zero if the requested character
+ * is not found.
+ */
+ public char skipTo(char to) throws JSONException {
+ char c;
+ try {
+ long startIndex = this.index;
+ long startCharacter = this.character;
+ long startLine = this.line;
+ this.reader.mark(1000000);
+ do {
+ c = this.next();
+ if (c == 0) {
+ this.reader.reset();
+ this.index = startIndex;
+ this.character = startCharacter;
+ this.line = startLine;
+ return c;
+ }
+ } while (c != to);
+ } catch (IOException exc) {
+ throw new JSONException(exc);
+ }
+
+ this.back();
+ return c;
+ }
+
+
+ /**
+ * Make a JSONException to signal a syntax error.
+ *
+ * @param message The error message.
+ * @return A JSONException object, suitable for throwing
+ */
+ public JSONException syntaxError(String message) {
+ return new JSONException(message + this.toString());
+ }
+
+
+ /**
+ * Make a printable string of this JSONTokener.
+ *
+ * @return " at {index} [character {character} line {line}]"
+ */
+ public String toString() {
+ return " at " + this.index + " [character " + this.character + " line " +
+ this.line + "]";
+ }
+}
diff --git a/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/JSONWriter.java b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/JSONWriter.java
new file mode 100644
index 000000000..06c6d21ed
--- /dev/null
+++ b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/JSONWriter.java
@@ -0,0 +1,327 @@
+package org.springframework.ide.eclipse.org.json;
+
+import java.io.IOException;
+import java.io.Writer;
+
+/*
+Copyright (c) 2006 JSON.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+The Software shall be used for Good, not Evil.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+/**
+ * JSONWriter provides a quick and convenient way of producing JSON text.
+ * The texts produced strictly conform to JSON syntax rules. No whitespace is
+ * added, so the results are ready for transmission or storage. Each instance of
+ * JSONWriter can produce one JSON text.
+ * value method for appending
+ * values to the
+ * text, and a key
+ * method for adding keys before values in objects. There are array
+ * and endArray methods that make and bound array values, and
+ * object and endObject methods which make and bound
+ * object values. All of these methods return the JSONWriter instance,
+ * permitting a cascade style. For example,
+ * new JSONWriter(myWriter)
+ * .object()
+ * .key("JSON")
+ * .value("Hello, World!")
+ * .endObject(); which writes
+ * {"JSON":"Hello, World!"}
+ * array or object.
+ * There are no methods for adding commas or colons. JSONWriter adds them for
+ * you. Objects and arrays can be nested up to 20 levels deep.
+ * endArray will be appended to this array. The
+ * endArray method must be called to mark the array's end.
+ * @return this
+ * @throws JSONException If the nesting is too deep, or if the object is
+ * started in the wrong place (for example as a key or after the end of the
+ * outermost array or object).
+ */
+ public JSONWriter array() throws JSONException {
+ if (this.mode == 'i' || this.mode == 'o' || this.mode == 'a') {
+ this.push(null);
+ this.append("[");
+ this.comma = false;
+ return this;
+ }
+ throw new JSONException("Misplaced array.");
+ }
+
+ /**
+ * End something.
+ * @param mode Mode
+ * @param c Closing character
+ * @return this
+ * @throws JSONException If unbalanced.
+ */
+ private JSONWriter end(char mode, char c) throws JSONException {
+ if (this.mode != mode) {
+ throw new JSONException(mode == 'a'
+ ? "Misplaced endArray."
+ : "Misplaced endObject.");
+ }
+ this.pop(mode);
+ try {
+ this.writer.write(c);
+ } catch (IOException e) {
+ throw new JSONException(e);
+ }
+ this.comma = true;
+ return this;
+ }
+
+ /**
+ * End an array. This method most be called to balance calls to
+ * array.
+ * @return this
+ * @throws JSONException If incorrectly nested.
+ */
+ public JSONWriter endArray() throws JSONException {
+ return this.end('a', ']');
+ }
+
+ /**
+ * End an object. This method most be called to balance calls to
+ * object.
+ * @return this
+ * @throws JSONException If incorrectly nested.
+ */
+ public JSONWriter endObject() throws JSONException {
+ return this.end('k', '}');
+ }
+
+ /**
+ * Append a key. The key will be associated with the next value. In an
+ * object, every value must be preceded by a key.
+ * @param string A key string.
+ * @return this
+ * @throws JSONException If the key is out of place. For example, keys
+ * do not belong in arrays or if the key is null.
+ */
+ public JSONWriter key(String string) throws JSONException {
+ if (string == null) {
+ throw new JSONException("Null key.");
+ }
+ if (this.mode == 'k') {
+ try {
+ this.stack[this.top - 1].putOnce(string, Boolean.TRUE);
+ if (this.comma) {
+ this.writer.write(',');
+ }
+ this.writer.write(JSONObject.quote(string));
+ this.writer.write(':');
+ this.comma = false;
+ this.mode = 'o';
+ return this;
+ } catch (IOException e) {
+ throw new JSONException(e);
+ }
+ }
+ throw new JSONException("Misplaced key.");
+ }
+
+
+ /**
+ * Begin appending a new object. All keys and values until the balancing
+ * endObject will be appended to this object. The
+ * endObject method must be called to mark the object's end.
+ * @return this
+ * @throws JSONException If the nesting is too deep, or if the object is
+ * started in the wrong place (for example as a key or after the end of the
+ * outermost array or object).
+ */
+ public JSONWriter object() throws JSONException {
+ if (this.mode == 'i') {
+ this.mode = 'o';
+ }
+ if (this.mode == 'o' || this.mode == 'a') {
+ this.append("{");
+ this.push(new JSONObject());
+ this.comma = false;
+ return this;
+ }
+ throw new JSONException("Misplaced object.");
+
+ }
+
+
+ /**
+ * Pop an array or object scope.
+ * @param c The scope to close.
+ * @throws JSONException If nesting is wrong.
+ */
+ private void pop(char c) throws JSONException {
+ if (this.top <= 0) {
+ throw new JSONException("Nesting error.");
+ }
+ char m = this.stack[this.top - 1] == null ? 'a' : 'k';
+ if (m != c) {
+ throw new JSONException("Nesting error.");
+ }
+ this.top -= 1;
+ this.mode = this.top == 0
+ ? 'd'
+ : this.stack[this.top - 1] == null
+ ? 'a'
+ : 'k';
+ }
+
+ /**
+ * Push an array or object scope.
+ * @param c The scope to open.
+ * @throws JSONException If nesting is too deep.
+ */
+ private void push(JSONObject jo) throws JSONException {
+ if (this.top >= maxdepth) {
+ throw new JSONException("Nesting too deep.");
+ }
+ this.stack[this.top] = jo;
+ this.mode = jo == null ? 'a' : 'k';
+ this.top += 1;
+ }
+
+
+ /**
+ * Append either the value true or the value
+ * false.
+ * @param b A boolean.
+ * @return this
+ * @throws JSONException
+ */
+ public JSONWriter value(boolean b) throws JSONException {
+ return this.append(b ? "true" : "false");
+ }
+
+ /**
+ * Append a double value.
+ * @param d A double.
+ * @return this
+ * @throws JSONException If the number is not finite.
+ */
+ public JSONWriter value(double d) throws JSONException {
+ return this.value(new Double(d));
+ }
+
+ /**
+ * Append a long value.
+ * @param l A long.
+ * @return this
+ * @throws JSONException
+ */
+ public JSONWriter value(long l) throws JSONException {
+ return this.append(Long.toString(l));
+ }
+
+
+ /**
+ * Append an object value.
+ * @param object The object to append. It can be null, or a Boolean, Number,
+ * String, JSONObject, or JSONArray, or an object that implements JSONString.
+ * @return this
+ * @throws JSONException If the value is out of sequence.
+ */
+ public JSONWriter value(Object object) throws JSONException {
+ return this.append(JSONObject.valueToString(object));
+ }
+}
diff --git a/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/Kim.java b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/Kim.java
new file mode 100644
index 000000000..780b8e48f
--- /dev/null
+++ b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/Kim.java
@@ -0,0 +1,373 @@
+package org.springframework.ide.eclipse.org.json;
+
+
+/*
+ Copyright (c) 2013 JSON.org
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ The Software shall be used for Good, not Evil.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+ */
+
+/**
+ * Kim makes immutable eight bit Unicode strings. If the MSB of a byte is set,
+ * then the next byte is a continuation byte. The last byte of a character
+ * never has the MSB reset. Every byte that is not the last byte has the MSB
+ * set. Kim stands for "Keep it minimal". A Unicode character is never longer
+ * than 3 bytes. Every byte contributes 7 bits to the character. ASCII is
+ * unmodified.
+ *
+ * Kim UTF-8
+ * one byte U+007F U+007F
+ * two bytes U+3FFF U+07FF
+ * three bytes U+10FFF U+FFFF
+ * four bytes U+10FFFF
+ *
+ * Characters in the ranges U+0800..U+3FFF and U+10000..U+10FFFF will be one
+ * byte smaller when encoded in Kim compared to UTF-8.
+ *
+ * Kim is beneficial when using scripts such as Old South Arabian, Aramaic,
+ * Avestan, Balinese, Batak, Bopomofo, Buginese, Buhid, Carian, Cherokee,
+ * Coptic, Cyrillic, Deseret, Egyptian Hieroglyphs, Ethiopic, Georgian,
+ * Glagolitic, Gothic, Hangul Jamo, Hanunoo, Hiragana, Kanbun, Kaithi,
+ * Kannada, Katakana, Kharoshthi, Khmer, Lao, Lepcha, Limbu, Lycian, Lydian,
+ * Malayalam, Mandaic, Meroitic, Miao, Mongolian, Myanmar, New Tai Lue,
+ * Ol Chiki, Old Turkic, Oriya, Osmanya, Pahlavi, Parthian, Phags-Pa,
+ * Phoenician, Samaritan, Sharada, Sinhala, Sora Sompeng, Tagalog, Tagbanwa,
+ * Takri, Tai Le, Tai Tham, Tamil, Telugu, Thai, Tibetan, Tifinagh, UCAS.
+ *
+ * A kim object can be constructed from an ordinary UTF-16 string, or from a
+ * byte array. A kim object can produce a UTF-16 string.
+ *
+ * As with UTF-8, it is possible to detect character boundaries within a byte
+ * sequence. UTF-8 is one of the world's great inventions. While Kim is more
+ * efficient, it is not clear that it is worth the expense of transition.
+ *
+ * @version 2013-04-18
+ */
+public class Kim {
+
+ /**
+ * The byte array containing the kim's content.
+ */
+ private byte[] bytes = null;
+
+ /**
+ * The kim's hashcode, conforming to Java's hashcode conventions.
+ */
+ private int hashcode = 0;
+
+ /**
+ * The number of bytes in the kim. The number of bytes can be as much as
+ * three times the number of characters.
+ */
+ public int length = 0;
+
+ /**
+ * The memoization of toString().
+ */
+ private String string = null;
+
+ /**
+ * Make a kim from a portion of a byte array.
+ *
+ * @param bytes
+ * A byte array.
+ * @param from
+ * The index of the first byte.
+ * @param thru
+ * The index of the last byte plus one.
+ */
+ public Kim(byte[] bytes, int from, int thru) {
+
+// As the bytes are copied into the new kim, a hashcode is computed using a
+// modified Fletcher code.
+
+ int sum = 1;
+ int value;
+ this.hashcode = 0;
+ this.length = thru - from;
+ if (this.length > 0) {
+ this.bytes = new byte[this.length];
+ for (int at = 0; at < this.length; at += 1) {
+ value = (int) bytes[at + from] & 0xFF;
+ sum += value;
+ this.hashcode += sum;
+ this.bytes[at] = (byte) value;
+ }
+ this.hashcode += sum << 16;
+ }
+ }
+
+ /**
+ * Make a kim from a byte array.
+ *
+ * @param bytes
+ * The byte array.
+ * @param length
+ * The number of bytes.
+ */
+ public Kim(byte[] bytes, int length) {
+ this(bytes, 0, length);
+ }
+
+ /**
+ * Make a new kim from a substring of an existing kim. The coordinates are
+ * in byte units, not character units.
+ *
+ * @param kim
+ * The source of bytes.
+ * @param from
+ * The point at which to take bytes.
+ * @param thru
+ * The point at which to stop taking bytes.
+ * @return the substring
+ */
+ public Kim(Kim kim, int from, int thru) {
+ this(kim.bytes, from, thru);
+ }
+
+ /**
+ * Make a kim from a string.
+ *
+ * @param string
+ * The string.
+ * @throws JSONException
+ * if surrogate pair mismatch.
+ */
+ public Kim(String string) throws JSONException {
+ int stringLength = string.length();
+ this.hashcode = 0;
+ this.length = 0;
+
+// First pass: Determine the length of the kim, allowing for the UTF-16
+// to UTF-32 conversion, and then the UTF-32 to Kim conversion.
+
+ if (stringLength > 0) {
+ for (int i = 0; i < stringLength; i += 1) {
+ int c = string.charAt(i);
+ if (c <= 0x7F) {
+ this.length += 1;
+ } else if (c <= 0x3FFF) {
+ this.length += 2;
+ } else {
+ if (c >= 0xD800 && c <= 0xDFFF) {
+ i += 1;
+ int d = string.charAt(i);
+ if (c > 0xDBFF || d < 0xDC00 || d > 0xDFFF) {
+ throw new JSONException("Bad UTF16");
+ }
+ }
+ this.length += 3;
+ }
+ }
+
+// Second pass: Allocate a byte array and fill that array with the conversion
+// while computing the hashcode.
+
+ this.bytes = new byte[length];
+ int at = 0;
+ int b;
+ int sum = 1;
+ for (int i = 0; i < stringLength; i += 1) {
+ int character = string.charAt(i);
+ if (character <= 0x7F) {
+ bytes[at] = (byte) character;
+ sum += character;
+ this.hashcode += sum;
+ at += 1;
+ } else if (character <= 0x3FFF) {
+ b = 0x80 | (character >>> 7);
+ bytes[at] = (byte) b;
+ sum += b;
+ this.hashcode += sum;
+ at += 1;
+ b = character & 0x7F;
+ bytes[at] = (byte) b;
+ sum += b;
+ this.hashcode += sum;
+ at += 1;
+ } else {
+ if (character >= 0xD800 && character <= 0xDBFF) {
+ i += 1;
+ character = (((character & 0x3FF) << 10) | (string
+ .charAt(i) & 0x3FF)) + 65536;
+ }
+ b = 0x80 | (character >>> 14);
+ bytes[at] = (byte) b;
+ sum += b;
+ this.hashcode += sum;
+ at += 1;
+ b = 0x80 | ((character >>> 7) & 0xFF);
+ bytes[at] = (byte) b;
+ sum += b;
+ this.hashcode += sum;
+ at += 1;
+ b = character & 0x7F;
+ bytes[at] = (byte) b;
+ sum += b;
+ this.hashcode += sum;
+ at += 1;
+ }
+ }
+ this.hashcode += sum << 16;
+ }
+ }
+
+ /**
+ * Returns the character at the specified index. The index refers to byte
+ * values and ranges from 0 to length - 1. The index of the next character
+ * is at index + Kim.characterSize(kim.characterAt(index)).
+ *
+ * @param at
+ * the index of the char value. The first character is at 0.
+ * @returns a Unicode character between 0 and 0x10FFFF.
+ * @throws JSONException
+ * if at does not point to a valid character.
+ */
+ public int characterAt(int at) throws JSONException {
+ int c = get(at);
+ if ((c & 0x80) == 0) {
+ return c;
+ }
+ int character;
+ int c1 = get(at + 1);
+ if ((c1 & 0x80) == 0) {
+ character = ((c & 0x7F) << 7) | c1;
+ if (character > 0x7F) {
+ return character;
+ }
+ } else {
+ int c2 = get(at + 2);
+ character = ((c & 0x7F) << 14) | ((c1 & 0x7F) << 7) | c2;
+ if ((c2 & 0x80) == 0 && character > 0x3FFF && character <= 0x10FFFF
+ && (character < 0xD800 || character > 0xDFFF)) {
+ return character;
+ }
+ }
+ throw new JSONException("Bad character at " + at);
+ }
+
+ /**
+ * Returns the number of bytes needed to contain the character in Kim
+ * format.
+ *
+ * @param character
+ * a Unicode character between 0 and 0x10FFFF.
+ * @return 1, 2, or 3
+ * @throws JSONException
+ * if the character is not representable in a kim.
+ */
+ public static int characterSize(int character) throws JSONException {
+ if (character < 0 || character > 0x10FFFF) {
+ throw new JSONException("Bad character " + character);
+ }
+ return character <= 0x7F ? 1 : character <= 0x3FFF ? 2 : 3;
+ }
+
+ /**
+ * Copy the contents of this kim to a byte array.
+ *
+ * @param bytes
+ * A byte array of sufficient size.
+ * @param at
+ * The position within the byte array to take the byes.
+ * @return The position immediately after the copy.
+ */
+ public int copy(byte[] bytes, int at) {
+ System.arraycopy(this.bytes, 0, bytes, at, this.length);
+ return at + this.length;
+ }
+
+ /**
+ * Two kim objects containing exactly the same bytes in the same order are
+ * equal to each other.
+ *
+ * @param obj
+ * the other kim with which to compare.
+ * @returns true if this and obj are both kim objects containing identical
+ * byte sequences.
+ */
+ public boolean equals(Object obj) {
+ if (!(obj instanceof Kim)) {
+ return false;
+ }
+ Kim that = (Kim) obj;
+ if (this == that) {
+ return true;
+ }
+ if (this.hashcode != that.hashcode) {
+ return false;
+ }
+ return java.util.Arrays.equals(this.bytes, that.bytes);
+ }
+
+ /**
+ * Get a byte from a kim.
+ * @param at
+ * The position of the byte. The first byte is at 0.
+ * @return The byte.
+ * @throws JSONException
+ * if there is no byte at that position.
+ */
+ public int get(int at) throws JSONException {
+ if (at < 0 || at > this.length) {
+ throw new JSONException("Bad character at " + at);
+ }
+ return ((int) this.bytes[at]) & 0xFF;
+ }
+
+ /**
+ * Returns a hash code value for the kim.
+ */
+ public int hashCode() {
+ return this.hashcode;
+ }
+
+ /**
+ * Produce a UTF-16 String from this kim. The number of codepoints in the
+ * string will not be greater than the number of bytes in the kim, although
+ * it could be less.
+ *
+ * @return The string. A kim memoizes its string representation.
+ * @throws JSONException
+ * if the kim is not valid.
+ */
+ public String toString() throws JSONException {
+ if (this.string == null) {
+ int c;
+ int length = 0;
+ char chars[] = new char[this.length];
+ for (int at = 0; at < this.length; at += characterSize(c)) {
+ c = this.characterAt(at);
+ if (c < 0x10000) {
+ chars[length] = (char) c;
+ length += 1;
+ } else {
+ chars[length] = (char) (0xD800 | ((c - 0x10000) >>> 10));
+ length += 1;
+ chars[length] = (char) (0xDC00 | (c & 0x03FF));
+ length += 1;
+ }
+ }
+ this.string = new String(chars, 0, length);
+ }
+ return this.string;
+ }
+}
diff --git a/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/Property.java b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/Property.java
new file mode 100644
index 000000000..8fc2de75c
--- /dev/null
+++ b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/Property.java
@@ -0,0 +1,74 @@
+package org.springframework.ide.eclipse.org.json;
+
+/*
+Copyright (c) 2002 JSON.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+The Software shall be used for Good, not Evil.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+import java.util.Enumeration;
+import java.util.Iterator;
+import java.util.Properties;
+
+/**
+ * Converts a Property file data into JSONObject and back.
+ * @author JSON.org
+ * @version 2013-05-23
+ */
+public class Property {
+ /**
+ * Converts a property file object into a JSONObject. The property file object is a table of name value pairs.
+ * @param properties java.util.Properties
+ * @return JSONObject
+ * @throws JSONException
+ */
+ public static JSONObject toJSONObject(java.util.Properties properties) throws JSONException {
+ JSONObject jo = new JSONObject();
+ if (properties != null && !properties.isEmpty()) {
+ Enumeration enumProperties = properties.propertyNames();
+ while(enumProperties.hasMoreElements()) {
+ String name = (String)enumProperties.nextElement();
+ jo.put(name, properties.getProperty(name));
+ }
+ }
+ return jo;
+
+ }
+
+ /**
+ * Converts the JSONObject into a property file object.
+ * @param jo JSONObject
+ * @return java.util.Properties
+ * @throws JSONException
+ */
+ public static Properties toProperties(JSONObject jo) throws JSONException {
+ Properties properties = new Properties();
+ if (jo != null) {
+ Iterator keys = jo.keys();
+
+ while (keys.hasNext()) {
+ String name = keys.next().toString();
+ properties.put(name, jo.getString(name));
+ }
+ }
+ return properties;
+ }
+}
\ No newline at end of file
diff --git a/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/XML.java b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/XML.java
new file mode 100644
index 000000000..d7d119ab6
--- /dev/null
+++ b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/XML.java
@@ -0,0 +1,495 @@
+package org.springframework.ide.eclipse.org.json;
+
+/*
+Copyright (c) 2002 JSON.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+The Software shall be used for Good, not Evil.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+import java.util.Iterator;
+
+
+/**
+ * This provides static methods to convert an XML text into a JSONObject,
+ * and to covert a JSONObject into an XML text.
+ * @author JSON.org
+ * @version 2013-11-12
+ */
+public class XML {
+
+ /** The Character '&'. */
+ public static final Character AMP = new Character('&');
+
+ /** The Character '''. */
+ public static final Character APOS = new Character('\'');
+
+ /** The Character '!'. */
+ public static final Character BANG = new Character('!');
+
+ /** The Character '='. */
+ public static final Character EQ = new Character('=');
+
+ /** The Character '>'. */
+ public static final Character GT = new Character('>');
+
+ /** The Character '<'. */
+ public static final Character LT = new Character('<');
+
+ /** The Character '?'. */
+ public static final Character QUEST = new Character('?');
+
+ /** The Character '"'. */
+ public static final Character QUOT = new Character('"');
+
+ /** The Character '/'. */
+ public static final Character SLASH = new Character('/');
+
+ /**
+ * Replace special characters with XML escapes:
+ *
+ * & (ampersand) is replaced by &
+ * < (less than) is replaced by <
+ * > (greater than) is replaced by >
+ * " (double quote) is replaced by "
+ *
+ * @param string The string to be escaped.
+ * @return The escaped string.
+ */
+ public static String escape(String string) {
+ StringBuffer sb = new StringBuffer();
+ for (int i = 0, length = string.length(); i < length; i++) {
+ char c = string.charAt(i);
+ switch (c) {
+ case '&':
+ sb.append("&");
+ break;
+ case '<':
+ sb.append("<");
+ break;
+ case '>':
+ sb.append(">");
+ break;
+ case '"':
+ sb.append(""");
+ break;
+ case '\'':
+ sb.append("'");
+ break;
+ default:
+ sb.append(c);
+ }
+ }
+ return sb.toString();
+ }
+
+ /**
+ * Throw an exception if the string contains whitespace.
+ * Whitespace is not allowed in tagNames and attributes.
+ * @param string
+ * @throws JSONException
+ */
+ public static void noSpace(String string) throws JSONException {
+ int i, length = string.length();
+ if (length == 0) {
+ throw new JSONException("Empty string.");
+ }
+ for (i = 0; i < length; i += 1) {
+ if (Character.isWhitespace(string.charAt(i))) {
+ throw new JSONException("'" + string +
+ "' contains a space character.");
+ }
+ }
+ }
+
+ /**
+ * Scan the content following the named tag, attaching it to the context.
+ * @param x The XMLTokener containing the source string.
+ * @param context The JSONObject that will include the new material.
+ * @param name The tag name.
+ * @return true if the close tag is processed.
+ * @throws JSONException
+ */
+ private static boolean parse(XMLTokener x, JSONObject context,
+ String name) throws JSONException {
+ char c;
+ int i;
+ JSONObject jsonobject = null;
+ String string;
+ String tagName;
+ Object token;
+
+// Test for and skip past these forms:
+//
+//
+//
+//
+// Report errors for these forms:
+// <>
+// <=
+// <<
+
+ token = x.nextToken();
+
+// ");
+ return false;
+ }
+ x.back();
+ } else if (c == '[') {
+ token = x.nextToken();
+ if ("CDATA".equals(token)) {
+ if (x.next() == '[') {
+ string = x.nextCDATA();
+ if (string.length() > 0) {
+ context.accumulate("content", string);
+ }
+ return false;
+ }
+ }
+ throw x.syntaxError("Expected 'CDATA['");
+ }
+ i = 1;
+ do {
+ token = x.nextMeta();
+ if (token == null) {
+ throw x.syntaxError("Missing '>' after ' 0);
+ return false;
+ } else if (token == QUEST) {
+
+// ");
+ return false;
+ } else if (token == SLASH) {
+
+// Close tag
+
+ } else if (token == SLASH) {
+ if (x.nextToken() != GT) {
+ throw x.syntaxError("Misshaped tag");
+ }
+ if (jsonobject.length() > 0) {
+ context.accumulate(tagName, jsonobject);
+ } else {
+ context.accumulate(tagName, "");
+ }
+ return false;
+
+// Content, between <...> and
+
+ } else if (token == GT) {
+ for (;;) {
+ token = x.nextContent();
+ if (token == null) {
+ if (tagName != null) {
+ throw x.syntaxError("Unclosed tag " + tagName);
+ }
+ return false;
+ } else if (token instanceof String) {
+ string = (String)token;
+ if (string.length() > 0) {
+ jsonobject.accumulate("content",
+ XML.stringToValue(string));
+ }
+
+// Nested element
+
+ } else if (token == LT) {
+ if (parse(x, jsonobject, tagName)) {
+ if (jsonobject.length() == 0) {
+ context.accumulate(tagName, "");
+ } else if (jsonobject.length() == 1 &&
+ jsonobject.opt("content") != null) {
+ context.accumulate(tagName,
+ jsonobject.opt("content"));
+ } else {
+ context.accumulate(tagName, jsonobject);
+ }
+ return false;
+ }
+ }
+ }
+ } else {
+ throw x.syntaxError("Misshaped tag");
+ }
+ }
+ }
+ }
+
+
+ /**
+ * Try to convert a string into a number, boolean, or null. If the string
+ * can't be converted, return the string. This is much less ambitious than
+ * JSONObject.stringToValue, especially because it does not attempt to
+ * convert plus forms, octal forms, hex forms, or E forms lacking decimal
+ * points.
+ * @param string A String.
+ * @return A simple JSON value.
+ */
+ public static Object stringToValue(String string) {
+ if ("true".equalsIgnoreCase(string)) {
+ return Boolean.TRUE;
+ }
+ if ("false".equalsIgnoreCase(string)) {
+ return Boolean.FALSE;
+ }
+ if ("null".equalsIgnoreCase(string)) {
+ return JSONObject.NULL;
+ }
+
+// If it might be a number, try converting it, first as a Long, and then as a
+// Double. If that doesn't work, return the string.
+
+ try {
+ char initial = string.charAt(0);
+ if (initial == '-' || (initial >= '0' && initial <= '9')) {
+ Long value = new Long(string);
+ if (value.toString().equals(string)) {
+ return value;
+ }
+ }
+ } catch (Exception ignore) {
+ try {
+ Double value = new Double(string);
+ if (value.toString().equals(string)) {
+ return value;
+ }
+ } catch (Exception ignoreAlso) {
+ }
+ }
+ return string;
+ }
+
+
+ /**
+ * Convert a well-formed (but not necessarily valid) XML string into a
+ * JSONObject. Some information may be lost in this transformation
+ * because JSON is a data format and XML is a document format. XML uses
+ * elements, attributes, and content text, while JSON uses unordered
+ * collections of name/value pairs and arrays of values. JSON does not
+ * does not like to distinguish between elements and attributes.
+ * Sequences of similar elements are represented as JSONArrays. Content
+ * text may be placed in a "content" member. Comments, prologs, DTDs, and
+ * <[ [ ]]> are ignored.
+ * @param string The source string.
+ * @return A JSONObject containing the structured data from the XML string.
+ * @throws JSONException
+ */
+ public static JSONObject toJSONObject(String string) throws JSONException {
+ JSONObject jo = new JSONObject();
+ XMLTokener x = new XMLTokener(string);
+ while (x.more() && x.skipPast("<")) {
+ parse(x, jo, null);
+ }
+ return jo;
+ }
+
+
+ /**
+ * Convert a JSONObject into a well-formed, element-normal XML string.
+ * @param object A JSONObject.
+ * @return A string.
+ * @throws JSONException
+ */
+ public static String toString(Object object) throws JSONException {
+ return toString(object, null);
+ }
+
+
+ /**
+ * Convert a JSONObject into a well-formed, element-normal XML string.
+ * @param object A JSONObject.
+ * @param tagName The optional name of the enclosing tag.
+ * @return A string.
+ * @throws JSONException
+ */
+ public static String toString(Object object, String tagName)
+ throws JSONException {
+ StringBuffer sb = new StringBuffer();
+ int i;
+ JSONArray ja;
+ JSONObject jo;
+ String key;
+ Iterator keys;
+ int length;
+ String string;
+ Object value;
+ if (object instanceof JSONObject) {
+
+// Emit ]]>.
+ * @throws JSONException If the ]]> is not found.
+ */
+ public String nextCDATA() throws JSONException {
+ char c;
+ int i;
+ StringBuffer sb = new StringBuffer();
+ for (;;) {
+ c = next();
+ if (end()) {
+ throw syntaxError("Unclosed CDATA");
+ }
+ sb.append(c);
+ i = sb.length() - 3;
+ if (i >= 0 && sb.charAt(i) == ']' &&
+ sb.charAt(i + 1) == ']' && sb.charAt(i + 2) == '>') {
+ sb.setLength(i);
+ return sb.toString();
+ }
+ }
+ }
+
+
+ /**
+ * Get the next XML outer token, trimming whitespace. There are two kinds
+ * of tokens: the '<' character which begins a markup tag, and the content
+ * text between markup tags.
+ *
+ * @return A string, or a '<' Character, or null if there is no more
+ * source text.
+ * @throws JSONException
+ */
+ public Object nextContent() throws JSONException {
+ char c;
+ StringBuffer sb;
+ do {
+ c = next();
+ } while (Character.isWhitespace(c));
+ if (c == 0) {
+ return null;
+ }
+ if (c == '<') {
+ return XML.LT;
+ }
+ sb = new StringBuffer();
+ for (;;) {
+ if (c == '<' || c == 0) {
+ back();
+ return sb.toString().trim();
+ }
+ if (c == '&') {
+ sb.append(nextEntity(c));
+ } else {
+ sb.append(c);
+ }
+ c = next();
+ }
+ }
+
+
+ /**
+ * Return the next entity. These entities are translated to Characters:
+ * & ' > < ".
+ * @param ampersand An ampersand character.
+ * @return A Character or an entity String if the entity is not recognized.
+ * @throws JSONException If missing ';' in XML entity.
+ */
+ public Object nextEntity(char ampersand) throws JSONException {
+ StringBuffer sb = new StringBuffer();
+ for (;;) {
+ char c = next();
+ if (Character.isLetterOrDigit(c) || c == '#') {
+ sb.append(Character.toLowerCase(c));
+ } else if (c == ';') {
+ break;
+ } else {
+ throw syntaxError("Missing ';' in XML entity: &" + sb);
+ }
+ }
+ String string = sb.toString();
+ Object object = entity.get(string);
+ return object != null ? object : ampersand + string + ";";
+ }
+
+
+ /**
+ * Returns the next XML meta token. This is used for skipping over
+ * and structures.
+ * @return Syntax characters (< > / = ! ?) are returned as
+ * Character, and strings and names are returned as Boolean. We don't care
+ * what the values actually are.
+ * @throws JSONException If a string is not properly closed or if the XML
+ * is badly structured.
+ */
+ public Object nextMeta() throws JSONException {
+ char c;
+ char q;
+ do {
+ c = next();
+ } while (Character.isWhitespace(c));
+ switch (c) {
+ case 0:
+ throw syntaxError("Misshaped meta tag");
+ case '<':
+ return XML.LT;
+ case '>':
+ return XML.GT;
+ case '/':
+ return XML.SLASH;
+ case '=':
+ return XML.EQ;
+ case '!':
+ return XML.BANG;
+ case '?':
+ return XML.QUEST;
+ case '"':
+ case '\'':
+ q = c;
+ for (;;) {
+ c = next();
+ if (c == 0) {
+ throw syntaxError("Unterminated string");
+ }
+ if (c == q) {
+ return Boolean.TRUE;
+ }
+ }
+ default:
+ for (;;) {
+ c = next();
+ if (Character.isWhitespace(c)) {
+ return Boolean.TRUE;
+ }
+ switch (c) {
+ case 0:
+ case '<':
+ case '>':
+ case '/':
+ case '=':
+ case '!':
+ case '?':
+ case '"':
+ case '\'':
+ back();
+ return Boolean.TRUE;
+ }
+ }
+ }
+ }
+
+
+ /**
+ * Get the next XML Token. These tokens are found inside of angle
+ * brackets. It may be one of these characters: / > = ! ? or it
+ * may be a string wrapped in single quotes or double quotes, or it may be a
+ * name.
+ * @return a String or a Character.
+ * @throws JSONException If the XML is not well formed.
+ */
+ public Object nextToken() throws JSONException {
+ char c;
+ char q;
+ StringBuffer sb;
+ do {
+ c = next();
+ } while (Character.isWhitespace(c));
+ switch (c) {
+ case 0:
+ throw syntaxError("Misshaped element");
+ case '<':
+ throw syntaxError("Misplaced '<'");
+ case '>':
+ return XML.GT;
+ case '/':
+ return XML.SLASH;
+ case '=':
+ return XML.EQ;
+ case '!':
+ return XML.BANG;
+ case '?':
+ return XML.QUEST;
+
+// Quoted string
+
+ case '"':
+ case '\'':
+ q = c;
+ sb = new StringBuffer();
+ for (;;) {
+ c = next();
+ if (c == 0) {
+ throw syntaxError("Unterminated string");
+ }
+ if (c == q) {
+ return sb.toString();
+ }
+ if (c == '&') {
+ sb.append(nextEntity(c));
+ } else {
+ sb.append(c);
+ }
+ }
+ default:
+
+// Name
+
+ sb = new StringBuffer();
+ for (;;) {
+ sb.append(c);
+ c = next();
+ if (Character.isWhitespace(c)) {
+ return sb.toString();
+ }
+ switch (c) {
+ case 0:
+ return sb.toString();
+ case '>':
+ case '/':
+ case '=':
+ case '!':
+ case '?':
+ case '[':
+ case ']':
+ back();
+ return sb.toString();
+ case '<':
+ case '"':
+ case '\'':
+ throw syntaxError("Bad character in a name");
+ }
+ }
+ }
+ }
+
+
+ /**
+ * Skip characters until past the requested string.
+ * If it is not found, we are left at the end of the source with a result of false.
+ * @param to A string to skip past.
+ * @throws JSONException
+ */
+ public boolean skipPast(String to) throws JSONException {
+ boolean b;
+ char c;
+ int i;
+ int j;
+ int offset = 0;
+ int length = to.length();
+ char[] circle = new char[length];
+
+ /*
+ * First fill the circle buffer with as many characters as are in the
+ * to string. If we reach an early end, bail.
+ */
+
+ for (i = 0; i < length; i += 1) {
+ c = next();
+ if (c == 0) {
+ return false;
+ }
+ circle[i] = c;
+ }
+
+ /* We will loop, possibly for all of the remaining characters. */
+
+ for (;;) {
+ j = offset;
+ b = true;
+
+ /* Compare the circle buffer with the to string. */
+
+ for (i = 0; i < length; i += 1) {
+ if (circle[j] != to.charAt(i)) {
+ b = false;
+ break;
+ }
+ j += 1;
+ if (j >= length) {
+ j -= length;
+ }
+ }
+
+ /* If we exit the loop with b intact, then victory is ours. */
+
+ if (b) {
+ return true;
+ }
+
+ /* Get the next character. If there isn't one, then defeat is ours. */
+
+ c = next();
+ if (c == 0) {
+ return false;
+ }
+ /*
+ * Shove the character in the circle buffer and advance the
+ * circle offset. The offset is mod n.
+ */
+ circle[offset] = c;
+ offset += 1;
+ if (offset >= length) {
+ offset -= length;
+ }
+ }
+ }
+}
diff --git a/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/zip/BitInputStream.java b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/zip/BitInputStream.java
new file mode 100644
index 000000000..3afe40c16
--- /dev/null
+++ b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/zip/BitInputStream.java
@@ -0,0 +1,169 @@
+package org.springframework.ide.eclipse.org.json.zip;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+/*
+ Copyright (c) 2013 JSON.org
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ The Software shall be used for Good, not Evil.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+ */
+
+/**
+ * This is a big endian bit reader. It reads its bits from an InputStream.
+ *
+ * @version 2013-04-18
+ *
+ */
+public class BitInputStream implements org.springframework.ide.eclipse.org.json.zip.BitReader {
+ /**
+ * 2^n - 1
+ */
+ static final int[] mask = { 0, 1, 3, 7, 15, 31, 63, 127, 255 };
+
+ /**
+ * The number of bits remaining in the current byte.
+ */
+ private int available = 0;
+
+ /**
+ * Up to a byte's worth of unread bits.
+ */
+ private int unread = 0;
+
+ /**
+ * The source of the bits.
+ */
+ private InputStream in;
+
+ /**
+ * The number of bits read so far. This is used in padding.
+ */
+ private long nrBits = 0;
+
+ /**
+ * Make a BitReader from an InputStream. The BitReader will take bytes from
+ * the InputStream and unpack them into bits.
+ *
+ * @param in
+ * An InputStream.
+ */
+ public BitInputStream(InputStream in) {
+ this.in = in;
+ }
+
+ /**
+ * Make a BitReader. The first byte is passed in explicitly, the remaining
+ * bytes are obtained from the InputStream. This makes it possible to look
+ * at the first byte of a stream before deciding that it should be read as
+ * bits.
+ *
+ * @param in
+ * An InputStream
+ * @param firstByte
+ * The first byte, which was probably read from in.
+ */
+ public BitInputStream(InputStream in, int firstByte) {
+ this.in = in;
+ this.unread = firstByte;
+ this.available = 8;
+ }
+
+ /**
+ * Read one bit.
+ *
+ * @return true if it is a 1 bit.
+ */
+ public boolean bit() throws IOException {
+ return read(1) != 0;
+ }
+
+ /**
+ * Get the number of bits that have been read from this BitInputStream.
+ * This includes pad bits that have been skipped, but might not include
+ * bytes that have been read from the underlying InputStream that have not
+ * yet been delivered as bits.
+ *
+ * @return The number of bits read so far.
+ */
+ public long nrBits() {
+ return this.nrBits;
+ }
+
+ /**
+ * Check that the rest of the block has been padded with zeroes.
+ *
+ * @param factor
+ * The size of the block to pad. This will typically be 8, 16,
+ * 32, 64, 128, 256, etc.
+ * @return true if the block was zero padded, or false if the the padding
+ * contains any one bits.
+ * @throws IOException
+ */
+ public boolean pad(int factor) throws IOException {
+ int padding = factor - (int) (this.nrBits % factor);
+ boolean result = true;
+
+ for (int i = 0; i < padding; i += 1) {
+ if (bit()) {
+ result = false;
+ }
+ }
+ return result;
+ }
+
+ /**
+ * Read some bits.
+ *
+ * @param width
+ * The number of bits to read. (0..32)
+ * @throws IOException
+ * @return the bits
+ */
+ public int read(int width) throws IOException {
+ if (width == 0) {
+ return 0;
+ }
+ if (width < 0 || width > 32) {
+ throw new IOException("Bad read width.");
+ }
+ int result = 0;
+ while (width > 0) {
+ if (this.available == 0) {
+ this.unread = this.in.read();
+ if (this.unread < 0) {
+ throw new IOException("Attempt to read past end.");
+ }
+ this.available = 8;
+ }
+ int take = width;
+ if (take > this.available) {
+ take = this.available;
+ }
+ result |= ((this.unread >>> (this.available - take)) & mask[take])
+ << (width - take);
+ this.nrBits += take;
+ this.available -= take;
+ width -= take;
+ }
+ return result;
+ }
+}
diff --git a/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/zip/BitOutputStream.java b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/zip/BitOutputStream.java
new file mode 100644
index 000000000..f8cfd5d1f
--- /dev/null
+++ b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/zip/BitOutputStream.java
@@ -0,0 +1,154 @@
+package org.springframework.ide.eclipse.org.json.zip;
+
+import java.io.IOException;
+import java.io.OutputStream;
+
+/*
+ Copyright (c) 2013 JSON.org
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ The Software shall be used for Good, not Evil.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+ */
+
+/**
+ * This is a big endian bit writer. It writes its bits to an OutputStream.
+ *
+ * @version 2013-04-18
+ *
+ */
+public class BitOutputStream implements BitWriter {
+
+ /**
+ * The number of bits written.
+ */
+ private long nrBits = 0;
+
+ /**
+ * The destination of the bits.
+ */
+ private OutputStream out;
+
+ /**
+ * Holder of bits not yet written.
+ */
+ private int unwritten;
+
+ /**
+ * The number of unused bits in this.unwritten.
+ */
+ private int vacant = 8;
+
+ /**
+ * Use an OutputStream to produce a BitWriter. The BitWriter will send its
+ * bits to the OutputStream as each byte is filled.
+ *
+ * @param out
+ * An Output Stream
+ */
+ public BitOutputStream(OutputStream out) {
+ this.out = out;
+ }
+
+ /**
+ * Returns the number of bits that have been written to this
+ * bitOutputStream. This may include bits that have not yet been written
+ * to the underlying outputStream.
+ */
+ public long nrBits() {
+ return this.nrBits;
+ }
+
+ /**
+ * Write a 1 bit.
+ *
+ * @throws IOException
+ */
+ public void one() throws IOException {
+ write(1, 1);
+ }
+
+ /**
+ * Pad the rest of the block with zeroes and flush. pad(8) flushes the last
+ * unfinished byte. The underlying OutputStream will be flushed.
+ *
+ * @param factor
+ * The size of the block to pad. This will typically be 8, 16,
+ * 32, 64, 128, 256, etc.
+ * @return this
+ * @throws IOException
+ */
+ public void pad(int factor) throws IOException {
+ int padding = factor - (int) (nrBits % factor);
+ int excess = padding & 7;
+ if (excess > 0) {
+ this.write(0, excess);
+ padding -= excess;
+ }
+ while (padding > 0) {
+ this.write(0, 8);
+ padding -= 8;
+ }
+ this.out.flush();
+ }
+
+ /**
+ * Write some bits. Up to 32 bits can be written at a time.
+ *
+ * @param bits
+ * The bits to be written.
+ * @param width
+ * The number of bits to write. (0..32)
+ * @throws IOException
+ */
+ public void write(int bits, int width) throws IOException {
+ if (bits == 0 && width == 0) {
+ return;
+ }
+ if (width <= 0 || width > 32) {
+ throw new IOException("Bad write width.");
+ }
+ while (width > 0) {
+ int actual = width;
+ if (actual > this.vacant) {
+ actual = this.vacant;
+ }
+ this.unwritten |= ((bits >>> (width - actual)) &
+ BitInputStream.mask[actual]) << (this.vacant - actual);
+ width -= actual;
+ nrBits += actual;
+ this.vacant -= actual;
+ if (this.vacant == 0) {
+ this.out.write(this.unwritten);
+ this.unwritten = 0;
+ this.vacant = 8;
+ }
+ }
+ }
+
+ /**
+ * Write a 0 bit.
+ *
+ * @throws IOException
+ */
+ public void zero() throws IOException {
+ write(0, 1);
+
+ }
+}
diff --git a/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/zip/BitReader.java b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/zip/BitReader.java
new file mode 100644
index 000000000..db4420801
--- /dev/null
+++ b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/zip/BitReader.java
@@ -0,0 +1,41 @@
+package org.springframework.ide.eclipse.org.json.zip;
+
+import java.io.IOException;
+
+public interface BitReader {
+ /**
+ * Read one bit.
+ *
+ * @return true if it is a 1 bit.
+ */
+ public boolean bit() throws IOException;
+
+ /**
+ * Returns the number of bits that have been read from this bitreader.
+ *
+ * @return The number of bits read so far.
+ */
+ public long nrBits();
+
+ /**
+ * Check that the rest of the block has been padded with zeroes.
+ *
+ * @param factor
+ * The size in bits of the block to pad. This will typically be
+ * 8, 16, 32, 64, 128, 256, etc.
+ * @return true if the block was zero padded, or false if the the padding
+ * contained any one bits.
+ * @throws IOException
+ */
+ public boolean pad(int factor) throws IOException;
+
+ /**
+ * Read some bits.
+ *
+ * @param width
+ * The number of bits to read. (0..32)
+ * @throws IOException
+ * @return the bits
+ */
+ public int read(int width) throws IOException;
+}
diff --git a/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/zip/BitWriter.java b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/zip/BitWriter.java
new file mode 100644
index 000000000..b728767dc
--- /dev/null
+++ b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/zip/BitWriter.java
@@ -0,0 +1,51 @@
+package org.springframework.ide.eclipse.org.json.zip;
+
+import java.io.IOException;
+
+/**
+ * A bitwriter is a an interface that allows for doing output at the bit level.
+ * Most IO interfaces only allow for writing at the byte level or higher.
+ */
+public interface BitWriter {
+ /**
+ * Returns the number of bits that have been written to this bitwriter.
+ */
+ public long nrBits();
+
+ /**
+ * Write a 1 bit.
+ *
+ * @throws IOException
+ */
+ public void one() throws IOException;
+
+ /**
+ * Pad the rest of the block with zeros and flush.
+ *
+ * @param factor
+ * The size in bits of the block to pad. This will typically be
+ * 8, 16, 32, 64, 128, 256, etc.
+ * @return true if the block was zero padded, or false if the the padding
+ * contains any one bits.
+ * @throws IOException
+ */
+ public void pad(int factor) throws IOException;
+
+ /**
+ * Write some bits. Up to 32 bits can be written at a time.
+ *
+ * @param bits
+ * The bits to be written.
+ * @param width
+ * The number of bits to write. (0..32)
+ * @throws IOException
+ */
+ public void write(int bits, int width) throws IOException;
+
+ /**
+ * Write a 0 bit.
+ *
+ * @throws IOException
+ */
+ public void zero() throws IOException;
+}
diff --git a/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/zip/Compressor.java b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/zip/Compressor.java
new file mode 100644
index 000000000..c22abaf39
--- /dev/null
+++ b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/zip/Compressor.java
@@ -0,0 +1,575 @@
+package org.springframework.ide.eclipse.org.json.zip;
+
+import java.io.IOException;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Map;
+
+import org.springframework.ide.eclipse.org.json.JSONArray;
+import org.springframework.ide.eclipse.org.json.JSONException;
+import org.springframework.ide.eclipse.org.json.JSONObject;
+import org.springframework.ide.eclipse.org.json.Kim;
+
+/*
+ Copyright (c) 2013 JSON.org
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ The Software shall be used for Good, not Evil.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+ */
+
+/**
+ * JSONzip is a compression scheme for JSON text.
+ *
+ * @author JSON.org
+ * @version 2013-04-18
+ */
+
+/**
+ * A compressor implements the compression behavior of JSONzip. It provides a
+ * zip method that takes a JSONObject or JSONArray and delivers a stream of
+ * bits to a BitWriter.
+ *
+ * FOR EVALUATION PURPOSES ONLY. THIS PACKAGE HAS NOT BEEN TESTED ADEQUATELY
+ * FOR PRODUCTION USE.
+ */
+public class Compressor extends JSONzip {
+
+ /**
+ * A compressor outputs to a BitWriter.
+ */
+ final BitWriter bitwriter;
+
+ /**
+ * Create a new compressor. It may be used for an entire session or
+ * subsession.
+ *
+ * @param bitwriter
+ * The BitWriter this Compressor will output to. Don't forget to
+ * flush.
+ */
+ public Compressor(BitWriter bitwriter) {
+ super();
+ this.bitwriter = bitwriter;
+ }
+
+ /**
+ * Return a 4 bit code for a character in a JSON number. The digits '0' to
+ * '9' get the codes 0 to 9. '.' is 10, '-' is 11, '+' is 12, and 'E' or
+ * 'e' is 13.
+ *
+ * @param digit
+ * An ASCII character from a JSIN number.
+ * @return
+ */
+ private static int bcd(char digit) {
+ if (digit >= '0' && digit <= '9') {
+ return digit - '0';
+ }
+ switch (digit) {
+ case '.':
+ return 10;
+ case '-':
+ return 11;
+ case '+':
+ return 12;
+ default:
+ return 13;
+ }
+ }
+
+ /**
+ * Finish the final byte and flush the bitwriter. This does the same thing
+ * as pad(8).
+ *
+ * @throws JSONException
+ */
+ public void flush() throws JSONException {
+ pad(8);
+ }
+
+ /**
+ * Output a one bit.
+ *
+ * @throws IOException
+ */
+ private void one() throws JSONException {
+ if (probe) {
+ log(1);
+ }
+ write(1, 1);
+ }
+
+ /**
+ * Pad the output to fill an allotment of bits.
+ *
+ * @param factor
+ * The size of the bit allotment. A value of 8 will complete and
+ * flush the current byte. If you don't pad, then some of the
+ * last bits might not be sent to the Output Stream.
+ * @throws JSONException
+ */
+ public void pad(int factor) throws JSONException {
+ try {
+ this.bitwriter.pad(factor);
+ } catch (Throwable e) {
+ throw new JSONException(e);
+ }
+ }
+
+ /**
+ * Write a number, using the number of bits necessary to hold the number.
+ *
+ * @param integer
+ * The value to be encoded.
+ * @param width
+ * The number of bits to encode the value, between 0 and 32.
+ * @throws JSONException
+ */
+ private void write(int integer, int width) throws JSONException {
+ try {
+ this.bitwriter.write(integer, width);
+ if (probe) {
+ log(integer, width);
+ }
+ } catch (Throwable e) {
+ throw new JSONException(e);
+ }
+ }
+
+ /**
+ * Write an integer with Huffman encoding. The bit pattern that is written
+ * will be determined by the Huffman encoder.
+ *
+ * @param integer
+ * The value to be written.
+ * @param huff
+ * The Huffman encoder.
+ * @throws JSONException
+ */
+ private void write(int integer, Huff huff) throws JSONException {
+ huff.write(integer, this.bitwriter);
+ }
+
+ /**
+ * Write each of the bytes in a kim with Huffman encoding.
+ *
+ * @param kim
+ * A kim containing the bytes to be written.
+ * @param huff
+ * The Huffman encoder.
+ * @throws JSONException
+ */
+ private void write(Kim kim, Huff huff) throws JSONException {
+ write(kim, 0, kim.length, huff);
+ }
+
+ /**
+ * Write a range of bytes from a Kim with Huffman encoding.
+ *
+ * @param kim
+ * A Kim containing the bytes to be written.
+ * @param from
+ * The index of the first byte to write.
+ * @param thru
+ * The index after the last byte to write.
+ * @param huff
+ * The Huffman encoder.
+ * @throws JSONException
+ */
+ private void write(Kim kim, int from, int thru, Huff huff)
+ throws JSONException {
+ for (int at = from; at < thru; at += 1) {
+ write(kim.get(at), huff);
+ }
+ }
+
+ /**
+ * Write an integer, using the number of bits necessary to hold the number
+ * as determined by its keep, and increment its usage count in the keep.
+ *
+ * @param integer
+ * The value to be encoded.
+ * @param keep
+ * The Keep that the integer is one of.
+ * @throws JSONException
+ */
+ private void writeAndTick(int integer, Keep keep) throws JSONException {
+ int width = keep.bitsize();
+ keep.tick(integer);
+ if (probe) {
+ log("\"" + keep.value(integer) + "\"");
+ }
+ write(integer, width);
+ }
+
+ /**
+ * Write a JSON Array.
+ *
+ * @param jsonarray
+ * @throws JSONException
+ */
+ private void writeArray(JSONArray jsonarray) throws JSONException {
+
+// JSONzip has three encodings for arrays:
+// The array is empty (zipEmptyArray).
+// First value in the array is a string (zipArrayString).
+// First value in the array is not a string (zipArrayValue).
+
+ boolean stringy = false;
+ int length = jsonarray.length();
+ if (length == 0) {
+ write(zipEmptyArray, 3);
+ } else {
+ Object value = jsonarray.get(0);
+ if (value == null) {
+ value = JSONObject.NULL;
+ }
+ if (value instanceof String) {
+ stringy = true;
+ write(zipArrayString, 3);
+ writeString((String) value);
+ } else {
+ write(zipArrayValue, 3);
+ writeValue(value);
+ }
+ for (int i = 1; i < length; i += 1) {
+ if (probe) {
+ log();
+ }
+ value = jsonarray.get(i);
+ if (value == null) {
+ value = JSONObject.NULL;
+ }
+ if (value instanceof String != stringy) {
+ zero();
+ }
+ one();
+ if (value instanceof String) {
+ writeString((String) value);
+ } else {
+ writeValue(value);
+ }
+ }
+ zero();
+ zero();
+
+ }
+ }
+
+ /**
+ * Write a JSON value.
+ *
+ * @param value
+ * One of these types: JSONObject, JSONArray (or Map or
+ * Collection or array), Number (or Integer or Long or Double),
+ * or String, or Boolean, or JSONObject.NULL, or null.
+ * @throws JSONException
+ */
+ private void writeJSON(Object value) throws JSONException {
+ if (JSONObject.NULL.equals(value)) {
+ write(zipNull, 3);
+ } else if (Boolean.FALSE.equals(value)) {
+ write(zipFalse, 3);
+ } else if (Boolean.TRUE.equals(value)) {
+ write(zipTrue, 3);
+ } else {
+ if (value instanceof Map) {
+ value = new JSONObject((Map) value);
+ } else if (value instanceof Collection) {
+ value = new JSONArray((Collection) value);
+ } else if (value.getClass().isArray()) {
+ value = new JSONArray(value);
+ }
+ if (value instanceof JSONObject) {
+ writeObject((JSONObject) value);
+ } else if (value instanceof JSONArray) {
+ writeArray((JSONArray) value);
+ } else {
+ throw new JSONException("Unrecognized object");
+ }
+ }
+ }
+
+ /**
+ * Write the name of an object property. Names have their own Keep and
+ * Huffman encoder because they are expected to be a more restricted set.
+ *
+ * @param name
+ * @throws JSONException
+ */
+ private void writeName(String name) throws JSONException {
+
+// If this name has already been registered, then emit its integer and
+// increment its usage count.
+
+ Kim kim = new Kim(name);
+ int integer = this.namekeep.find(kim);
+ if (integer != none) {
+ one();
+ writeAndTick(integer, this.namekeep);
+ } else {
+
+// Otherwise, emit the string with Huffman encoding, and register it.
+
+ zero();
+ write(kim, this.namehuff);
+ write(end, namehuff);
+ this.namekeep.register(kim);
+ }
+ }
+
+ /**
+ * Write a JSON object.
+ *
+ * @param jsonobject
+ * @return
+ * @throws JSONException
+ */
+ private void writeObject(JSONObject jsonobject) throws JSONException {
+
+// JSONzip has two encodings for objects: Empty Objects (zipEmptyObject) and
+// non-empty objects (zipObject).
+
+ boolean first = true;
+ Iterator keys = jsonobject.keys();
+ while (keys.hasNext()) {
+ if (probe) {
+ log("\n");
+ }
+ Object key = keys.next();
+ if (key instanceof String) {
+ if (first) {
+ first = false;
+ write(zipObject, 3);
+ } else {
+ one();
+ }
+ writeName((String) key);
+ Object value = jsonobject.get((String) key);
+ if (value instanceof String) {
+ zero();
+ writeString((String) value);
+ } else {
+ one();
+ writeValue(value);
+ }
+ }
+ }
+ if (first) {
+ write(zipEmptyObject, 3);
+ } else {
+ zero();
+ }
+ }
+
+ /**
+ * Write a string.
+ *
+ * @param string
+ * @throws JSONException
+ */
+ private void writeString(String string) throws JSONException {
+
+// Special case for empty strings.
+
+ if (string.length() == 0) {
+ zero();
+ zero();
+ write(end, this.substringhuff);
+ zero();
+ } else {
+ Kim kim = new Kim(string);
+
+// Look for the string in the strings keep. If it is found, emit its
+// integer and count that as a use.
+
+ int integer = this.stringkeep.find(kim);
+ if (integer != none) {
+ one();
+ writeAndTick(integer, this.stringkeep);
+ } else {
+
+// But if it is not found, emit the string's substrings. Register the string
+// so that the next lookup will succeed.
+
+ writeSubstring(kim);
+ this.stringkeep.register(kim);
+ }
+ }
+ }
+
+ /**
+ * Write a string, attempting to match registered substrings.
+ *
+ * @param kim
+ * @throws JSONException
+ */
+ private void writeSubstring(Kim kim) throws JSONException {
+ this.substringkeep.reserve();
+ zero();
+ int from = 0;
+ int thru = kim.length;
+ int until = thru - JSONzip.minSubstringLength;
+ int previousFrom = none;
+ int previousThru = 0;
+
+// Find a substring from the substring keep.
+
+ while (true) {
+ int at;
+ int integer = none;
+ for (at = from; at <= until; at += 1) {
+ integer = this.substringkeep.match(kim, at, thru);
+ if (integer != none) {
+ break;
+ }
+ }
+ if (integer == none) {
+ break;
+ }
+
+// If a substring is found, emit any characters that were before the matched
+// substring. Then emit the substring's integer and loop back to match the
+// remainder with another substring.
+
+ if (from != at) {
+ zero();
+ write(kim, from, at, this.substringhuff);
+ write(end, this.substringhuff);
+ if (previousFrom != none) {
+ this.substringkeep.registerOne(kim, previousFrom,
+ previousThru);
+ previousFrom = none;
+ }
+ }
+ one();
+ writeAndTick(integer, this.substringkeep);
+ from = at + this.substringkeep.length(integer);
+ if (previousFrom != none) {
+ this.substringkeep.registerOne(kim, previousFrom,
+ previousThru);
+ previousFrom = none;
+ }
+ previousFrom = at;
+ previousThru = from + 1;
+ }
+
+// If a substring is not found, then emit the remaining characters.
+
+ zero();
+ if (from < thru) {
+ write(kim, from, thru, this.substringhuff);
+ if (previousFrom != none) {
+ this.substringkeep.registerOne(kim, previousFrom, previousThru);
+ }
+ }
+ write(end, this.substringhuff);
+ zero();
+
+// Register the string's substrings in the trie in hopes of future substring
+// matching.
+
+ substringkeep.registerMany(kim);
+ }
+
+ /**
+ * Write a value.
+ *
+ * @param value
+ * One of these types: Boolean, Number, etc.
+ * @throws JSONException
+ */
+ private void writeValue(Object value) throws JSONException {
+ if (value instanceof Number) {
+ String string = JSONObject.numberToString((Number) value);
+ int integer = this.values.find(string);
+ if (integer != none) {
+ write(2, 2);
+ writeAndTick(integer, this.values);
+ return;
+ }
+ if (value instanceof Integer || value instanceof Long) {
+ long longer = ((Number) value).longValue();
+ if (longer >= 0 && longer < int14) {
+ write(0, 2);
+ if (longer < int4) {
+ zero();
+ write((int) longer, 4);
+ return;
+ }
+ one();
+ if (longer < int7) {
+ zero();
+ write((int) longer, 7);
+ return;
+ }
+ one();
+ write((int) longer, 14);
+ return;
+ }
+ }
+ write(1, 2);
+ for (int i = 0; i < string.length(); i += 1) {
+ write(bcd(string.charAt(i)), 4);
+ }
+ write(endOfNumber, 4);
+ this.values.register(string);
+ } else {
+ write(3, 2);
+ writeJSON(value);
+ }
+ }
+
+ /**
+ * Output a zero bit.
+ *
+ * @throws JSONException
+ *
+ * @throws IOException
+ */
+ private void zero() throws JSONException {
+ if (probe) {
+ log(0);
+ }
+ write(0, 1);
+ }
+
+ /**
+ * Compress a JSONObject.
+ *
+ * @param jsonobject
+ * @throws JSONException
+ */
+ public void zip(JSONObject jsonobject) throws JSONException {
+ begin();
+ writeJSON(jsonobject);
+ }
+
+ /**
+ * Compress a JSONArray.
+ *
+ * @param jsonarray
+ * @throws JSONException
+ */
+ public void zip(JSONArray jsonarray) throws JSONException {
+ begin();
+ writeJSON(jsonarray);
+ }
+}
diff --git a/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/zip/Decompressor.java b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/zip/Decompressor.java
new file mode 100644
index 000000000..65faebd48
--- /dev/null
+++ b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/zip/Decompressor.java
@@ -0,0 +1,325 @@
+package org.springframework.ide.eclipse.org.json.zip;
+
+import java.io.UnsupportedEncodingException;
+
+import org.springframework.ide.eclipse.org.json.JSONArray;
+import org.springframework.ide.eclipse.org.json.JSONException;
+import org.springframework.ide.eclipse.org.json.JSONObject;
+import org.springframework.ide.eclipse.org.json.Kim;
+
+/*
+ Copyright (c) 2012 JSON.org
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ The Software shall be used for Good, not Evil.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+ */
+
+/**
+ * JSONzip is a compression scheme for JSON text.
+ *
+ * @author JSON.org
+ * @version 2013-04-18
+ */
+
+public class Decompressor extends JSONzip {
+
+ /**
+ * A decompressor reads bits from a BitReader.
+ */
+ BitReader bitreader;
+
+ /**
+ * Create a new compressor. It may be used for an entire session or
+ * subsession.
+ *
+ * @param bitreader
+ * The bitreader that this decompressor will read from.
+ */
+ public Decompressor(BitReader bitreader) {
+ super();
+ this.bitreader = bitreader;
+ }
+
+ /**
+ * Read one bit.
+ *
+ * @return true if 1, false if 0.
+ * @throws JSONException
+ */
+ private boolean bit() throws JSONException {
+ boolean value;
+ try {
+ value = this.bitreader.bit();
+ if (probe) {
+ log(value ? 1 : 0);
+ }
+ return value;
+ } catch (Throwable e) {
+ throw new JSONException(e);
+ }
+
+ }
+
+ /**
+ * Read enough bits to obtain an integer from the keep, and increase that
+ * integer's weight.
+ *
+ * @param keep
+ * @param bitreader
+ * @return
+ * @throws JSONException
+ */
+ private Object getAndTick(Keep keep, BitReader bitreader)
+ throws JSONException {
+ try {
+ int width = keep.bitsize();
+ int integer = bitreader.read(width);
+ Object value = keep.value(integer);
+ if (JSONzip.probe) {
+ JSONzip.log("\"" + value + "\"");
+ JSONzip.log(integer, width);
+ }
+ if (integer >= keep.length) {
+ throw new JSONException("Deep error.");
+ }
+ keep.tick(integer);
+ return value;
+ } catch (Throwable e) {
+ throw new JSONException(e);
+ }
+ }
+
+ /**
+ * The pad method skips the bits that padded a stream to fit some
+ * allocation. pad(8) will skip over the remainder of a byte.
+ *
+ * @param factor
+ * @return true if all of the padding bits were zero.
+ * @throws JSONException
+ */
+ public boolean pad(int factor) throws JSONException {
+ try {
+ return this.bitreader.pad(factor);
+ } catch (Throwable e) {
+ throw new JSONException(e);
+ }
+ }
+
+ /**
+ * Read an integer, specifying its width in bits.
+ *
+ * @param width
+ * 0 to 32.
+ * @return An unsigned integer.
+ * @throws JSONException
+ */
+ private int read(int width) throws JSONException {
+ try {
+ int value = this.bitreader.read(width);
+ if (probe) {
+ log(value, width);
+ }
+ return value;
+ } catch (Throwable e) {
+ throw new JSONException(e);
+ }
+ }
+
+ /**
+ * Read a JSONArray.
+ *
+ * @param stringy
+ * true if the first element is a string.
+ * @return
+ * @throws JSONException
+ */
+ private JSONArray readArray(boolean stringy) throws JSONException {
+ JSONArray jsonarray = new JSONArray();
+ jsonarray.put(stringy ? readString() : readValue());
+ while (true) {
+ if (probe) {
+ log("\n");
+ }
+ if (!bit()) {
+ if (!bit()) {
+ return jsonarray;
+ }
+ jsonarray.put(stringy ? readValue() : readString());
+ } else {
+ jsonarray.put(stringy ? readString() : readValue());
+ }
+ }
+ }
+
+ /**
+ * Read a JSON value. The type of value is determined by the next 3 bits.
+ *
+ * @return
+ * @throws JSONException
+ */
+ private Object readJSON() throws JSONException {
+ switch (read(3)) {
+ case zipObject:
+ return readObject();
+ case zipArrayString:
+ return readArray(true);
+ case zipArrayValue:
+ return readArray(false);
+ case zipEmptyObject:
+ return new JSONObject();
+ case zipEmptyArray:
+ return new JSONArray();
+ case zipTrue:
+ return Boolean.TRUE;
+ case zipFalse:
+ return Boolean.FALSE;
+ default:
+ return JSONObject.NULL;
+ }
+ }
+
+ private String readName() throws JSONException {
+ byte[] bytes = new byte[65536];
+ int length = 0;
+ if (!bit()) {
+ while (true) {
+ int c = this.namehuff.read(this.bitreader);
+ if (c == end) {
+ break;
+ }
+ bytes[length] = (byte) c;
+ length += 1;
+ }
+ if (length == 0) {
+ return "";
+ }
+ Kim kim = new Kim(bytes, length);
+ this.namekeep.register(kim);
+ return kim.toString();
+ }
+ return getAndTick(this.namekeep, this.bitreader).toString();
+ }
+
+ private JSONObject readObject() throws JSONException {
+ JSONObject jsonobject = new JSONObject();
+ while (true) {
+ if (probe) {
+ log("\n");
+ }
+ String name = readName();
+ jsonobject.put(name, !bit() ? readString() : readValue());
+ if (!bit()) {
+ return jsonobject;
+ }
+ }
+ }
+
+ private String readString() throws JSONException {
+ Kim kim;
+ int from = 0;
+ int thru = 0;
+ int previousFrom = none;
+ int previousThru = 0;
+ if (bit()) {
+ return getAndTick(this.stringkeep, this.bitreader).toString();
+ }
+ byte[] bytes = new byte[65536];
+ boolean one = bit();
+ this.substringkeep.reserve();
+ while (true) {
+ if (one) {
+ from = thru;
+ kim = (Kim) getAndTick(this.substringkeep, this.bitreader);
+ thru = kim.copy(bytes, from);
+ if (previousFrom != none) {
+ this.substringkeep.registerOne(new Kim(bytes, previousFrom,
+ previousThru + 1));
+ }
+ previousFrom = from;
+ previousThru = thru;
+ one = bit();
+ } else {
+ from = none;
+ while (true) {
+ int c = this.substringhuff.read(this.bitreader);
+ if (c == end) {
+ break;
+ }
+ bytes[thru] = (byte) c;
+ thru += 1;
+ if (previousFrom != none) {
+ this.substringkeep.registerOne(new Kim(bytes,
+ previousFrom, previousThru + 1));
+ previousFrom = none;
+ }
+ }
+ if (!bit()) {
+ break;
+ }
+ one = true;
+ }
+ }
+ if (thru == 0) {
+ return "";
+ }
+ kim = new Kim(bytes, thru);
+ this.stringkeep.register(kim);
+ this.substringkeep.registerMany(kim);
+ return kim.toString();
+ }
+
+ private Object readValue() throws JSONException {
+ switch (read(2)) {
+ case 0:
+ return new Integer(read(!bit() ? 4 : !bit() ? 7 : 14));
+ case 1:
+ byte[] bytes = new byte[256];
+ int length = 0;
+ while (true) {
+ int c = read(4);
+ if (c == endOfNumber) {
+ break;
+ }
+ bytes[length] = bcd[c];
+ length += 1;
+ }
+ Object value;
+ try {
+ value = JSONObject.stringToValue(new String(bytes, 0, length,
+ "US-ASCII"));
+ } catch (UnsupportedEncodingException e) {
+ throw new JSONException(e);
+ }
+ this.values.register(value);
+ return value;
+ case 2:
+ return getAndTick(this.values, this.bitreader);
+ case 3:
+ return readJSON();
+ default:
+ throw new JSONException("Impossible.");
+ }
+ }
+
+ public Object unzip() throws JSONException {
+ begin();
+ return readJSON();
+ }
+}
diff --git a/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/zip/Huff.java b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/zip/Huff.java
new file mode 100644
index 000000000..2fc5c2e80
--- /dev/null
+++ b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/zip/Huff.java
@@ -0,0 +1,406 @@
+package org.springframework.ide.eclipse.org.json.zip;
+
+import org.springframework.ide.eclipse.org.json.JSONException;
+
+/*
+ Copyright (c) 2013 JSON.org
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ The Software shall be used for Good, not Evil.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+ */
+
+/**
+ * JSONzip is a compression scheme for JSON text.
+ * @author JSON.org
+ * @version 2013-04-18
+ */
+
+/**
+ * A Huffman encoder/decoder. It operates over a domain of integers, which may
+ * map to characters or other symbols. Symbols that are used frequently are
+ * given shorter codes than symbols that are used infrequently. This usually
+ * produces shorter messages.
+ *
+ * Initially, all of the symbols are given the same weight. The weight of a
+ * symbol is incremented by the tick method. The generate method is used to
+ * generate the encoding table. The table must be generated before encoding or
+ * decoding. You may regenerate the table with the latest weights at any time.
+ */
+public class Huff implements None, PostMortem {
+
+ /**
+ * The number of symbols known to the encoder.
+ */
+ private final int domain;
+
+ /**
+ * An array that maps symbol values to symbols.
+ */
+ private final Symbol[] symbols;
+
+ /**
+ * The root of the decoding table, and the terminal of the encoding table.
+ */
+ private Symbol table;
+
+ /**
+ * Have any weights changed since the table was last generated?
+ */
+ private boolean upToDate = false;
+
+ /**
+ * The number of bits in the last symbol. This is used in tracing.
+ */
+ private int width;
+
+ private static class Symbol implements PostMortem {
+ public Symbol back;
+ public Symbol next;
+ public Symbol zero;
+ public Symbol one;
+ public final int integer;
+ public long weight;
+
+ /**
+ * Make a symbol representing a character or other value.
+ *
+ * @param integer
+ * The symbol's number
+ */
+ public Symbol(int integer) {
+ this.integer = integer;
+ this.weight = 0;
+ this.next = null;
+ this.back = null;
+ this.one = null;
+ this.zero = null;
+ }
+
+ public boolean postMortem(PostMortem pm) {
+ boolean result = true;
+ Symbol that = (Symbol) pm;
+
+ if (this.integer != that.integer || this.weight != that.weight) {
+ return false;
+ }
+ if ((this.back != null) != (that.back != null)) {
+ return false;
+ }
+ Symbol zero = this.zero;
+ Symbol one = this.one;
+ if (zero == null) {
+ if (that.zero != null) {
+ return false;
+ }
+ } else {
+ result = zero.postMortem(that.zero);
+ }
+ if (one == null) {
+ if (that.one != null) {
+ return false;
+ }
+ } else {
+ result = one.postMortem(that.one);
+ }
+ return result;
+ }
+
+ }
+
+ /**
+ * Construct a Huffman encoder/decoder.
+ *
+ * @param domain
+ * The number of values known to the object.
+ */
+ public Huff(int domain) {
+ this.domain = domain;
+ int length = domain * 2 - 1;
+ this.symbols = new Symbol[length];
+
+// Make the leaf symbols.
+
+ for (int i = 0; i < domain; i += 1) {
+ symbols[i] = new Symbol(i);
+ }
+
+// SMake the links.
+
+ for (int i = domain; i < length; i += 1) {
+ symbols[i] = new Symbol(none);
+ }
+ }
+
+ /**
+ * Generate the encoding/decoding table. The table determines the bit
+ * sequences used by the read and write methods.
+ *
+ * @return this
+ */
+ public void generate() {
+ if (!this.upToDate) {
+
+// Phase One: Sort the symbols by weight into a linked list.
+
+ Symbol head = this.symbols[0];
+ Symbol next;
+ Symbol previous = head;
+ Symbol symbol;
+
+ this.table = null;
+ head.next = null;
+ for (int i = 1; i < this.domain; i += 1) {
+ symbol = symbols[i];
+
+// If this symbol weights less than the head, then it becomes the new head.
+
+ if (symbol.weight < head.weight) {
+ symbol.next = head;
+ head = symbol;
+ } else {
+
+// To save time, we will start the search from the previous symbol instead
+// of the head unless the current symbol weights less than the previous symbol.
+
+ if (symbol.weight < previous.weight) {
+ previous = head;
+ }
+
+// Find a connected pair (previous and next) where the symbol weighs the same
+// or more than previous but less than the next. Link the symbol between them.
+
+ while (true) {
+ next = previous.next;
+ if (next == null || symbol.weight < next.weight) {
+ break;
+ }
+ previous = next;
+ }
+ symbol.next = next;
+ previous.next = symbol;
+ previous = symbol;
+ }
+ }
+
+// Phase Two: Make new symbols from the two lightest symbols until only one
+// symbol remains. The final symbol becomes the root of the table binary tree.
+
+ int avail = this.domain;
+ Symbol first;
+ Symbol second;
+ previous = head;
+ while (true) {
+ first = head;
+ second = first.next;
+ head = second.next;
+ symbol = this.symbols[avail];
+ avail += 1;
+ symbol.weight = first.weight + second.weight;
+ symbol.zero = first;
+ symbol.one = second;
+ symbol.back = null;
+ first.back = symbol;
+ second.back = symbol;
+ if (head == null) {
+ break;
+ }
+
+// Insert the new symbol back into the sorted list.
+
+ if (symbol.weight < head.weight) {
+ symbol.next = head;
+ head = symbol;
+ previous = head;
+ } else {
+ while (true) {
+ next = previous.next;
+ if (next == null || symbol.weight < next.weight) {
+ break;
+ }
+ previous = next;
+ }
+ symbol.next = next;
+ previous.next = symbol;
+ previous = symbol;
+ }
+
+ }
+
+// The last remaining symbol is the root of the table.
+
+ this.table = symbol;
+ this.upToDate = true;
+ }
+ }
+
+ private boolean postMortem(int integer) {
+ int[] bits = new int[this.domain];
+ Symbol symbol = this.symbols[integer];
+ if (symbol.integer != integer) {
+ return false;
+ }
+ int i = 0;
+ while (true) {
+ Symbol back = symbol.back;
+ if (back == null) {
+ break;
+ }
+ if (back.zero == symbol) {
+ bits[i] = 0;
+ } else if (back.one == symbol) {
+ bits[i] = 1;
+ } else {
+ return false;
+ }
+ i += 1;
+ symbol = back;
+ }
+ if (symbol != this.table) {
+ return false;
+ }
+ this.width = 0;
+ symbol = this.table;
+ while (symbol.integer == none) {
+ i -= 1;
+ symbol = bits[i] != 0 ? symbol.one : symbol.zero;
+ }
+ return symbol.integer == integer && i == 0;
+ }
+
+ /**
+ * Compare two Huffman tables.
+ */
+ public boolean postMortem(PostMortem pm) {
+
+// Go through every integer in the domain, generating its bit sequence, and
+// then proving that that bit sequence produces the same integer.
+
+ for (int integer = 0; integer < this.domain; integer += 1) {
+ if (!postMortem(integer)) {
+ JSONzip.log("\nBad huff ");
+ JSONzip.logchar(integer, integer);
+ return false;
+ }
+ }
+ return this.table.postMortem(((Huff) pm).table);
+ }
+
+ /**
+ * Read bits until a symbol can be identified. The weight of the read
+ * symbol will be incremented.
+ *
+ * @param bitreader
+ * The source of bits.
+ * @return The integer value of the symbol.
+ * @throws JSONException
+ */
+ public int read(BitReader bitreader) throws JSONException {
+ try {
+ this.width = 0;
+ Symbol symbol = this.table;
+ while (symbol.integer == none) {
+ this.width += 1;
+ symbol = bitreader.bit() ? symbol.one : symbol.zero;
+ }
+ tick(symbol.integer);
+ if (JSONzip.probe) {
+ JSONzip.logchar(symbol.integer, this.width);
+ }
+ return symbol.integer;
+ } catch (Throwable e) {
+ throw new JSONException(e);
+ }
+ }
+
+ /**
+ * Increase by 1 the weight associated with a value.
+ *
+ * @param value
+ * The number of the symbol to tick
+ * @return this
+ */
+ public void tick(int value) {
+ this.symbols[value].weight += 1;
+ this.upToDate = false;
+ }
+
+ /**
+ * Increase by 1 the weight associated with a range of values.
+ *
+ * @param from
+ * The first symbol to tick
+ * @param to
+ * The last symbol to tick
+ * @return this
+ */
+ public void tick(int from, int to) {
+ for (int value = from; value <= to; value += 1) {
+ tick(value);
+ }
+ }
+
+ /**
+ * Recur from a symbol back, emitting bits. We recur before emitting to
+ * make the bits come out in the right order.
+ *
+ * @param symbol
+ * The symbol to write.
+ * @param bitwriter
+ * The bitwriter to write it to.
+ * @throws JSONException
+ */
+ private void write(Symbol symbol, BitWriter bitwriter)
+ throws JSONException {
+ try {
+ Symbol back = symbol.back;
+ if (back != null) {
+ this.width += 1;
+ write(back, bitwriter);
+ if (back.zero == symbol) {
+ bitwriter.zero();
+ } else {
+ bitwriter.one();
+ }
+ }
+ } catch (Throwable e) {
+ throw new JSONException(e);
+ }
+ }
+
+ /**
+ * Write the bits corresponding to a symbol. The weight of the symbol will
+ * be incremented.
+ *
+ * @param value
+ * The number of the symbol to write
+ * @param bitwriter
+ * The destination of the bits.
+ * @return this
+ * @throws JSONException
+ */
+ public void write(int value, BitWriter bitwriter) throws JSONException {
+ this.width = 0;
+ write(this.symbols[value], bitwriter);
+ tick(value);
+ if (JSONzip.probe) {
+ JSONzip.logchar(value, this.width);
+ }
+ }
+}
diff --git a/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/zip/JSONzip.java b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/zip/JSONzip.java
new file mode 100644
index 000000000..8565f52a8
--- /dev/null
+++ b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/zip/JSONzip.java
@@ -0,0 +1,281 @@
+package org.springframework.ide.eclipse.org.json.zip;
+
+
+/*
+ Copyright (c) 2013 JSON.org
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ The Software shall be used for Good, not Evil.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+ */
+
+/**
+ * JSONzip is a binary-encoded JSON dialect. It is designed to compress the
+ * messages in a session. It is adaptive, so with each message seen, it should
+ * improve its compression. It minimizes JSON's overhead, reducing punctuation
+ * to a small number of bits. It uses Huffman encoding to reduce the average
+ * size of characters. It uses caches (or Keeps) to keep recently seen strings
+ * and values, so repetitive content (such as object keys) can be
+ * substantially reduced. It uses a character encoding called Kim (Keep it
+ * minimal) that is smaller than UTF-8 for most East European, African, and
+ * Asian scripts.
+ *
+ * JSONzip tends to reduce most content by about half. If there is a lot of
+ * recurring information, the reduction can be much more dramatic.
+ *
+ * FOR EVALUATION PURPOSES ONLY. THIS PACKAGE HAS NOT YET BEEN TESTED
+ * ADEQUATELY FOR PRODUCTION USE.
+ *
+ * @author JSON.org
+ * @version 2013-04-18
+ */
+public abstract class JSONzip implements None, PostMortem {
+ /**
+ * Powers of 2.
+ */
+ public static final int[] twos = {
+ 1, 2, 4, 8, 16, 32, 64, 128, 256, 512,
+ 1024, 2048, 4096, 8192, 16384, 32768, 65536
+ };
+
+ /**
+ * The characters in JSON numbers can be reduced to 4 bits each.
+ */
+ public static final byte[] bcd = {
+ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.', '-', '+', 'E'
+ };
+
+ /**
+ * The number of integers that can be encoded in 4 bits.
+ */
+ public static final long int4 = 16;
+
+ /**
+ * The number of integers that can be encoded in 7 bits.
+ */
+ public static final long int7 = 128;
+
+ /**
+ * The number of integers that can be encoded in 14 bits.
+ */
+ public static final long int14 = 16384;
+
+ /**
+ * The end of string code.
+ */
+ public static final int end = 256;
+
+ /**
+ * The end of number code.
+ */
+ public static final int endOfNumber = bcd.length;
+
+ /**
+ * The maximum substring length when registering many. The registration of
+ * one substring may be longer.
+ */
+ public static final int maxSubstringLength = 10;
+
+ /**
+ * The minimum substring length.
+ */
+ public static final int minSubstringLength = 3;
+
+ /**
+ * The package supports tracing for debugging.
+ */
+ public static final boolean probe = false;
+
+ /**
+ * The maximum number of substrings added to the substrings keep per
+ * string.
+ */
+ public static final int substringLimit = 40;
+
+ /**
+ * The value code for an empty object.
+ */
+ public static final int zipEmptyObject = 0;
+
+ /**
+ * The value code for an empty array.
+ */
+ public static final int zipEmptyArray = 1;
+
+ /**
+ * The value code for true.
+ */
+ public static final int zipTrue = 2;
+
+ /**
+ * The value code for false.
+ */
+ public static final int zipFalse = 3;
+
+ /**
+ * The value code for null.
+ */
+ public static final int zipNull = 4;
+
+ /**
+ * The value code for a non-empty object.
+ */
+ public static final int zipObject = 5;
+
+ /**
+ * The value code for an array with a string as its first element.
+ */
+ public static final int zipArrayString = 6;
+
+ /**
+ * The value code for an array with a non-string value as its first element.
+ */
+ public static final int zipArrayValue = 7;
+
+ /**
+ * A Huffman encoder for names.
+ */
+ protected final Huff namehuff;
+
+ /**
+ * A place to keep the names (keys).
+ */
+ protected final MapKeep namekeep;
+
+ /**
+ * A place to keep the strings.
+ */
+ protected final MapKeep stringkeep;
+
+ /**
+ * A Huffman encoder for string values.
+ */
+ protected final Huff substringhuff;
+
+ /**
+ * A place to keep the strings.
+ */
+ protected final TrieKeep substringkeep;
+
+ /**
+ * A place to keep the values.
+ */
+ protected final MapKeep values;
+
+ /**
+ * Initialize the data structures.
+ */
+ protected JSONzip() {
+ this.namehuff = new Huff(end + 1);
+ this.namekeep = new MapKeep(9);
+ this.stringkeep = new MapKeep(11);
+ this.substringhuff = new Huff(end + 1);
+ this.substringkeep = new TrieKeep(12);
+ this.values = new MapKeep(10);
+
+// Increase the weights of the ASCII letters, digits, and special characters
+// because they are highly likely to occur more frequently. The weight of each
+// character will increase as it is used. The Huffman encoder will tend to
+// use fewer bits to encode heavier characters.
+
+ this.namehuff.tick(' ', '}');
+ this.namehuff.tick('a', 'z');
+ this.namehuff.tick(end);
+ this.namehuff.tick(end);
+ this.substringhuff.tick(' ', '}');
+ this.substringhuff.tick('a', 'z');
+ this.substringhuff.tick(end);
+ this.substringhuff.tick(end);
+ }
+
+ /**
+ *
+ */
+ protected void begin() {
+ this.namehuff.generate();
+ this.substringhuff.generate();
+ }
+
+ /**
+ * Write an end-of-line to the console.
+ */
+ static void log() {
+ log("\n");
+ }
+
+ /**
+ * Write an integer to the console.
+ *
+ * @param integer
+ */
+ static void log(int integer) {
+ log(integer + " ");
+ }
+
+ /**
+ * Write two integers, separated by ':' to the console.
+ *
+ * @param integer
+ * @param width
+ */
+ static void log(int integer, int width) {
+ log(integer + ":" + width + " ");
+ }
+
+ /**
+ * Write a string to the console.
+ *
+ * @param string
+ */
+ static void log(String string) {
+ System.out.print(string);
+ }
+
+ /**
+ * Write a character or its code to the console.
+ *
+ * @param integer
+ * @param width
+ */
+ static void logchar(int integer, int width) {
+ if (integer > ' ' && integer <= '}') {
+ log("'" + (char) integer + "':" + width + " ");
+ } else {
+ log(integer, width);
+ }
+ }
+
+ /**
+ * This method is used for testing the implementation of JSONzip. It is not
+ * suitable for any other purpose. It is used to compare a Compressor and a
+ * Decompressor, verifying that the data structures that were built during
+ * zipping and unzipping were the same.
+ *
+ * @return true if the structures match.
+ */
+ public boolean postMortem(PostMortem pm) {
+ JSONzip that = (JSONzip) pm;
+ return this.namehuff.postMortem(that.namehuff)
+ && this.namekeep.postMortem(that.namekeep)
+ && this.stringkeep.postMortem(that.stringkeep)
+ && this.substringhuff.postMortem(that.substringhuff)
+ && this.substringkeep.postMortem(that.substringkeep)
+ && this.values.postMortem(that.values);
+ }
+}
diff --git a/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/zip/Keep.java b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/zip/Keep.java
new file mode 100644
index 000000000..0959edeaf
--- /dev/null
+++ b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/zip/Keep.java
@@ -0,0 +1,84 @@
+package org.springframework.ide.eclipse.org.json.zip;
+
+
+/*
+ Copyright (c) 2013 JSON.org
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ The Software shall be used for Good, not Evil.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+ */
+
+/**
+ * A keep is a data structure that associates strings (or substrings) with
+ * numbers. This allows the sending of small integers instead of strings.
+ *
+ * @author JSON.org
+ * @version 2013-04-18
+ */
+abstract class Keep implements None, PostMortem {
+ protected int capacity;
+ protected int length;
+ protected int power;
+ protected long[] uses;
+
+ public Keep(int bits) {
+ this.capacity = JSONzip.twos[bits];
+ this.length = 0;
+ this.power = 0;
+ this.uses = new long[this.capacity];
+ }
+
+ /**
+ * When an item ages, its use count is reduced by at least half.
+ *
+ * @param use
+ * The current use count of an item.
+ * @return The new use count for that item.
+ */
+ public static long age(long use) {
+ return use >= 32 ? 16 : use / 2;
+ }
+
+ /**
+ * Return the number of bits required to contain an integer based on the
+ * current length of the keep. As the keep fills up, the number of bits
+ * required to identify one of its items goes up.
+ */
+ public int bitsize() {
+ while (JSONzip.twos[this.power] < this.length) {
+ this.power += 1;
+ }
+ return this.power;
+ }
+
+ /**
+ * Increase the usage count on an integer value.
+ */
+ public void tick(int integer) {
+ this.uses[integer] += 1;
+ }
+
+ /**
+ * Get the value associated with an integer.
+ * @param integer The number of an item in the keep.
+ * @return The value.
+ */
+ abstract public Object value(int integer);
+}
diff --git a/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/zip/MapKeep.java b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/zip/MapKeep.java
new file mode 100644
index 000000000..543b7f83a
--- /dev/null
+++ b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/zip/MapKeep.java
@@ -0,0 +1,160 @@
+package org.springframework.ide.eclipse.org.json.zip;
+
+import java.util.HashMap;
+
+import org.springframework.ide.eclipse.org.json.Kim;
+
+/*
+ Copyright (c) 2013 JSON.org
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ The Software shall be used for Good, not Evil.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+ */
+
+/**
+ * A keep is an associative data structure that maintains usage counts of each
+ * of the associations in its keeping. When the keep becomes full, it purges
+ * little used associations, and ages the survivors. Each key is assigned an
+ * integer value. When the keep is compacted, each key can be given a new
+ * value.
+ */
+class MapKeep extends Keep {
+ private Object[] list;
+ private HashMap map;
+
+ /**
+ * Create a new Keep.
+ * @param bits
+ * The capacity of the keep expressed in the number of bits
+ * required to hold an integer.
+ */
+ public MapKeep(int bits) {
+ super(bits);
+ this.list = new Object[this.capacity];
+ this.map = new HashMap(this.capacity);
+ }
+
+ /**
+ * Compact the keep. A keep may contain at most this.capacity elements.
+ * The keep contents can be reduced by deleting all elements with low use
+ * counts, and by reducing the use counts of the survivors.
+ */
+ private void compact() {
+ int from = 0;
+ int to = 0;
+ while (from < this.capacity) {
+ Object key = this.list[from];
+ long usage = age(this.uses[from]);
+ if (usage > 0) {
+ this.uses[to] = usage;
+ this.list[to] = key;
+ this.map.put(key, new Integer(to));
+ to += 1;
+ } else {
+ this.map.remove(key);
+ }
+ from += 1;
+ }
+ if (to < this.capacity) {
+ this.length = to;
+ } else {
+ this.map.clear();
+ this.length = 0;
+ }
+ this.power = 0;
+ }
+
+ /**
+ * Find the integer value associated with this key, or nothing if this key
+ * is not in the keep.
+ *
+ * @param key
+ * An object.
+ * @return An integer
+ */
+ public int find(Object key) {
+ Object o = this.map.get(key);
+ return o instanceof Integer ? ((Integer) o).intValue() : none;
+ }
+
+ public boolean postMortem(PostMortem pm) {
+ MapKeep that = (MapKeep) pm;
+ if (this.length != that.length) {
+ JSONzip.log(this.length + " <> " + that.length);
+ return false;
+ }
+ for (int i = 0; i < this.length; i += 1) {
+ boolean b;
+ if (this.list[i] instanceof Kim) {
+ b = ((Kim) this.list[i]).equals(that.list[i]);
+ } else {
+ Object o = this.list[i];
+ Object q = that.list[i];
+ if (o instanceof Number) {
+ o = o.toString();
+ }
+ if (q instanceof Number) {
+ q = q.toString();
+ }
+ b = o.equals(q);
+ }
+ if (!b) {
+ JSONzip.log("\n[" + i + "]\n " + this.list[i] + "\n "
+ + that.list[i] + "\n " + this.uses[i] + "\n "
+ + that.uses[i]);
+ return false;
+ }
+ }
+ return true;
+ }
+
+ /**
+ * Register a value in the keep. Compact the keep if it is full. The next
+ * time this value is encountered, its integer can be sent instead.
+ * @param value A value.
+ */
+ public void register(Object value) {
+ if (JSONzip.probe) {
+ int integer = find(value);
+ if (integer >= 0) {
+ JSONzip.log("\nDuplicate key " + value);
+ }
+ }
+ if (this.length >= this.capacity) {
+ compact();
+ }
+ this.list[this.length] = value;
+ this.map.put(value, new Integer(this.length));
+ this.uses[this.length] = 1;
+ if (JSONzip.probe) {
+ JSONzip.log("<" + this.length + " " + value + "> ");
+ }
+ this.length += 1;
+ }
+
+ /**
+ * Return the value associated with the integer.
+ * @param integer The number of an item in the keep.
+ * @return The value.
+ */
+ public Object value(int integer) {
+ return this.list[integer];
+ }
+}
diff --git a/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/zip/None.java b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/zip/None.java
new file mode 100644
index 000000000..f848afbf5
--- /dev/null
+++ b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/zip/None.java
@@ -0,0 +1,15 @@
+package org.springframework.ide.eclipse.org.json.zip;
+
+/**
+ * None is an interface that makes the constant none (short for
+ * negative one or long for -1) available to any class that implements it.
+ * The none value is used to stand for an integer that is not an integer,
+ * such as the negative result of a search.
+ */
+public interface None {
+ /**
+ * Negative One.
+ */
+ public static final int none = -1;
+
+}
diff --git a/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/zip/PostMortem.java b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/zip/PostMortem.java
new file mode 100644
index 000000000..aca5005af
--- /dev/null
+++ b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/zip/PostMortem.java
@@ -0,0 +1,47 @@
+package org.springframework.ide.eclipse.org.json.zip;
+
+/*
+ Copyright (c) 2013 JSON.org
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ The Software shall be used for Good, not Evil.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+ */
+
+/**
+ * The PostMortem interface allows for testing the internal state of JSONzip
+ * processors. Testing that JSONzip can compress an object and reproduce a
+ * corresponding object is not sufficient. Complete testing requires that the
+ * same internal data structures were constructed on both ends. If those
+ * structures are not equivalent, then it is likely that the implementations
+ * are not correct, even if convention tests are passed.
+ *
+ * PostMortem allows for testing of deep structures without breaking
+ * encapsulation.
+ */
+public interface PostMortem {
+ /**
+ * Determine if two objects are equivalent.
+ *
+ * @param pm
+ * Another object of the same type.
+ * @return true if they match.
+ */
+ public boolean postMortem(PostMortem pm);
+}
diff --git a/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/zip/README b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/zip/README
new file mode 100644
index 000000000..93e6470b7
--- /dev/null
+++ b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/zip/README
@@ -0,0 +1,2 @@
+FOR EVALUATION PURPOSES ONLY. THIS PACKAGE HAS NOT BEEN TESTED ADEQUATELY FOR
+PRODUCTION USE.
diff --git a/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/zip/TrieKeep.java b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/zip/TrieKeep.java
new file mode 100644
index 000000000..66697557e
--- /dev/null
+++ b/headless-services/commons/org.json/src/main/java/org/springframework/ide/eclipse/org/json/zip/TrieKeep.java
@@ -0,0 +1,396 @@
+package org.springframework.ide.eclipse.org.json.zip;
+
+import org.springframework.ide.eclipse.org.json.Kim;
+
+/*
+ Copyright (c) 2013 JSON.org
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ The Software shall be used for Good, not Evil.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+ */
+
+/**
+ * A TrieKeep is a Keep that implements a Trie.
+ */
+class TrieKeep extends Keep {
+
+ /**
+ * The trie is made of nodes.
+ */
+ class Node implements PostMortem {
+ private int integer;
+ private Node[] next;
+
+ /**
+ * Each non-leaf node contains links to up to 256 next nodes. Each node
+ * has an integer value.
+ */
+ public Node() {
+ this.integer = none;
+ this.next = null;
+ }
+
+ /**
+ * Get one of a node's 256 links. If it is a leaf node, it returns
+ * null.
+ *
+ * @param cell
+ * A integer between 0 and 255.
+ * @return
+ */
+ public Node get(int cell) {
+ return this.next == null ? null : this.next[cell];
+ }
+
+ /**
+ * Get one of a node's 256 links. If it is a leap node, it returns
+ * null. The argument is treated as an unsigned integer.
+ *
+ * @param cell
+ * A byte.
+ * @return
+ */
+ public Node get(byte cell) {
+ return get(((int) cell) & 0xFF);
+ }
+
+ /**
+ * Compare two nodes. Their lengths must be equal. Their links must
+ * also compare.
+ */
+ public boolean postMortem(PostMortem pm) {
+ Node that = (Node) pm;
+ if (that == null) {
+ JSONzip.log("\nMisalign");
+ return false;
+ }
+ if (this.integer != that.integer) {
+ JSONzip.log("\nInteger " + this.integer + " <> " +
+ that.integer);
+ return false;
+ }
+ if (this.next == null) {
+ if (that.next == null) {
+ return true;
+ }
+ JSONzip.log("\nNext is null " + this.integer);
+ return false;
+ }
+ for (int i = 0; i < 256; i += 1) {
+ Node node = this.next[i];
+ if (node != null) {
+ if (!node.postMortem(that.next[i])) {
+ return false;
+ }
+ } else if (that.next[i] != null) {
+ JSONzip.log("\nMisalign " + i);
+ return false;
+ }
+ }
+ return true;
+ }
+
+ /**
+ * Set a node's link to another node.
+ *
+ * @param cell
+ * An integer between 0 and 255.
+ * @param node
+ * The new value for the cell.
+ */
+ public void set(int cell, Node node) {
+ if (this.next == null) {
+ this.next = new Node[256];
+ }
+ if (JSONzip.probe) {
+ if (node == null || this.next[cell] != null) {
+ JSONzip.log("\nUnexpected set.\n");
+ }
+ }
+ this.next[cell] = node;
+ }
+
+ /**
+ * Set a node's link to another node.
+ *
+ * @param cell
+ * A byte.
+ * @param node
+ * The new value for the cell.
+ */
+ public void set(byte cell, Node node) {
+ set(((int) cell) & 0xFF, node);
+ }
+
+ /**
+ * Get one of a node's 256 links. It will not return null. If there is
+ * no link, then a link is manufactured.
+ *
+ * @param cell
+ * A integer between 0 and 255.
+ * @return
+ */
+ public Node vet(int cell) {
+ Node node = get(cell);
+ if (node == null) {
+ node = new Node();
+ set(cell, node);
+ }
+ return node;
+ }
+
+ /**
+ * Get one of a node's 256 links. It will not return null. If there is
+ * no link, then a link is manufactured.
+ *
+ * @param cell
+ * A byte.
+ * @return
+ */
+ public Node vet(byte cell) {
+ return vet(((int) cell) & 0xFF);
+ }
+ }
+
+ private int[] froms;
+ private int[] thrus;
+ private Node root;
+ private Kim[] kims;
+
+ /**
+ * Create a new Keep of kims.
+ *
+ * @param bits
+ * The log2 of the capacity of the Keep. For example, if bits is
+ * 12, then the keep's capacity will be 4096.
+ */
+ public TrieKeep(int bits) {
+ super(bits);
+ this.froms = new int[this.capacity];
+ this.thrus = new int[this.capacity];
+ this.kims = new Kim[this.capacity];
+ this.root = new Node();
+ }
+
+ /**
+ * Get the kim associated with an integer.
+ *
+ * @param integer
+ * @return
+ */
+ public Kim kim(int integer) {
+ Kim kim = this.kims[integer];
+ int from = this.froms[integer];
+ int thru = this.thrus[integer];
+ if (from != 0 || thru != kim.length) {
+ kim = new Kim(kim, from, thru);
+ this.froms[integer] = 0;
+ this.thrus[integer] = kim.length;
+ this.kims[integer] = kim;
+ }
+ return kim;
+ }
+
+ /**
+ * Get the length of the Kim associated with an integer. This is sometimes
+ * much faster than get(integer).length.
+ *
+ * @param integer
+ * @return
+ */
+ public int length(int integer) {
+ return this.thrus[integer] - this.froms[integer];
+ }
+
+ /**
+ * Find the integer value associated with this key, or nothing if this key
+ * is not in the keep.
+ *
+ * @param key
+ * An object.
+ * @return An integer
+ */
+ public int match(Kim kim, int from, int thru) {
+ Node node = this.root;
+ int best = none;
+ for (int at = from; at < thru; at += 1) {
+ node = node.get(kim.get(at));
+ if (node == null) {
+ break;
+ }
+ if (node.integer != none) {
+ best = node.integer;
+ }
+ from += 1;
+ }
+ return best;
+ }
+
+ public boolean postMortem(PostMortem pm) {
+ boolean result = true;
+ TrieKeep that = (TrieKeep) pm;
+ if (this.length != that.length) {
+ JSONzip.log("\nLength " + this.length + " <> " + that.length);
+ return false;
+ }
+ if (this.capacity != that.capacity) {
+ JSONzip.log("\nCapacity " + this.capacity + " <> " +
+ that.capacity);
+ return false;
+ }
+ for (int i = 0; i < this.length; i += 1) {
+ Kim thiskim = this.kim(i);
+ Kim thatkim = that.kim(i);
+ if (!thiskim.equals(thatkim)) {
+ JSONzip.log("\n[" + i + "] " + thiskim + " <> " + thatkim);
+ result = false;
+ }
+ }
+ return result && this.root.postMortem(that.root);
+ }
+
+ public void registerMany(Kim kim) {
+ int length = kim.length;
+ int limit = this.capacity - this.length;
+ if (limit > JSONzip.substringLimit) {
+ limit = JSONzip.substringLimit;
+ }
+ int until = length - (JSONzip.minSubstringLength - 1);
+ for (int from = 0; from < until; from += 1) {
+ int len = length - from;
+ if (len > JSONzip.maxSubstringLength) {
+ len = JSONzip.maxSubstringLength;
+ }
+ len += from;
+ Node node = this.root;
+ for (int at = from; at < len; at += 1) {
+ Node next = node.vet(kim.get(at));
+ if (next.integer == none
+ && at - from >= (JSONzip.minSubstringLength - 1)) {
+ next.integer = this.length;
+ this.uses[this.length] = 1;
+ this.kims[this.length] = kim;
+ this.froms[this.length] = from;
+ this.thrus[this.length] = at + 1;
+ if (JSONzip.probe) {
+ try {
+ JSONzip.log("<<" + this.length + " "
+ + new Kim(kim, from, at + 1) + ">> ");
+ } catch (Throwable ignore) {
+ }
+ }
+ this.length += 1;
+ limit -= 1;
+ if (limit <= 0) {
+ return;
+ }
+ }
+ node = next;
+ }
+ }
+ }
+
+ public void registerOne(Kim kim) {
+ int integer = registerOne(kim, 0, kim.length);
+ if (integer != none) {
+ this.kims[integer] = kim;
+ }
+ }
+
+ public int registerOne(Kim kim, int from, int thru) {
+ if (this.length < this.capacity) {
+ Node node = this.root;
+ for (int at = from; at < thru; at += 1) {
+ node = node.vet(kim.get(at));
+ }
+ if (node.integer == none) {
+ int integer = this.length;
+ node.integer = integer;
+ this.uses[integer] = 1;
+ this.kims[integer] = kim;
+ this.froms[integer] = from;
+ this.thrus[integer] = thru;
+ if (JSONzip.probe) {
+ try {
+ JSONzip.log("<<" + integer + " " + new Kim(kim, from, thru) + ">> ");
+ } catch (Throwable ignore) {
+ }
+ }
+ this.length += 1;
+ return integer;
+ }
+ }
+ return none;
+ }
+
+ /**
+ * Reserve space in the keep, compacting if necessary. A keep may contain
+ * at most -capacity- elements. The keep contents can be reduced by
+ * deleting all elements with low use counts, rebuilding the trie with the
+ * survivors.
+ */
+ public void reserve() {
+ if (this.capacity - this.length < JSONzip.substringLimit) {
+ int from = 0;
+ int to = 0;
+ this.root = new Node();
+ while (from < this.capacity) {
+ if (this.uses[from] > 1) {
+ Kim kim = this.kims[from];
+ int thru = this.thrus[from];
+ Node node = this.root;
+ for (int at = this.froms[from]; at < thru; at += 1) {
+ Node next = node.vet(kim.get(at));
+ node = next;
+ }
+ node.integer = to;
+ this.uses[to] = age(this.uses[from]);
+ this.froms[to] = this.froms[from];
+ this.thrus[to] = thru;
+ this.kims[to] = kim;
+ to += 1;
+ }
+ from += 1;
+ }
+
+// It is possible, but highly unlikely, that too many items survive.
+// If that happens, clear the keep.
+
+ if (this.capacity - to < JSONzip.substringLimit) {
+ this.power = 0;
+ this.root = new Node();
+ to = 0;
+ }
+ this.length = to;
+ while (to < this.capacity) {
+ this.uses[to] = 0;
+ this.kims[to] = null;
+ this.froms[to] = 0;
+ this.thrus[to] = 0;
+ to += 1;
+
+ }
+ }
+ }
+
+ public Object value(int integer) {
+ return kim(integer);
+ }
+}
diff --git a/headless-services/commons/pom.xml b/headless-services/commons/pom.xml
index 299a14ee4..816b278aa 100644
--- a/headless-services/commons/pom.xml
+++ b/headless-services/commons/pom.xml
@@ -30,6 +30,7 @@