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 ...

随机推荐

hdoj5818【模拟】
2016 Multi-University Training Contest 7 1010 思路: 我相信T的绝对是直接根据题目意思来了. 正确的一点小转变,比较一下那个队列小,然后把小的给大的,每次 ...
IT兄弟连 JavaWeb教程 ServletContext对象
ServletContext是Servlet与Servlet容器之间直接通信的接口.Servlet容器在启动一个Web应用时,会为它创建一个ServletContext对象.每个Web应用都有唯一的S ...
常用JSTL标签
1.判断是否为空 <c:choose> <c:when test="${not empty reportInfo.user_register_orgs.register_o ...
noi.ac 邀请赛1 By cellur925
A. array 考场:上来就想暴力,首先第一个子任务肯定没问题,怎么搞都行.然后第二个子任务用个数组记下新修的值就行了.第三个子任务用一下等差数列求和公式帮助求解,每次都重新算(因为每次改变全部元素 ...
Asp.net core 框架整理
https://github.com/thangchung/awesome-dotnet-core#cms
Selenium | 基础入门 | 利用Xpath寻找用户框
以微信公众号登陆界面为例, 找到相对应的Xpath的方法, 核心代码: System.setProperty(“webdriver.chrome.driver”,“ C:\\Program Files ...
使用PlSQLDeveloper工具查询Oracle会话数
PlSQLDeveloper工具提供了会话管理功能. 能够查询会话内容.杀死会话.查看会话SQL等操作. 常用的会话查询SQL如下: -- 查询所有会话 select * from v$session ...
正则表达式exec方法的陷阱
http://www.w3school.com.cn/jsref/jsref_exec_regexp.asp exec() 方法的功能非常强大,它是一个通用的方法,而且使用起来也比 test() 方法 ...
Eclipse的ant调用maven
需要在 eclipse 的 windows - preferences - ant - runtime - classpath - global entries 加入 eclipse 里面的 jsch ...
Invitation Cards POJ 1511 SPFA || dij + heap
http://poj.org/problem?id=1511 求解从1去其他顶点的最短距离之和. 加上其他顶点到1的最短距离之和. 边是单向的. 第一种很容易,直接一个最短路, 然后第二个,需要把边反 ...

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

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

随机推荐

热门专题

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

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