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

随机推荐

hdoj1465【错排公式(直接水过)】
//注意会爆 int #include <bits/stdc++.h> using namespace std; typedef long long LL; typedef unsigne ...
关于 <meta name="viewport" content="width=device-width, initial-scale=1.0">的解释
对于移动开发来讲,我还不太熟悉.今天在github上荡了一个系统源码,进行分析.发现其中有这样一段话: <meta name="viewport" content=" ...
（二分图最大匹配）51NOD 2006 飞行员配对
第二次世界大战时期,英国皇家空军从沦陷国征募了大量外籍飞行员.由皇家空军派出的每一架飞机都需要配备在航行技能和语言上能互相配合的2名飞行员,其中1名是英国飞行员,另1名是外籍飞行员.在众多的飞行员中, ...
（三）SpringBoot定义统一返回result对象
一:定义响应码枚举 package com.example.demo.core.ret; /** * @Description: 响应码枚举,参考HTTP状态码的语义 * @author * @dat ...
tomcat复习
javaEE 服务器: java企业版服务器:是一个标准 BS/CS: 1> CS: client/Server 优点:易操作性比较高缺点:客户端需要升级维护. 2> BS: Brows ...
multiprocessing多进程模块
1 基本理解 python不支持真多线程,无法在单进程中调用多核cpu.对于cpu密集型任务,可以使用多进程.python会调用OS原生多进程,运行在多核上,以此提高运行速度. 2 基本实现 impo ...
Jmeter之文件下载
Jmeter文件下载 1.打开jmeter新建线程组—>http请求 2.在百度上选择一个图片下载,选择图片右击复制图片地址 https://ss1.baidu.com/9vo3dSag_xI4 ...
C/C++ 动态库so的生成与调用
1. Linux-(C/C++)动态链接库生成以及使用(libxxx.so) 2. C++文件如何在linux下生成动态库So,以及如何使用这个动态库 3. c++ 发布动态.so 简记1. 编译生成 ...
Fzu Problem 1901 Period II (kmp)
题目链接: Problem 1901 Period II 题目描述: 给出一个串,满足长度为p的前缀和长度为p的后缀相等的p的个数,输出p的个数,和p分别是多少? 解题思路: 对kmp的next数组的 ...
Educational Codeforces Round 18 B
Description n children are standing in a circle and playing the counting-out game. Children are numb ...

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

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

随机推荐

热门专题

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

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