From 6eb915c129fc90c6f4c82ae097dd6ffad5239efc Mon Sep 17 00:00:00 2001 From: chai Date: Mon, 25 Jan 2021 14:28:30 +0800 Subject: +scripts --- .../Assets/Scripts/XUtliPoolLib/MiniJSON/Json.cs | 638 +++++++++++++++++++++ .../Scripts/XUtliPoolLib/MiniJSON/Json.cs.meta | 12 + 2 files changed, 650 insertions(+) create mode 100644 Client/Assets/Scripts/XUtliPoolLib/MiniJSON/Json.cs create mode 100644 Client/Assets/Scripts/XUtliPoolLib/MiniJSON/Json.cs.meta (limited to 'Client/Assets/Scripts/XUtliPoolLib/MiniJSON') diff --git a/Client/Assets/Scripts/XUtliPoolLib/MiniJSON/Json.cs b/Client/Assets/Scripts/XUtliPoolLib/MiniJSON/Json.cs new file mode 100644 index 00000000..ac3e1d5e --- /dev/null +++ b/Client/Assets/Scripts/XUtliPoolLib/MiniJSON/Json.cs @@ -0,0 +1,638 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.IO; +using System.Text; + +namespace MiniJSON +{ + public static class Json + { + private sealed class Parser : IDisposable + { + private char PeekChar + { + get + { + return Convert.ToChar(this.json.Peek()); + } + } + + private char NextChar + { + get + { + return Convert.ToChar(this.json.Read()); + } + } + + private string NextWord + { + get + { + StringBuilder stringBuilder = new StringBuilder(); + while (!Json.Parser.IsWordBreak(this.PeekChar)) + { + stringBuilder.Append(this.NextChar); + bool flag = this.json.Peek() == -1; + if (flag) + { + break; + } + } + return stringBuilder.ToString(); + } + } + + private Json.Parser.TOKEN NextToken + { + get + { + this.EatWhitespace(); + bool flag = this.json.Peek() == -1; + Json.Parser.TOKEN result; + if (flag) + { + result = Json.Parser.TOKEN.NONE; + } + else + { + char peekChar = this.PeekChar; + if (peekChar <= '[') + { + switch (peekChar) + { + case '"': + return Json.Parser.TOKEN.STRING; + case '#': + case '$': + case '%': + case '&': + case '\'': + case '(': + case ')': + case '*': + case '+': + case '.': + case '/': + break; + case ',': + this.json.Read(); + return Json.Parser.TOKEN.COMMA; + case '-': + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + return Json.Parser.TOKEN.NUMBER; + case ':': + return Json.Parser.TOKEN.COLON; + default: + if (peekChar == '[') + { + return Json.Parser.TOKEN.SQUARED_OPEN; + } + break; + } + } + else + { + if (peekChar == ']') + { + this.json.Read(); + return Json.Parser.TOKEN.SQUARED_CLOSE; + } + if (peekChar == '{') + { + return Json.Parser.TOKEN.CURLY_OPEN; + } + if (peekChar == '}') + { + this.json.Read(); + return Json.Parser.TOKEN.CURLY_CLOSE; + } + } + string nextWord = this.NextWord; + if (!(nextWord == "false")) + { + if (!(nextWord == "true")) + { + if (!(nextWord == "null")) + { + result = Json.Parser.TOKEN.NONE; + } + else + { + result = Json.Parser.TOKEN.NULL; + } + } + else + { + result = Json.Parser.TOKEN.TRUE; + } + } + else + { + result = Json.Parser.TOKEN.FALSE; + } + } + return result; + } + } + + private const string WORD_BREAK = "{}[],:\""; + + private StringReader json; + + private enum TOKEN + { + NONE, + CURLY_OPEN, + CURLY_CLOSE, + SQUARED_OPEN, + SQUARED_CLOSE, + COLON, + COMMA, + STRING, + NUMBER, + TRUE, + FALSE, + NULL + } + + public static bool IsWordBreak(char c) + { + return char.IsWhiteSpace(c) || "{}[],:\"".IndexOf(c) != -1; + } + + private Parser(string jsonString) + { + this.json = new StringReader(jsonString); + } + + public static object Parse(string jsonString) + { + object result; + using (Json.Parser parser = new Json.Parser(jsonString)) + { + result = parser.ParseValue(); + } + return result; + } + + public void Dispose() + { + this.json.Dispose(); + this.json = null; + } + + private Dictionary ParseObject() + { + Dictionary dictionary = new Dictionary(); + this.json.Read(); + for (;;) + { + Json.Parser.TOKEN nextToken = this.NextToken; + if (nextToken == Json.Parser.TOKEN.NONE) + { + break; + } + if (nextToken == Json.Parser.TOKEN.CURLY_CLOSE) + { + goto IL_34; + } + if (nextToken != Json.Parser.TOKEN.COMMA) + { + string text = this.ParseString(); + bool flag = text == null; + if (flag) + { + goto Block_4; + } + bool flag2 = this.NextToken != Json.Parser.TOKEN.COLON; + if (flag2) + { + goto Block_5; + } + this.json.Read(); + dictionary[text] = this.ParseValue(); + } + } + return null; + IL_34: + return dictionary; + Block_4: + return null; + Block_5: + return null; + } + + private List ParseArray() + { + List list = new List(); + this.json.Read(); + bool flag = true; + while (flag) + { + Json.Parser.TOKEN nextToken = this.NextToken; + Json.Parser.TOKEN token = nextToken; + if (token == Json.Parser.TOKEN.NONE) + { + return null; + } + if (token != Json.Parser.TOKEN.SQUARED_CLOSE) + { + if (token != Json.Parser.TOKEN.COMMA) + { + object item = this.ParseByToken(nextToken); + list.Add(item); + } + } + else + { + flag = false; + } + } + return list; + } + + private object ParseValue() + { + Json.Parser.TOKEN nextToken = this.NextToken; + return this.ParseByToken(nextToken); + } + + private object ParseByToken(Json.Parser.TOKEN token) + { + switch (token) + { + case Json.Parser.TOKEN.CURLY_OPEN: + return this.ParseObject(); + case Json.Parser.TOKEN.SQUARED_OPEN: + return this.ParseArray(); + case Json.Parser.TOKEN.STRING: + return this.ParseString(); + case Json.Parser.TOKEN.NUMBER: + return this.ParseNumber(); + case Json.Parser.TOKEN.TRUE: + return true; + case Json.Parser.TOKEN.FALSE: + return false; + case Json.Parser.TOKEN.NULL: + return null; + } + return null; + } + + private string ParseString() + { + StringBuilder stringBuilder = new StringBuilder(); + this.json.Read(); + bool flag = true; + while (flag) + { + bool flag2 = this.json.Peek() == -1; + if (flag2) + { + break; + } + char nextChar = this.NextChar; + char c = nextChar; + if (c != '"') + { + if (c != '\\') + { + stringBuilder.Append(nextChar); + } + else + { + bool flag3 = this.json.Peek() == -1; + if (flag3) + { + flag = false; + } + else + { + nextChar = this.NextChar; + char c2 = nextChar; + if (c2 <= '\\') + { + if (c2 == '"' || c2 == '/' || c2 == '\\') + { + stringBuilder.Append(nextChar); + } + } + else if (c2 <= 'f') + { + if (c2 != 'b') + { + if (c2 == 'f') + { + stringBuilder.Append('\f'); + } + } + else + { + stringBuilder.Append('\b'); + } + } + else if (c2 != 'n') + { + switch (c2) + { + case 'r': + stringBuilder.Append('\r'); + break; + case 't': + stringBuilder.Append('\t'); + break; + case 'u': + { + char[] array = new char[4]; + for (int i = 0; i < 4; i++) + { + array[i] = this.NextChar; + } + stringBuilder.Append((char)Convert.ToInt32(new string(array), 16)); + break; + } + } + } + else + { + stringBuilder.Append('\n'); + } + } + } + } + else + { + flag = false; + } + } + return stringBuilder.ToString(); + } + + private object ParseNumber() + { + string nextWord = this.NextWord; + bool flag = nextWord.IndexOf('.') == -1; + object result; + if (flag) + { + long num; + long.TryParse(nextWord, out num); + result = num; + } + else + { + double num2; + double.TryParse(nextWord, out num2); + result = num2; + } + return result; + } + + private void EatWhitespace() + { + while (char.IsWhiteSpace(this.PeekChar)) + { + this.json.Read(); + bool flag = this.json.Peek() == -1; + if (flag) + { + break; + } + } + } + } + + private sealed class Serializer + { + private StringBuilder builder; + + private Serializer() + { + this.builder = new StringBuilder(); + } + + public static string Serialize(object obj) + { + Json.Serializer serializer = new Json.Serializer(); + serializer.SerializeValue(obj); + return serializer.builder.ToString(); + } + + private void SerializeValue(object value) + { + bool flag = value == null; + if (flag) + { + this.builder.Append("null"); + } + else + { + string str; + bool flag2 = (str = (value as string)) != null; + if (flag2) + { + this.SerializeString(str); + } + else + { + bool flag3 = value is bool; + if (flag3) + { + this.builder.Append(((bool)value) ? "true" : "false"); + } + else + { + IList anArray; + bool flag4 = (anArray = (value as IList)) != null; + if (flag4) + { + this.SerializeArray(anArray); + } + else + { + IDictionary obj; + bool flag5 = (obj = (value as IDictionary)) != null; + if (flag5) + { + this.SerializeObject(obj); + } + else + { + bool flag6 = value is char; + if (flag6) + { + this.SerializeString(new string((char)value, 1)); + } + else + { + this.SerializeOther(value); + } + } + } + } + } + } + } + + private void SerializeObject(IDictionary obj) + { + bool flag = true; + this.builder.Append('{'); + foreach (object obj2 in obj.Keys) + { + bool flag2 = !flag; + if (flag2) + { + this.builder.Append(','); + } + this.SerializeString(obj2.ToString()); + this.builder.Append(':'); + this.SerializeValue(obj[obj2]); + flag = false; + } + this.builder.Append('}'); + } + + private void SerializeArray(IList anArray) + { + this.builder.Append('['); + bool flag = true; + foreach (object value in anArray) + { + bool flag2 = !flag; + if (flag2) + { + this.builder.Append(','); + } + this.SerializeValue(value); + flag = false; + } + this.builder.Append(']'); + } + + private void SerializeString(string str) + { + this.builder.Append('"'); + char[] array = str.ToCharArray(); + char[] array2 = array; + int i = 0; + while (i < array2.Length) + { + char c = array2[i]; + char c2 = c; + switch (c2) + { + case '\b': + this.builder.Append("\\b"); + break; + case '\t': + this.builder.Append("\\t"); + break; + case '\n': + this.builder.Append("\\n"); + break; + case '\v': + goto IL_F2; + case '\f': + this.builder.Append("\\f"); + break; + case '\r': + this.builder.Append("\\r"); + break; + default: + if (c2 != '"') + { + if (c2 != '\\') + { + goto IL_F2; + } + this.builder.Append("\\\\"); + } + else + { + this.builder.Append("\\\""); + } + break; + } + IL_150: + i++; + continue; + IL_F2: + int num = Convert.ToInt32(c); + bool flag = num >= 32 && num <= 126; + if (flag) + { + this.builder.Append(c); + } + else + { + this.builder.Append("\\u"); + this.builder.Append(num.ToString("x4")); + } + goto IL_150; + } + this.builder.Append('"'); + } + + private void SerializeOther(object value) + { + bool flag = value is float; + if (flag) + { + this.builder.Append(((float)value).ToString("R")); + } + else + { + bool flag2 = value is int || value is uint || value is long || value is sbyte || value is byte || value is short || value is ushort || value is ulong; + if (flag2) + { + this.builder.Append(value); + } + else + { + bool flag3 = value is double || value is decimal; + if (flag3) + { + this.builder.Append(Convert.ToDouble(value).ToString("R")); + } + else + { + this.SerializeString(value.ToString()); + } + } + } + } + } + + public static object Deserialize(string json) + { + bool flag = json == null; + object result; + if (flag) + { + result = null; + } + else + { + result = Json.Parser.Parse(json); + } + return result; + } + + public static string Serialize(object obj) + { + return Json.Serializer.Serialize(obj); + } + } +} diff --git a/Client/Assets/Scripts/XUtliPoolLib/MiniJSON/Json.cs.meta b/Client/Assets/Scripts/XUtliPoolLib/MiniJSON/Json.cs.meta new file mode 100644 index 00000000..9e25738a --- /dev/null +++ b/Client/Assets/Scripts/XUtliPoolLib/MiniJSON/Json.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: f722e7fd0fb17de438933a6379c0e8cc +timeCreated: 1611465809 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: -- cgit v1.1-26-g67d0