Chinaunix首页 | 论坛 | 博客

疯狂Erlangyueming.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

yueming

  • 博客访问： 5003958
  • 博文数量： 921
  • 博客积分： 16037
  • 博客等级： 上将
  • 技术积分： 8469
  • 用 户 组： 普通用户
  • 注册时间： 2006-04-05 02:08
文章分类

全部博文（921）

文章存档

2020年（1）

2019年（3）

2018年（3）

2017年（6）

2016年（47）

2015年（72）

2014年（25）

2013年（72）

2012年（125）

2011年（182）

2010年（42）

2009年（14）

2008年（85）

2007年（89）

2006年（155）

我的朋友
最近访客
推荐博文
相关博文
erlang与as3 socket解析

分类： Python/Ruby

2012-11-15 11:29:25

这个解析类是我现在项目中用到的一个as3与erlang sokcet通信的一个类。 解析出来的数据是数组。
本想做成object的, 不过这得服务器那边配合. 服务器这边的工作量就会加大了， 因为每一个值都要加一个元素符这样才能构成object基本的组成元素。
我们的做法是：服务端那边返回的数据，在协作平台上把数据元素列出来， 前端做开发就参考这个数据列表来做开发 。

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

  1. package app.model.comsocket.comParse {

  3. /**

  5. * 字节头类型

  7. * @author zl-主程

  9. */

  11. public class BertClass{

  13.      public static const BERT_START:String = String.fromCharCode(131);

  15.      public static const SMALL_ATOM:String = String.fromCharCode(115);

  17.      public static const ATOM:String = String.fromCharCode(100);

  19.      public static const BINARY:String = String.fromCharCode(109);

  21.      public static const SMALL_INTEGER:String = String.fromCharCode(97);

  23.      public static const INTEGER:String = String.fromCharCode(98);

  25.      public static const SMALL_BIG:String = String.fromCharCode(110);

  27.      public static const LARGE_BIG:String = String.fromCharCode(111);

  29.      public static const FLOAT:String = String.fromCharCode(99);

  31.      public static const STRING:String = String.fromCharCode(107);

  33.      public static const LIST:String = String.fromCharCode(108);

  35.      public static const SMALL_TUPLE:String = String.fromCharCode(104);

  37.      public static const LARGE_TUPLE:String = String.fromCharCode(105);

  39.      public static const NIL:String = String.fromCharCode(106);

  41.      public static const ZERO:String = String.fromCharCode(0);

  43. }



  47. }

 

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


 

  1. package app.model.comsocket.comParse {

  3. import app.utility.debug.Debug;

  5. import flash.display.Sprite;

  7. import flash.utils.ByteArray;

  9. /**

  11. * @author silva-主程

  13. */

  15. public class ParseSocketData extends Sprite {

  17.      public static function bytes_to_string(arr:ByteArray):String {

  19.          var str:String = ";";;

  21.          var len:int = arr.length;

  23.        //Debug.log(";len:"; + arr.length);


  26.        for (var i:int = 0; i <; len; i++) {

  28.          //Debug.log(arr[i])


  31.            str += String.fromCharCode(arr[i]);

  33.          }

  35.        return str;

  37.        }

  39.      /**

  41.        *

  43.        * @param str Unicode 字符代码

  45.        * @return

  47.        */

  49.      public static function decode(str:String):Array {

  51.        if (String.fromCharCode(str.charCodeAt(0)) != BertClass.BERT_START) {

  53.            Debug.error(";不是有效的二进制";);

  55.          return [];

  57.          }

  59.          var Obj:Object = decode_inner(str.substring(1));

  61.        try {

  63.          if (Obj.rest !== ";";) {

  65.              Debug.error(";空";);

  67.            }

  69.          }catch (e:Error) {

  71.            Debug.error(";解析出错！！"; + e.toString());

  73.          }

  75.      

  77.        return Obj.value;

  79.        };

  81.      /**

  83.        * 从不同类型中拿数据

  85.        * @param str

  87.        */

  89.      private static function decode_inner(str:String):Object {

  91.          var Type:String = String.fromCharCode(str.charCodeAt(0));

  93.        //Debug.log(";Type:";+str.charCodeAt(0));


  96.        //跳过头


  99.          var str:String = str.substring(1);

  101.        switch (Type) {

  103.          case BertClass.SMALL_INTEGER:

  105.            //97


  108.            return decode_integer(str, 1);

  110.          break;

  112.          case BertClass.INTEGER:

  114.            //98


  117.            return decode_integer(str, 4);

  119.          break;

  121.          case BertClass.SMALL_ATOM:

  123.            //115


  126.            return decode_atom(str, 1);

  128.          break;

  130.          case BertClass.FLOAT:

  132.            //99


  135.            return decode_float(str);

  137.          break;

  139.          case BertClass.ATOM:

  141.            //常量 100


  144.            return decode_atom(str, 2);

  146.          break;

  148.          case BertClass.STRING:

  150.            //字符型 107


  153.            return decode_string(str);

  155.          case BertClass.LIST:

  157.            //LIST 108


  160.            return decode_list(str);

  162.          break;

  164.          case BertClass.SMALL_TUPLE:

  166.            //104 {}


  169.            return decode_tuple(str, 1);

  171.          break;

  173.          case BertClass.NIL:

  175.            //


  178.            return decode_nil(str);

  180.          break;

  182.          case BertClass.SMALL_BIG:

  184.            //110


  187.            return decode_big(str, 1);

  189.          break;

  191.          case BertClass.LARGE_BIG:

  193.            //111


  196.            return decode_big(str, 4);

  198.          break;

  200.          default:

  202.              Debug.error(";找不到字节头类型"; + str.charCodeAt(0));

  204.              Debug.error(";找不到字节头类型"; + Type==BertClass.SMALL_INTEGER);

  206.              Debug.error(";找不到字节头类型"; + Type);

  208.              Debug.error(";找不到字节头类型"; + BertClass.SMALL_INTEGER);

  210.            return {

  212.                value:null

  214.              };

  216.            }

  218.        };

  220.      /**

  222.        * 97 98 获取

  224.        * @param str

  226.        * @param count

  228.        */

  230.      private static function decode_integer(str:String, count:int):Object {

  232.          var Value:int = bytes_to_int(str, count);

  234.          var temStr:String = str.substring(count);

  236.        return {

  238.            value: Value,

  240.            rest: temStr

  242.          };

  244.        };

  246.      /**

  248.        * 99

  250.        * @param str

  252.        * @return

  254.        */

  256.      private static function decode_float(str:String):Object {

  258.          var Size:int = 31;

  260.        return {

  262.            value: parseFloat(str.substring(0, Size)),

  264.            rest: str.substring(Size)

  266.          };

  268.        };

  270.      /**

  272.        * 100 常量字符获取

  274.        * @param str

  276.        * @param count

  278.        * @return

  280.        */

  282.      private static function decode_atom(str:String, count:int):Object {

  284.          var Size:int;

  286.          Size = bytes_to_int(str, count);

  288.          var temStr:String = str.substring(count);

  290.          var value:String;

  292.          var temBy:ByteArray = new ByteArray();

  294.        for (var i:int = 0; i <; Size; i++) {

  296.            temBy.writeByte(temStr.charCodeAt(i));

  298.          }

  300.          temBy.position = 0;

  302.          value = temBy.readUTFBytes(Size);

  304.        return {

  306.            value:value,

  308.            rest:temStr.substring(Size)

  310.          }

  312.        };

  314.    

  316.      private static function decode_nil(str:String):Object {

  318.        // nil is an empty list


  321.        return {

  323.            value: [],

  325.            rest: str

  327.          };

  329.        };

  331.      /**

  333.        * 107

  335.        * 获取字符串

  337.        * @param str

  339.        */

  341.      private static function decode_string(str:String):Object {

  343.          var Size:int = bytes_to_int(str, 2);

  345.          var temStr:String = str.substring(2);

  347.          var temBy:ByteArray = new ByteArray();

  349.          var value:String;

  351.        for (var i:int = 0; i <; Size; i++) {

  353.            temBy.writeByte(temStr.charCodeAt(i));

  355.          }

  357.          temBy.position = 0;

  359.          value = temBy.readUTFBytes(Size);

  361.        return {

  363.            value: value,

  365.            rest: temStr.substring(Size)

  367.          };

  369.        };

  371.      /**

  373.        * 104

  375.        * @param str

  377.        * @param count

  379.        * @return

  381.        */

  383.      private static function decode_tuple(str:String, count:int):Object {

  385.          var Arr:Array = new Array();

  387.          var El:Object;

  389.          var Size:int = bytes_to_int(str, count);

  391.          var temStr:String = str.substring(count);

  393.        for (var i:int = 0; i <; Size; i++) {

  395.            El = decode_inner(temStr);

  397.            Arr.push(El.value);

  399.            temStr = El.rest;

  401.          }

  403.        return {

  405.            value: Arr,

  407.            rest: temStr

  409.          };

  411.        };

  413.      /**

  415.        * 108

  417.        */

  419.      private static function decode_list(str:String):Object {

  421.          var Size:int;

  423.          var El:Object;

  425.          var LastChar:String;

  427.          var Arr:Array = new Array();

  429.          Size = bytes_to_int(str, 4);

  431.          var temStr:String = str.substring(4);

  433.        for (var i:int = 0; i <; Size; i++) {

  435.            El = decode_inner(temStr);

  437.            Arr.push(El.value);

  439.            temStr = El.rest;

  441.          }

  443.          LastChar = String.fromCharCode(temStr.charCodeAt(0));

  445.        if (LastChar != BertClass.NIL) {

  447.            Debug.error(";数组未结束";);

  449.          }

  451.          var temStr2:String = temStr.substring(1);

  453.        return {

  455.            value: Arr,

  457.            rest: temStr2

  459.          };

  461.        };

  463.      /**

  465.        * 110 111

  467.        */

  469.      private static function decode_big(str:String, count:int):Object {

  471.          var Size:int, Value:Number;

  473.          Size = bytes_to_int(str, count);

  475.          var temStr:String = str.substring(count);

  477.          Value = bytes_to_bignum(temStr, Size);

  479.        return {

  481.            value : Value,

  483.            rest: temStr.substring(Size + 1)

  485.          };

  487.        };

  489.      /**

  491.        * 大数字算法

  493.        * @param str

  495.        * @param count

  497.        */

  499.      private static function bytes_to_bignum(str:String, count:int):Number {

  501.          var isNegative:Boolean;

  503.          var n:Number;

  505.          var Num:Number;

  507.          isNegative = (str.charCodeAt(0) === 1);

  509.          str = str.substring(1);

  511.        for (var i:int = count - 1; i >;= 0; i--) {

  513.            n = str.charCodeAt(i);

  515.          if (Num === 0) {

  517.              Num = n;

  519.            }

  521.          else {

  523.              Num = Num * 256 + n;

  525.            }

  527.          }

  529.        if (isNegative) {

  531.          return Num * -1;

  533.          }

  535.        return Num;

  537.        };

  539.      /**

  541.        * 返回获取数据的长度

  543.        * @param str

  545.        * @param Length

  547.        * @return

  549.        */

  551.      private static function bytes_to_int(str:String, Length:int):int {

  553.          var isNegative:Boolean;

  555.          var n:Number ;

  557.          var Num:int;

  559.          isNegative = (str.charCodeAt(0) >; 128);

  561.        for (var i:int = 0; i <; Length; i++) {

  563.            n = str.charCodeAt(i);

  565.          if (isNegative) {

  567.              n = 255 - n;

  569.            }

  571.          if (Num === 0) {

  573.              Num = n;

  575.            }else {

  577.              Num = Num * 256 + n;

  579.            }

  581.          }

  583.        if (isNegative) {

  585.            Num = Num * (0 - 1);

  587.          }

  589.        return Num;

  591.        };

  593.      ///----发送---


  596.      /**

  598.        * 发送数据解析

  600.        * @param _arr:Array 发送数据数组

  602.        * @return 返回ByteArray 对象

  604.        */

  606.      public static function parseSendData(_arr:Array):ByteArray {

  608.          var TemByteArr:ByteArray = new ByteArray();

  610.          var ReturnTemArr:ByteArray = new ByteArray();

  612.          var temBy:Array = new Array();

  614.        //TemByteArr.writeShort(_arr.length);


  617.          TemByteArr.writeByte(131);

  619.          TemByteArr.writeByte(104);

  621.          TemByteArr.writeByte(_arr.length);

  623.          temBy = sendData(_arr);

  625.        for (var i :int = 0; i <; temBy.length; i++) {

  627.          //Debug.log(temBy[i])


  630.            TemByteArr.writeByte(temBy[i]);

  632.          }

  634.          ReturnTemArr.writeUnsignedInt(TemByteArr.length);

  636.        //加密发送


  639.          ReturnTemArr.writeBytes(Encrypt.enArc4(TemByteArr));

  641.        return ReturnTemArr as ByteArray;

  643.        }

  645.      /**

  647.        * 声明 暂时没找到AS3区分字符串与常量的办法 故已特殊字符做了一下处理

  649.        * @param _arr:Array 查询数组

  651.        * @return 二进制数组

  653.        */

  655.      private static function sendData(_arr:Array):Array {

  657.          var len:int = _arr.length;

  659.          var SendByteArray:Array = new Array();

  661.        for (var s:int = 0; s <; len; s++) {

  663.          if (_arr[s] is String) {

  665.            if (_arr[s].substr(0, 6) == ";const@";) {

  667.                SendByteArray=SendByteArray.concat(DataUtil.parseCode(_arr[s].split(/@/)[1], ";const";));

  669.              }else {

  671.                SendByteArray=SendByteArray.concat(DataUtil.parseCode(_arr[s], ";string";));

  673.              }

  675.            }else if (_arr[s] is Number) {

  677.              SendByteArray = SendByteArray.concat(DataUtil.parseCode(_arr[s], ";number";));

  679.            }else if (_arr[s] is Array) {

  681.              SendByteArray = SendByteArray.concat([104,_arr[s].length]);

  683.              sendData(_arr[s]);

  685.            continue;

  687.            }

  689.          }

  691.      

  693.        return SendByteArray as Array;

  695.        }

  697. }

  699. }


 

 


文章来自：

 

阅读(2250) | 评论(0) | 转发(0) |
0

上一篇：Erlang Socket解析二进制数据包

下一篇：Python使用动态变量名

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6