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

随机推荐

IT兄弟连 Java Web教程 Tomcat
本文采用的Tomcat服务器版本是Tomcat8.5版本,Tomcat8.5支持Servlet3.1.JSP2.3以及EL3.0规范.并且Tomcat8.5版本对JDK8的支持比Tomcat8更加全面 ...
跟我一起玩Win32开发（13）：握手对话框
一提到对话框,相信对它熟悉的人不在少数,更不用说码农们了,你可能会问,对话框和窗口有什么区别吗?本质上是没有区别的,对话框也是一种窗口(前面也说过,控件也可视为子窗口). 最简单的对话框要数Messa ...
h5-16-插入SVG图片
<!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <title> ...
C. Alyona and mex
http://codeforces.com/contest/740/problem/C 构造思维题. 第一直觉就是区间长度+1的最小值就是答案. 然而不知道怎么去构造这个序列. 其实就是每个区间,都要 ...
solrJ的使用--覆盖创建索引，查询，删除索引【转自http://blog.sina.com.cn/s/blog_64ac3ab10100t3mq.html】
package com.xzhe.common.search; import java.util.ArrayList; import java.util.Collection; import java ...
rhel7使用centos7yum组件
1)rpm -qa|grep yum --查看已安装的yum组件包 2)rpm -e 包名 --nodeps --卸载包 3)下载安装以下组件包: 使用rpm -ivh yum-* yum-3.4.3 ...
Centos系统安装 phpredis 扩展
Git地址:https://github.com/nicolasff/phpredis 一.安装: phpize ./configure make && make install 其中 ...
PHP pack和unpack函数详解
pack 压缩资料到位字符串之中. 语法: string pack(string format, mixed [args]...); 返回值: 字符串函数种类: 资料处理内容说明本函数用来将资料 ...
P1979 华容道 spfa题解
题目描述 [问题描述] 小 B 最近迷上了华容道,可是他总是要花很长的时间才能完成一次.于是,他想到用编程来完成华容道:给定一种局面, 华容道是否根本就无法完成,如果能完成, 最少需要多少时间. 小 ...
js中关于this的理解
常见:在普通函数中的this,指向全局 function thisObj(name){ this.name = name; console.log(this); } 但是在严格模式下的函数,this ...

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

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

随机推荐

热门专题

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

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