home *** CD-ROM | disk | FTP | other *** search
/ Computer Active 2010 August / CA08.iso / Darbas / kidoz_v1.air / kidoz.swf / scripts / mx / utils / Base64Encoder.as < prev    next >
Encoding:
Text File  |  2009-05-06  |  4.6 KB  |  171 lines
  1. package mx.utils
  2. {
  3.    import flash.utils.ByteArray;
  4.    
  5.    public class Base64Encoder
  6.    {
  7.       public static const CHARSET_UTF_8:String = "UTF-8";
  8.       
  9.       public static var newLine:int = 10;
  10.       
  11.       public static const MAX_BUFFER_SIZE:uint = 32767;
  12.       
  13.       private static const ESCAPE_CHAR_CODE:Number = 61;
  14.       
  15.       private static const ALPHABET_CHAR_CODES:Array = [65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,48,49,50,51,52,53,54,55,56,57,43,47];
  16.       
  17.       private var _line:uint;
  18.       
  19.       private var _count:uint;
  20.       
  21.       private var _buffers:Array;
  22.       
  23.       public var insertNewLines:Boolean = true;
  24.       
  25.       private var _work:Array = [0,0,0];
  26.       
  27.       public function Base64Encoder()
  28.       {
  29.          super();
  30.          reset();
  31.       }
  32.       
  33.       public function flush() : String
  34.       {
  35.          if(_count > 0)
  36.          {
  37.             encodeBlock();
  38.          }
  39.          var _loc1_:String = drain();
  40.          reset();
  41.          return _loc1_;
  42.       }
  43.       
  44.       public function toString() : String
  45.       {
  46.          return flush();
  47.       }
  48.       
  49.       public function reset() : void
  50.       {
  51.          _buffers = [];
  52.          _buffers.push([]);
  53.          _count = 0;
  54.          _line = 0;
  55.          _work[0] = 0;
  56.          _work[1] = 0;
  57.          _work[2] = 0;
  58.       }
  59.       
  60.       public function encodeBytes(param1:ByteArray, param2:uint = 0, param3:uint = 0) : void
  61.       {
  62.          if(param3 == 0)
  63.          {
  64.             param3 = param1.length;
  65.          }
  66.          var _loc4_:uint = param1.position;
  67.          param1.position = param2;
  68.          var _loc5_:uint = param2;
  69.          while(_loc5_ < param3)
  70.          {
  71.             _work[_count] = param1[_loc5_];
  72.             ++_count;
  73.             if(_count == _work.length || param2 + param3 - _loc5_ == 1)
  74.             {
  75.                encodeBlock();
  76.                _count = 0;
  77.                _work[0] = 0;
  78.                _work[1] = 0;
  79.                _work[2] = 0;
  80.             }
  81.             _loc5_++;
  82.          }
  83.          param1.position = _loc4_;
  84.       }
  85.       
  86.       public function encode(param1:String, param2:uint = 0, param3:uint = 0) : void
  87.       {
  88.          if(param3 == 0)
  89.          {
  90.             param3 = uint(param1.length);
  91.          }
  92.          var _loc4_:uint = param2;
  93.          while(_loc4_ < param2 + param3)
  94.          {
  95.             _work[_count] = param1.charCodeAt(_loc4_);
  96.             ++_count;
  97.             if(_count == _work.length || param2 + param3 - _loc4_ == 1)
  98.             {
  99.                encodeBlock();
  100.                _count = 0;
  101.                _work[0] = 0;
  102.                _work[1] = 0;
  103.                _work[2] = 0;
  104.             }
  105.             _loc4_++;
  106.          }
  107.       }
  108.       
  109.       private function encodeBlock() : void
  110.       {
  111.          var _loc1_:Array = _buffers[_buffers.length - 1] as Array;
  112.          if(_loc1_.length >= MAX_BUFFER_SIZE)
  113.          {
  114.             _loc1_ = [];
  115.             _buffers.push(_loc1_);
  116.          }
  117.          _loc1_.push(ALPHABET_CHAR_CODES[(_work[0] & 0xFF) >> 2]);
  118.          _loc1_.push(ALPHABET_CHAR_CODES[(_work[0] & 3) << 4 | (_work[1] & 0xF0) >> 4]);
  119.          if(_count > 1)
  120.          {
  121.             _loc1_.push(ALPHABET_CHAR_CODES[(_work[1] & 0x0F) << 2 | (_work[2] & 0xC0) >> 6]);
  122.          }
  123.          else
  124.          {
  125.             _loc1_.push(ESCAPE_CHAR_CODE);
  126.          }
  127.          if(_count > 2)
  128.          {
  129.             _loc1_.push(ALPHABET_CHAR_CODES[_work[2] & 0x3F]);
  130.          }
  131.          else
  132.          {
  133.             _loc1_.push(ESCAPE_CHAR_CODE);
  134.          }
  135.          if(insertNewLines)
  136.          {
  137.             if((_line = _line + 4) == 76)
  138.             {
  139.                _loc1_.push(newLine);
  140.                _line = 0;
  141.             }
  142.          }
  143.       }
  144.       
  145.       public function encodeUTFBytes(param1:String) : void
  146.       {
  147.          var _loc2_:ByteArray = new ByteArray();
  148.          _loc2_.writeUTFBytes(param1);
  149.          _loc2_.position = 0;
  150.          encodeBytes(_loc2_);
  151.       }
  152.       
  153.       public function drain() : String
  154.       {
  155.          var _loc3_:Array = null;
  156.          var _loc1_:String = "";
  157.          var _loc2_:uint = 0;
  158.          while(_loc2_ < _buffers.length)
  159.          {
  160.             _loc3_ = _buffers[_loc2_] as Array;
  161.             _loc1_ += String.fromCharCode.apply(null,_loc3_);
  162.             _loc2_++;
  163.          }
  164.          _buffers = [];
  165.          _buffers.push([]);
  166.          return _loc1_;
  167.       }
  168.    }
  169. }
  170.  
  171.