quickfast 编解码_quickfast解析中国的fastfix包

最新推荐文章于 2022-04-30 15:28:36 发布
最新推荐文章于 2022-04-30 15:28:36 发布
阅读量329 收藏
点赞数
文章标签： quickfast 编解码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39640573/article/details/111786966
版权

#include //注，解析未完善，仅解析上海深圳所需！！！，喜欢大而全的可以去用xerces来解析。

namespace QuickFAST

{

namespace Codecs

{

//具体的解析函数

bool parse(SegmentBodyPtr body,pugi::xml_node &node_item);

bool parseOp(FieldInstructionPtr field,pugi::xml_node &node_item)

{

pugi::xml_node nodeop=node_item.first_child();

if(nodeop.empty())

return true;

FieldOpPtr op;

std::string opname=nodeop.name();

if(opname=="increment")

op.reset(new FieldOpIncrement());

else if(opname=="default")

op.reset(new FieldOpDefault());

else if(opname=="copy")

op.reset(new FieldOpCopy());

else if(opname=="delta")

op.reset(new FieldOpDelta());

else if(opname=="constant")

{

op.reset(new FieldOpConstant());

}

else

{

return true;

}

std::string dictionary=nodeop.attribute("dictionary").value();

if(!dictionary.empty())

{

op->setDictionaryName(dictionary);

}

std::string key=nodeop.attribute("key").value();;

if(!key.empty())

{

op->setKey(key);

std::string nsKey=nodeop.attribute("nskey").value();

if(!nsKey.empty())

{

op->setKeyNamespace(nsKey);

}

}

std::string value=nodeop.attribute("value").value();

if(!value.empty())

{

op->setValue(value);

}

std::string pmapBitStr=nodeop.attribute("pmap").value();

if(!pmapBitStr.empty())

{

size_t pmapBit = atoi(pmapBitStr.c_str());

op->setPMapBit(pmapBit);

}

field->setFieldOp(op);

return true;

}

bool parseLength(std::string &tag,SegmentBodyPtr body,pugi::xml_node &node_item)

{

std::string name=node_item.attribute("name").value();

std::string ns=node_item.attribute("ns").value();

FieldInstructionPtr field(new FieldInstructionUInt32(name, ns));

std::string id=node_item.attribute("id").value();

if (!id.empty())

{

field->setId(atoi(id.c_str()));

}

std::string presence=node_item.attribute("presence").value();

if(!presence.empty())

{

field->setPresence(presence == "mandatory");

}

parseOp(field,node_item);

body->allowLengthField();

body->addLengthInstruction(field);

return true;

}

bool parseInt8(std::string &tag,SegmentBodyPtr body,pugi::xml_node &node_item)

{

std::string name=node_item.attribute("name").value();

std::string ns=node_item.attribute("ns").value();

FieldInstructionPtr field(new FieldInstructionInt8(name, ns));

std::string id=node_item.attribute("id").value();

if (!id.empty())

{

field->setId(atoi(id.c_str()));

}

std::string presence=node_item.attribute("presence").value();

if(!presence.empty())

{

field->setPresence(presence == "mandatory");

}

parseOp(field,node_item);

body->addInstruction(field);

return true;

}

bool parseUInt8(std::string &tag,SegmentBodyPtr body,pugi::xml_node &node_item)

{

std::string name=node_item.attribute("name").value();

std::string ns=node_item.attribute("ns").value();

FieldInstructionPtr field(new FieldInstructionUInt8(name, ns));

std::string id=node_item.attribute("id").value();

if (!id.empty())

{

field->setId(atoi(id.c_str()));

}

std::string presence=node_item.attribute("presence").value();

if(!presence.empty())

{

field->setPresence(presence == "mandatory");

}

parseOp(field,node_item);

body->addInstruction(field);

return true;

}

//16

bool parseInt16(std::string &tag,SegmentBodyPtr body,pugi::xml_node &node_item)

{

std::string name=node_item.attribute("name").value();

std::string ns=node_item.attribute("ns").value();

FieldInstructionPtr field(new FieldInstructionInt16(name, ns));

std::string id=node_item.attribute("id").value();

if (!id.empty())

{

field->setId(atoi(id.c_str()));

}

std::string presence=node_item.attribute("presence").value();

if(!presence.empty())

{

field->setPresence(presence == "mandatory");

}

parseOp(field,node_item);

body->addInstruction(field);

return true;

}

bool parseUInt16(std::string &tag,SegmentBodyPtr body,pugi::xml_node &node_item)

{

std::string name=node_item.attribute("name").value();

std::string ns=node_item.attribute("ns").value();

FieldInstructionPtr field(new FieldInstructionUInt16(name, ns));

std::string id=node_item.attribute("id").value();

if (!id.empty())

{

field->setId(atoi(id.c_str()));

}

std::string presence=node_item.attribute("presence").value();

if(!presence.empty())

{

field->setPresence(presence == "mandatory");

}

parseOp(field,node_item);

body->addInstruction(field);

return true;

}

//32

bool parseInt32(std::string &tag,SegmentBodyPtr body,pugi::xml_node &node_item)

{

std::string name=node_item.attribute("name").value();

std::string ns=node_item.attribute("ns").value();

FieldInstructionPtr field(new FieldInstructionInt32(name, ns));

std::string id=node_item.attribute("id").value();

if (!id.empty())

{

field->setId(atoi(id.c_str()));

}

std::string presence=node_item.attribute("presence").value();

if(!presence.empty())

{

field->setPresence(presence == "mandatory");

}

parseOp(field,node_item);

body->addInstruction(field);

return true;

}

bool parseUInt32(std::string &tag,SegmentBodyPtr body,pugi::xml_node &node_item)

{

std::string name=node_item.attribute("name").value();

std::string ns=node_item.attribute("ns").value();

FieldInstructionPtr field(new FieldInstructionUInt32(name, ns));

std::string id=node_item.attribute("id").value();

if (!id.empty())

{

field->setId(atoi(id.c_str()));

}

std::string presence=node_item.attribute("presence").value();

if(!presence.empty())

{

field->setPresence(presence == "mandatory");

}

parseOp(field,node_item);

body->addInstruction(field);

return true;

}

//64

bool parseInt64(std::string &tag,SegmentBodyPtr body,pugi::xml_node &node_item)

{

std::string name=node_item.attribute("name").value();

std::string ns=node_item.attribute("ns").value();

FieldInstructionPtr field(new FieldInstructionInt64(name, ns));

std::string id=node_item.attribute("id").value();

if (!id.empty())

{

field->setId(atoi(id.c_str()));

}

std::string presence=node_item.attribute("presence").value();

if(!presence.empty())

{

field->setPresence(presence == "mandatory");

}

parseOp(field,node_item);

body->addInstruction(field);

return true;

}

bool parseUInt64(std::string &tag,SegmentBodyPtr body,pugi::xml_node &node_item)

{

std::string name=node_item.attribute("name").value();

std::string ns=node_item.attribute("ns").value();

FieldInstructionPtr field(new FieldInstructionUInt64(name, ns));

std::string id=node_item.attribute("id").value();

if (!id.empty())

{

field->setId(atoi(id.c_str()));

}

std::string presence=node_item.attribute("presence").value();

if(!presence.empty())

{

field->setPresence(presence == "mandatory");

}

parseOp(field,node_item);

body->addInstruction(field);

return true;

}

bool parseDecimal(std::string &tag,SegmentBodyPtr body,pugi::xml_node &node_item)

{

std::string name=node_item.attribute("name").value();

std::string ns=node_item.attribute("ns").value();

FieldInstructionPtr field(new FieldInstructionDecimal(name, ns));

std::string id=node_item.attribute("id").value();

if (!id.empty())

{

field->setId(atoi(id.c_str()));

}

std::string presence=node_item.attribute("presence").value();

if(!presence.empty())

{

field->setPresence(presence == "mandatory");

}

parseOp(field,node_item);

body->addInstruction(field);

return true;

}

bool parseString(std::string &tag,SegmentBodyPtr body,pugi::xml_node &node_item)

{

std::string name=node_item.attribute("name").value();

std::string ns=node_item.attribute("ns").value();

std::string charset = "ascii";

if(!node_item.attribute("charset").empty())

charset=node_item.attribute("charset").value();

FieldInstructionPtr field;

if(charset == "unicode")

{

field.reset(new FieldInstructionUtf8(name, ns));

}

else

{

field.reset(new FieldInstructionAscii(name, ns));

}

std::string id=node_item.attribute("id").value();

if (!id.empty())

{

field->setId(atoi(id.c_str()));

}

std::string presence=node_item.attribute("presence").value();

if(!presence.empty())

{

field->setPresence(presence == "mandatory");

}

parseOp(field,node_item);

body->addInstruction(field);

return true;

}

bool parseSequence(std::string &tag,SegmentBodyPtr body,pugi::xml_node &node_item)

{

std::string name=node_item.attribute("name").value();

std::string ns=node_item.attribute("ns").value();

FieldInstructionPtr field(new FieldInstructionSequence(name, ns));

std::string id=node_item.attribute("id").value();

if (!id.empty())

{

field->setId(atoi(id.c_str()));

}

std::string presence=node_item.attribute("presence").value();

bool mandatory = false;

if(!presence.empty())

{

mandatory = (presence == "mandatory");

field->setPresence(mandatory);

}

std::string dictionary=node_item.attribute("dictionary").value();

if(!dictionary.empty())

{

field->setDictionaryName(dictionary);

}

SegmentBodyPtr seqbody(new SegmentBody);

field->setSegmentBody(seqbody);

for(pugi::xml_node node_subitem=node_item.first_child();!node_subitem.empty();node_subitem=node_subitem.next_sibling())

{

//parse_template(node_item,templateRegistry);

std::string itemname=node_subitem.name();

parse(seqbody,node_subitem);

int xxx=1;

}

seqbody->allowLengthField();

seqbody->setMandatoryLength(mandatory);

body->addInstruction(field);

return true;

}

bool parseGroup(std::string &tag,SegmentBodyPtr body,pugi::xml_node &node_item)

{

std::string name=node_item.attribute("name").value();

std::string ns=node_item.attribute("ns").value();

FieldInstructionPtr field(new FieldInstructionGroup(name, ns));

std::string id=node_item.attribute("id").value();

if (!id.empty())

{

field->setId(atoi(id.c_str()));

}

std::string presence=node_item.attribute("presence").value();

bool mandatory = false;

if(!presence.empty())

{

mandatory = (presence == "mandatory");

field->setPresence(mandatory);

}

std::string dictionary=node_item.attribute("dictionary").value();

if(!dictionary.empty())

{

field->setDictionaryName(dictionary);

}

SegmentBodyPtr seqbody(new SegmentBody);

field->setSegmentBody(seqbody);

for(pugi::xml_node node_subitem=node_item.first_child();!node_subitem.empty();node_subitem=node_subitem.next_sibling())

{

//parse_template(node_item,templateRegistry);

std::string itemname=node_subitem.name();

parse(seqbody,node_subitem);

int xxx=1;

}

seqbody->allowLengthField();

seqbody->setMandatoryLength(mandatory);

body->addInstruction(field);

return true;

}

bool parse(SegmentBodyPtr body,pugi::xml_node &node_item)

{

//解析子函数

std::string tag=node_item.name();

if (tag == "int8")

{

parseInt8(tag, body,node_item);

}

else if (tag == "uInt8")

{

parseUInt8(tag, body,node_item);

}

else if (tag == "int16")

{

parseInt16(tag, body,node_item);

}

else if (tag == "uInt16")

{

parseUInt16(tag, body,node_item);

}

else if (tag == "int32")

{

parseInt32(tag, body,node_item);

}

else if (tag == "uInt32")

{

parseUInt32(tag, body,node_item);

}

else if (tag == "int64")

{

parseInt64(tag, body,node_item);

}

else if (tag == "uInt64")

{

parseUInt64(tag, body,node_item);

}

else if (tag == "decimal")

{

parseDecimal(tag, body,node_item);

}

else if (tag == "string")

{

parseString(tag, body,node_item);

}

else if (tag == "sequence")

{

parseSequence(tag, body,node_item);

}

else if(tag=="group")

{

parseGroup(tag,body,node_item);

}

else if(tag=="length")

{

parseLength(tag,body,node_item);

}

else

{

int xxsd=1;

}

return true;

}

bool parse_template(pugi::xml_node &node_template,TemplateRegistryPtr registry_)

{

TemplatePtr target(new Template);

target->setTemplateName(node_template.attribute("name").value());

std::string ns=node_template.attribute("ns").value();

if(!ns.empty())

{

target->setNamespace(ns);

}

std::string templateNs=node_template.attribute("templateNs").value();

if(!templateNs.empty())

{

target->setTemplateNamespace(templateNs);

}

std::string id=node_template.attribute("id").value();

if (!id.empty())

{

target->setId(

boost::lexical_cast(id)

);

}

std::string dictionary=node_template.attribute("dictionary").value();

if (!dictionary.empty())

{

target->setDictionaryName(dictionary);

}

bool ignore=node_template.attribute("ignore").as_bool();

target->setIgnore(ignore);

//解析具体的字段

for(pugi::xml_node node_item=node_template.first_child();!node_item.empty();node_item=node_item.next_sibling())

{

//parse_template(node_item,templateRegistry);

std::string itemname=node_item.name();

parse(target,node_item);

int xxx=1;

}

registry_->addTemplate(target);

return true;

}

TemplateRegistryPtr parse_template_file(const char *file)

{

pugi::xml_document doc;

if(!doc.load_file(file))

{

throw 0;

}

pugi::xml_node root_node=doc.document_element();

if(root_node.empty())

{

throw 1;

}

TemplateRegistryPtr templateRegistry(

new TemplateRegistry

);

for(pugi::xml_node node_template=root_node.first_child();!node_template.empty();node_template=node_template.next_sibling())

{

parse_template(node_template,templateRegistry);

}

templateRegistry->finalize();

return templateRegistry;

}

}

}

weixin_39640573
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
quickfast-linux：QuickFAST-用于本机C ++ linux的FAST协议的实现
02-07
QuickFAST / FIX适用于流协议（Linux） 依存关系 安装 在ubuntu 14.04上进行了测试，并在deps中填充了库的版本 步骤1：为编译过程准备环境 安装编译工具和依赖项，请遵循以下命令： $ sudo apt-get install build-essential g++ python-dev autotools-dev libicu-dev build-essential libbz2-dev libboost-all-dev libxml2 创建工作目录并将依赖项移至创建的文件夹。 在tar.gz中下载依赖项归档文件（“依赖项”部分中的跟随链接），将源保存到
编译quickfast解析库（沪深level2行情转码库）
热门推荐
开心乐源的专栏
12-26 1万+
编译链接level2行情转码机. 下载quickfast项目（windows平台）： http://quickfast.googlecode.com/files/quickfast_win_src_1_4.zip 下载第三方库： 1，下载activeperl （google it） 2，下载mpc http://www.ociweb.com/produ
quickfast 编解码_fast和quick的区别
weixin_39611765的博客
01-13 389
展开全部1，词性上面的区别。fast既是形容词，也是副词。quick是形容词，它的副词形式是quickly。2，强调重e5a48de588b63231313335323631343130323136353331333431343031点不同。fast强调速度快，强调的是“速度”。比如：一辆汽车行驶的非常快(It's a very fast car)，一个人跑的非常快(He runs very fa...
FAST 协议解析 （一） 一个最简单的FAST编解码例子
qq_33601179的博客
01-05 2377
废话 能搜到的文档，比我头发还少，有个OpenFast的包是专门解析这玩意的（C++的是QuickFast），但是官网都打不开了，搜又全是风力发电模拟的玩意（也是叫OpenFast这个名字）。 甚至我下载到了一个OpenFast的源码+包+文档，我都无法确定这玩意是不是我要的东西，反正就是令人头大头秃。 通俗理解 FAST协议，详情可以查看《FAST 1.1 规范中文版全文参考》，推荐还是看一下吧，就算不需要懂原理，但想要知道支持哪几种类型也总得翻翻书不是。 通俗点的说法，就是打包解包，可以理解.
cmake3 编译 quickfast
gaoli8393的博客
04-30 417
cmake3编译示例 linux环境编译quickfast
FastFix:戴尔支持代理的快速修复-开源
06-06
一个小型实用工具，可减少时间和搜索以将可下载到客户端系统。 仍处于测试版，因此改进将继续进行。 它专供 Dell @ Sitel Mumbai。 软件有任何问题或反馈，请联系：[email protected]
FastFix Remote Software Maintenance:远程软件维护的监视控制-开源
05-12
FastFix的总体目的是为软件工程师提供及时的维护环境，以提高效率并降低总成本，提高故障原因识别的准确性并促进其解决。 监视软件执行故障复制补丁生成
jquery.event.fastfix:jquery.event.fix 的嵌入式回流友好替代品
06-19
jquery.event.fastfix jquery.event.fix的内部结构可能会在某些事件期间导致回流。 这个库提供了一个使用 ES5 getter 来避免这个问题的替代品。 代码基本上是 fastfix 的独立副本，支持AMD / CommonJS和一些小的...
java笔试题算法-SubMicroTrading:超低延迟交易框架（FixEngine、OMS、FastFix、ETI、AlgoContai
06-03
java笔试题算法
FastFix2.0:FastFix是一个网站，专为汽车维修车间和需要寻找最佳汽车维修地点的人们提供。 在芬兰，类似物是autojerry.fi
03-29
FastFix2.0:FastFix是一个网站，专为汽车维修车间和需要寻找最佳汽车维修地点的人们提供。 在芬兰，类似物是autojerry.fi
java英文的笔试题-quickfast:FAST协议的C++实现
06-13
java中文的笔试题QuickFAST——本机 C++ 和 .NET 的 FAST 协议的实现 QuickFAST 是 FAST 协议 [SM] 的开源本机 C++ 实现。 FAST（Fix Adapted for STreaming）协议由 FIX Protocol Limited [FPL] () 开发，作为减少带宽和网络延迟的一种方式 由于 FAST 并非特定于市场数据或金融行业，因此有机会在各种情况下使用 FAST。 QuickFAST 被编写为可移植到许多平台。 它在 Windows 和 Linux 上进行了常规测试。 该项目还包括一个支持在 .NET 环境中使用 QuickFAST 的 .NET 包装器。 询问您是否需要其他平台的支持。 说明 QuickFAST 由 Object Computing Inc. (OCI) St. Louis Missouri USA 开发。 OCI 已将 QuickFAST 作为开源软件提供，无需支付开发或运行时许可费用即可使用。 OCI 为 QuickFAST 提供商业支持。 有关 QuickFAST 的问题和讨论，请访问 ###列表规则
quickfast:快速编解码器的回购
06-08
_ _ __ _ __ _ _ _(_) ___| | __/ _| __ _ ___| |_ / _` | | | | |/ __| |/ / |_ / _` / __| __| | (_| | |_| | | (__| <| _| (_| \__ \ |_ \__, |\__,_|_|\___|_|\_\_| \__,_|___/\__| |_| 用于快速编解码器的回购。 ＃＃＃安装 cd \win\v1.4\quickfast_1_4_0 修
FAST技术及在上海证券交易所的应用 - 转载
wqfhenanxc的专栏
05-22 2499
个人读后小结： FAST协议也是一套自身比较完整的协议，包括协议层和会话层，目前国内交易所使用FAST协议，主要还是在STEP协议的内部使用FAST的压缩算法，将STEP消息体（具体一点对于L2行情来说，就是tag96的内容）压缩。 FAST采用了多种压缩数据的方法： 1.利用先后发送的消息间的字段数据的规律和相互联系来降低冗余度。定义了copy、delta、default、increment、constant、tail等运算符来对字段进行优化运算。 2. “隐示标签”：通过模版规定了字段的顺序、.
quickfast 编解码_quickfast解析中国的fastfix包--2
weixin_35600369的博客
01-30 238
#include #include "XmlTemplateParser_Pugixml.h"class FastFixConsumer : public QuickFAST::Codecs::MessageConsumer{public:FastFixConsumer(){pdata=NULL;cb=NULL;}~FastFixConsumer(){}virtual bool consumeMe...
fix/fast协议中PMAP（存在图）和Sequence的解析要点
wmnothing的专栏
08-08 5849
fix/fast协议中PMAP（存在图）和Sequence的解析要点   吴旻 泰岩网络工作室            因为升级的原因，我整理了一个从前的兄弟写的FIX/FAST解析代码。其中一直让我看不懂的是PMAP和Sequence的解法（因为代码事实上是有问题的），我也没找到相关的文档。下载了Quickfast的安装包，费了牛劲安装好，发现更复杂。好在只用到了一点点，算是把这两件事弄
深交所第五版行情解析
嘉诩的专栏
02-26 2082
深交所第五版行情用到了FIX和FAST协议，正好有几个开源项目可以拿来用，比如QUICKFix，QUICKFAST。quickFast托管在google code上，由于众所周知的原因，无法直接获得。我是在github上找了一个分支。 FAST是二进制的，FIX是字符串的 C/C++这样char和byte不区分的还好 用.net版的QuickFIX解析，就会有问题，因为.Net里的Char是
quickfast 编解码_QuickReport 转换成 FastReport时，中文乱码的解决方式
weixin_39946239的博客
12-21 166
我用的是fastreport 4.68这个版本中有个单元：ConverterQR2FR.pas，就是用来将 quickrep转换成fastreport的，转换过程中，注意事项：1.代码中要 using ConverterQR2FR2.quickreport要4.0以上的版本，delphi6自带的版本缺少一个const定义，无法转换 delphifasns.com上有quickrep4.05的下载3...
quickfast 编解码_词汇辨析—fast和quick，quickly的区别（吕兵老师）
weixin_39973410的博客
12-21 4652
一、词性上面的区别：fast既是形容词，也是副词。quick是形容词，它的副词形式是quickly。二、fast和quick，quickly都翻译成“快速”，但是它们强调的地方是完全不一样的。1)fast表示物体的运动速度很快，强调的是“速度”。比如：一辆汽车在快速行驶；一个人在快速奔跑。在此时，我们不能使用quick来表达。例如：It is a fast train.它是一辆速度很快的火车。(强...
quickfast 编解码_quickfast解析中国的fastfix包--3
weixin_39805119的博客
12-21 233
BastEt2014-4-7 15:43:00阅读(1913)评论(0)编译quickfast，其实很容易就编译出来了，我用的是vc2003,把xerces解析的地方去掉了。QQ:43791167,有不对或者好的思路，不妨共享。一般要修改一些地方，比如说加上decoder的设置模板id，在message里加个成员变量templateid，这样会方便不少。比如这里可能就可以这样写：Messages:...
quickfast 编解码_区别辨析fast、quick、rapid、swift、hasty、prompt、speedy与instant
weixin_39611510的博客
12-30 1561
fast、quick、rapid、swift、hasty、prompt、speedy与instant这些形容词均含有“快速”的意思。fast : 常指人或物持续地高速运动，强调运动的方式。fast cars速度快的汽车a fast swimmer速度快的游泳者Computers are getting faster all the time.计算机的速度在不断提升。The fast train (...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值