FastNet C++/Python 网络通信库之协议

协议可以使用的基础数据类型：

UInt8,UInt16,UInt32,UInt64
Int8,Int16,Int32,Int64
Float,Double,Bool,String

[T] 数组，T代表元素类型
[K,V] 字典，K代表键，V代表值，注意键只能为基础类型。

以及三种不同的协议类型类型：

Message　　和protobuf的message类似一个Message就代表一个协议，Message可以包含Struct和Enum，可以包含基础数据类型

Struct　　结构体，和Message的区别就是结构体只能包含基础数据类型和枚举（Enum），还有就是结构体在生成代码时不会生成相关的协议ID部分代码，因为Struct就是被设计为被嵌入到其他Message当中。

Enum　　枚举，只能包含整数

支持默认值（直接在类型后面加上双括号以及变量值）

下面是协议的一个例子：

from GenProto import *

class DemoEnum(Enum):

    one = 1

    two = 2

class DemoStruct(Struct):

    u8 = UInt8

    u16 = UInt16

    u32 = UInt32

    u64 = UInt64

    i8 = Int8

    i16 = Int16(1111)

    i32 = Int32

    i64 = Int64(1000000000000)

    f = Float

    d = Double

    b = Bool(True)

    s = String('defVal')

    de = DemoEnum(DemoEnum.two)

class DemoMessage(Message):

    u8 = UInt8(255)

    u16 = UInt16

    u32 = UInt32

    u64 = UInt64

    i8 = Int8(-127)

    i16 = Int16

    i32 = Int32

    i64 = Int64

    f = Float(0.234234)

    d = Double

    b = Bool

    s = String

    de = DemoEnum(DemoEnum.one)

    ds = DemoStruct

    arr = [DemoStruct]

    arr2 = [String]

    dict2 = [String,DemoStruct]

    dict3 = [UInt32,String]

下面是经过协议工具生成的C++/Python结构体：

 #pragma once

 #include "FastNet/core/ClassFactory.h"

 #include "FastNet/core/Stream.h"

 #include "FastNet/core/App.h"

 #include "FastNet/core/Cfg.h"

 namespace pkt{

 namespace demo{

 using FastNet::UInt8;

 using FastNet::UInt16;

 using FastNet::UInt32;

 using FastNet::UInt64;

 using FastNet::Int8;

 using FastNet::Int16;

 using FastNet::Int32;

 using FastNet::Int64;

 using FastNet::Double;

 using FastNet::Float;

 using FastNet::String;

 using FastNet::Bool;

     enum class DemoEnum:FastNet::Int32 {

         one = ,

         two = ,

     };

     struct DemoStruct : public FastNet::Struct {

         bool operator==(DemoStruct const& ) const { return false; }

         bool operator!=(DemoStruct const& ) const { return true; }

         DefStruct("pkt.demo.DemoStruct",,)

         UInt8 u8=;

         UInt16 u16=;

         UInt32 u32=;

         UInt64 u64=;

         Int8 i8=;

         Int16 i16=;

         Int32 i32=;

         Int64 i64=;

         Float f=0.0f;

         Double d=0.0;

         Bool b=false;

         String s="";

         DemoEnum de=(DemoEnum);

         virtual void Deserialize(FastNet::StreamRead& stream) {

             stream.read(u8);

             stream.read(u16);

             stream.read(u32);

             stream.read(u64);

             stream.read(i8);

             stream.read(i16);

             stream.read(i32);

             stream.read(i64);

             stream.read(f);

             stream.read(d);

             stream.read(b);

             stream.read(s);

             stream.read(de);

         }

         virtual void Serialize(FastNet::StreamWrite& stream) {

             stream.write(u8);

             stream.write(u16);

             stream.write(u32);

             stream.write(u64);

             stream.write(i8);

             stream.write(i16);

             stream.write(i32);

             stream.write(i64);

             stream.write(f);

             stream.write(d);

             stream.write(b);

             stream.write(s);

             stream.write(de);

         }

         virtual FastNet::UInt32 SerializeSize() override{

             FastNet::UInt32 size();

             CalcSerializeSize(size,u8);

             CalcSerializeSize(size,u16);

             CalcSerializeSize(size,u32);

             CalcSerializeSize(size,u64);

             CalcSerializeSize(size,i8);

             CalcSerializeSize(size,i16);

             CalcSerializeSize(size,i32);

             CalcSerializeSize(size,i64);

             CalcSerializeSize(size,f);

             CalcSerializeSize(size,d);

             CalcSerializeSize(size,b);

             CalcSerializeSize(size,s);

             CalcSerializeSize(size,de);

             return size;

         }

         virtual void Reset() override{

             u8=;

             u16=;

             u32=;

             u64=;

             i8=;

             i16=;

             i32=;

             i64=;

             f=0.0f;

             d=0.0;

             b=false;

             s="";

             de=(DemoEnum);

         }

         static void Export(){

             boost::python::class_<DemoStruct,boost::python::bases<FastNet::Struct>,boost::shared_ptr<DemoStruct>,boost::noncopyable> _e("DemoStruct");

             boost::python::scope _s = _e;

             _e.def_readwrite("u8",&DemoStruct::u8);

             _e.def_readwrite("u16",&DemoStruct::u16);

             _e.def_readwrite("u32",&DemoStruct::u32);

             _e.def_readwrite("u64",&DemoStruct::u64);

             _e.def_readwrite("i8",&DemoStruct::i8);

             _e.def_readwrite("i16",&DemoStruct::i16);

             _e.def_readwrite("i32",&DemoStruct::i32);

             _e.def_readwrite("i64",&DemoStruct::i64);

             _e.def_readwrite("f",&DemoStruct::f);

             _e.def_readwrite("d",&DemoStruct::d);

             _e.def_readwrite("b",&DemoStruct::b);

             _e.def_readwrite("s",&DemoStruct::s);

             _e.def_readwrite("de",&DemoStruct::de);

             _e.add_static_property("sClsId",&DemoStruct::sClsId);

             _e.add_static_property("sClsName",&DemoStruct::sClsName);

             _e.add_static_property("sSignId",&DemoStruct::sSignId);

         }

     };

     class DemoMessage final: public FastNet::Message {

     public:

         DefStruct("pkt.demo.DemoMessage",,)

         UInt8 u8=;

         UInt16 u16=;

         UInt32 u32=;

         UInt64 u64=;

         Int8 i8=;

         Int16 i16=;

         Int32 i32=;

         Int64 i64=;

         Float f=0.0f;

         Double d=0.0;

         Bool b=false;

         String s="";

         DemoEnum de=(DemoEnum);

         DemoStruct ds;

         std::vector<DemoStruct> arr;

         std::vector<String> arr2;

         std::map<String,DemoStruct> dict2;

         std::map<UInt32,String> dict3;

         virtual void Deserialize(FastNet::StreamRead& stream) {

             stream.read(u8);

             stream.read(u16);

             stream.read(u32);

             stream.read(u64);

             stream.read(i8);

             stream.read(i16);

             stream.read(i32);

             stream.read(i64);

             stream.read(f);

             stream.read(d);

             stream.read(b);

             stream.read(s);

             stream.read(de);

             stream.read(ds);

             stream.read(arr);

             stream.read(arr2);

             stream.read(dict2);

             stream.read(dict3);

         }

         virtual void Serialize(FastNet::StreamWrite& stream) {

             stream.write(u8);

             stream.write(u16);

             stream.write(u32);

             stream.write(u64);

             stream.write(i8);

             stream.write(i16);

             stream.write(i32);

             stream.write(i64);

             stream.write(f);

             stream.write(d);

             stream.write(b);

             stream.write(s);

             stream.write(de);

             stream.write(ds);

             stream.write(arr);

             stream.write(arr2);

             stream.write(dict2);

             stream.write(dict3);

         }

         virtual FastNet::UInt32 SerializeSize() override{

             FastNet::UInt32 size();

             CalcSerializeSize(size,u8);

             CalcSerializeSize(size,u16);

             CalcSerializeSize(size,u32);

             CalcSerializeSize(size,u64);

             CalcSerializeSize(size,i8);

             CalcSerializeSize(size,i16);

             CalcSerializeSize(size,i32);

             CalcSerializeSize(size,i64);

             CalcSerializeSize(size,f);

             CalcSerializeSize(size,d);

             CalcSerializeSize(size,b);

             CalcSerializeSize(size,s);

             CalcSerializeSize(size,de);

             CalcSerializeSize(size,ds);

             CalcSerializeSize(size,arr);

             CalcSerializeSize(size,arr2);

             CalcSerializeSize(size,dict2);

             CalcSerializeSize(size,dict3);

             return size;

         }

         virtual void Reset() override{

             u8=;

             u16=;

             u32=;

             u64=;

             i8=;

             i16=;

             i32=;

             i64=;

             f=0.0f;

             d=0.0;

             b=false;

             s="";

             de=(DemoEnum);

             ds.Reset();

             arr.clear();

             arr2.clear();

             dict2.clear();

             dict3.clear();

         }

         static void Export(){

             boost::python::class_<DemoMessage,boost::python::bases<FastNet::Message>,boost::shared_ptr<DemoMessage>,boost::noncopyable> _e("DemoMessage");

             boost::python::scope _s = _e;

             _e.def_readwrite("u8",&DemoMessage::u8);

             _e.def_readwrite("u16",&DemoMessage::u16);

             _e.def_readwrite("u32",&DemoMessage::u32);

             _e.def_readwrite("u64",&DemoMessage::u64);

             _e.def_readwrite("i8",&DemoMessage::i8);

             _e.def_readwrite("i16",&DemoMessage::i16);

             _e.def_readwrite("i32",&DemoMessage::i32);

             _e.def_readwrite("i64",&DemoMessage::i64);

             _e.def_readwrite("f",&DemoMessage::f);

             _e.def_readwrite("d",&DemoMessage::d);

             _e.def_readwrite("b",&DemoMessage::b);

             _e.def_readwrite("s",&DemoMessage::s);

             _e.def_readwrite("de",&DemoMessage::de);

             _e.def_readwrite("ds",&DemoMessage::ds);

             FastNet::App::RegisterStlVector<std::vector<DemoStruct> >("v_2553082456");

             _e.def_readwrite("arr",&DemoMessage::arr);

             FastNet::App::RegisterStlVector<std::vector<String> >("v_2147306297");

             _e.def_readwrite("arr2",&DemoMessage::arr2);

             FastNet::App::RegisterStlMap<std::map<String,DemoStruct> >("m_2979050852");

             _e.def_readwrite("dict2",&DemoMessage::dict2);

             FastNet::App::RegisterStlMap<std::map<UInt32,String>,true>("m_3331818994");

             _e.def_readwrite("dict3",&DemoMessage::dict3);

             _e.add_static_property("sClsId",&DemoMessage::sClsId);

             _e.add_static_property("sClsName",&DemoMessage::sClsName);

             _e.add_static_property("sSignId",&DemoMessage::sSignId);

         }

     };

 } //end namespace demo

 } //end namespace pkt

使用(Python)：

m = FastNet.Message.Create(demo.DemoMessage.sClsId)

m.u8 = 255

m.u16 = 65535

...

session.SendMsg(m)

使用(C++)：

auto m = FastNet::Message::Create<demo::DemoMessage>();

m->u8 = ;

m->u16 = ;

...

session->SendMsg(m);

FastNet C++/Python 网络通信库之协议的更多相关文章

python常用库
本文由伯乐在线 - 艾凌风翻译,Namco 校稿.未经许可,禁止转载!英文出处:vinta.欢迎加入翻译组. Awesome Python ,这又是一个 Awesome XXX 系列的资源整理,由 ...
python标准库00 学习准备
Python标准库----走马观花 python有一套很有用的标准库.标准库会随着python解释器一起安装在你的电脑上的.它是python的一个组成部分.这些标准库是python为你准备的利器,可以 ...
Python标准库的学习准备
作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明.谢谢! Python标准库是Python强大的动力所在,我们已经在前文中有所介绍.由于标准 ...
Python标准库——走马观花
作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明.谢谢! Python有一套很有用的标准库(standard library).标准库会随着 ...
Python标准库与第三方库详解(转载)
转载地址: http://www.codeweblog.com/python%e6%a0%87%e5%87%86%e5%ba%93%e4%b8%8e%e7%ac%ac%e4%b8%89%e6%96%b ...
python标准库之字符编码详解
codesc官方地址:https://docs.python.org/2/library/codecs.html 相关帮助:http://www.cnblogs.com/huxi/archive/20 ...
[python标准库]Pickle模块
Pickle-------python对象序列化本文主要阐述以下几点: 1.pickle模块简介 2.pickle模块提供的方法 3.注意事项 4.实例解析 1.pickle模块简介 The pic ...
Python常用库大全
环境管理管理 Python 版本和环境的工具 p – 非常简单的交互式 python 版本管理工具. pyenv – 简单的 Python 版本管理工具. Vex – 可以在虚拟环境中执行命令. v ...
python模块：网络协议和支持
python模块:网络协议和支持 webbrowser 调用浏览器显示html文件 webbrowser.open('map.html') [webbrowser - Convenient Web-b ...

随机推荐

hdoj3711【水】
题意: 给你两个集合,对于每个B集合的元素,从A集合找一个数使得a^b的二进制的1个数最少. 思路: 直接搞= = #include <bits/stdc++.h> using names ...
CodeForces 13C【DP】
题意: 给你n个数,每次只能让一个数+1,或者-1,目标是最终使这个序列构成一个非递减的序列: n是5e3,复杂度n^2内.值是1e9: 思路: 可以发现子结构是保证一个区间的非递减, 如果只是dp[ ...
鉴于spfa基础上的差分约束算法
怎么搞? 1. 如果要求最大值想办法把每个不等式变为标准x-y<=k的形式,然后建立一条从y到x权值为k的边,变得时候注意x-y<k =>x-y<=k ...
python list生成表达式
列表生成式即List Comprehensions,是Python内置的非常简单却强大的可以用来创建list的生成式.运用列表生成式,可以写出非常简洁的代码. >>> list(ra ...
bzoj 1060: [ZJOI2007]时态同步【树形dp】
可能算不上dp,大概是个树形模拟先一遍dfs算出f[u]为每个点最深的叶子到u的距离,然后再dfs一下,ans加上f[u]-f[e[i].to]-e[i].va,f[u]-f[e[i].to]是这条 ...
（12）用css设计电子相册 {下}
本篇学习资料讲解: 延续上一篇的学习资料,仍然介绍使用css对电子相册进行排版和侧面强调“盒子模型.标准流.浮动和定位”的重要性. 上篇学习资料介绍的“阵列模式电子相册”,如果也能 ...
P1251 递推专练3
递推专练3 描述 Description 圆周上有N个点.连接任意多条(可能是0条)不相交的弦(共用端点也算相交)共有多少种方案? 输入格式 Input Format 读入一个数N.<=N< ...
common.py OpenCv例程阅读
#!/usr/bin/env python ''' This module contais some common routines used by other samples. ''' import ...
mysql查询所有表名
mysql使用sql查询表名的两种方法: 1.show tables; 2.SELECT TABLE_NAME,TABLE_ROWS FROM INFORMATION_SCHEMA.TABLES WH ...
Oracle、MySQL和SqlServe分页查询的语句区别
★先来定义分页语句将要用到的几个参数: int currentPage ; //当前页 int pageRecord ; //每页显示记录数以之前的ADDRESSBOOK数据表为例(每页显示10条记 ...

FastNet C++/Python 网络通信库之 协议

FastNet C++/Python 网络通信库之 协议的更多相关文章

随机推荐

热门专题

FastNet C++/Python 网络通信库之协议

FastNet C++/Python 网络通信库之协议的更多相关文章