You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
812 lines
20 KiB
C#
812 lines
20 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.Text;
|
|
|
|
namespace Prime31
|
|
{
|
|
// Token: 0x0200001A RID: 26
|
|
public class SimpleJson
|
|
{
|
|
// Token: 0x17000008 RID: 8
|
|
// (get) Token: 0x0600008D RID: 141 RVA: 0x00006384 File Offset: 0x00004584
|
|
// (set) Token: 0x0600008E RID: 142 RVA: 0x000063B0 File Offset: 0x000045B0
|
|
public static IJsonSerializerStrategy currentJsonSerializerStrategy
|
|
{
|
|
get
|
|
{
|
|
IJsonSerializerStrategy result;
|
|
if ((result = SimpleJson._currentJsonSerializerStrategy) == null)
|
|
{
|
|
result = (SimpleJson._currentJsonSerializerStrategy = SimpleJson.pocoJsonSerializerStrategy);
|
|
}
|
|
return result;
|
|
}
|
|
set
|
|
{
|
|
SimpleJson.currentJsonSerializerStrategy = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000009 RID: 9
|
|
// (get) Token: 0x0600008F RID: 143 RVA: 0x000063BC File Offset: 0x000045BC
|
|
public static PocoJsonSerializerStrategy pocoJsonSerializerStrategy
|
|
{
|
|
get
|
|
{
|
|
PocoJsonSerializerStrategy result;
|
|
if ((result = SimpleJson._pocoJsonSerializerStrategy) == null)
|
|
{
|
|
result = (SimpleJson._pocoJsonSerializerStrategy = new PocoJsonSerializerStrategy());
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000091 RID: 145 RVA: 0x000063F0 File Offset: 0x000045F0
|
|
public static string encode(object obj)
|
|
{
|
|
StringBuilder stringBuilder = new StringBuilder(2000);
|
|
bool flag = SimpleJson.serializeValue(SimpleJson.currentJsonSerializerStrategy, obj, stringBuilder);
|
|
return (!flag) ? null : stringBuilder.ToString();
|
|
}
|
|
|
|
// Token: 0x06000092 RID: 146 RVA: 0x00006430 File Offset: 0x00004630
|
|
public static bool tryDeserializeObject(string json, out object obj)
|
|
{
|
|
bool result = true;
|
|
if (json != null)
|
|
{
|
|
char[] json2 = json.ToCharArray();
|
|
int num = 0;
|
|
obj = SimpleJson.parseValue(json2, ref num, ref result);
|
|
}
|
|
else
|
|
{
|
|
obj = null;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// Token: 0x06000093 RID: 147 RVA: 0x00006470 File Offset: 0x00004670
|
|
public static object decode(string json)
|
|
{
|
|
object obj;
|
|
object result;
|
|
if (SimpleJson.tryDeserializeObject(json, out obj))
|
|
{
|
|
result = obj;
|
|
}
|
|
else
|
|
{
|
|
Utils.logObject("Something went wrong deserializing the json. We got a null return. Here is the json we tried to deserialize: " + json);
|
|
result = null;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// Token: 0x06000094 RID: 148 RVA: 0x000064B0 File Offset: 0x000046B0
|
|
private static object decode(string json, Type type)
|
|
{
|
|
return SimpleJson.decode(json, type, null);
|
|
}
|
|
|
|
// Token: 0x06000095 RID: 149 RVA: 0x000064D0 File Offset: 0x000046D0
|
|
public static T decode<T>(string json)
|
|
{
|
|
return (T)((object)SimpleJson.decode(json, typeof(T)));
|
|
}
|
|
|
|
// Token: 0x06000096 RID: 150 RVA: 0x000064FC File Offset: 0x000046FC
|
|
public static T decode<T>(string json, string rootElement) where T : new()
|
|
{
|
|
return (T)((object)SimpleJson.decode(json, typeof(T), rootElement));
|
|
}
|
|
|
|
// Token: 0x06000097 RID: 151 RVA: 0x00006528 File Offset: 0x00004728
|
|
private static object decode(string json, Type type, string rootElement = null)
|
|
{
|
|
object obj = SimpleJson.decode(json);
|
|
object result;
|
|
if (type == null || (obj != null && obj.GetType().IsAssignableFrom(type)))
|
|
{
|
|
result = obj;
|
|
}
|
|
else
|
|
{
|
|
if (rootElement != null)
|
|
{
|
|
if (obj is JsonObject)
|
|
{
|
|
JsonObject jsonObject = obj as JsonObject;
|
|
if (jsonObject.ContainsKey(rootElement))
|
|
{
|
|
obj = jsonObject[rootElement];
|
|
}
|
|
else
|
|
{
|
|
Utils.logObject(string.Format("A rootElement was requested ({0}) but does not exist in the decoded Dictionary", rootElement));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Utils.logObject(string.Format("A rootElement was requested ({0}) but the decoded object is not a Dictionary. It is a {1}", rootElement, obj.GetType()));
|
|
}
|
|
}
|
|
result = SimpleJson.currentJsonSerializerStrategy.deserializeObject(obj, type);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// Token: 0x06000098 RID: 152 RVA: 0x000065D8 File Offset: 0x000047D8
|
|
public static T decodeObject<T>(object jsonObject, string rootElement = null)
|
|
{
|
|
Type typeFromHandle = typeof(T);
|
|
T result;
|
|
if (typeFromHandle == null || (jsonObject != null && jsonObject.GetType().IsAssignableFrom(typeFromHandle)))
|
|
{
|
|
result = (T)((object)jsonObject);
|
|
}
|
|
else
|
|
{
|
|
if (rootElement != null)
|
|
{
|
|
if (jsonObject is Dictionary<string, object>)
|
|
{
|
|
Dictionary<string, object> dictionary = jsonObject as Dictionary<string, object>;
|
|
if (dictionary.ContainsKey(rootElement))
|
|
{
|
|
jsonObject = dictionary[rootElement];
|
|
}
|
|
else
|
|
{
|
|
Utils.logObject(string.Format("A rootElement was requested ({0}) but does not exist in the decoded Dictionary", rootElement));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Utils.logObject(string.Format("A rootElement was requested ({0}) but the decoded object is not a Dictionary. It is a {1}", rootElement, jsonObject.GetType()));
|
|
}
|
|
}
|
|
result = (T)((object)SimpleJson.currentJsonSerializerStrategy.deserializeObject(jsonObject, typeFromHandle));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// Token: 0x06000099 RID: 153 RVA: 0x00006698 File Offset: 0x00004898
|
|
protected static IDictionary<string, object> parseObject(char[] json, ref int index, ref bool success)
|
|
{
|
|
IDictionary<string, object> dictionary = new JsonObject();
|
|
SimpleJson.nextToken(json, ref index);
|
|
bool flag = false;
|
|
while (!flag)
|
|
{
|
|
int num = SimpleJson.lookAhead(json, index);
|
|
if (num != 0)
|
|
{
|
|
if (num == 6)
|
|
{
|
|
SimpleJson.nextToken(json, ref index);
|
|
}
|
|
else
|
|
{
|
|
if (num == 2)
|
|
{
|
|
SimpleJson.nextToken(json, ref index);
|
|
return dictionary;
|
|
}
|
|
string key = SimpleJson.parseString(json, ref index, ref success);
|
|
if (!success)
|
|
{
|
|
success = false;
|
|
return null;
|
|
}
|
|
num = SimpleJson.nextToken(json, ref index);
|
|
if (num != 5)
|
|
{
|
|
success = false;
|
|
return null;
|
|
}
|
|
object value = SimpleJson.parseValue(json, ref index, ref success);
|
|
if (!success)
|
|
{
|
|
success = false;
|
|
return null;
|
|
}
|
|
dictionary[key] = value;
|
|
}
|
|
continue;
|
|
}
|
|
success = false;
|
|
return null;
|
|
}
|
|
return dictionary;
|
|
}
|
|
|
|
// Token: 0x0600009A RID: 154 RVA: 0x00006770 File Offset: 0x00004970
|
|
protected static JsonArray parseArray(char[] json, ref int index, ref bool success)
|
|
{
|
|
JsonArray jsonArray = new JsonArray();
|
|
SimpleJson.nextToken(json, ref index);
|
|
bool flag = false;
|
|
while (!flag)
|
|
{
|
|
int num = SimpleJson.lookAhead(json, index);
|
|
if (num != 0)
|
|
{
|
|
if (num == 6)
|
|
{
|
|
SimpleJson.nextToken(json, ref index);
|
|
}
|
|
else
|
|
{
|
|
if (num == 4)
|
|
{
|
|
SimpleJson.nextToken(json, ref index);
|
|
break;
|
|
}
|
|
object item = SimpleJson.parseValue(json, ref index, ref success);
|
|
if (!success)
|
|
{
|
|
return null;
|
|
}
|
|
jsonArray.Add(item);
|
|
}
|
|
continue;
|
|
}
|
|
success = false;
|
|
return null;
|
|
}
|
|
return jsonArray;
|
|
}
|
|
|
|
// Token: 0x0600009B RID: 155 RVA: 0x00006808 File Offset: 0x00004A08
|
|
protected static object parseValue(char[] json, ref int index, ref bool success)
|
|
{
|
|
switch (SimpleJson.lookAhead(json, index))
|
|
{
|
|
case 1:
|
|
return SimpleJson.parseObject(json, ref index, ref success);
|
|
case 3:
|
|
return SimpleJson.parseArray(json, ref index, ref success);
|
|
case 7:
|
|
return SimpleJson.parseString(json, ref index, ref success);
|
|
case 8:
|
|
return SimpleJson.parseNumber(json, ref index, ref success);
|
|
case 9:
|
|
SimpleJson.nextToken(json, ref index);
|
|
return true;
|
|
case 10:
|
|
SimpleJson.nextToken(json, ref index);
|
|
return false;
|
|
case 11:
|
|
SimpleJson.nextToken(json, ref index);
|
|
return null;
|
|
}
|
|
success = false;
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x0600009C RID: 156 RVA: 0x000068DC File Offset: 0x00004ADC
|
|
protected static string parseString(char[] json, ref int index, ref bool success)
|
|
{
|
|
StringBuilder stringBuilder = new StringBuilder(2000);
|
|
SimpleJson.eatWhitespace(json, ref index);
|
|
char c = json[index++];
|
|
bool flag = false;
|
|
while (!flag)
|
|
{
|
|
if (index == json.Length)
|
|
{
|
|
break;
|
|
}
|
|
c = json[index++];
|
|
if (c == '"')
|
|
{
|
|
flag = true;
|
|
break;
|
|
}
|
|
if (c == '\\')
|
|
{
|
|
if (index == json.Length)
|
|
{
|
|
break;
|
|
}
|
|
c = json[index++];
|
|
if (c == '"')
|
|
{
|
|
stringBuilder.Append('"');
|
|
}
|
|
else if (c == '\\')
|
|
{
|
|
stringBuilder.Append('\\');
|
|
}
|
|
else if (c == '/')
|
|
{
|
|
stringBuilder.Append('/');
|
|
}
|
|
else if (c == 'b')
|
|
{
|
|
stringBuilder.Append('\b');
|
|
}
|
|
else if (c == 'f')
|
|
{
|
|
stringBuilder.Append('\f');
|
|
}
|
|
else if (c == 'n')
|
|
{
|
|
stringBuilder.Append('\n');
|
|
}
|
|
else if (c == 'r')
|
|
{
|
|
stringBuilder.Append('\r');
|
|
}
|
|
else if (c == 't')
|
|
{
|
|
stringBuilder.Append('\t');
|
|
}
|
|
else if (c == 'u')
|
|
{
|
|
int num = json.Length - index;
|
|
if (num >= 4)
|
|
{
|
|
uint num2;
|
|
string result;
|
|
if (!(success = uint.TryParse(new string(json, index, 4), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out num2)))
|
|
{
|
|
result = "";
|
|
}
|
|
else
|
|
{
|
|
if (55296U > num2 || num2 > 56319U)
|
|
{
|
|
stringBuilder.Append(char.ConvertFromUtf32((int)num2));
|
|
index += 4;
|
|
continue;
|
|
}
|
|
index += 4;
|
|
num = json.Length - index;
|
|
if (num >= 6)
|
|
{
|
|
uint num3;
|
|
if (new string(json, index, 2) == "\\u" && uint.TryParse(new string(json, index + 2, 4), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out num3))
|
|
{
|
|
if (56320U <= num3 && num3 <= 57343U)
|
|
{
|
|
stringBuilder.Append((char)num2);
|
|
stringBuilder.Append((char)num3);
|
|
index += 6;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
success = false;
|
|
result = "";
|
|
}
|
|
return result;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
stringBuilder.Append(c);
|
|
}
|
|
}
|
|
if (!flag)
|
|
{
|
|
success = false;
|
|
return null;
|
|
}
|
|
return stringBuilder.ToString();
|
|
}
|
|
|
|
// Token: 0x0600009D RID: 157 RVA: 0x00006B64 File Offset: 0x00004D64
|
|
protected static object parseNumber(char[] json, ref int index, ref bool success)
|
|
{
|
|
SimpleJson.eatWhitespace(json, ref index);
|
|
int lastIndexOfNumber = SimpleJson.getLastIndexOfNumber(json, index);
|
|
int length = lastIndexOfNumber - index + 1;
|
|
string text = new string(json, index, length);
|
|
object result;
|
|
if (text.IndexOf(".", StringComparison.OrdinalIgnoreCase) != -1 || text.IndexOf("e", StringComparison.OrdinalIgnoreCase) != -1)
|
|
{
|
|
double num;
|
|
success = double.TryParse(new string(json, index, length), NumberStyles.Any, CultureInfo.InvariantCulture, out num);
|
|
result = num;
|
|
}
|
|
else
|
|
{
|
|
long num2;
|
|
success = long.TryParse(new string(json, index, length), NumberStyles.Any, CultureInfo.InvariantCulture, out num2);
|
|
result = num2;
|
|
}
|
|
index = lastIndexOfNumber + 1;
|
|
return result;
|
|
}
|
|
|
|
// Token: 0x0600009E RID: 158 RVA: 0x00006C18 File Offset: 0x00004E18
|
|
protected static int getLastIndexOfNumber(char[] json, int index)
|
|
{
|
|
int i;
|
|
for (i = index; i < json.Length; i++)
|
|
{
|
|
if ("0123456789+-.eE".IndexOf(json[i]) == -1)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
return i - 1;
|
|
}
|
|
|
|
// Token: 0x0600009F RID: 159 RVA: 0x00006C5C File Offset: 0x00004E5C
|
|
protected static void eatWhitespace(char[] json, ref int index)
|
|
{
|
|
while (index < json.Length)
|
|
{
|
|
if (" \t\n\r\b\f".IndexOf(json[index]) == -1)
|
|
{
|
|
break;
|
|
}
|
|
index++;
|
|
}
|
|
}
|
|
|
|
// Token: 0x060000A0 RID: 160 RVA: 0x00006C90 File Offset: 0x00004E90
|
|
protected static int lookAhead(char[] json, int index)
|
|
{
|
|
int num = index;
|
|
return SimpleJson.nextToken(json, ref num);
|
|
}
|
|
|
|
// Token: 0x060000A1 RID: 161 RVA: 0x00006CB0 File Offset: 0x00004EB0
|
|
protected static int nextToken(char[] json, ref int index)
|
|
{
|
|
SimpleJson.eatWhitespace(json, ref index);
|
|
int result;
|
|
if (index == json.Length)
|
|
{
|
|
result = 0;
|
|
}
|
|
else
|
|
{
|
|
char c = json[index];
|
|
index++;
|
|
switch (c)
|
|
{
|
|
case ',':
|
|
result = 6;
|
|
break;
|
|
case '-':
|
|
case '0':
|
|
case '1':
|
|
case '2':
|
|
case '3':
|
|
case '4':
|
|
case '5':
|
|
case '6':
|
|
case '7':
|
|
case '8':
|
|
case '9':
|
|
result = 8;
|
|
break;
|
|
default:
|
|
switch (c)
|
|
{
|
|
case '[':
|
|
result = 3;
|
|
break;
|
|
default:
|
|
switch (c)
|
|
{
|
|
case '{':
|
|
result = 1;
|
|
break;
|
|
default:
|
|
if (c != '"')
|
|
{
|
|
index--;
|
|
int num = json.Length - index;
|
|
if (num >= 5)
|
|
{
|
|
if (json[index] == 'f' && json[index + 1] == 'a' && json[index + 2] == 'l' && json[index + 3] == 's' && json[index + 4] == 'e')
|
|
{
|
|
index += 5;
|
|
result = 10;
|
|
break;
|
|
}
|
|
}
|
|
if (num >= 4)
|
|
{
|
|
if (json[index] == 't' && json[index + 1] == 'r' && json[index + 2] == 'u' && json[index + 3] == 'e')
|
|
{
|
|
index += 4;
|
|
result = 9;
|
|
break;
|
|
}
|
|
}
|
|
if (num >= 4)
|
|
{
|
|
if (json[index] == 'n' && json[index + 1] == 'u' && json[index + 2] == 'l' && json[index + 3] == 'l')
|
|
{
|
|
index += 4;
|
|
result = 11;
|
|
break;
|
|
}
|
|
}
|
|
result = 0;
|
|
}
|
|
else
|
|
{
|
|
result = 7;
|
|
}
|
|
break;
|
|
case '}':
|
|
result = 2;
|
|
break;
|
|
}
|
|
break;
|
|
case ']':
|
|
result = 4;
|
|
break;
|
|
}
|
|
break;
|
|
case ':':
|
|
result = 5;
|
|
break;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// Token: 0x060000A2 RID: 162 RVA: 0x00006E98 File Offset: 0x00005098
|
|
protected static bool serializeValue(IJsonSerializerStrategy jsonSerializerStrategy, object value, StringBuilder builder)
|
|
{
|
|
bool flag = true;
|
|
if (value is string)
|
|
{
|
|
flag = SimpleJson.serializeString((string)value, builder);
|
|
}
|
|
else if (value is IDictionary<string, object>)
|
|
{
|
|
IDictionary<string, object> dictionary = (IDictionary<string, object>)value;
|
|
flag = SimpleJson.serializeObject(jsonSerializerStrategy, dictionary.Keys, dictionary.Values, builder);
|
|
}
|
|
else if (value is IDictionary<string, string>)
|
|
{
|
|
IDictionary<string, string> dictionary2 = (IDictionary<string, string>)value;
|
|
flag = SimpleJson.serializeObject(jsonSerializerStrategy, dictionary2.Keys, dictionary2.Values, builder);
|
|
}
|
|
else if (value is IDictionary)
|
|
{
|
|
IDictionary dictionary3 = (IDictionary)value;
|
|
flag = SimpleJson.serializeObject(jsonSerializerStrategy, dictionary3.Keys, dictionary3.Values, builder);
|
|
}
|
|
else if (value is IEnumerable)
|
|
{
|
|
flag = SimpleJson.serializeArray(jsonSerializerStrategy, (IEnumerable)value, builder);
|
|
}
|
|
else if (SimpleJson.isNumeric(value))
|
|
{
|
|
flag = SimpleJson.serializeNumber(value, builder);
|
|
}
|
|
else if (value is bool)
|
|
{
|
|
builder.Append((!(bool)value) ? "false" : "true");
|
|
}
|
|
else if (value == null)
|
|
{
|
|
builder.Append("null");
|
|
}
|
|
else
|
|
{
|
|
object value2;
|
|
flag = jsonSerializerStrategy.serializeNonPrimitiveObject(value, out value2);
|
|
if (flag)
|
|
{
|
|
SimpleJson.serializeValue(jsonSerializerStrategy, value2, builder);
|
|
}
|
|
}
|
|
return flag;
|
|
}
|
|
|
|
// Token: 0x060000A3 RID: 163 RVA: 0x00006FF0 File Offset: 0x000051F0
|
|
protected static bool serializeObject(IJsonSerializerStrategy jsonSerializerStrategy, IEnumerable keys, IEnumerable values, StringBuilder builder)
|
|
{
|
|
builder.Append("{");
|
|
IEnumerator enumerator = keys.GetEnumerator();
|
|
IEnumerator enumerator2 = values.GetEnumerator();
|
|
bool flag = true;
|
|
while (enumerator.MoveNext() && enumerator2.MoveNext())
|
|
{
|
|
object obj = enumerator.Current;
|
|
object value = enumerator2.Current;
|
|
if (!flag)
|
|
{
|
|
builder.Append(",");
|
|
}
|
|
if (obj is string)
|
|
{
|
|
SimpleJson.serializeString((string)obj, builder);
|
|
}
|
|
else if (!SimpleJson.serializeValue(jsonSerializerStrategy, value, builder))
|
|
{
|
|
return false;
|
|
}
|
|
builder.Append(":");
|
|
if (SimpleJson.serializeValue(jsonSerializerStrategy, value, builder))
|
|
{
|
|
flag = false;
|
|
continue;
|
|
}
|
|
return false;
|
|
}
|
|
builder.Append("}");
|
|
return true;
|
|
}
|
|
|
|
// Token: 0x060000A4 RID: 164 RVA: 0x000070C8 File Offset: 0x000052C8
|
|
protected static bool serializeArray(IJsonSerializerStrategy jsonSerializerStrategy, IEnumerable anArray, StringBuilder builder)
|
|
{
|
|
builder.Append("[");
|
|
bool flag = true;
|
|
IEnumerator enumerator = anArray.GetEnumerator();
|
|
try
|
|
{
|
|
while (enumerator.MoveNext())
|
|
{
|
|
object value = enumerator.Current;
|
|
if (!flag)
|
|
{
|
|
builder.Append(",");
|
|
}
|
|
if (!SimpleJson.serializeValue(jsonSerializerStrategy, value, builder))
|
|
{
|
|
return false;
|
|
}
|
|
flag = false;
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
IDisposable disposable;
|
|
if ((disposable = (enumerator as IDisposable)) != null)
|
|
{
|
|
disposable.Dispose();
|
|
}
|
|
}
|
|
builder.Append("]");
|
|
return true;
|
|
}
|
|
|
|
// Token: 0x060000A5 RID: 165 RVA: 0x0000716C File Offset: 0x0000536C
|
|
protected static bool serializeString(string aString, StringBuilder builder)
|
|
{
|
|
builder.Append("\"");
|
|
foreach (char c in aString.ToCharArray())
|
|
{
|
|
if (c == '"')
|
|
{
|
|
builder.Append("\\\"");
|
|
}
|
|
else if (c == '\\')
|
|
{
|
|
builder.Append("\\\\");
|
|
}
|
|
else if (c == '\b')
|
|
{
|
|
builder.Append("\\b");
|
|
}
|
|
else if (c == '\f')
|
|
{
|
|
builder.Append("\\f");
|
|
}
|
|
else if (c == '\n')
|
|
{
|
|
builder.Append("\\n");
|
|
}
|
|
else if (c == '\r')
|
|
{
|
|
builder.Append("\\r");
|
|
}
|
|
else if (c == '\t')
|
|
{
|
|
builder.Append("\\t");
|
|
}
|
|
else
|
|
{
|
|
builder.Append(c);
|
|
}
|
|
}
|
|
builder.Append("\"");
|
|
return true;
|
|
}
|
|
|
|
// Token: 0x060000A6 RID: 166 RVA: 0x00007274 File Offset: 0x00005474
|
|
protected static bool serializeNumber(object number, StringBuilder builder)
|
|
{
|
|
if (number is long)
|
|
{
|
|
builder.Append(((long)number).ToString(CultureInfo.InvariantCulture));
|
|
}
|
|
else if (number is ulong)
|
|
{
|
|
builder.Append(((ulong)number).ToString(CultureInfo.InvariantCulture));
|
|
}
|
|
else if (number is int)
|
|
{
|
|
builder.Append(((int)number).ToString(CultureInfo.InvariantCulture));
|
|
}
|
|
else if (number is uint)
|
|
{
|
|
builder.Append(((uint)number).ToString(CultureInfo.InvariantCulture));
|
|
}
|
|
else if (number is decimal)
|
|
{
|
|
builder.Append(((decimal)number).ToString(CultureInfo.InvariantCulture));
|
|
}
|
|
else if (number is float)
|
|
{
|
|
builder.Append(((float)number).ToString(CultureInfo.InvariantCulture));
|
|
}
|
|
else
|
|
{
|
|
builder.Append(Convert.ToDouble(number, CultureInfo.InvariantCulture).ToString("r", CultureInfo.InvariantCulture));
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Token: 0x060000A7 RID: 167 RVA: 0x000073C0 File Offset: 0x000055C0
|
|
protected static bool isNumeric(object value)
|
|
{
|
|
return value is sbyte || value is byte || value is short || value is ushort || value is int || value is uint || value is long || value is ulong || value is float || value is double || value is decimal;
|
|
}
|
|
|
|
// Token: 0x04000040 RID: 64
|
|
private const int TOKEN_NONE = 0;
|
|
|
|
// Token: 0x04000041 RID: 65
|
|
private const int TOKEN_CURLY_OPEN = 1;
|
|
|
|
// Token: 0x04000042 RID: 66
|
|
private const int TOKEN_CURLY_CLOSE = 2;
|
|
|
|
// Token: 0x04000043 RID: 67
|
|
private const int TOKEN_SQUARED_OPEN = 3;
|
|
|
|
// Token: 0x04000044 RID: 68
|
|
private const int TOKEN_SQUARED_CLOSE = 4;
|
|
|
|
// Token: 0x04000045 RID: 69
|
|
private const int TOKEN_COLON = 5;
|
|
|
|
// Token: 0x04000046 RID: 70
|
|
private const int TOKEN_COMMA = 6;
|
|
|
|
// Token: 0x04000047 RID: 71
|
|
private const int TOKEN_STRING = 7;
|
|
|
|
// Token: 0x04000048 RID: 72
|
|
private const int TOKEN_NUMBER = 8;
|
|
|
|
// Token: 0x04000049 RID: 73
|
|
private const int TOKEN_TRUE = 9;
|
|
|
|
// Token: 0x0400004A RID: 74
|
|
private const int TOKEN_FALSE = 10;
|
|
|
|
// Token: 0x0400004B RID: 75
|
|
private const int TOKEN_NULL = 11;
|
|
|
|
// Token: 0x0400004C RID: 76
|
|
private const int BUILDER_CAPACITY = 2000;
|
|
|
|
// Token: 0x0400004D RID: 77
|
|
private static IJsonSerializerStrategy _currentJsonSerializerStrategy;
|
|
|
|
// Token: 0x0400004E RID: 78
|
|
private static PocoJsonSerializerStrategy _pocoJsonSerializerStrategy;
|
|
}
|
|
}
|