/* | |
* Copyright (c) 2013 Calvin Rien | |
* | |
* Based on the JSON parser by Patrick van Bergen | |
* http://techblog.procurios.nl/k/618/news/view/14605/14863/How-do-I-write-my-own-parser-for-JSON.html | |
* | |
* Simplified it so that it doesn't throw exceptions | |
* and can be used in Unity iPhone with maximum code stripping. | |
* | |
* 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 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. | |
*/ | |
using System; | |
using System.Collections; | |
using System.Collections.Generic; | |
using System.IO; | |
using System.Text; | |
namespace MiniJSON { | |
// Example usage: | |
// | |
// using UnityEngine; | |
// using System.Collections; | |
// using System.Collections.Generic; | |
// using MiniJSON; | |
// | |
// public class MiniJSONTest : MonoBehaviour { | |
// void Start () { | |
// var jsonString = "{ \"array\": [1.44,2,3], " + | |
// "\"object\": {\"key1\":\"value1\", \"key2\":256}, " + | |
// "\"string\": \"The quick brown fox \\\"jumps\\\" over the lazy dog \", " + | |
// "\"unicode\": \"\\u3041 Men\u00fa sesi\u00f3n\", " + | |
// "\"int\": 65536, " + | |
// "\"float\": 3.1415926, " + | |
// "\"bool\": true, " + | |
// "\"null\": null }"; | |
// | |
// var dict = Json.Deserialize(jsonString) as Dictionary<string,object>; | |
// | |
// Debug.Log("deserialized: " + dict.GetType()); | |
// Debug.Log("dict['array'][0]: " + ((List<object>) dict["array"])[0]); | |
// Debug.Log("dict['string']: " + (string) dict["string"]); | |
// Debug.Log("dict['float']: " + (double) dict["float"]); // floats come out as doubles | |
// Debug.Log("dict['int']: " + (long) dict["int"]); // ints come out as longs | |
// Debug.Log("dict['unicode']: " + (string) dict["unicode"]); | |
// | |
// var str = Json.Serialize(dict); | |
// | |
// Debug.Log("serialized: " + str); | |
// } | |
// } | |
/// <summary> | |
/// This class encodes and decodes JSON strings. | |
/// Spec. details, see http://www.json.org/ | |
/// | |
/// JSON uses Arrays and Objects. These correspond here to the datatypes IList and IDictionary. | |
/// All numbers are parsed to doubles. | |
/// </summary> | |
public static class Json { | |
/// <summary> | |
/// Parses the string json into a value | |
/// </summary> | |
/// <param name="json">A JSON string.</param> | |
/// <returns>An List<object>, a Dictionary<string, object>, a double, an integer,a string, null, true, or false</returns> | |
public static object Deserialize(string json) { | |
// save the string for debug information | |
if (json == null) { | |
return null; | |
} | |
return Parser.Parse(json); | |
} | |
sealed class Parser : IDisposable { | |
const string WORD_BREAK = "{}[],:\""; | |
public static bool IsWordBreak(char c) { | |
return Char.IsWhiteSpace(c) || WORD_BREAK.IndexOf(c) != -1; | |
} | |
enum TOKEN { | |
NONE, | |
CURLY_OPEN, | |
CURLY_CLOSE, | |
SQUARED_OPEN, | |
SQUARED_CLOSE, | |
COLON, | |
COMMA, | |
STRING, | |
NUMBER, | |
TRUE, | |
FALSE, | |
NULL | |
}; | |
StringReader json; | |
Parser(string jsonString) { | |
json = new StringReader(jsonString); | |
} | |
public static object Parse(string jsonString) { | |
using (var instance = new Parser(jsonString)) { | |
return instance.ParseValue(); | |
} | |
} | |
public void Dispose() { | |
json.Dispose(); | |
json = null; | |
} | |
Dictionary<string, object> ParseObject() { | |
Dictionary<string, object> table = new Dictionary<string, object>(); | |
// ditch opening brace | |
json.Read(); | |
// { | |
while (true) { | |
switch (NextToken) { | |
case TOKEN.NONE: | |
return null; | |
case TOKEN.COMMA: | |
continue; | |
case TOKEN.CURLY_CLOSE: | |
return table; | |
default: | |
// name | |
string name = ParseString(); | |
if (name == null) { | |
return null; | |
} | |
// : | |
if (NextToken != TOKEN.COLON) { | |
return null; | |
} | |
// ditch the colon | |
json.Read(); | |
// value | |
table[name] = ParseValue(); | |
break; | |
} | |
} | |
} | |
List<object> ParseArray() { | |
List<object> array = new List<object>(); | |
// ditch opening bracket | |
json.Read(); | |
// [ | |
var parsing = true; | |
while (parsing) { | |
TOKEN nextToken = NextToken; | |
switch (nextToken) { | |
case TOKEN.NONE: | |
return null; | |
case TOKEN.COMMA: | |
continue; | |
case TOKEN.SQUARED_CLOSE: | |
parsing = false; | |
break; | |
default: | |
object value = ParseByToken(nextToken); | |
array.Add(value); | |
break; | |
} | |
} | |
return array; | |
} | |
object ParseValue() { | |
TOKEN nextToken = NextToken; | |
return ParseByToken(nextToken); | |
} | |
object ParseByToken(TOKEN token) { | |
switch (token) { | |
case TOKEN.STRING: | |
return ParseString(); | |
case TOKEN.NUMBER: | |
return ParseNumber(); | |
case TOKEN.CURLY_OPEN: | |
return ParseObject(); | |
case TOKEN.SQUARED_OPEN: | |
return ParseArray(); | |
case TOKEN.TRUE: | |
return true; | |
case TOKEN.FALSE: | |
return false; | |
case TOKEN.NULL: | |
return null; | |
default: | |
return null; | |
} | |
} | |
string ParseString() { | |
StringBuilder s = new StringBuilder(); | |
char c; | |
// ditch opening quote | |
json.Read(); | |
bool parsing = true; | |
while (parsing) { | |
if (json.Peek() == -1) { | |
parsing = false; | |
break; | |
} | |
c = NextChar; | |
switch (c) { | |
case '"': | |
parsing = false; | |
break; | |
case '\\': | |
if (json.Peek() == -1) { | |
parsing = false; | |
break; | |
} | |
c = NextChar; | |
switch (c) { | |
case '"': | |
case '\\': | |
case '/': | |
s.Append(c); | |
break; | |
case 'b': | |
s.Append('\b'); | |
break; | |
case 'f': | |
s.Append('\f'); | |
break; | |
case 'n': | |
s.Append('\n'); | |
break; | |
case 'r': | |
s.Append('\r'); | |
break; | |
case 't': | |
s.Append('\t'); | |
break; | |
case 'u': | |
var hex = new char[4]; | |
for (int i=0; i< 4; i++) { | |
hex[i] = NextChar; | |
} | |
s.Append((char) Convert.ToInt32(new string(hex), 16)); | |
break; | |
} | |
break; | |
default: | |
s.Append(c); | |
break; | |
} | |
} | |
return s.ToString(); | |
} | |
object ParseNumber() { | |
string number = NextWord; | |
if (number.IndexOf('.') == -1) { | |
long parsedInt; | |
Int64.TryParse(number, out parsedInt); | |
return parsedInt; | |
} | |
double parsedDouble; | |
Double.TryParse(number, out parsedDouble); | |
return parsedDouble; | |
} | |
void EatWhitespace() { | |
while (Char.IsWhiteSpace(PeekChar)) { | |
json.Read(); | |
if (json.Peek() == -1) { | |
break; | |
} | |
} | |
} | |
char PeekChar { | |
get { | |
return Convert.ToChar(json.Peek()); | |
} | |
} | |
char NextChar { | |
get { | |
return Convert.ToChar(json.Read()); | |
} | |
} | |
string NextWord { | |
get { | |
StringBuilder word = new StringBuilder(); | |
while (!IsWordBreak(PeekChar)) { | |
word.Append(NextChar); | |
if (json.Peek() == -1) { | |
break; | |
} | |
} | |
return word.ToString(); | |
} | |
} | |
TOKEN NextToken { | |
get { | |
EatWhitespace(); | |
if (json.Peek() == -1) { | |
return TOKEN.NONE; | |
} | |
switch (PeekChar) { | |
case '{': | |
return TOKEN.CURLY_OPEN; | |
case '}': | |
json.Read(); | |
return TOKEN.CURLY_CLOSE; | |
case '[': | |
return TOKEN.SQUARED_OPEN; | |
case ']': | |
json.Read(); | |
return TOKEN.SQUARED_CLOSE; | |
case ',': | |
json.Read(); | |
return TOKEN.COMMA; | |
case '"': | |
return TOKEN.STRING; | |
case ':': | |
return TOKEN.COLON; | |
case '0': | |
case '1': | |
case '2': | |
case '3': | |
case '4': | |
case '5': | |
case '6': | |
case '7': | |
case '8': | |
case '9': | |
case '-': | |
return TOKEN.NUMBER; | |
} | |
switch (NextWord) { | |
case "false": | |
return TOKEN.FALSE; | |
case "true": | |
return TOKEN.TRUE; | |
case "null": | |
return TOKEN.NULL; | |
} | |
return TOKEN.NONE; | |
} | |
} | |
} | |
/// <summary> | |
/// Converts a IDictionary / IList object or a simple type (string, int, etc.) into a JSON string | |
/// </summary> | |
/// <param name="json">A Dictionary<string, object> / List<object></param> | |
/// <returns>A JSON encoded string, or null if object 'json' is not serializable</returns> | |
public static string Serialize(object obj) { | |
return Serializer.Serialize(obj); | |
} | |
sealed class Serializer { | |
StringBuilder builder; | |
Serializer() { | |
builder = new StringBuilder(); | |
} | |
public static string Serialize(object obj) { | |
var instance = new Serializer(); | |
instance.SerializeValue(obj); | |
return instance.builder.ToString(); | |
} | |
void SerializeValue(object value) { | |
IList asList; | |
IDictionary asDict; | |
string asStr; | |
if (value == null) { | |
builder.Append("null"); | |
} else if ((asStr = value as string) != null) { | |
SerializeString(asStr); | |
} else if (value is bool) { | |
builder.Append((bool) value ? "true" : "false"); | |
} else if ((asList = value as IList) != null) { | |
SerializeArray(asList); | |
} else if ((asDict = value as IDictionary) != null) { | |
SerializeObject(asDict); | |
} else if (value is char) { | |
SerializeString(new string((char) value, 1)); | |
} else { | |
SerializeOther(value); | |
} | |
} | |
void SerializeObject(IDictionary obj) { | |
bool first = true; | |
builder.Append('{'); | |
foreach (object e in obj.Keys) { | |
if (!first) { | |
builder.Append(','); | |
} | |
SerializeString(e.ToString()); | |
builder.Append(':'); | |
SerializeValue(obj[e]); | |
first = false; | |
} | |
builder.Append('}'); | |
} | |
void SerializeArray(IList anArray) { | |
builder.Append('['); | |
bool first = true; | |
foreach (object obj in anArray) { | |
if (!first) { | |
builder.Append(','); | |
} | |
SerializeValue(obj); | |
first = false; | |
} | |
builder.Append(']'); | |
} | |
void SerializeString(string str) { | |
builder.Append('\"'); | |
char[] charArray = str.ToCharArray(); | |
foreach (var c in charArray) { | |
switch (c) { | |
case '"': | |
builder.Append("\\\""); | |
break; | |
case '\\': | |
builder.Append("\\\\"); | |
break; | |
case '\b': | |
builder.Append("\\b"); | |
break; | |
case '\f': | |
builder.Append("\\f"); | |
break; | |
case '\n': | |
builder.Append("\\n"); | |
break; | |
case '\r': | |
builder.Append("\\r"); | |
break; | |
case '\t': | |
builder.Append("\\t"); | |
break; | |
default: | |
int codepoint = Convert.ToInt32(c); | |
if ((codepoint >= 32) && (codepoint <= 126)) { | |
builder.Append(c); | |
} else { | |
builder.Append("\\u"); | |
builder.Append(codepoint.ToString("x4")); | |
} | |
break; | |
} | |
} | |
builder.Append('\"'); | |
} | |
void SerializeOther(object value) { | |
// NOTE: decimals lose precision during serialization. | |
// They always have, I'm just letting you know. | |
// Previously floats and doubles lost precision too. | |
if (value is float) { | |
builder.Append(((float) value).ToString("R")); | |
} else if (value is int | |
|| value is uint | |
|| value is long | |
|| value is sbyte | |
|| value is byte | |
|| value is short | |
|| value is ushort | |
|| value is ulong) { | |
builder.Append(value); | |
} else if (value is double | |
|| value is decimal) { | |
builder.Append(Convert.ToDouble(value).ToString("R")); | |
} else { | |
SerializeString(value.ToString()); | |
} | |
} | |
} | |
} | |
} |
This comment has been minimized.
This comment has been minimized.
Can this work with 2 dimensional arrays? |
This comment has been minimized.
This comment has been minimized.
Fixed the float, double, decimal issue where the serialiser saved it as "0" instead of "0.0" In the Function SerializeOther at Line 529 void SerializeOther(object value) { |
This comment has been minimized.
This comment has been minimized.
Has anyone come across a bug where when it tries to serialize a dictionary, it instead makes the string into something like this?: System.Collections.Generic.Dictionary`2[System.String,System.Object] It's as if instead of grabbing the keys, it's grabbing each character of the type somehow. This appears to be happening randomly, working sometimes, but not others. |
This comment has been minimized.
This comment has been minimized.
@tonyzahnle, I saw some similar issues using this and other JSON libraries. If you swap all the generic collections in this code for Hashtables and ArrayLists it will fix your issue. I think that Unity for iOS has some kind of problem with iterating over generic collections. More about the issue here, although their fix didn't completely solve it for me. |
This comment has been minimized.
This comment has been minimized.
What exactly would be the problem with an extremely large json string? Im pretty sure we are using strings larger than that just fine... |
This comment has been minimized.
This comment has been minimized.
This implementation currently generates and parses invalid JSON when the system locale is set to use comma instead of periods with decimal numbers. By instructing TryParse and ToString to ignore the user locale, this fixes the issue. |
This comment has been minimized.
This comment has been minimized.
Apparently, the Mono runtime incorrectly handles the current locale and in most situations returns en-us or invariant, at least in the current Unity3D version (4.2.1) and earlier. https://bugzilla.xamarin.com/show_bug.cgi?id=2957 So number parsing and encoding is working by chance. If the Mono runtime is fixed, the code will be broken. You should consider @elaberge suggestions. As a side note, I encourage you to replace foreach with a standard for when possible (check out my fork, for performance). Great work by the way and thanks for sharing! :) |
This comment has been minimized.
This comment has been minimized.
Deserializing large ulong (UInt64) returns 0. Following code return zero:
Solution 1: Solution 2:
Solution 3:
|
This comment has been minimized.
This comment has been minimized.
Hello I have problem.
The problem is that i need integer as Key and not string. Is it not possible to change? |
This comment has been minimized.
This comment has been minimized.
MiniJSON causes an OutOfMemoryException on a machine with 8GB of RAM on the following invalid JSON string:
It also blocks for 10+ seconds before doing so. Solution:
|
This comment has been minimized.
This comment has been minimized.
Hi ... I am a bit noob on JSON and really also c# I hope to be able to make my game grid from this Json: { } But how would I go about to get this json from the dictionary to my int layout[9,9] I hope someone will be able to help. |
This comment has been minimized.
This comment has been minimized.
I got the answer from stack var dict = (Dictionary<string, object>)Json.Deserialize(jsonString); for (int row = 0; row < 9; row++) |
This comment has been minimized.
This comment has been minimized.
not coding topic... Hi, it seems I have a trouble to see the following page: Is this right? |
This comment has been minimized.
This comment has been minimized.
I cannot get this to give me an array of a custom object. What is the correct way to do this? |
This comment has been minimized.
This comment has been minimized.
How to use where clause in MiniJSON I have 2 array names called categories and products and i'm getting the values from products table but i want to pass the id value from categories to products using WHERE clause. But how can i use WHERE in MiniJSON? {"Categories":[{"id":"1","name":"Test1"},{"id":"2","name":"Test2"},}], "Products": IList linksObject = (IList) search["Products"]
} |
This comment has been minimized.
This comment has been minimized.
How to solve problems with double type: object ParseNumber()
{
string number = NextWord;
if (number.IndexOf('.') == -1)
{
long parsedInt;
Int64.TryParse(number, out parsedInt);
return parsedInt;
}
double parsedDouble;
//use invariant number format to parse double
Double.TryParse(number, System.Globalization.NumberStyles.Float, System.Globalization.NumberFormatInfo.InvariantInfo, out parsedDouble);
return parsedDouble;
} |
This comment has been minimized.
This comment has been minimized.
Passing in a blank string (not valid json) throws an Overflow Exception in Deserialize.. OverflowException: Value is greater than Char.MaxValue or less than Char.MinValue |
This comment has been minimized.
This comment has been minimized.
well, just launch an exception, this can be simple to fix if(string.IsNullOrWhitespace(content)) or something else, there is millions of solutions to this issue, if the author allow me, I can fix the error and put it as a gist. |
This comment has been minimized.
This comment has been minimized.
Thanks for very useful code. Infinite loop occurs in following json. [
{
a: 1
}
] We could change the ParseArray() method as follows. default:
object value = ParseByToken (nextToken);
array.Add(value);
// Add code
if (value == null) {
json.Read();
}
break; As a matter of course, if enclose the key in double quotation, it normally move. |
This comment has been minimized.
This comment has been minimized.
I ran in to the same problem as @nikibobi and after trying a few things (cast to decimal, declare G9, etc.) decided to write a simple fix. string FloatingPointString(string number) {
if (number.IndexOf('.') < 0) {
return number + ".0";
}
return number;
} which then wraps the floating point and double conversions following line 530. |
This comment has been minimized.
This comment has been minimized.
In case it helps anybody, these are some helper functions I use when extracting my data from a MiniJSON <string, object> dictionary: |
This comment has been minimized.
This comment has been minimized.
Given the following json: |
This comment has been minimized.
This comment has been minimized.
MiniJSON fails parsing floating point notation (like @@ -290,7 +290,7 @@ namespace MiniJSON {
object ParseNumber() {
string number = NextWord;
- if (number.IndexOf('.') == -1) {
+ if (number.IndexOf('.') == -1 && number.IndexOf('E') == -1 && number.IndexOf('e') == -1) {
long parsedInt;
Int64.TryParse(number, out parsedInt);
return parsedInt; |
This comment has been minimized.
This comment has been minimized.
Thanks for this great piece of code! I started using it for my Unity project. However, there has been many comments about issues and fixes, I think it would be a good idea if they are managed somewhere so that someone who want to use the library doesn't have to copy paste all those fixes. Therefore, I've create a repo: https://github.com/Jackyjjc/MiniJSON.cs I've included quite a few fixes mentioned above but not all of them since I didn't understand the full context of the fix. Feel free to submit a pull request for your fix though. I'm happy to hand it to @darktable if he is willing to manage it :) |
This comment has been minimized.
This comment has been minimized.
w.r.t. ParseArray throwing an OutOfMemoryException, I had to change the 'array' variable in ParseArray to be lazily allocated in addition to @prestonmediaspike's changes
|
This comment has been minimized.
This comment has been minimized.
When serializing arbitrary objects it would be much better to use Unity's JsonUtility.ToJson method which uses reflection instead of serializing the string of the object's ToString() method. In other words change line 542: The reason is that presently you can serialize objects with Unity but you cannot serialize arbitrary arrays, lists or dictionaries. And with MiniJSON you can serialize arbitrary arrays, lists and dictionaries, but turning an object into its ToString() string and then serializing that string is pretty useless. Now you can do something like this:
And you get: |
This comment has been minimized.
This comment has been minimized.
@kornman00 and @sotirosn mind putting your changes to https://github.com/Jackyjjc/MiniJSON.cs? That would be a great help! |
This comment has been minimized.
This comment has been minimized.
At the top it says MiniJSON is best for strings less than 32K characters, so I should not use this for a file ranging around 300,000 characters, are there downsides to using this on larger files besides runtime? |
This comment has been minimized.
This comment has been minimized.
i load a json from server. but MiniJSON return null, and i feel it get problem in "Convert.ToChar(json.Peek())". What should i do if the string is not in Unicode? |
This comment has been minimized.
This comment has been minimized.
There are bug with double. Steps:
Fixed like this:
|
This comment has been minimized.
I found one nasty bug. When I serialize a double that is a whole number like 1, it writes it like 1. And when the parser wants to parse it it doesn't have '.' and it reads it as integer type. I suggest splitting the if on line 530 for ints and floats and then doing something like string.Format("0.0"); for the floats.
Other than that your mini json lib is very useful and I thank you for doing it :D