csharp/365082218/meteor_original_ios/Assets/ThirdParty/NGUI/Scripts/Editor/NGUIJson.cs

NGUIJson.cs
using System;
using System.Collections;
using System.Text;
using System.Collections.Generic;
using UnityEngine;

// Source: UIToolkit -- https://github.com/prime31/UIToolkit/blob/master/astets/Plugins/MiniJSON.cs

// Based on the JSON parser from 
// http://techblog.procurios.nl/k/618/news/view/14605/14863/How-do-I-write-my-own-parser-for-JSON.html

/// 
/// This clast encodes and decodes JSON strings.
/// Spec. details, see http://www.json.org/
/// 
/// JSON uses Arrays and Objects. These correspond here to the datatypes ArrayList and Hashtable.
/// All numbers are parsed to doubles.
/// 

public clast NGUIJson
{
	private const int TOKEN_NONE = 0;
	private const int TOKEN_CURLY_OPEN = 1;
	private const int TOKEN_CURLY_CLOSE = 2;
	private const int TOKEN_SQUARED_OPEN = 3;
	private const int TOKEN_SQUARED_CLOSE = 4;
	private const int TOKEN_COLON = 5;
	private const int TOKEN_COMMA = 6;
	private const int TOKEN_STRING = 7;
	private const int TOKEN_NUMBER = 8;
	private const int TOKEN_TRUE = 9;
	private const int TOKEN_FALSE = 10;
	private const int TOKEN_NULL = 11;
	private const int BUILDER_CAPACITY = 2000;

	/// 
	/// On decoding, this value holds the position at which the parse failed (-1 = no error).
	/// 
	protected static int lastErrorIndex = -1;
	protected static string lastDecode = "";

	/// 
	/// Parse the specified JSon file, loading sprite information for the specified atlas.
	/// 

	public static void LoadSpriteData (UIAtlas atlas, Textastet astet)
	{
		if (astet == null || atlas == null) return;

		string jsonString = astet.text;
		Hashtable decodedHash = jsonDecode(jsonString) as Hashtable;
		
		if (decodedHash == null)
		{
			Debug.LogWarning("Unable to parse Json file: " + astet.name);
			return;
		}

		atlas.coordinates = UIAtlas.Coordinates.Pixels;
		List oldSprites = atlas.spriteList;
		atlas.spriteList = new List();

		Hashtable frames = (Hashtable)decodedHash["frames"];

		foreach (System.Collections.DictionaryEntry item in frames)
		{
			UIAtlas.Sprite newSprite = new UIAtlas.Sprite();
			newSprite.name = item.Key.ToString();

			bool exists = false;

			// Check to see if this sprite exists
			foreach (UIAtlas.Sprite oldSprite in oldSprites)
			{
				if (oldSprite.name.Equals(newSprite.name, StringComparison.OrdinalIgnoreCase))
				{
					exists = true;
					break;
				}
			}

			// Get rid of the extension if the sprite doesn't exist
			// The extension is kept for backwards compatibility so it's still possible to update older atlases.
			if (!exists)
			{
				newSprite.name = newSprite.name.Replace(".png", "");
				newSprite.name = newSprite.name.Replace(".tga", "");
			}

			// Extract the info we need from the TexturePacker json file, mainly uvRect and size
			Hashtable table = (Hashtable)item.Value;
			Hashtable frame = (Hashtable)table["frame"];

			int frameX = int.Parse(frame["x"].ToString());
			int frameY = int.Parse(frame["y"].ToString());
			int frameW = int.Parse(frame["w"].ToString());
			int frameH = int.Parse(frame["h"].ToString());

			// Read the rotation value
			newSprite.rotated = (bool)table["rotated"];

			// Fill in the proper values
			if (newSprite.rotated)
			{
				newSprite.outer = new Rect(frameX, frameY, frameH, frameW);
				newSprite.inner = new Rect(frameX, frameY, frameH, frameW);
			}
			else
			{
				newSprite.outer = new Rect(frameX, frameY, frameW, frameH);
				newSprite.inner = new Rect(frameX, frameY, frameW, frameH);
			}

			// Support for trimmed sprites
			Hashtable sourceSize = (Hashtable)table["sourceSize"];
			Hashtable spriteSize = (Hashtable)table["spriteSourceSize"];

			if (spriteSize != null && sourceSize != null)
			{
				// TODO: Account for rotated sprites
				if (frameW > 0)
				{
					float spriteX = int.Parse(spriteSize["x"].ToString());
					float spriteW = int.Parse(spriteSize["w"].ToString());
					float sourceW = int.Parse(sourceSize["w"].ToString());

					newSprite.paddingLeft = spriteX / frameW;
					newSprite.paddingRight = (sourceW - (spriteX + spriteW)) / frameW;
				}

				if (frameH > 0)
				{
					float spriteY = int.Parse(spriteSize["y"].ToString());
					float spriteH = int.Parse(spriteSize["h"].ToString());
					float sourceH = int.Parse(sourceSize["h"].ToString());

					newSprite.paddingTop = spriteY / frameH;
					newSprite.paddingBottom = (sourceH - (spriteY + spriteH)) / frameH;
				}
			}

			// If the sprite was present before, see if we can copy its inner rect
			foreach (UIAtlas.Sprite oldSprite in oldSprites)
			{
				if (oldSprite.name.Equals(newSprite.name, StringComparison.OrdinalIgnoreCase))
				{
					CopyInnerRect(oldSprite, newSprite);
				}
			}

			// Add this new sprite
			atlas.spriteList.Add(newSprite);
		}

		// Sort imported sprites alphabetically
		atlas.spriteList.Sort(CompareSprites);
		Debug.Log("Imported " + atlas.spriteList.Count + " sprites");

		// Unload the astet
		astet = null;
		Resources.UnloadUnusedastets();
	}

	/// 
	/// Sprite comparison function for sorting.
	/// 

	static int CompareSprites (UIAtlas.Sprite a, UIAtlas.Sprite b) { return a.name.CompareTo(b.name); }

	/// 
	/// Copy the inner rectangle from one sprite to another.
	/// 

	static void CopyInnerRect (UIAtlas.Sprite oldSprite, UIAtlas.Sprite newSprite)
	{
		float offsetX = oldSprite.inner.xMin - oldSprite.outer.xMin;
		float offsetY = oldSprite.inner.yMin - oldSprite.outer.yMin;
		float sizeX = oldSprite.inner.width;
		float sizeY = oldSprite.inner.height;

		if (Mathf.Approximately(newSprite.outer.width, oldSprite.outer.width))
		{
			// The sprite has not been rotated or it's a square
			newSprite.inner = new Rect(newSprite.outer.xMin + offsetX, newSprite.outer.yMin + offsetY, sizeX, sizeY);
		}
		else if (Mathf.Approximately(newSprite.outer.width, oldSprite.outer.height))
		{
			// The sprite was rotated since the last time it was imported
			newSprite.inner = new Rect(newSprite.outer.xMin + offsetY, newSprite.outer.yMin + offsetX, sizeY, sizeX);
		}
	}

	/// 
	/// Parses the string json into a value
	/// 
	/// A JSON string.
	/// An ArrayList, a Hashtable, a double, a string, null, true, or false
	public static object jsonDecode( string json )
	{
		// save the string for debug information
		NGUIJson.lastDecode = json;

		if( json != null )
		{
			char[] charArray = json.ToCharArray();
			int index = 0;
			bool success = true;
			object value = NGUIJson.parseValue( charArray, ref index, ref success );

			if( success )
				NGUIJson.lastErrorIndex = -1;
			else
				NGUIJson.lastErrorIndex = index;

			return value;
		}
		else
		{
			return null;
		}
	}


	/// 
	/// Converts a Hashtable / ArrayList / Dictionary(string,string) object into a JSON string
	/// 
	/// A Hashtable / ArrayList
	/// A JSON encoded string, or null if object 'json' is not serializable
	public static string jsonEncode( object json )
	{
		var builder = new StringBuilder( BUILDER_CAPACITY );
		var success = NGUIJson.serializeValue( json, builder );
		
		return ( success ? builder.ToString() : null );
	}


	/// 
	/// On decoding, this function returns the position at which the parse failed (-1 = no error).
	/// 
	/// 
	public static bool lastDecodeSuccessful()
	{
		return ( NGUIJson.lastErrorIndex == -1 );
	}


	/// 
	/// On decoding, this function returns the position at which the parse failed (-1 = no error).
	/// 
	/// 
	public static int getLastErrorIndex()
	{
		return NGUIJson.lastErrorIndex;
	}


	/// 
	/// If a decoding error occurred, this function returns a piece of the JSON string 
	/// at which the error took place. To ease debugging.
	/// 
	/// 
	public static string getLastErrorSnippet()
	{
		if( NGUIJson.lastErrorIndex == -1 )
		{
			return "";
		}
		else
		{
			int startIndex = NGUIJson.lastErrorIndex - 5;
			int endIndex = NGUIJson.lastErrorIndex + 15;
			if( startIndex < 0 )
				startIndex = 0;

			if( endIndex >= NGUIJson.lastDecode.Length )
				endIndex = NGUIJson.lastDecode.Length - 1;

			return NGUIJson.lastDecode.Substring( startIndex, endIndex - startIndex + 1 );
		}
	}

	
	#region Parsing
	
	protected static Hashtable parseObject( char[] json, ref int index )
	{
		Hashtable table = new Hashtable();
		int token;

		// {
		nextToken( json, ref index );

		bool done = false;
		while( !done )
		{
			token = lookAhead( json, index );
			if( token == NGUIJson.TOKEN_NONE )
			{
				return null;
			}
			else if( token == NGUIJson.TOKEN_COMMA )
			{
				nextToken( json, ref index );
			}
			else if( token == NGUIJson.TOKEN_CURLY_CLOSE )
			{
				nextToken( json, ref index );
				return table;
			}
			else
			{
				// name
				string name = parseString( json, ref index );
				if( name == null )
				{
					return null;
				}

				// :
				token = nextToken( json, ref index );
				if( token != NGUIJson.TOKEN_COLON )
					return null;

				// value
				bool success = true;
				object value = parseValue( json, ref index, ref success );
				if( !success )
					return null;

				table[name] = value;
			}
		}

		return table;
	}

	
	protected static ArrayList parseArray( char[] json, ref int index )
	{
		ArrayList array = new ArrayList();

		// [
		nextToken( json, ref index );

		bool done = false;
		while( !done )
		{
			int token = lookAhead( json, index );
			if( token == NGUIJson.TOKEN_NONE )
			{
				return null;
			}
			else if( token == NGUIJson.TOKEN_COMMA )
			{
				nextToken( json, ref index );
			}
			else if( token == NGUIJson.TOKEN_SQUARED_CLOSE )
			{
				nextToken( json, ref index );
				break;
			}
			else
			{
				bool success = true;
				object value = parseValue( json, ref index, ref success );
				if( !success )
					return null;

				array.Add( value );
			}
		}

		return array;
	}

	
	protected static object parseValue( char[] json, ref int index, ref bool success )
	{
		switch( lookAhead( json, index ) )
		{
			case NGUIJson.TOKEN_STRING:
				return parseString( json, ref index );
			case NGUIJson.TOKEN_NUMBER:
				return parseNumber( json, ref index );
			case NGUIJson.TOKEN_CURLY_OPEN:
				return parseObject( json, ref index );
			case NGUIJson.TOKEN_SQUARED_OPEN:
				return parseArray( json, ref index );
			case NGUIJson.TOKEN_TRUE:
				nextToken( json, ref index );
				return Boolean.Parse( "TRUE" );
			case NGUIJson.TOKEN_FALSE:
				nextToken( json, ref index );
				return Boolean.Parse( "FALSE" );
			case NGUIJson.TOKEN_NULL:
				nextToken( json, ref index );
				return null;
			case NGUIJson.TOKEN_NONE:
				break;
		}

		success = false;
		return null;
	}

	
	protected static string parseString( char[] json, ref int index )
	{
		string s = "";
		char c;

		eatWhitespace( json, ref index );
		
		// "
		c = json[index++];

		bool complete = false;
		while( !complete )
		{
			if( index == json.Length )
				break;

			c = json[index++];
			if( c == '"' )
			{
				complete = true;
				break;
			}
			else if( c == '\\' )
			{
				if( index == json.Length )
					break;

				c = json[index++];
				if( c == '"' )
				{
					s += '"';
				}
				else if( c == '\\' )
				{
					s += '\\';
				}
				else if( c == '/' )
				{
					s += '/';
				}
				else if( c == 'b' )
				{
					s += '\b';
				}
				else if( c == 'f' )
				{
					s += '\f';
				}
				else if( c == 'n' )
				{
					s += '\n';
				}
				else if( c == 'r' )
				{
					s += '\r';
				}
				else if( c == 't' )
				{
					s += '\t';
				}
				else if( c == 'u' )
				{
					int remainingLength = json.Length - index;
					if( remainingLength >= 4 )
					{
						char[] unicodeCharArray = new char[4];
						Array.Copy( json, index, unicodeCharArray, 0, 4 );

						// Drop in the HTML markup for the unicode character
						s += "&#x" + new string( unicodeCharArray ) + ";";

						/*
uint codePoint = UInt32.Parse(new string(unicodeCharArray), NumberStyles.HexNumber);
// convert the integer codepoint to a unicode char and add to string
s += Char.ConvertFromUtf32((int)codePoint);
*/

						// skip 4 chars
						index += 4;
					}
					else
					{
						break;
					}

				}
			}
			else
			{
				s += c;
			}

		}

		if( !complete )
			return null;

		return s;
	}
	
	
	protected static double parseNumber( char[] json, ref int index )
	{
		eatWhitespace( json, ref index );

		int lastIndex = getLastIndexOfNumber( json, index );
		int charLength = ( lastIndex - index ) + 1;
		char[] numberCharArray = new char[charLength];

		Array.Copy( json, index, numberCharArray, 0, charLength );
		index = lastIndex + 1;
		return Double.Parse( new string( numberCharArray ) ); // , CultureInfo.InvariantCulture);
	}
	
	
	protected static int getLastIndexOfNumber( char[] json, int index )
	{
		int lastIndex;
		for( lastIndex = index; lastIndex < json.Length; lastIndex++ )
			if( "0123456789+-.eE".IndexOf( json[lastIndex] ) == -1 )
			{
				break;
			}
		return lastIndex - 1;
	}
	
	
	protected static void eatWhitespace( char[] json, ref int index )
	{
		for( ; index < json.Length; index++ )
			if( " \t\n\r".IndexOf( json[index] ) == -1 )
			{
				break;
			}
	}
	
	
	protected static int lookAhead( char[] json, int index )
	{
		int saveIndex = index;
		return nextToken( json, ref saveIndex );
	}

	
	protected static int nextToken( char[] json, ref int index )
	{
		eatWhitespace( json, ref index );

		if( index == json.Length )
		{
			return NGUIJson.TOKEN_NONE;
		}
		
		char c = json[index];
		index++;
		switch( c )
		{
			case '{':
				return NGUIJson.TOKEN_CURLY_OPEN;
			case '}':
				return NGUIJson.TOKEN_CURLY_CLOSE;
			case '[':
				return NGUIJson.TOKEN_SQUARED_OPEN;
			case ']':
				return NGUIJson.TOKEN_SQUARED_CLOSE;
			case ',':
				return NGUIJson.TOKEN_COMMA;
			case '"':
				return NGUIJson.TOKEN_STRING;
			case '0':
			case '1':
			case '2':
			case '3':
			case '4': 
			case '5':
			case '6':
			case '7':
			case '8':
			case '9':
			case '-': 
				return NGUIJson.TOKEN_NUMBER;
			case ':':
				return NGUIJson.TOKEN_COLON;
		}
		index--;

		int remainingLength = json.Length - index;

		// false
		if( remainingLength >= 5 )
		{
			if( json[index] == 'f' &&
				json[index + 1] == 'a' &&
				json[index + 2] == 'l' &&
				json[index + 3] == 's' &&
				json[index + 4] == 'e' )
			{
				index += 5;
				return NGUIJson.TOKEN_FALSE;
			}
		}

		// true
		if( remainingLength >= 4 )
		{
			if( json[index] == 't' &&
				json[index + 1] == 'r' &&
				json[index + 2] == 'u' &&
				json[index + 3] == 'e' )
			{
				index += 4;
				return NGUIJson.TOKEN_TRUE;
			}
		}

		// null
		if( remainingLength >= 4 )
		{
			if( json[index] == 'n' &&
				json[index + 1] == 'u' &&
				json[index + 2] == 'l' &&
				json[index + 3] == 'l' )
			{
				index += 4;
				return NGUIJson.TOKEN_NULL;
			}
		}

		return NGUIJson.TOKEN_NONE;
	}

	#endregion
	
	
	#region Serialization
	
	protected static bool serializeObjectOrArray( object objectOrArray, StringBuilder builder )
	{
		if( objectOrArray is Hashtable )
		{
			return serializeObject( (Hashtable)objectOrArray, builder );
		}
		else if( objectOrArray is ArrayList )
			{
				return serializeArray( (ArrayList)objectOrArray, builder );
			}
			else
			{
				return false;
			}
	}

	
	protected static bool serializeObject( Hashtable anObject, StringBuilder builder )
	{
		builder.Append( "{" );

		IDictionaryEnumerator e = anObject.GetEnumerator();
		bool first = true;
		while( e.MoveNext() )
		{
			string key = e.Key.ToString();
			object value = e.Value;

			if( !first )
			{
				builder.Append( ", " );
			}

			serializeString( key, builder );
			builder.Append( ":" );
			if( !serializeValue( value, builder ) )
			{
				return false;
			}

			first = false;
		}

		builder.Append( "}" );
		return true;
	}
	
	
	protected static bool serializeDictionary( Dictionary dict, StringBuilder builder )
	{
		builder.Append( "{" );
		
		bool first = true;
		foreach( var kv in dict )
		{
			if( !first )
				builder.Append( ", " );
			
			serializeString( kv.Key, builder );
			builder.Append( ":" );
			serializeString( kv.Value, builder );

			first = false;
		}

		builder.Append( "}" );
		return true;
	}
	
	
	protected static bool serializeArray( ArrayList anArray, StringBuilder builder )
	{
		builder.Append( "[" );

		bool first = true;
		for( int i = 0; i < anArray.Count; i++ )
		{
			object value = anArray[i];

			if( !first )
			{
				builder.Append( ", " );
			}

			if( !serializeValue( value, builder ) )
			{
				return false;
			}

			first = false;
		}

		builder.Append( "]" );
		return true;
	}

	
	protected static bool serializeValue( object value, StringBuilder builder )
	{
		// Type t = value.GetType();
		// Debug.Log("type: " + t.ToString() + " isArray: " + t.IsArray);

		if( value == null )
		{
			builder.Append( "null" );
		}
		else if( value.GetType().IsArray )
		{
			serializeArray( new ArrayList( (ICollection)value ), builder );
		}
		else if( value is string )
		{
			serializeString( (string)value, builder );
		}
		else if( value is Char )
		{
			serializeString( Convert.ToString( (char)value ), builder );
		}
		else if( value is Hashtable )
		{
			serializeObject( (Hashtable)value, builder );
		}
		else if( value is Dictionary )
		{
			serializeDictionary( (Dictionary)value, builder );
		}
		else if( value is ArrayList )
		{
			serializeArray( (ArrayList)value, builder );
		}
		else if( ( value is Boolean ) && ( (Boolean)value == true ) )
		{
			builder.Append( "true" );
		}
		else if( ( value is Boolean ) && ( (Boolean)value == false ) )
		{
			builder.Append( "false" );
		}
		else if( value.GetType().IsPrimitive )
		{
			serializeNumber( Convert.ToDouble( value ), builder );
		}
		else
		{
			return false;
		}

		return true;
	}

	
	protected static void serializeString( string aString, StringBuilder builder )
	{
		builder.Append( "\"" );

		char[] charArray = aString.ToCharArray();
		for( int i = 0; i < charArray.Length; i++ )
		{
			char c = charArray[i];
			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
			{
				int codepoint = Convert.ToInt32( c );
				if( ( codepoint >= 32 ) && ( codepoint