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