home *** CD-ROM | disk | FTP | other *** search
/ Champak 48 / cdrom_image.iso / Games / alex_trax.swf / scripts / __Packages / com / neodelight / std / XString.as < prev    next >
Encoding:
Text File  |  2007-10-01  |  7.8 KB  |  295 lines
  1. class com.neodelight.std.XString
  2. {
  3.    function XString()
  4.    {
  5.    }
  6.    static function dump(o, params)
  7.    {
  8.       var _loc1_ = undefined;
  9.       params.depth = com.neodelight.std.XMath.toNumber(params.depth);
  10.       switch(typeof o)
  11.       {
  12.          case "string":
  13.             _loc1_ = "\"" + o + "\"";
  14.             break;
  15.          case "undefined":
  16.             _loc1_ = "[undefined]";
  17.             break;
  18.          case "array":
  19.             _loc1_ = "[Array]";
  20.             break;
  21.          case "number":
  22.             _loc1_ = String(o);
  23.             break;
  24.          default:
  25.             _loc1_ = "{";
  26.             var _loc5_ = true;
  27.             for(var _loc7_ in o)
  28.             {
  29.                if(!_loc5_)
  30.                {
  31.                   _loc1_ += ", ";
  32.                }
  33.                _loc5_ = false;
  34.                if(params.br)
  35.                {
  36.                   _loc1_ += "\n";
  37.                }
  38.                var _loc2_ = 0;
  39.                while(_loc2_ < int(params.indent))
  40.                {
  41.                   _loc1_ += " ";
  42.                   _loc2_ = _loc2_ + 1;
  43.                }
  44.                _loc1_ += _loc7_ + ":";
  45.                if(typeof o[_loc7_] == "object")
  46.                {
  47.                   if(params.depth > 0)
  48.                   {
  49.                      _loc1_ += com.neodelight.std.XString.dump(o[_loc7_],{depth:params.depth - 1});
  50.                   }
  51.                   else
  52.                   {
  53.                      _loc1_ += "[Object]";
  54.                   }
  55.                }
  56.                else
  57.                {
  58.                   _loc1_ += com.neodelight.std.XString.dump(o[_loc7_],{depth:params.depth - 1});
  59.                }
  60.             }
  61.             if(params.br)
  62.             {
  63.                _loc1_ += "\n";
  64.             }
  65.             _loc1_ += "}";
  66.       }
  67.       return _loc1_;
  68.    }
  69.    static function numberFormat(num, digits)
  70.    {
  71.       var _loc2_ = String(int(num));
  72.       var _loc1_ = _loc2_.length - 4;
  73.       while(_loc1_ >= 0)
  74.       {
  75.          _loc2_ = _loc2_.substring(0,_loc1_ + 1) + "," + _loc2_.substr(_loc1_ + 1);
  76.          _loc1_ -= 3;
  77.       }
  78.       if(int(digits) > 0)
  79.       {
  80.          _loc2_ += ".";
  81.          var _loc3_ = String(int((num - int(num)) * Math.pow(10,digits)));
  82.          while(_loc3_.length < digits)
  83.          {
  84.             _loc3_ = "0" + _loc3_;
  85.          }
  86.          _loc2_ += _loc3_;
  87.       }
  88.       return _loc2_;
  89.    }
  90.    static function timeFormat(millis, format)
  91.    {
  92.       var _loc5_ = "";
  93.       var _loc8_ = new Object();
  94.       var _loc6_ = undefined;
  95.       var _loc2_ = 0;
  96.       while(_loc2_ < format.length)
  97.       {
  98.          _loc6_ = format.charAt(_loc2_);
  99.          if(_loc6_ == "%")
  100.          {
  101.             _loc2_ = _loc2_ + 1;
  102.             var _loc3_ = format.charAt(_loc2_);
  103.             if(_loc8_[_loc3_] == undefined)
  104.             {
  105.                var _loc1_ = undefined;
  106.                switch(_loc3_)
  107.                {
  108.                   case "H":
  109.                      _loc1_ = String(Math.floor(millis / 3600000));
  110.                      while(_loc1_.length < 2)
  111.                      {
  112.                         _loc1_ = "0" + _loc1_;
  113.                      }
  114.                      break;
  115.                   case "i":
  116.                      _loc1_ = String(Math.floor(millis / 60000) % 60);
  117.                      while(_loc1_.length < 2)
  118.                      {
  119.                         _loc1_ = "0" + _loc1_;
  120.                      }
  121.                      break;
  122.                   case "s":
  123.                      _loc1_ = String(Math.floor(millis / 1000) % 60);
  124.                      while(_loc1_.length < 2)
  125.                      {
  126.                         _loc1_ = "0" + _loc1_;
  127.                      }
  128.                      break;
  129.                   case "c":
  130.                      _loc1_ = String(Math.floor(millis / 10) % 100);
  131.                      while(_loc1_.length < 2)
  132.                      {
  133.                         _loc1_ = "0" + _loc1_;
  134.                      }
  135.                      break;
  136.                   case "q":
  137.                      _loc1_ = String(Math.floor(millis) % 1000);
  138.                      while(_loc1_.length < 3)
  139.                      {
  140.                         _loc1_ = "0" + _loc1_;
  141.                      }
  142.                      break;
  143.                   default:
  144.                      _loc1_ = "";
  145.                }
  146.                _loc8_[_loc3_] = _loc1_;
  147.                _loc5_ += _loc1_;
  148.             }
  149.             else
  150.             {
  151.                _loc5_ += _loc8_[_loc3_];
  152.             }
  153.          }
  154.          else if(_loc6_ == "\\")
  155.          {
  156.             _loc2_ = _loc2_ + 1;
  157.             _loc5_ += format.charAt(_loc2_);
  158.          }
  159.          else
  160.          {
  161.             _loc5_ += _loc6_;
  162.          }
  163.          _loc2_ = _loc2_ + 1;
  164.       }
  165.       return _loc5_;
  166.    }
  167.    static function ordinal(n)
  168.    {
  169.       switch(n)
  170.       {
  171.          case 1:
  172.             return "1st";
  173.          case 2:
  174.             return "2nd";
  175.          case 3:
  176.             return "3rd";
  177.          default:
  178.             return n + "th";
  179.       }
  180.    }
  181.    static function trim(s)
  182.    {
  183.       var _loc3_ = 0;
  184.       var _loc4_ = s.length;
  185.       var _loc1_ = 0;
  186.       while(_loc1_ < s.length)
  187.       {
  188.          switch(s.charCodeAt(_loc1_))
  189.          {
  190.             case 32:
  191.             case 9:
  192.             case 10:
  193.             case 13:
  194.                _loc3_ = _loc1_ + 1;
  195.          }
  196.          if(_loc3_ != _loc1_ + 1)
  197.          {
  198.             break;
  199.          }
  200.          _loc1_ = _loc1_ + 1;
  201.       }
  202.       _loc1_ = s.length - 1;
  203.       while(_loc1_ >= 0)
  204.       {
  205.          switch(s.charCodeAt(_loc1_))
  206.          {
  207.             case 32:
  208.             case 9:
  209.             case 10:
  210.             case 13:
  211.                _loc4_ = _loc1_;
  212.          }
  213.          if(_loc4_ != _loc1_)
  214.          {
  215.             break;
  216.          }
  217.          _loc1_ = _loc1_ - 1;
  218.       }
  219.       return s.substring(_loc3_,_loc4_);
  220.    }
  221.    static function replace(search, replace, subject)
  222.    {
  223.       return subject.split(search).join(replace);
  224.    }
  225.    static function parse(str)
  226.    {
  227.       if(String(com.neodelight.std.XMath.toNumber(Number(str))) == str)
  228.       {
  229.          return com.neodelight.std.XMath.toNumber(Number(str));
  230.       }
  231.       if(str.charAt(0) == "{" && str.charAt(str.length - 1) == "}")
  232.       {
  233.          var _loc3_ = new Object();
  234.          return _loc3_;
  235.       }
  236.       if(str.charAt(0) == "[" && str.charAt(str.length - 1) == "]")
  237.       {
  238.          var _loc2_ = new Array();
  239.          return _loc2_;
  240.       }
  241.       if(str.charAt(0) == "\"" && str.charAt(str.length - 1) == "\"")
  242.       {
  243.          return str.substring(1,str.length - 2);
  244.       }
  245.       return str;
  246.    }
  247.    static function parseHex(str)
  248.    {
  249.       str = str.substr(-6,6);
  250.       var _loc3_ = str.length;
  251.       var _loc4_ = 0;
  252.       var _loc2_ = 0;
  253.       while(_loc2_ < _loc3_)
  254.       {
  255.          var _loc1_ = str.charCodeAt(_loc3_ - _loc2_ - 1);
  256.          if(_loc1_ <= 57)
  257.          {
  258.             _loc1_ -= 48;
  259.          }
  260.          else if(_loc1_ > 64 && _loc1_ < 71)
  261.          {
  262.             _loc1_ -= 55;
  263.          }
  264.          _loc4_ += _loc1_ * Math.pow(16,_loc2_);
  265.          _loc2_ = _loc2_ + 1;
  266.       }
  267.       return _loc4_;
  268.    }
  269.    static function stripSlashes(str)
  270.    {
  271.       var _loc1_ = 0;
  272.       while(_loc1_ < str.length)
  273.       {
  274.          if(str.charAt(_loc1_) == "\\")
  275.          {
  276.             var _loc3_ = undefined;
  277.             var _loc4_ = str.charAt(_loc1_ + 1);
  278.             var _loc0_ = null;
  279.             if((_loc0_ = _loc4_) !== "n")
  280.             {
  281.                _loc3_ = _loc4_;
  282.             }
  283.             else
  284.             {
  285.                _loc3_ = "\n";
  286.             }
  287.             str = str.slice(0,_loc1_) + _loc3_ + str.slice(_loc1_ + 2,str.length);
  288.             _loc1_ = _loc1_ - 1;
  289.          }
  290.          _loc1_ = _loc1_ + 1;
  291.       }
  292.       return str;
  293.    }
  294. }
  295.