You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
478 lines
9.2 KiB
478 lines
9.2 KiB
/*
|
|
JavaScriptSerializer.as
|
|
|
|
Part of the Flash / JavaScript Integration Kit
|
|
http://www.macromedia.com/go/flashjavascript
|
|
|
|
Created by:
|
|
|
|
Mike Chambers
|
|
http://weblogs.macromedia.com/mesh/
|
|
mesh@macromedia.com
|
|
|
|
Christian Cantrell
|
|
http://weblogs.macromedia.com/cantrell/
|
|
cantrell@macromedia.com
|
|
|
|
----
|
|
Macromedia(r) Flash(r)./ JavaScript Integration Kit License
|
|
|
|
|
|
Copyright (c) 2005 Macromedia, inc. All rights reserved.
|
|
|
|
Redistribution and use in source and binary forms, with or without modification,
|
|
are permitted provided that the following conditions are met:
|
|
|
|
1. Redistributions of source code must retain the above copyright notice, this
|
|
list of conditions and the following disclaimer.
|
|
|
|
2. Redistributions in binary form must reproduce the above copyright notice,
|
|
this list of conditions and the following disclaimer in the documentation and/or
|
|
other materials provided with the distribution.
|
|
|
|
3. The end-user documentation included with the redistribution, if any, must
|
|
include the following acknowledgment:
|
|
|
|
"This product includes software developed by Macromedia, Inc.
|
|
(http://www.macromedia.com)."
|
|
|
|
Alternately, this acknowledgment may appear in the software itself, if and
|
|
wherever such third-party acknowledgments normally appear.
|
|
|
|
4. The name Macromedia must not be used to endorse or promote products derived
|
|
from this software without prior written permission. For written permission,
|
|
please contact devrelations@macromedia.com.
|
|
|
|
5. Products derived from this software may not be called "Macromedia" or
|
|
“Macromedia Flash”, nor may "Macromedia" or “Macromedia Flash” appear in their
|
|
name.
|
|
|
|
THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED WARRANTIES,
|
|
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
|
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL MACROMEDIA OR
|
|
ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
|
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
|
|
OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
|
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
|
|
DAMAGE.
|
|
|
|
*/
|
|
|
|
class com.macromedia.javascript.JavaScriptSerializer
|
|
{
|
|
|
|
/**************** Serialization Methods ****************/
|
|
|
|
/*
|
|
Static function that serializes any supported data types.
|
|
|
|
Returns a String
|
|
*/
|
|
public static function serializeItem(item:Object):String
|
|
{
|
|
var type:String = typeof(item);
|
|
var out:String;
|
|
|
|
switch (type)
|
|
{
|
|
case "string":
|
|
{
|
|
out = JavaScriptSerializer.serializeString(String(item));
|
|
break;
|
|
}
|
|
case "number":
|
|
{
|
|
out = JavaScriptSerializer.serializeNumber(Number(item));
|
|
break;
|
|
}
|
|
case "boolean":
|
|
{
|
|
out = JavaScriptSerializer.serializeBoolean(Boolean(item));
|
|
break;
|
|
}
|
|
case "null":
|
|
{
|
|
out = JavaScriptSerializer.serializeNull();
|
|
break;
|
|
}
|
|
case "undefined":
|
|
{
|
|
out = JavaScriptSerializer.serializeUndefined();
|
|
break;
|
|
}
|
|
case "object":
|
|
{
|
|
if(item instanceof Date)
|
|
{
|
|
out = JavaScriptSerializer.serializeDate(new Date(item.getTime()));
|
|
}
|
|
else if(item instanceof Array)
|
|
{
|
|
out = JavaScriptSerializer.serializeArray(item);
|
|
}
|
|
else
|
|
{
|
|
//treat it as regular Object
|
|
out = JavaScriptSerializer.serializeObject(item);
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
return out;
|
|
|
|
}
|
|
|
|
/* Serializes an Object */
|
|
public static function serializeObject(o:Object):String
|
|
{
|
|
var sb:String = "{";
|
|
|
|
for(var x:String in o)
|
|
{
|
|
|
|
//dont include functions
|
|
if(typeof(x[o]) == "function")
|
|
{
|
|
continue;
|
|
}
|
|
|
|
sb += x + ":" + serializeItem(o[x]) + ",";
|
|
}
|
|
|
|
//remove the trailing ","
|
|
if(sb.substring(sb.length - 1) == ",")
|
|
{
|
|
sb = sb.substring(0, sb.length - 1);
|
|
}
|
|
|
|
sb += "}";
|
|
|
|
return sb;
|
|
}
|
|
|
|
/* Serializes an Array */
|
|
//not typed since I can't cast an object to Array
|
|
public static function serializeArray(o):String
|
|
{
|
|
var len:Number = o.length;
|
|
|
|
var sb:String = "[";
|
|
|
|
for(var i:Number = 0; i < len; i++)
|
|
{
|
|
sb += serializeItem(o[i]);
|
|
|
|
if(i != len - 1)
|
|
{
|
|
sb += ",";
|
|
}
|
|
}
|
|
|
|
sb += "]";
|
|
|
|
return sb;
|
|
}
|
|
|
|
/* Serializes a String */
|
|
public static function serializeString(s:String):String
|
|
{
|
|
return "'" + s + "'";
|
|
}
|
|
|
|
/* Serializes a Number */
|
|
public static function serializeNumber(n:Number):String
|
|
{
|
|
return String(n);
|
|
}
|
|
|
|
/* Serializes a Boolean value */
|
|
public static function serializeBoolean(b:Boolean):String
|
|
{
|
|
return String(b);
|
|
}
|
|
|
|
/* Serializes undefined */
|
|
public static function serializeUndefined(Void):String
|
|
{
|
|
return "undefined";
|
|
}
|
|
|
|
/* Serializes null */
|
|
public static function serializeNull(Void):String
|
|
{
|
|
return "null";
|
|
}
|
|
|
|
/* Serializes a Date */
|
|
public static function serializeDate(d:Date):String
|
|
{
|
|
return "new Date(" + d.getTime() + ")";
|
|
}
|
|
|
|
|
|
/**************** De-Serialization Methods ****************/
|
|
|
|
/*
|
|
Static function that de-serializes any supported data types.
|
|
|
|
Returns a String
|
|
*/
|
|
public static function deserializeItem(type:String, data:String):Object
|
|
{
|
|
var out:Object;
|
|
|
|
switch (type)
|
|
{
|
|
case "str":
|
|
{
|
|
out = JavaScriptSerializer.deserializeString(data);
|
|
break;
|
|
}
|
|
case "num":
|
|
{
|
|
out = JavaScriptSerializer.deserializeNumber(data);
|
|
break;
|
|
}
|
|
case "bool":
|
|
{
|
|
out = JavaScriptSerializer.deserializeBoolean(data);
|
|
break;
|
|
}
|
|
case "null":
|
|
{
|
|
out = JavaScriptSerializer.deserializeNull();
|
|
break;
|
|
}
|
|
case "undf":
|
|
{
|
|
out = JavaScriptSerializer.deserializeUndefined();
|
|
break;
|
|
}
|
|
case "date":
|
|
{
|
|
out = JavaScriptSerializer.deserializeDate(data);
|
|
|
|
break;
|
|
}
|
|
case "xser":
|
|
{
|
|
out = JavaScriptSerializer.deserializeXMLSerializedItem(data);
|
|
|
|
trace(data);
|
|
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
return out;
|
|
}
|
|
|
|
/* Deserializes a String */
|
|
public static function deserializeString(s:String):String
|
|
{
|
|
return s;
|
|
}
|
|
|
|
/* Deserializes a Number */
|
|
public static function deserializeNumber(s:String):Number
|
|
{
|
|
return Number(s);
|
|
}
|
|
|
|
/* Deserializes a Boolean Value */
|
|
public static function deserializeBoolean(s:String):String
|
|
{
|
|
return Boolean(s);
|
|
}
|
|
|
|
/* Deserializes undefined */
|
|
//returns undefined
|
|
public static function deserializeUndefined(s:String)
|
|
{
|
|
return undefined;
|
|
}
|
|
|
|
/* Deserializes null */
|
|
//returns null
|
|
public static function deserializeNull(s:String)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/* Deserializes a Date */
|
|
public static function deserializeDate(s:String):Date
|
|
{
|
|
return new Date(Number(s));
|
|
}
|
|
|
|
|
|
/**************** De-Serialization XML Methods ****************/
|
|
|
|
/*
|
|
The methods below are for deserializing data serialized in XML format.
|
|
|
|
This is used for serializing Objects and Arrays
|
|
*/
|
|
|
|
|
|
/*
|
|
Static function that de-serializes any supported XML serialized data types.
|
|
|
|
Returns a String
|
|
*/
|
|
public static function deserializeXMLSerializedItem(data:String):Object
|
|
{
|
|
var x:XML = new XML();
|
|
x.ignoreWhite = true;
|
|
x.parseXML(data);
|
|
|
|
var out:Object = parseNode(x.firstChild.firstChild, new Object);
|
|
|
|
return out;
|
|
}
|
|
|
|
/* recursive function that parses the xml tree */
|
|
public static function parseNode(x:XMLNode, o:Object):Object
|
|
{
|
|
|
|
var nodeName:String = x.nodeName;
|
|
var nodeValue:String = x.firstChild.nodeValue;
|
|
var varName:String = x.attributes["name"];
|
|
|
|
var children:Array = x.childNodes;
|
|
var len:Number = children.length;
|
|
|
|
switch(nodeName)
|
|
{
|
|
case "obj":
|
|
{
|
|
if(varName == null)
|
|
{
|
|
o = new Object();
|
|
}
|
|
else
|
|
{
|
|
o[varName] = new Object();
|
|
}
|
|
break;
|
|
}
|
|
case "str":
|
|
{
|
|
if(varName == undefined)
|
|
{
|
|
o = String(nodeValue);
|
|
}
|
|
else
|
|
{
|
|
o[varName] = nodeValue;
|
|
}
|
|
|
|
break;
|
|
}
|
|
case "num":
|
|
{
|
|
if(varName == null)
|
|
{
|
|
o = Number(nodeValue);
|
|
}
|
|
else
|
|
{
|
|
o[varName] = Number(nodeValue);
|
|
}
|
|
|
|
break;
|
|
}
|
|
case "bool":
|
|
{
|
|
if(varName == null)
|
|
{
|
|
o = Boolean(nodeValue);
|
|
}
|
|
else
|
|
{
|
|
o[varName] = Boolean(nodeValue);
|
|
}
|
|
|
|
break;
|
|
}
|
|
case "null":
|
|
{
|
|
if(varName == null)
|
|
{
|
|
o = null;
|
|
}
|
|
else
|
|
{
|
|
o[varName] = null;
|
|
}
|
|
|
|
break;
|
|
}
|
|
case "undf":
|
|
{
|
|
if(varName == null)
|
|
{
|
|
o = undefined;
|
|
}
|
|
else
|
|
{
|
|
o[varName] = undefined;
|
|
}
|
|
|
|
break;
|
|
}
|
|
case "date":
|
|
{
|
|
if(varName == null)
|
|
{
|
|
o = new Date(Number(nodeValue));
|
|
}
|
|
else
|
|
{
|
|
o[varName] = new Date(Number(nodeValue));
|
|
}
|
|
|
|
break;
|
|
}
|
|
case "array":
|
|
{
|
|
//this is not typed because the compiler gets confused about
|
|
//the explicit type change for o below.
|
|
var arr;
|
|
if(varName == null)
|
|
{
|
|
o = new Array();
|
|
arr = o;
|
|
}
|
|
else
|
|
{
|
|
o[varName] = new Array();
|
|
arr = o[varName];
|
|
}
|
|
|
|
for(var x:Number = 0; x < len; x++)
|
|
{
|
|
arr.push(parseNode(children[x], o));
|
|
}
|
|
|
|
return arr;
|
|
}
|
|
}
|
|
|
|
for(var i:Number = 0; i < len; i++)
|
|
{
|
|
parseNode(children[i], o);
|
|
}
|
|
|
|
|
|
return o;
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|