home *** CD-ROM | disk | FTP | other *** search
/ Computer Active 2010 August / CA08.iso / Multimedija / shufflr.air / ShufflrClient.swf / scripts / mx / utils / ObjectUtil.as < prev    next >
Encoding:
Text File  |  2010-06-23  |  27.6 KB  |  909 lines

  1. package mx.utils
  2. {
  3.    import flash.utils.ByteArray;
  4.    import flash.utils.Dictionary;
  5.    import flash.utils.getQualifiedClassName;
  6.    import flash.xml.XMLNode;
  7.    import mx.collections.IList;
  8.    import mx.core.mx_internal;
  9.    
  10.    use namespace mx_internal;
  11.    
  12.    public class ObjectUtil
  13.    {
  14.       mx_internal static const VERSION:String = "3.5.0.12683";
  15.       
  16.       private static var defaultToStringExcludes:Array = ["password","credentials"];
  17.       
  18.       private static var refCount:int = 0;
  19.       
  20.       private static var CLASS_INFO_CACHE:Object = {};
  21.       
  22.       public function ObjectUtil()
  23.       {
  24.          super();
  25.       }
  26.       
  27.       public static function isSimple(param1:Object) : Boolean
  28.       {
  29.          var _loc2_:* = typeof param1;
  30.          switch(_loc2_)
  31.          {
  32.             case "number":
  33.             case "string":
  34.             case "boolean":
  35.                return true;
  36.             case "object":
  37.                return param1 is Date || param1 is Array;
  38.             default:
  39.                return false;
  40.          }
  41.       }
  42.       
  43.       private static function internalToString(param1:Object, param2:int = 0, param3:Dictionary = null, param4:Array = null, param5:Array = null) : String
  44.       {
  45.          var str:String = null;
  46.          var classInfo:Object = null;
  47.          var properties:Array = null;
  48.          var isArray:Boolean = false;
  49.          var isDict:Boolean = false;
  50.          var prop:* = undefined;
  51.          var j:int = 0;
  52.          var id:Object = null;
  53.          var value:Object = param1;
  54.          var indent:int = param2;
  55.          var refs:Dictionary = param3;
  56.          var namespaceURIs:Array = param4;
  57.          var exclude:Array = param5;
  58.          var type:String = value == null ? "null" : typeof value;
  59.          switch(type)
  60.          {
  61.             case "boolean":
  62.             case "number":
  63.                return value.toString();
  64.             case "string":
  65.                return "\"" + value.toString() + "\"";
  66.             case "object":
  67.                if(value is Date)
  68.                {
  69.                   return value.toString();
  70.                }
  71.                if(value is XMLNode)
  72.                {
  73.                   return value.toString();
  74.                }
  75.                if(value is Class)
  76.                {
  77.                   return "(" + getQualifiedClassName(value) + ")";
  78.                }
  79.                classInfo = getClassInfo(value,exclude,{
  80.                   "includeReadOnly":true,
  81.                   "uris":namespaceURIs
  82.                });
  83.                properties = classInfo.properties;
  84.                str = "(" + classInfo.name + ")";
  85.                if(refs == null)
  86.                {
  87.                   refs = new Dictionary(true);
  88.                }
  89.                try
  90.                {
  91.                   id = refs[value];
  92.                   if(id != null)
  93.                   {
  94.                      str += "#" + int(id);
  95.                      return str;
  96.                   }
  97.                }
  98.                catch(e:Error)
  99.                {
  100.                   return String(value);
  101.                }
  102.                if(value != null)
  103.                {
  104.                   str += "#" + refCount.toString();
  105.                   refs[value] = refCount;
  106.                   ++refCount;
  107.                }
  108.                isArray = value is Array;
  109.                isDict = value is Dictionary;
  110.                indent += 2;
  111.                j = 0;
  112.                while(j < properties.length)
  113.                {
  114.                   str = newline(str,indent);
  115.                   prop = properties[j];
  116.                   if(isArray)
  117.                   {
  118.                      str += "[";
  119.                   }
  120.                   else if(isDict)
  121.                   {
  122.                      str += "{";
  123.                   }
  124.                   if(isDict)
  125.                   {
  126.                      str += internalToString(prop,indent,refs,namespaceURIs,exclude);
  127.                   }
  128.                   else
  129.                   {
  130.                      str += prop.toString();
  131.                   }
  132.                   if(isArray)
  133.                   {
  134.                      str += "] ";
  135.                   }
  136.                   else if(isDict)
  137.                   {
  138.                      str += "} = ";
  139.                   }
  140.                   else
  141.                   {
  142.                      str += " = ";
  143.                   }
  144.                   try
  145.                   {
  146.                      str += internalToString(value[prop],indent,refs,namespaceURIs,exclude);
  147.                   }
  148.                   catch(e:Error)
  149.                   {
  150.                      str += "?";
  151.                   }
  152.                   j++;
  153.                }
  154.                indent -= 2;
  155.                return str;
  156.                break;
  157.             case "xml":
  158.                return value.toXMLString();
  159.             default:
  160.                return "(" + type + ")";
  161.          }
  162.       }
  163.       
  164.       public static function getClassInfo(param1:Object, param2:Array = null, param3:Object = null) : Object
  165.       {
  166.          var isDict:Boolean;
  167.          var excludeObject:Object;
  168.          var dynamic:Boolean;
  169.          var isArray:Boolean;
  170.          var propertyNames:Array;
  171.          var n:int = 0;
  172.          var i:int = 0;
  173.          var result:Object = null;
  174.          var cacheKey:String = null;
  175.          var className:String = null;
  176.          var classAlias:String = null;
  177.          var properties:XMLList = null;
  178.          var prop:XML = null;
  179.          var metadataInfo:Object = null;
  180.          var classInfo:XML = null;
  181.          var numericIndex:Boolean = false;
  182.          var key:* = undefined;
  183.          var p:String = null;
  184.          var pi:Number = NaN;
  185.          var uris:Array = null;
  186.          var uri:String = null;
  187.          var qName:QName = null;
  188.          var j:int = 0;
  189.          var obj:Object = param1;
  190.          var excludes:Array = param2;
  191.          var options:Object = param3;
  192.          if(obj is ObjectProxy)
  193.          {
  194.             obj = ObjectProxy(obj).object_proxy::object;
  195.          }
  196.          if(options == null)
  197.          {
  198.             options = {
  199.                "includeReadOnly":true,
  200.                "uris":null,
  201.                "includeTransient":true
  202.             };
  203.          }
  204.          propertyNames = [];
  205.          dynamic = false;
  206.          if(typeof obj == "xml")
  207.          {
  208.             className = "XML";
  209.             properties = obj.text();
  210.             if(properties.length())
  211.             {
  212.                propertyNames.push("*");
  213.             }
  214.             properties = obj.attributes();
  215.          }
  216.          else
  217.          {
  218.             classInfo = DescribeTypeCache.describeType(obj).typeDescription;
  219.             className = classInfo.@name.toString();
  220.             classAlias = classInfo.@alias.toString();
  221.             dynamic = classInfo.@isDynamic.toString() == "true";
  222.             if(options.includeReadOnly)
  223.             {
  224.                properties = classInfo..accessor.(@access != "writeonly") + classInfo..variable;
  225.             }
  226.             else
  227.             {
  228.                properties = classInfo..accessor.(@access == "readwrite") + classInfo..variable;
  229.             }
  230.             numericIndex = false;
  231.          }
  232.          if(!dynamic)
  233.          {
  234.             cacheKey = getCacheKey(obj,excludes,options);
  235.             result = CLASS_INFO_CACHE[cacheKey];
  236.             if(result != null)
  237.             {
  238.                return result;
  239.             }
  240.          }
  241.          result = {};
  242.          result["name"] = className;
  243.          result["alias"] = classAlias;
  244.          result["properties"] = propertyNames;
  245.          result["dynamic"] = dynamic;
  246.          result["metadata"] = metadataInfo = recordMetadata(properties);
  247.          excludeObject = {};
  248.          if(excludes)
  249.          {
  250.             n = int(excludes.length);
  251.             i = 0;
  252.             while(i < n)
  253.             {
  254.                excludeObject[excludes[i]] = 1;
  255.                i++;
  256.             }
  257.          }
  258.          isArray = className == "Array";
  259.          isDict = className == "flash.utils::Dictionary";
  260.          if(isDict)
  261.          {
  262.             for(key in obj)
  263.             {
  264.                propertyNames.push(key);
  265.             }
  266.          }
  267.          else if(dynamic)
  268.          {
  269.             for(p in obj)
  270.             {
  271.                if(excludeObject[p] != 1)
  272.                {
  273.                   if(isArray)
  274.                   {
  275.                      pi = parseInt(p);
  276.                      if(isNaN(pi))
  277.                      {
  278.                         propertyNames.push(new QName("",p));
  279.                      }
  280.                      else
  281.                      {
  282.                         propertyNames.push(pi);
  283.                      }
  284.                   }
  285.                   else
  286.                   {
  287.                      propertyNames.push(new QName("",p));
  288.                   }
  289.                }
  290.             }
  291.             numericIndex = isArray && !isNaN(Number(p));
  292.          }
  293.          if(!(isArray || isDict || className == "Object"))
  294.          {
  295.             if(className == "XML")
  296.             {
  297.                n = int(properties.length());
  298.                i = 0;
  299.                while(i < n)
  300.                {
  301.                   p = properties[i].name();
  302.                   if(excludeObject[p] != 1)
  303.                   {
  304.                      propertyNames.push(new QName("","@" + p));
  305.                   }
  306.                   i++;
  307.                }
  308.             }
  309.             else
  310.             {
  311.                n = int(properties.length());
  312.                uris = options.uris;
  313.                i = 0;
  314.                for(; i < n; i++)
  315.                {
  316.                   prop = properties[i];
  317.                   p = prop.@name.toString();
  318.                   uri = prop.@uri.toString();
  319.                   if(excludeObject[p] != 1)
  320.                   {
  321.                      if(!(!options.includeTransient && internalHasMetadata(metadataInfo,p,"Transient")))
  322.                      {
  323.                         if(uris != null)
  324.                         {
  325.                            if(uris.length == 1 && uris[0] == "*")
  326.                            {
  327.                               qName = new QName(uri,p);
  328.                               try
  329.                               {
  330.                                  obj[qName];
  331.                                  propertyNames.push();
  332.                               }
  333.                               catch(e:Error)
  334.                               {
  335.                               }
  336.                            }
  337.                            else
  338.                            {
  339.                               j = 0;
  340.                               while(j < uris.length)
  341.                               {
  342.                                  uri = uris[j];
  343.                                  if(prop.@uri.toString() == uri)
  344.                                  {
  345.                                     qName = new QName(uri,p);
  346.                                     try
  347.                                     {
  348.                                        obj[qName];
  349.                                        propertyNames.push(qName);
  350.                                     }
  351.                                     catch(e:Error)
  352.                                     {
  353.                                     }
  354.                                  }
  355.                                  j++;
  356.                               }
  357.                            }
  358.                         }
  359.                         else if(uri.length == 0)
  360.                         {
  361.                            qName = new QName(uri,p);
  362.                            try
  363.                            {
  364.                               obj[qName];
  365.                               propertyNames.push(qName);
  366.                            }
  367.                            catch(e:Error)
  368.                            {
  369.                            }
  370.                            continue;
  371.                         }
  372.                      }
  373.                   }
  374.                }
  375.             }
  376.          }
  377.          propertyNames.sort(Array.CASEINSENSITIVE | (numericIndex ? Array.NUMERIC : 0));
  378.          if(!isDict)
  379.          {
  380.             i = 0;
  381.             while(i < propertyNames.length - 1)
  382.             {
  383.                if(propertyNames[i].toString() == propertyNames[i + 1].toString())
  384.                {
  385.                   propertyNames.splice(i,1);
  386.                   i--;
  387.                }
  388.                i++;
  389.             }
  390.          }
  391.          if(!dynamic)
  392.          {
  393.             cacheKey = getCacheKey(obj,excludes,options);
  394.             CLASS_INFO_CACHE[cacheKey] = result;
  395.          }
  396.          return result;
  397.       }
  398.       
  399.       private static function arrayCompare(param1:Array, param2:Array, param3:int, param4:int, param5:Dictionary) : int
  400.       {
  401.          var _loc7_:Object = null;
  402.          var _loc6_:int = 0;
  403.          if(param1.length != param2.length)
  404.          {
  405.             if(param1.length < param2.length)
  406.             {
  407.                _loc6_ = -1;
  408.             }
  409.             else
  410.             {
  411.                _loc6_ = 1;
  412.             }
  413.          }
  414.          else
  415.          {
  416.             for(_loc7_ in param1)
  417.             {
  418.                if(!param2.hasOwnProperty(_loc7_))
  419.                {
  420.                   return -1;
  421.                }
  422.                _loc6_ = internalCompare(param1[_loc7_],param2[_loc7_],param3,param4,param5);
  423.                if(_loc6_ != 0)
  424.                {
  425.                   return _loc6_;
  426.                }
  427.             }
  428.             for(_loc7_ in param2)
  429.             {
  430.                if(!param1.hasOwnProperty(_loc7_))
  431.                {
  432.                   return 1;
  433.                }
  434.             }
  435.          }
  436.          return _loc6_;
  437.       }
  438.       
  439.       public static function stringCompare(param1:String, param2:String, param3:Boolean = false) : int
  440.       {
  441.          if(param1 == null && param2 == null)
  442.          {
  443.             return 0;
  444.          }
  445.          if(param1 == null)
  446.          {
  447.             return 1;
  448.          }
  449.          if(param2 == null)
  450.          {
  451.             return -1;
  452.          }
  453.          if(param3)
  454.          {
  455.             param1 = param1.toLocaleLowerCase();
  456.             param2 = param2.toLocaleLowerCase();
  457.          }
  458.          var _loc4_:int = int(param1.localeCompare(param2));
  459.          if(_loc4_ < -1)
  460.          {
  461.             _loc4_ = -1;
  462.          }
  463.          else if(_loc4_ > 1)
  464.          {
  465.             _loc4_ = 1;
  466.          }
  467.          return _loc4_;
  468.       }
  469.       
  470.       public static function dateCompare(param1:Date, param2:Date) : int
  471.       {
  472.          if(param1 == null && param2 == null)
  473.          {
  474.             return 0;
  475.          }
  476.          if(param1 == null)
  477.          {
  478.             return 1;
  479.          }
  480.          if(param2 == null)
  481.          {
  482.             return -1;
  483.          }
  484.          var _loc3_:Number = Number(param1.getTime());
  485.          var _loc4_:Number = Number(param2.getTime());
  486.          if(_loc3_ < _loc4_)
  487.          {
  488.             return -1;
  489.          }
  490.          if(_loc3_ > _loc4_)
  491.          {
  492.             return 1;
  493.          }
  494.          return 0;
  495.       }
  496.       
  497.       public static function numericCompare(param1:Number, param2:Number) : int
  498.       {
  499.          if(isNaN(param1) && isNaN(param2))
  500.          {
  501.             return 0;
  502.          }
  503.          if(isNaN(param1))
  504.          {
  505.             return 1;
  506.          }
  507.          if(isNaN(param2))
  508.          {
  509.             return -1;
  510.          }
  511.          if(param1 < param2)
  512.          {
  513.             return -1;
  514.          }
  515.          if(param1 > param2)
  516.          {
  517.             return 1;
  518.          }
  519.          return 0;
  520.       }
  521.       
  522.       private static function newline(param1:String, param2:int = 0) : String
  523.       {
  524.          var _loc3_:* = param1;
  525.          _loc3_ += "\n";
  526.          var _loc4_:int = 0;
  527.          while(_loc4_ < param2)
  528.          {
  529.             _loc3_ += " ";
  530.             _loc4_++;
  531.          }
  532.          return _loc3_;
  533.       }
  534.       
  535.       private static function getRef(param1:Object, param2:Dictionary) : Object
  536.       {
  537.          var _loc3_:Object = param2[param1];
  538.          while(Boolean(_loc3_) && _loc3_ != param2[_loc3_])
  539.          {
  540.             _loc3_ = param2[_loc3_];
  541.          }
  542.          if(!_loc3_)
  543.          {
  544.             _loc3_ = param1;
  545.          }
  546.          if(_loc3_ != param2[param1])
  547.          {
  548.             param2[param1] = _loc3_;
  549.          }
  550.          return _loc3_;
  551.       }
  552.       
  553.       private static function recordMetadata(param1:XMLList) : Object
  554.       {
  555.          var prop:XML = null;
  556.          var propName:String = null;
  557.          var metadataList:XMLList = null;
  558.          var metadata:Object = null;
  559.          var md:XML = null;
  560.          var mdName:String = null;
  561.          var argsList:XMLList = null;
  562.          var value:Object = null;
  563.          var arg:XML = null;
  564.          var existing:Object = null;
  565.          var argKey:String = null;
  566.          var argValue:String = null;
  567.          var existingArray:Array = null;
  568.          var properties:XMLList = param1;
  569.          var result:Object = null;
  570.          try
  571.          {
  572.             for each(prop in properties)
  573.             {
  574.                propName = prop.attribute("name").toString();
  575.                metadataList = prop.metadata;
  576.                if(metadataList.length() > 0)
  577.                {
  578.                   if(result == null)
  579.                   {
  580.                      result = {};
  581.                   }
  582.                   metadata = {};
  583.                   result[propName] = metadata;
  584.                   for each(md in metadataList)
  585.                   {
  586.                      mdName = md.attribute("name").toString();
  587.                      argsList = md.arg;
  588.                      value = {};
  589.                      for each(arg in argsList)
  590.                      {
  591.                         argKey = arg.attribute("key").toString();
  592.                         if(argKey != null)
  593.                         {
  594.                            argValue = arg.attribute("value").toString();
  595.                            value[argKey] = argValue;
  596.                         }
  597.                      }
  598.                      existing = metadata[mdName];
  599.                      if(existing != null)
  600.                      {
  601.                         if(existing is Array)
  602.                         {
  603.                            existingArray = existing as Array;
  604.                         }
  605.                         else
  606.                         {
  607.                            existingArray = [existing];
  608.                            delete metadata[mdName];
  609.                         }
  610.                         existingArray.push(value);
  611.                         existing = existingArray;
  612.                      }
  613.                      else
  614.                      {
  615.                         existing = value;
  616.                      }
  617.                      metadata[mdName] = existing;
  618.                   }
  619.                }
  620.             }
  621.          }
  622.          catch(e:Error)
  623.          {
  624.          }
  625.          return result;
  626.       }
  627.       
  628.       public static function compare(param1:Object, param2:Object, param3:int = -1) : int
  629.       {
  630.          return internalCompare(param1,param2,0,param3,new Dictionary(true));
  631.       }
  632.       
  633.       private static function listCompare(param1:IList, param2:IList, param3:int, param4:int, param5:Dictionary) : int
  634.       {
  635.          var _loc7_:int = 0;
  636.          var _loc6_:int = 0;
  637.          if(param1.length != param2.length)
  638.          {
  639.             if(param1.length < param2.length)
  640.             {
  641.                _loc6_ = -1;
  642.             }
  643.             else
  644.             {
  645.                _loc6_ = 1;
  646.             }
  647.          }
  648.          else
  649.          {
  650.             _loc7_ = 0;
  651.             while(_loc7_ < param1.length)
  652.             {
  653.                _loc6_ = internalCompare(param1.getItemAt(_loc7_),param2.getItemAt(_loc7_),param3 + 1,param4,param5);
  654.                if(_loc6_ != 0)
  655.                {
  656.                   _loc7_ = param1.length;
  657.                }
  658.                _loc7_++;
  659.             }
  660.          }
  661.          return _loc6_;
  662.       }
  663.       
  664.       private static function internalCompare(param1:Object, param2:Object, param3:int, param4:int, param5:Dictionary) : int
  665.       {
  666.          var result:int;
  667.          var typeOfA:String;
  668.          var typeOfB:String;
  669.          var newDepth:int = 0;
  670.          var aRef:Object = null;
  671.          var bRef:Object = null;
  672.          var aProps:Array = null;
  673.          var bProps:Array = null;
  674.          var isDynamicObject:Boolean = false;
  675.          var propName:QName = null;
  676.          var aProp:Object = null;
  677.          var bProp:Object = null;
  678.          var i:int = 0;
  679.          var a:Object = param1;
  680.          var b:Object = param2;
  681.          var currentDepth:int = param3;
  682.          var desiredDepth:int = param4;
  683.          var refs:Dictionary = param5;
  684.          if(a == null && b == null)
  685.          {
  686.             return 0;
  687.          }
  688.          if(a == null)
  689.          {
  690.             return 1;
  691.          }
  692.          if(b == null)
  693.          {
  694.             return -1;
  695.          }
  696.          if(a is ObjectProxy)
  697.          {
  698.             a = ObjectProxy(a).object_proxy::object;
  699.          }
  700.          if(b is ObjectProxy)
  701.          {
  702.             b = ObjectProxy(b).object_proxy::object;
  703.          }
  704.          typeOfA = typeof a;
  705.          typeOfB = typeof b;
  706.          result = 0;
  707.          if(typeOfA == typeOfB)
  708.          {
  709.             switch(typeOfA)
  710.             {
  711.                case "boolean":
  712.                   result = numericCompare(Number(a),Number(b));
  713.                   break;
  714.                case "number":
  715.                   result = numericCompare(a as Number,b as Number);
  716.                   break;
  717.                case "string":
  718.                   result = stringCompare(a as String,b as String);
  719.                   break;
  720.                case "object":
  721.                   newDepth = desiredDepth > 0 ? desiredDepth - 1 : desiredDepth;
  722.                   aRef = getRef(a,refs);
  723.                   bRef = getRef(b,refs);
  724.                   if(aRef == bRef)
  725.                   {
  726.                      return 0;
  727.                   }
  728.                   refs[bRef] = aRef;
  729.                   if(desiredDepth != -1 && currentDepth > desiredDepth)
  730.                   {
  731.                      result = stringCompare(a.toString(),b.toString());
  732.                   }
  733.                   else if(a is Array && b is Array)
  734.                   {
  735.                      result = arrayCompare(a as Array,b as Array,currentDepth,desiredDepth,refs);
  736.                   }
  737.                   else if(a is Date && b is Date)
  738.                   {
  739.                      result = dateCompare(a as Date,b as Date);
  740.                   }
  741.                   else if(a is IList && b is IList)
  742.                   {
  743.                      result = listCompare(a as IList,b as IList,currentDepth,desiredDepth,refs);
  744.                   }
  745.                   else if(a is ByteArray && b is ByteArray)
  746.                   {
  747.                      result = byteArrayCompare(a as ByteArray,b as ByteArray);
  748.                   }
  749.                   else
  750.                   {
  751.                      if(getQualifiedClassName(a) != getQualifiedClassName(b))
  752.                      {
  753.                         return 1;
  754.                      }
  755.                      aProps = getClassInfo(a).properties;
  756.                      isDynamicObject = true;
  757.                      try
  758.                      {
  759.                         a["wootHackwoot"];
  760.                      }
  761.                      catch(e:Error)
  762.                      {
  763.                         isDynamicObject = false;
  764.                      }
  765.                      if(isDynamicObject)
  766.                      {
  767.                         bProps = getClassInfo(b).properties;
  768.                         result = arrayCompare(aProps,bProps,currentDepth,newDepth,refs);
  769.                         if(result != 0)
  770.                         {
  771.                            return result;
  772.                         }
  773.                      }
  774.                      i = 0;
  775.                      while(i < aProps.length)
  776.                      {
  777.                         propName = aProps[i];
  778.                         aProp = a[propName];
  779.                         bProp = b[propName];
  780.                         result = internalCompare(aProp,bProp,currentDepth + 1,newDepth,refs);
  781.                         if(result != 0)
  782.                         {
  783.                            return result;
  784.                         }
  785.                         i++;
  786.                      }
  787.                   }
  788.                   break;
  789.             }
  790.             return result;
  791.          }
  792.          return stringCompare(typeOfA,typeOfB);
  793.       }
  794.       
  795.       public static function hasMetadata(param1:Object, param2:String, param3:String, param4:Array = null, param5:Object = null) : Boolean
  796.       {
  797.          var _loc6_:Object = getClassInfo(param1,param4,param5);
  798.          var _loc7_:Object = _loc6_["metadata"];
  799.          return internalHasMetadata(_loc7_,param2,param3);
  800.       }
  801.       
  802.       private static function internalHasMetadata(param1:Object, param2:String, param3:String) : Boolean
  803.       {
  804.          var _loc4_:Object = null;
  805.          if(param1 != null)
  806.          {
  807.             _loc4_ = param1[param2];
  808.             if(_loc4_ != null)
  809.             {
  810.                if(_loc4_[param3] != null)
  811.                {
  812.                   return true;
  813.                }
  814.             }
  815.          }
  816.          return false;
  817.       }
  818.       
  819.       public static function toString(param1:Object, param2:Array = null, param3:Array = null) : String
  820.       {
  821.          if(param3 == null)
  822.          {
  823.             param3 = defaultToStringExcludes;
  824.          }
  825.          refCount = 0;
  826.          return internalToString(param1,0,null,param2,param3);
  827.       }
  828.       
  829.       private static function byteArrayCompare(param1:ByteArray, param2:ByteArray) : int
  830.       {
  831.          var _loc4_:int = 0;
  832.          var _loc3_:int = 0;
  833.          if(param1 == param2)
  834.          {
  835.             return _loc3_;
  836.          }
  837.          if(param1.length != param2.length)
  838.          {
  839.             if(param1.length < param2.length)
  840.             {
  841.                _loc3_ = -1;
  842.             }
  843.             else
  844.             {
  845.                _loc3_ = 1;
  846.             }
  847.          }
  848.          else
  849.          {
  850.             _loc4_ = 0;
  851.             while(_loc4_ < param1.length)
  852.             {
  853.                _loc3_ = numericCompare(param1[_loc4_],param2[_loc4_]);
  854.                if(_loc3_ != 0)
  855.                {
  856.                   _loc4_ = int(param1.length);
  857.                }
  858.                _loc4_++;
  859.             }
  860.          }
  861.          return _loc3_;
  862.       }
  863.       
  864.       public static function copy(param1:Object) : Object
  865.       {
  866.          var _loc2_:ByteArray = new ByteArray();
  867.          _loc2_.writeObject(param1);
  868.          _loc2_.position = 0;
  869.          return _loc2_.readObject();
  870.       }
  871.       
  872.       private static function getCacheKey(param1:Object, param2:Array = null, param3:Object = null) : String
  873.       {
  874.          var _loc5_:uint = 0;
  875.          var _loc6_:String = null;
  876.          var _loc7_:String = null;
  877.          var _loc8_:String = null;
  878.          var _loc4_:String = getQualifiedClassName(param1);
  879.          if(param2 != null)
  880.          {
  881.             _loc5_ = 0;
  882.             while(_loc5_ < param2.length)
  883.             {
  884.                _loc6_ = param2[_loc5_] as String;
  885.                if(_loc6_ != null)
  886.                {
  887.                   _loc4_ += _loc6_;
  888.                }
  889.                _loc5_++;
  890.             }
  891.          }
  892.          if(param3 != null)
  893.          {
  894.             for(_loc7_ in param3)
  895.             {
  896.                _loc4_ += _loc7_;
  897.                _loc8_ = param3[_loc7_] as String;
  898.                if(_loc8_ != null)
  899.                {
  900.                   _loc4_ += _loc8_;
  901.                }
  902.             }
  903.          }
  904.          return _loc4_;
  905.       }
  906.    }
  907. }
  908.  
  909.