erlang与as3 socket 解析

这个解析类是我现在项目中用到的一个as3与erlang sokcet通信的一个类

解析出来的数据是数组

本想做成object的 不过这得服务器那边配合 服务器这边的工作量就会加大了 因为每一个值都要加一个元素符 这样才能构成object基本的组成元素

我们的做法是 服务端那边 返回的数据 在协作平台上把数据元素 列出来 前端做开发 就参考这个数据列表来做开发

BertClass.as文件定义一些字头类型

package app.model.comsocket.comParse {
/**
* 字节头类型
* @author zl-主程
*/
public class BertClass{
   public static const BERT_START:String = String.fromCharCode(131);
   public static const SMALL_ATOM:String = String.fromCharCode(115);
   public static const ATOM:String = String.fromCharCode(100);
   public static const BINARY:String = String.fromCharCode(109);
   public static const SMALL_INTEGER:String = String.fromCharCode(97);
   public static const INTEGER:String = String.fromCharCode(98);
   public static const SMALL_BIG:String = String.fromCharCode(110);
   public static const LARGE_BIG:String = String.fromCharCode(111);
   public static const FLOAT:String = String.fromCharCode(99);
   public static const STRING:String = String.fromCharCode(107);
   public static const LIST:String = String.fromCharCode(108);
   public static const SMALL_TUPLE:String = String.fromCharCode(104);
   public static const LARGE_TUPLE:String = String.fromCharCode(105);
   public static const NIL:String = String.fromCharCode(106);
   public static const ZERO:String = String.fromCharCode(0);
}

}

ParseSocketData.as 解析erlang神发送的二进制和发送数据给erlang神

package app.model.comsocket.comParse {
import app.utility.debug.Debug;
import flash.display.Sprite;
import flash.utils.ByteArray;
/**
* @author silva-主程
*/
public class ParseSocketData extends Sprite {
   public static function bytes_to_string(arr:ByteArray):String {
     var str:String = "";
     var len:int = arr.length;
    //Debug.log("len:" + arr.length);
    for (var i:int = 0; i < len; i++) {
     //Debug.log(arr[i])
      str += String.fromCharCode(arr[i]);
     }
    return str;
    }
   /**
    *
    * @param str Unicode 字符代码
    * @return
    */
   public static function decode(str:String):Array {
    if (String.fromCharCode(str.charCodeAt(0)) != BertClass.BERT_START) {
      Debug.error("不是有效的二进制");
     return [];
     }
     var Obj:Object = decode_inner(str.substring(1));
    try {
     if (Obj.rest !== "") {
       Debug.error("空");
      }
     }catch (e:Error) {
      Debug.error("解析出错！！" + e.toString());
     }
  
    return Obj.value;
    };
   /**
    * 从不同类型中拿数据
    * @param str
    */
   private static function decode_inner(str:String):Object {
     var Type:String = String.fromCharCode(str.charCodeAt(0));
    //Debug.log("Type:"+str.charCodeAt(0));
    //跳过头
     var str:String = str.substring(1);
    switch (Type) {
     case BertClass.SMALL_INTEGER:
      //97
      return decode_integer(str, 1);
     break;
     case BertClass.INTEGER:
      //98
      return decode_integer(str, 4);
     break;
     case BertClass.SMALL_ATOM:
      //115
      return decode_atom(str, 1);
     break;
     case BertClass.FLOAT:
      //99
      return decode_float(str);
     break;
     case BertClass.ATOM:
      //常量 100
      return decode_atom(str, 2);
     break;
     case BertClass.STRING:
      //字符型 107
      return decode_string(str);
     case BertClass.LIST:
      //LIST 108
      return decode_list(str);
     break;
     case BertClass.SMALL_TUPLE:
      //104 {}
      return decode_tuple(str, 1);
     break;
     case BertClass.NIL:
      //
      return decode_nil(str);
     break;
     case BertClass.SMALL_BIG:
      //110
      return decode_big(str, 1);
     break;
     case BertClass.LARGE_BIG:
      //111
      return decode_big(str, 4);
     break;
     default:
       Debug.error("找不到字节头类型" + str.charCodeAt(0));
       Debug.error("找不到字节头类型" + Type==BertClass.SMALL_INTEGER);
       Debug.error("找不到字节头类型" + Type);
       Debug.error("找不到字节头类型" + BertClass.SMALL_INTEGER);
      return {
        value:null
       };
      }
    };
   /**
    * 97 98 获取
    * @param str
    * @param count
    */
   private static function decode_integer(str:String, count:int):Object {
     var Value:int = bytes_to_int(str, count);
     var temStr:String = str.substring(count);
    return {
      value: Value,
      rest: temStr
     };
    };
   /**
    * 99
    * @param str
    * @return
    */
   private static function decode_float(str:String):Object {
     var Size:int = 31;
    return {
      value: parseFloat(str.substring(0, Size)),
      rest: str.substring(Size)
     };
    };
   /**
    * 100 常量字符获取
    * @param str
    * @param count
    * @return
    */
   private static function decode_atom(str:String, count:int):Object {
     var Size:int;
     Size = bytes_to_int(str, count);
     var temStr:String = str.substring(count);
     var value:String;
     var temBy:ByteArray = new ByteArray();
    for (var i:int = 0; i < Size; i++) {
      temBy.writeByte(temStr.charCodeAt(i));
     }
     temBy.position = 0;
     value = temBy.readUTFBytes(Size);
    return {
      value:value,
      rest:temStr.substring(Size)
     }
    };
 
   private static function decode_nil(str:String):Object {
    // nil is an empty list
    return {
      value: [],
      rest: str
     };
    };
   /**
    * 107
    * 获取字符串
    * @param str
    */
   private static function decode_string(str:String):Object {
     var Size:int = bytes_to_int(str, 2);
     var temStr:String = str.substring(2);
     var temBy:ByteArray = new ByteArray();
     var value:String;
    for (var i:int = 0; i < Size; i++) {
      temBy.writeByte(temStr.charCodeAt(i));
     }
     temBy.position = 0;
     value = temBy.readUTFBytes(Size);
    return {
      value: value,
      rest: temStr.substring(Size)
     };
    };
   /**
    * 104
    * @param str
    * @param count
    * @return
    */
   private static function decode_tuple(str:String, count:int):Object {
     var Arr:Array = new Array();
     var El:Object;
     var Size:int = bytes_to_int(str, count);
     var temStr:String = str.substring(count);
    for (var i:int = 0; i < Size; i++) {
      El = decode_inner(temStr);
      Arr.push(El.value);
      temStr = El.rest;
     }
    return {
      value: Arr,
      rest: temStr
     };
    };
   /**
    * 108
    */
   private static function decode_list(str:String):Object {
     var Size:int;
     var El:Object;
     var LastChar:String;
     var Arr:Array = new Array();
     Size = bytes_to_int(str, 4);
     var temStr:String = str.substring(4);
    for (var i:int = 0; i < Size; i++) {
      El = decode_inner(temStr);
      Arr.push(El.value);
      temStr = El.rest;
     }
     LastChar = String.fromCharCode(temStr.charCodeAt(0));
    if (LastChar != BertClass.NIL) {
      Debug.error("数组未结束");
     }
     var temStr2:String = temStr.substring(1);
    return {
      value: Arr,
      rest: temStr2
     };
    };
   /**
    * 110 111
    */
   private static function decode_big(str:String, count:int):Object {
     var Size:int, Value:Number;
     Size = bytes_to_int(str, count);
     var temStr:String = str.substring(count);
     Value = bytes_to_bignum(temStr, Size);
    return {
      value : Value,
      rest: temStr.substring(Size + 1)
     };
    };
   /**
    * 大数字算法
    * @param str
    * @param count
    */
   private static function bytes_to_bignum(str:String, count:int):Number {
     var isNegative:Boolean;
     var n:Number;
     var Num:Number;
     isNegative = (str.charCodeAt(0) === 1);
     str = str.substring(1);
    for (var i:int = count - 1; i >= 0; i--) {
      n = str.charCodeAt(i);
     if (Num === 0) {
       Num = n;
      }
     else {
       Num = Num * 256 + n;
      }
     }
    if (isNegative) {
     return Num * -1;
     }
    return Num;
    };
   /**
    * 返回获取数据的长度
    * @param str
    * @param Length
    * @return
    */
   private static function bytes_to_int(str:String, Length:int):int {
     var isNegative:Boolean;
     var n:Number ;
     var Num:int;
     isNegative = (str.charCodeAt(0) > 128);
    for (var i:int = 0; i < Length; i++) {
      n = str.charCodeAt(i);
     if (isNegative) {
       n = 255 - n;
      }
     if (Num === 0) {
       Num = n;
      }else {
       Num = Num * 256 + n;
      }
     }
    if (isNegative) {
      Num = Num * (0 - 1);
     }
    return Num;
    };
   ///----发送---
   /**
    * 发送数据解析
    * @param _arr:Array 发送数据数组
    * @return 返回ByteArray 对象
    */
   public static function parseSendData(_arr:Array):ByteArray {
     var TemByteArr:ByteArray = new ByteArray();
     var ReturnTemArr:ByteArray = new ByteArray();
     var temBy:Array = new Array();
    //TemByteArr.writeShort(_arr.length);
     TemByteArr.writeByte(131);
     TemByteArr.writeByte(104);
     TemByteArr.writeByte(_arr.length);
     temBy = sendData(_arr);
    for (var i :int = 0; i < temBy.length; i++) {
     //Debug.log(temBy[i])
      TemByteArr.writeByte(temBy[i]);
     }
     ReturnTemArr.writeUnsignedInt(TemByteArr.length);
    //加密发送
     ReturnTemArr.writeBytes(Encrypt.enArc4(TemByteArr));
    return ReturnTemArr as ByteArray;
    }
   /**
    * 声明 暂时没找到AS3区分字符串与常量的办法 故已特殊字符做了一下处理
    * @param _arr:Array 查询数组
    * @return 二进制数组
    */
   private static function sendData(_arr:Array):Array {
     var len:int = _arr.length;
     var SendByteArray:Array = new Array();
    for (var s:int = 0; s < len; s++) {
     if (_arr[s] is String) {
      if (_arr[s].substr(0, 6) == "const@") {
        SendByteArray=SendByteArray.concat(DataUtil.parseCode(_arr[s].split(/@/)[1], "const"));
       }else {
        SendByteArray=SendByteArray.concat(DataUtil.parseCode(_arr[s], "string"));
       }
      }else if (_arr[s] is Number) {
       SendByteArray = SendByteArray.concat(DataUtil.parseCode(_arr[s], "number"));
      }else if (_arr[s] is Array) {
       SendByteArray = SendByteArray.concat([104,_arr[s].length]);
       sendData(_arr[s]);
      continue;
      }
     }
  
    return SendByteArray as Array;
    }
}
}