home *** CD-ROM | disk | FTP | other *** search
/ Computer Active 2010 August / CA08.iso / Multimedija / shufflr.air / ShufflrClient.swf / scripts / mx / utils / URLUtil.as < prev    next >
Encoding:
Text File  |  2010-06-23  |  13.1 KB  |  421 lines
  1. package mx.utils
  2. {
  3.    import mx.messaging.config.LoaderConfig;
  4.    
  5.    public class URLUtil
  6.    {
  7.       public static const SERVER_NAME_TOKEN:String = "{server.name}";
  8.       
  9.       public static const SERVER_PORT_TOKEN:String = "{server.port}";
  10.       
  11.       private static const SERVER_NAME_REGEX:RegExp = /\{server.name\}/g;
  12.       
  13.       private static const SERVER_PORT_REGEX:RegExp = /\{server.port\}/g;
  14.       
  15.       public function URLUtil()
  16.       {
  17.          super();
  18.       }
  19.       
  20.       public static function hasUnresolvableTokens() : Boolean
  21.       {
  22.          return LoaderConfig.url != null;
  23.       }
  24.       
  25.       public static function getServerName(param1:String) : String
  26.       {
  27.          var _loc2_:String = getServerNameWithPort(param1);
  28.          var _loc3_:int = int(_loc2_.indexOf("]"));
  29.          _loc3_ = _loc3_ > -1 ? int(_loc2_.indexOf(":",_loc3_)) : int(_loc2_.indexOf(":"));
  30.          if(_loc3_ > 0)
  31.          {
  32.             _loc2_ = _loc2_.substring(0,_loc3_);
  33.          }
  34.          return _loc2_;
  35.       }
  36.       
  37.       public static function isHttpsURL(param1:String) : Boolean
  38.       {
  39.          return param1 != null && param1.indexOf("https://") == 0;
  40.       }
  41.       
  42.       private static function internalObjectToString(param1:Object, param2:String, param3:String, param4:Boolean) : String
  43.       {
  44.          var _loc7_:String = null;
  45.          var _loc8_:Object = null;
  46.          var _loc9_:String = null;
  47.          var _loc5_:String = "";
  48.          var _loc6_:Boolean = true;
  49.          for(_loc7_ in param1)
  50.          {
  51.             if(_loc6_)
  52.             {
  53.                _loc6_ = false;
  54.             }
  55.             else
  56.             {
  57.                _loc5_ += param2;
  58.             }
  59.             _loc8_ = param1[_loc7_];
  60.             _loc9_ = !!param3 ? param3 + "." + _loc7_ : _loc7_;
  61.             if(param4)
  62.             {
  63.                _loc9_ = encodeURIComponent(_loc9_);
  64.             }
  65.             if(_loc8_ is String)
  66.             {
  67.                _loc5_ += _loc9_ + "=" + (param4 ? encodeURIComponent(_loc8_ as String) : _loc8_);
  68.             }
  69.             else if(_loc8_ is Number)
  70.             {
  71.                _loc8_ = _loc8_.toString();
  72.                if(param4)
  73.                {
  74.                   _loc8_ = encodeURIComponent(_loc8_ as String);
  75.                }
  76.                _loc5_ += _loc9_ + "=" + _loc8_;
  77.             }
  78.             else if(_loc8_ is Boolean)
  79.             {
  80.                _loc5_ += _loc9_ + "=" + (!!_loc8_ ? "true" : "false");
  81.             }
  82.             else if(_loc8_ is Array)
  83.             {
  84.                _loc5_ += internalArrayToString(_loc8_ as Array,param2,_loc9_,param4);
  85.             }
  86.             else
  87.             {
  88.                _loc5_ += internalObjectToString(_loc8_,param2,_loc9_,param4);
  89.             }
  90.          }
  91.          return _loc5_;
  92.       }
  93.       
  94.       public static function getFullURL(param1:String, param2:String) : String
  95.       {
  96.          var _loc3_:Number = NaN;
  97.          if(param2 != null && !URLUtil.isHttpURL(param2))
  98.          {
  99.             if(param2.indexOf("./") == 0)
  100.             {
  101.                param2 = param2.substring(2);
  102.             }
  103.             if(URLUtil.isHttpURL(param1))
  104.             {
  105.                if(param2.charAt(0) == "/")
  106.                {
  107.                   _loc3_ = Number(param1.indexOf("/",8));
  108.                   if(_loc3_ == -1)
  109.                   {
  110.                      _loc3_ = param1.length;
  111.                   }
  112.                }
  113.                else
  114.                {
  115.                   _loc3_ = param1.lastIndexOf("/") + 1;
  116.                   if(_loc3_ <= 8)
  117.                   {
  118.                      param1 += "/";
  119.                      _loc3_ = param1.length;
  120.                   }
  121.                }
  122.                if(_loc3_ > 0)
  123.                {
  124.                   param2 = param1.substring(0,_loc3_) + param2;
  125.                }
  126.             }
  127.          }
  128.          return param2;
  129.       }
  130.       
  131.       public static function getServerNameWithPort(param1:String) : String
  132.       {
  133.          var _loc2_:int = param1.indexOf("/") + 2;
  134.          var _loc3_:int = int(param1.indexOf("/",_loc2_));
  135.          return _loc3_ == -1 ? param1.substring(_loc2_) : param1.substring(_loc2_,_loc3_);
  136.       }
  137.       
  138.       public static function replaceProtocol(param1:String, param2:String) : String
  139.       {
  140.          return param1.replace(getProtocol(param1),param2);
  141.       }
  142.       
  143.       public static function urisEqual(param1:String, param2:String) : Boolean
  144.       {
  145.          if(param1 != null && param2 != null)
  146.          {
  147.             param1 = StringUtil.trim(param1).toLowerCase();
  148.             param2 = StringUtil.trim(param2).toLowerCase();
  149.             if(param1.charAt(param1.length - 1) != "/")
  150.             {
  151.                param1 += "/";
  152.             }
  153.             if(param2.charAt(param2.length - 1) != "/")
  154.             {
  155.                param2 += "/";
  156.             }
  157.          }
  158.          return param1 == param2;
  159.       }
  160.       
  161.       public static function getProtocol(param1:String) : String
  162.       {
  163.          var _loc2_:int = int(param1.indexOf("/"));
  164.          var _loc3_:int = int(param1.indexOf(":/"));
  165.          if(_loc3_ > -1 && _loc3_ < _loc2_)
  166.          {
  167.             return param1.substring(0,_loc3_);
  168.          }
  169.          _loc3_ = int(param1.indexOf("::"));
  170.          if(_loc3_ > -1 && _loc3_ < _loc2_)
  171.          {
  172.             return param1.substring(0,_loc3_);
  173.          }
  174.          return "";
  175.       }
  176.       
  177.       private static function internalArrayToString(param1:Array, param2:String, param3:String, param4:Boolean) : String
  178.       {
  179.          var _loc9_:Object = null;
  180.          var _loc10_:String = null;
  181.          var _loc5_:String = "";
  182.          var _loc6_:Boolean = true;
  183.          var _loc7_:int = int(param1.length);
  184.          var _loc8_:int = 0;
  185.          while(_loc8_ < _loc7_)
  186.          {
  187.             if(_loc6_)
  188.             {
  189.                _loc6_ = false;
  190.             }
  191.             else
  192.             {
  193.                _loc5_ += param2;
  194.             }
  195.             _loc9_ = param1[_loc8_];
  196.             _loc10_ = param3 + "." + _loc8_;
  197.             if(param4)
  198.             {
  199.                _loc10_ = encodeURIComponent(_loc10_);
  200.             }
  201.             if(_loc9_ is String)
  202.             {
  203.                _loc5_ += _loc10_ + "=" + (param4 ? encodeURIComponent(_loc9_ as String) : _loc9_);
  204.             }
  205.             else if(_loc9_ is Number)
  206.             {
  207.                _loc9_ = _loc9_.toString();
  208.                if(param4)
  209.                {
  210.                   _loc9_ = encodeURIComponent(_loc9_ as String);
  211.                }
  212.                _loc5_ += _loc10_ + "=" + _loc9_;
  213.             }
  214.             else if(_loc9_ is Boolean)
  215.             {
  216.                _loc5_ += _loc10_ + "=" + (!!_loc9_ ? "true" : "false");
  217.             }
  218.             else if(_loc9_ is Array)
  219.             {
  220.                _loc5_ += internalArrayToString(_loc9_ as Array,param2,_loc10_,param4);
  221.             }
  222.             else
  223.             {
  224.                _loc5_ += internalObjectToString(_loc9_,param2,_loc10_,param4);
  225.             }
  226.             _loc8_++;
  227.          }
  228.          return _loc5_;
  229.       }
  230.       
  231.       public static function objectToString(param1:Object, param2:String = ";", param3:Boolean = true) : String
  232.       {
  233.          return internalObjectToString(param1,param2,null,param3);
  234.       }
  235.       
  236.       public static function replaceTokens(param1:String) : String
  237.       {
  238.          var _loc4_:String = null;
  239.          var _loc5_:String = null;
  240.          var _loc6_:uint = 0;
  241.          var _loc2_:String = LoaderConfig.url == null ? "" : LoaderConfig.url;
  242.          if(param1.indexOf(SERVER_NAME_TOKEN) > 0)
  243.          {
  244.             _loc4_ = URLUtil.getProtocol(_loc2_);
  245.             _loc5_ = "localhost";
  246.             if(_loc4_.toLowerCase() != "file")
  247.             {
  248.                _loc5_ = URLUtil.getServerName(_loc2_);
  249.             }
  250.             param1 = param1.replace(SERVER_NAME_REGEX,_loc5_);
  251.          }
  252.          var _loc3_:int = int(param1.indexOf(SERVER_PORT_TOKEN));
  253.          if(_loc3_ > 0)
  254.          {
  255.             _loc6_ = URLUtil.getPort(_loc2_);
  256.             if(_loc6_ > 0)
  257.             {
  258.                param1 = param1.replace(SERVER_PORT_REGEX,_loc6_);
  259.             }
  260.             else
  261.             {
  262.                if(param1.charAt(_loc3_ - 1) == ":")
  263.                {
  264.                   param1 = param1.substring(0,_loc3_ - 1) + param1.substring(_loc3_);
  265.                }
  266.                param1 = param1.replace(SERVER_PORT_REGEX,"");
  267.             }
  268.          }
  269.          return param1;
  270.       }
  271.       
  272.       public static function getPort(param1:String) : uint
  273.       {
  274.          var _loc5_:Number = NaN;
  275.          var _loc2_:String = getServerNameWithPort(param1);
  276.          var _loc3_:int = int(_loc2_.indexOf("]"));
  277.          _loc3_ = _loc3_ > -1 ? int(_loc2_.indexOf(":",_loc3_)) : int(_loc2_.indexOf(":"));
  278.          var _loc4_:uint = 0;
  279.          if(_loc3_ > 0)
  280.          {
  281.             _loc5_ = Number(_loc2_.substring(_loc3_ + 1));
  282.             if(!isNaN(_loc5_))
  283.             {
  284.                _loc4_ = uint(int(_loc5_));
  285.             }
  286.          }
  287.          return _loc4_;
  288.       }
  289.       
  290.       public static function stringToObject(param1:String, param2:String = ";", param3:Boolean = true) : Object
  291.       {
  292.          var _loc8_:Array = null;
  293.          var _loc9_:String = null;
  294.          var _loc10_:Object = null;
  295.          var _loc11_:Object = null;
  296.          var _loc12_:int = 0;
  297.          var _loc13_:int = 0;
  298.          var _loc14_:Object = null;
  299.          var _loc15_:String = null;
  300.          var _loc16_:String = null;
  301.          var _loc17_:Object = null;
  302.          var _loc4_:Object = {};
  303.          var _loc5_:Array = param1.split(param2);
  304.          var _loc6_:int = int(_loc5_.length);
  305.          var _loc7_:int = 0;
  306.          while(_loc7_ < _loc6_)
  307.          {
  308.             _loc8_ = _loc5_[_loc7_].split("=");
  309.             _loc9_ = _loc8_[0];
  310.             if(param3)
  311.             {
  312.                _loc9_ = decodeURIComponent(_loc9_);
  313.             }
  314.             _loc10_ = _loc8_[1];
  315.             if(param3)
  316.             {
  317.                _loc10_ = decodeURIComponent(_loc10_ as String);
  318.             }
  319.             if(_loc10_ == "true")
  320.             {
  321.                _loc10_ = true;
  322.             }
  323.             else if(_loc10_ == "false")
  324.             {
  325.                _loc10_ = false;
  326.             }
  327.             else
  328.             {
  329.                _loc14_ = int(_loc10_);
  330.                if(_loc14_.toString() == _loc10_)
  331.                {
  332.                   _loc10_ = _loc14_;
  333.                }
  334.                else
  335.                {
  336.                   _loc14_ = Number(_loc10_);
  337.                   if(_loc14_.toString() == _loc10_)
  338.                   {
  339.                      _loc10_ = _loc14_;
  340.                   }
  341.                }
  342.             }
  343.             _loc11_ = _loc4_;
  344.             _loc8_ = _loc9_.split(".");
  345.             _loc12_ = int(_loc8_.length);
  346.             _loc13_ = 0;
  347.             while(_loc13_ < _loc12_ - 1)
  348.             {
  349.                _loc15_ = _loc8_[_loc13_];
  350.                if(_loc11_[_loc15_] == null && _loc13_ < _loc12_ - 1)
  351.                {
  352.                   _loc16_ = _loc8_[_loc13_ + 1];
  353.                   _loc17_ = int(_loc16_);
  354.                   if(_loc17_.toString() == _loc16_)
  355.                   {
  356.                      _loc11_[_loc15_] = [];
  357.                   }
  358.                   else
  359.                   {
  360.                      _loc11_[_loc15_] = {};
  361.                   }
  362.                }
  363.                _loc11_ = _loc11_[_loc15_];
  364.                _loc13_++;
  365.             }
  366.             _loc11_[_loc8_[_loc13_]] = _loc10_;
  367.             _loc7_++;
  368.          }
  369.          return _loc4_;
  370.       }
  371.       
  372.       public static function replacePort(param1:String, param2:uint) : String
  373.       {
  374.          var _loc6_:int = 0;
  375.          var _loc3_:String = "";
  376.          var _loc4_:int = int(param1.indexOf("]"));
  377.          if(_loc4_ == -1)
  378.          {
  379.             _loc4_ = int(param1.indexOf(":"));
  380.          }
  381.          var _loc5_:int = int(param1.indexOf(":",_loc4_ + 1));
  382.          if(_loc5_ > -1)
  383.          {
  384.             _loc5_++;
  385.             _loc6_ = int(param1.indexOf("/",_loc5_));
  386.             _loc3_ = param1.substring(0,_loc5_) + param2.toString() + param1.substring(_loc6_,param1.length);
  387.          }
  388.          else
  389.          {
  390.             _loc6_ = int(param1.indexOf("/",_loc4_));
  391.             if(_loc6_ > -1)
  392.             {
  393.                if(param1.charAt(_loc6_ + 1) == "/")
  394.                {
  395.                   _loc6_ = int(param1.indexOf("/",_loc6_ + 2));
  396.                }
  397.                if(_loc6_ > 0)
  398.                {
  399.                   _loc3_ = param1.substring(0,_loc6_) + ":" + param2.toString() + param1.substring(_loc6_,param1.length);
  400.                }
  401.                else
  402.                {
  403.                   _loc3_ = param1 + ":" + param2.toString();
  404.                }
  405.             }
  406.             else
  407.             {
  408.                _loc3_ = param1 + ":" + param2.toString();
  409.             }
  410.          }
  411.          return _loc3_;
  412.       }
  413.       
  414.       public static function isHttpURL(param1:String) : Boolean
  415.       {
  416.          return param1 != null && (param1.indexOf("http://") == 0 || param1.indexOf("https://") == 0);
  417.       }
  418.    }
  419. }
  420.  
  421.