com.dahuatech.hutool.json.JSONTokener Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of java-sdk-common Show documentation
Show all versions of java-sdk-common Show documentation
Dahua ICC Open API SDK for Java
package com.dahuatech.hutool.json;
import java.io.*;
/**
* JSON解析器，用于将JSON字符串解析为JSONObject或者JSONArray
*
* @author from JSON.org
*/
public class JSONTokener {
private long character;
/** 是否结尾 End of stream */
private boolean eof;
/** 在Reader的位置（解析到第几个字符） */
private long index;
/** 当前所在行 */
private long line;
/** 前一个字符 */
private char previous;
/** 是否使用前一个字符 */
private boolean usePrevious;
/** 源 */
private Reader reader;
// ------------------------------------------------------------------------------------
// Constructor start
/**
* 从Reader中构建
*
* @param reader 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;
}
/**
* 从InputStream中构建
*
* @param inputStream InputStream
*/
public JSONTokener(InputStream inputStream) throws JSONException {
this(new InputStreamReader(inputStream));
}
/**
* 从字符串中构建
*
* @param s JSON字符串
*/
public JSONTokener(String s) {
this(new StringReader(s));
}
// ------------------------------------------------------------------------------------
// Constructor end
/** 将标记回退到第一个字符，重新开始解析新的JSON */
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;
}
/** @return 是否进入结尾 */
public boolean end() {
return this.eof && false == this.usePrevious;
}
/**
* 源字符串是否有更多的字符
*
* @return 如果未达到结尾返回true，否则false
*/
public boolean more() throws JSONException {
this.next();
if (this.end()) {
return false;
}
this.back();
return true;
}
/**
* 获得源字符串中的下一个字符
*
* @return 下一个字符, or 0 if past the end of the source string.
* @throws JSONException JSON异常，包装IO异常
*/
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;
}
/**
* 读取下一个字符，并比对是否和指定字符匹配
*
* @param c 被匹配的字符
* @return The character 匹配到的字符
* @throws JSONException 如果不匹配抛出此异常
*/
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;
}
/**
* 获得接下来的n个字符
*
* @param n 字符数
* @return 获得的n个字符组成的字符串
* @throws JSONException 如果源中余下的字符数不足以提供所需的字符数，抛出此异常
*/
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);
}
/**
* 获得下一个字符，跳过空白符
*
* @throws JSONException 获得下一个字符时抛出的异常
* @return 获得的字符，0表示没有更多的字符
*/
public char nextClean() throws JSONException {
char c;
while (true) {
c = this.next();
if (c == 0 || c > ' ') {
return c;
}
}
}
/**
* 返回当前位置到指定引号前的所有字符，反斜杠的转义符也会被处理。
* 标准的JSON是不允许使用单引号包含字符串的，但是此实现允许。
*
* @param quote 字符引号, 包括 "（双引号） 或 '（单引号）。
* @return 截止到引号前的字符串
* @throws JSONException 出现无结束的字符串时抛出此异常
*/
public String nextString(char quote) throws JSONException {
char c;
StringBuilder sb = new StringBuilder();
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': // Unicode符
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 分隔符
* @return 字符串
*/
public String nextTo(char delimiter) throws JSONException {
StringBuilder sb = new StringBuilder();
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;
StringBuilder sb = new StringBuilder();
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);
}
}
/**
* 获得下一个值，值类型可以是Boolean, Double, Integer, JSONArray, JSONObject, Long, or String, or the
* JSONObject.NULL
*
* @throws JSONException 语法错误
* @return Boolean, Double, Integer, JSONArray, JSONObject, Long, or String, or the
* JSONObject.NULL
*/
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.
*/
StringBuilder sb = new StringBuilder();
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 InternalJSONUtil.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 需要定位的字符
* @return 定位的字符，如果字符未找到返回0
*/
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 exception) {
throw new JSONException(exception);
}
this.back();
return c;
}
/**
* Make a JSONException to signal a syntax error.
* 构建 JSONException 用于表示语法错误
*
* @param message 错误消息
* @return A JSONException object, suitable for throwing
*/
public JSONException syntaxError(String message) {
return new JSONException(message + this.toString());
}
/**
* 转为 {@link JSONArray}
*
* @return {@link JSONArray}
*/
public JSONArray toJSONArray() {
JSONArray jsonArray = new JSONArray();
if (this.nextClean() != '[') {
throw this.syntaxError("A JSONArray text must start with '['");
}
if (this.nextClean() != ']') {
this.back();
while (true) {
if (this.nextClean() == ',') {
this.back();
jsonArray.add(JSONNull.NULL);
} else {
this.back();
jsonArray.add(this.nextValue());
}
switch (this.nextClean()) {
case ',':
if (this.nextClean() == ']') {
return jsonArray;
}
this.back();
break;
case ']':
return jsonArray;
default:
throw this.syntaxError("Expected a ',' or ']'");
}
}
}
return jsonArray;
}
/**
* Make a printable string of this JSONTokener.
*
* @return " at {index} [character {character} line {line}]"
*/
@Override
public String toString() {
return " at " + this.index + " [character " + this.character + " line " + this.line + "]";
}
}