xml 与 protobuf之间的转换

最新推荐文章于 2024-05-22 07:56:23 发布
最新推荐文章于 2024-05-22 07:56:23 发布
阅读量6k 收藏 2
点赞数 2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WEIWODUMO/article/details/50433938
版权
这段代码展示了如何使用C++将TinyXML解析的XML数据转换为protobuf消息，以及将protobuf消息转换回XML。它利用了protobuf的反射API来处理各种字段类型，并支持不同的字符编码。
摘要由CSDN通过智能技术生成 
#ifndef _INTER_PROTO_TINYXML_H_
#define _INTER_PROTO_TINYXML_H_


#include <string>
#include "google/protobuf/message.h"


bool tinyxml2proto(const std::string& xml, google::protobuf::Message& msg);


enum tinyxml_type
{
	TINYXML_GB2312,
	TINYXML_UTF8,
};


bool proto2tinyxml(const google::protobuf::Message& msg, std::string& xml, tinyxml_type type = TINYXML_UTF8);


#endif //_INTER_PROTO_TINYXML_H_
#include "InterProtoTinyXml.h"
#include "tinyxml/tinyxml.h"
#include "google/protobuf/descriptor.h"
#include "utils/utils.h"

#define INTER_PROTO_TINYXML_NAME		"_name"
#define INTER_PROTO_TINYXML_VALUE		"_value"
#define INTER_PROTO_TINYXML_ATTR		"_attr_"
#define INTER_PROTO_TINYXML_ATTR_SIZE	6

using namespace google::protobuf;

template<class T>
static T get_xml_field(TiXmlNode* node, bool& get_ok)
{
	for(TiXmlNode* child_node = node->FirstChild(); child_node != NULL; child_node = node->NextSibling())
	{
		if(child_node->Type() == TiXmlNode::TINYXML_TEXT)
		{
			get_ok = true;
			return from_string<T>(string_trim(child_node->ValueStr(), " \r\n\t\""));
		}
	}

	get_ok = false;
	return T();
}

template<>
static std::string get_xml_field<std::string>(TiXmlNode* node, bool& get_ok)
{
	for(TiXmlNode* child_node = node->FirstChild(); child_node != NULL; child_node = node->NextSibling())
	{
		if(child_node->Type() == TiXmlNode::TINYXML_TEXT)
		{
			get_ok = true;
			return string_trim(child_node->ValueStr(), " \r\n\t\"");
		}
	}

	get_ok = false;
	return "";
}

template<>
static bool get_xml_field<bool>(TiXmlNode* node, bool& get_ok)
{
	for(TiXmlNode* child_node = node->FirstChild(); child_node != NULL; child_node = node->NextSibling())
	{
		if(child_node->Type() == TiXmlNode::TINYXML_TEXT)
		{
			get_ok = true;
			return (bool)from_string<int>(string_trim(child_node->ValueStr(), " \r\n\t\""));
		}
	}

	get_ok = false;
	return false;
}

static bool parse_xmlattr2proto(TiXmlElement* element, google::protobuf::Message& msg)
{
	if(!element)
	{
		assert(0);
		return false;
	}
	
	//解析XML文件
	const google::protobuf::Reflection* reflection = msg.GetReflection();
	const google::protobuf::Descriptor* des = msg.GetDescriptor();
	for(TiXmlAttribute* attr = element->FirstAttribute(); attr != NULL; attr = attr->Next())
	{
		std::string name = attr->Name();
		std::string value = attr->Value();
		const google::protobuf::FieldDescriptor* fd = des->FindFieldByName(INTER_PROTO_TINYXML_ATTR + name);
		if(fd)
		{
			switch(fd->type())
			{
				// double, exactly eight bytes on the wire.
			case FieldDescriptor::TYPE_DOUBLE:
				if(fd->is_repeated())
				{
					reflection->AddDouble(&msg, fd, from_string<double>(value));
				}
				else
				{
					reflection->SetDouble(&msg, fd, from_string<double>(value));
				}

				break;

				// float, exactly four bytes on the wire.
			case FieldDescriptor::TYPE_FLOAT:
				if(fd->is_repeated())
				{
					reflection->AddFloat(&msg, fd, from_string<float>(value));
				}
				else
				{
					reflection->SetFloat(&msg, fd, from_string<float>(value));
				}

				break;

				// int32, varint on the wire.  Negative numbers
				// take 10 bytes.  Use TYPE_SINT32 if negative
				// values are likely.
			case FieldDescriptor::TYPE_INT32:
				// int32, exactly four bytes on the wire
			case FieldDescriptor::TYPE_SFIXED32:
				// int32, ZigZag-encoded varint on the wire
			case FieldDescriptor::TYPE_SINT32:
				if(fd->is_repeated())
				{
					reflection->AddInt32(&msg, fd, from_string<google::protobuf::int32>(value));
				}
				else
				{
					reflection->SetInt32(&msg, fd, from_string<google::protobuf::int32>(value));
				}

				break;

				// uint32, varint on the wire
			case FieldDescriptor::TYPE_UINT32:
				// uint32, exactly four bytes on the wire.
			case FieldDescriptor::TYPE_FIXED32:
				if(fd->is_repeated())
				{
					reflection->AddUInt32(&msg, fd, from_string<google::protobuf::uint32>(value));
				}
				else
				{
					reflection->SetUInt32(&msg, fd, from_string<google::protobuf::uint32>(value));
				}

				break;

				// int64, varint on the wire.  Negative numbers
				// take 10 bytes.  Use TYPE_SINT64 if negative
				// values are likely.
			case FieldDescriptor::TYPE_INT64:
				// int64, exactly eight bytes on the wire
			case FieldDescriptor::TYPE_SFIXED64:
				// int64, ZigZag-encoded varint on the wire
			case FieldDescriptor::TYPE_SINT64:
				if(fd->is_repeated())
				{
					reflection->AddInt64(&msg, fd, from_string<google::protobuf::int64>(value));
				}
				else
				{
					reflection->SetInt64(&msg, fd, from_string<google::protobuf::int64>(value));
				}
				break;

				// uint64, varint on the wire.
			case FieldDescriptor::TYPE_UINT64:
				// uint64, exactly eight bytes on the wire.
			case FieldDescriptor::TYPE_FIXED64:
				if(fd->is_repeated())
				{
					reflection->AddUInt64(&msg, fd, from_string<google::protobuf::uint64>(value));
				}
				else
				{
					reflection->SetUInt64(&msg, fd, from_string<google::protobuf::uint64>(value));
				}

				break;

				// bool, varint on the wire.
			case FieldDescriptor::TYPE_BOOL:
				if(fd->is_repeated())
				{
					reflection->AddBool(&msg, fd, from_string<bool>(value));
				}
				else
				{
					reflection->SetBool(&msg, fd, from_string<bool>(value));
				}

				break;

				// UTF-8 text.
			case FieldDescriptor::TYPE_STRING:
				// Arbitrary byte array.
			case FieldDescriptor::TYPE_BYTES:
				if(fd->is_repeated())
				{
					reflection->AddString(&msg, fd, value);
				}
				else
				{
					reflection->SetString(&msg, fd, value);
				}

				break;

				// Tag-delimited message.  Deprecated.
			case FieldDescriptor::TYPE_GROUP:
				// Length-delimited message.
			case FieldDescriptor::TYPE_MESSAGE:
				assert(0);
				return false;
				break;

				// Enum, varint on the wire
			case FieldDescriptor::TYPE_ENUM:
				{
					const google::protobuf::EnumValueDescriptor* evd = fd->enum_type()->FindValueByNumber(from_string<int>(value));
					if(!evd)
					{
						return false;
					}

					if(fd->is_repeated())
					{
						reflection->AddEnum(&msg, fd, evd);
					}
					else
					{
						reflection->SetEnum(&msg, fd, evd);
					}
				}

				break;
			default:
				assert(0);
				return false;
				break;
			}
		}
	}

	return true;
}

static bool parse_xml2proto_msg(TiXmlNode* node, google::protobuf::Message& msg)
{
	assert(node && node->Type() == TiXmlNode::TINYXML_ELEMENT);
	//解析XML文件
	const google::protobuf::Reflection* reflection = msg.GetReflection();
	const google::protobuf::Descriptor* des = msg.GetDescriptor();
	for(TiXmlNode* child_node = node->FirstChild(); child_node != NULL; child_node = child_node->NextSibling())
	{
		std::string child_value = child_node->ValueStr();
		switch(child_node->Type())
		{
		case TiXmlNode::TINYXML_ELEMENT:
			{
				const google::protobuf::FieldDescriptor* fd = des->FindFieldByName(child_value);
				if(fd)
				{
					switch(fd->type())
					{
						// double, exactly eight bytes on the wire.
					case FieldDescriptor::TYPE_DOUBLE:
						{
							bool get_ok = false;
							double temp_value = get_xml_field<double>(child_node, get_ok);
							if(!get_ok)
							{
								return false;
							}

							if(fd->is_repeated())
							{
								reflection->AddDouble(&msg, fd, temp_value);
							}
							else
							{
								reflection->SetDouble(&msg, fd, temp_value);
							}
						}
						
						break;

						// float, exactly four bytes on the wire.
					case FieldDescriptor::TYPE_FLOAT:
						{
							bool get_ok = false;
							float temp_value = get_xml_field<float>(child_node, get_ok);
							if(!get_ok)
							{
								return false;
							}

							if(fd->is_repeated())
							{
								reflection->AddFloat(&msg, fd, temp_value);
							}
							else
							{
								reflection->SetFloat(&msg, fd, temp_value);
							}
						}
						break;

						// int32, varint on the wire.  Negative numbers
						// take 10 bytes.  Use TYPE_SINT32 if negative
						// values are likely.
					case FieldDescriptor::TYPE_INT32:
						// int32, exactly four bytes on the wire
					case FieldDescriptor::TYPE_SFIXED32:
						// int32, ZigZag-encoded varint on the wire
					case FieldDescriptor::TYPE_SINT32:
						{
							bool get_ok = false;
							google::protobuf::int32 temp_value = get_xml_field<google::protobuf::int32>(child_node, get_ok);
							if(!get_ok)
							{
								return false;
							}

							if(fd->is_repeated())
							{
								reflection->AddInt32(&msg, fd, temp_value);
							}
							else
							{
								reflection->SetInt32(&msg, fd, temp_value);
							}
						}

						break;

						// uint32, varint on the wire
					case FieldDescriptor::TYPE_UINT32:
						// uint32, exactly four bytes on the wire.
					case FieldDescriptor::TYPE_FIXED32:
						{
							bool get_ok = false;
							google::protobuf::uint32 temp_value = get_xml_field<google::protobuf::uint32>(child_node, get_ok);
							if(!get_ok)
							{
								return false;
							}

							if(fd->is_repeated())
							{
								reflection->AddUInt32(&msg, fd, temp_value);
							}
							else
							{
								reflection->SetUInt32(&msg, fd, temp_value);
							}
						}

						break;

						// int64, varint on the wire.  Negative numbers
						// take 10 bytes.  Use TYPE_SINT64 if negative
						// values are likely.
					case FieldDescriptor::TYPE_INT64:
						// int64, exactly eight bytes on the wire
					case FieldDescriptor::TYPE_SFIXED64:
						// int64, ZigZag-encoded varint on the wire
					case FieldDescriptor::TYPE_SINT64:
						{
							bool get_ok = false;
							google::protobuf::int64 temp_value = get_xml_field<google::protobuf::int64>(child_node, get_ok);
							if(!get_ok)
							{
								return false;
							}

							if(fd->is_repeated())
							{
								reflection->AddInt64(&msg, fd, temp_value);
							}
							else
							{
								reflection->SetInt64(&msg, fd, temp_value);
							}
						}

						break;

						// uint64, varint on the wire.
					case FieldDescriptor::TYPE_UINT64:
						// uint64, exactly eight bytes on the wire.
					case FieldDescriptor::TYPE_FIXED64:
						{
							bool get_ok = false;
							google::protobuf::uint64 temp_value = get_xml_field<google::protobuf::uint64>(child_node, get_ok);
							if(!get_ok)
							{
								return false;
							}

							if(fd->is_repeated())
							{
								reflection->AddUInt64(&msg, fd, temp_value);
							}
							else
							{
								reflection->SetUInt64(&msg, fd, temp_value);
							}
						}

						break;

						// bool, varint on the wire.
					case FieldDescriptor::TYPE_BOOL:
						{
							bool get_ok = false;
							bool temp_value = get_xml_field<bool>(child_node, get_ok);
							if(!get_ok)
							{
								return false;
							}

							if(fd->is_repeated())
							{
								reflection->AddBool(&msg, fd, temp_value);
							}
							else
							{
								reflection->SetBool(&msg, fd, temp_value);
							}
						}

						break;

						// UTF-8 text.
					case FieldDescriptor::TYPE_STRING:
						// Arbitrary byte array.
					case FieldDescriptor::TYPE_BYTES:
						{
							bool get_ok = false;
							std::string temp_value = get_xml_field<std::string>(child_node, get_ok);
							if(!get_ok)
							{
								return false;
							}

							if(fd->is_repeated())
							{
								reflection->AddString(&msg, fd, temp_value);
							}
							else
							{
								reflection->SetString(&msg, fd, temp_value);
							}
						}

						break;

						// Tag-delimited message.  Deprecated.
					case FieldDescriptor::TYPE_GROUP:
						// Length-delimited message.
					case FieldDescriptor::TYPE_MESSAGE:
						if(fd->is_repeated())
						{
							if(!parse_xml2proto_msg(child_node, *reflection->AddMessage(&msg, fd)))
							{
								return false;
							}
						}
						else
						{
							if(!parse_xml2proto_msg(child_node, *reflection->MutableMessage(&msg, fd)))
							{
								return false;
							}
						}

						break;

						// Enum, varint on the wire
					case FieldDescriptor::TYPE_ENUM:
						{
							bool get_ok = false;
							int temp_value = get_xml_field<int>(child_node, get_ok);
							if(!get_ok)
							{
								return false;
							}

							const google::protobuf::EnumValueDescriptor* evd = fd->enum_type()->FindValueByNumber(temp_value);
							if(!evd)
							{
								return false;
							}

							if(fd->is_repeated())
							{
								reflection->AddEnum(&msg, fd, evd);
							}
							else
							{
								reflection->SetEnum(&msg, fd, evd);
							}
						}

						break;
					default:
						assert(0);
						return false;
						break;
					}
				}
			}

			break;
		case TiXmlNode::TINYXML_TEXT:
			{
				const google::protobuf::FieldDescriptor* fd = des->FindFieldByName(INTER_PROTO_TINYXML_VALUE);
				if(fd)
				{
					child_value = string_trim(child_value, " \r\n\t\"");
					switch(fd->type())
					{
						// double, exactly eight bytes on the wire.
					case FieldDescriptor::TYPE_DOUBLE:
						if(fd->is_repeated())
						{
							reflection->AddDouble(&msg, fd, from_string<double>(child_value));
						}
						else
						{
							reflection->SetDouble(&msg, fd, from_string<double>(child_value));
						}

						break;

						// float, exactly four bytes on the wire.
					case FieldDescriptor::TYPE_FLOAT:
						if(fd->is_repeated())
						{
							reflection->AddFloat(&msg, fd, from_string<float>(child_value));
						}
						else
						{
							reflection->SetFloat(&msg, fd, from_string<float>(child_value));
						}

						break;
				
						// int32, varint on the wire.  Negative numbers
						// take 10 bytes.  Use TYPE_SINT32 if negative
						// values are likely.
					case FieldDescriptor::TYPE_INT32:
						// int32, exactly four bytes on the wire
					case FieldDescriptor::TYPE_SFIXED32:
						// int32, ZigZag-encoded varint on the wire
					case FieldDescriptor::TYPE_SINT32:
						if(fd->is_repeated())
						{
							reflection->AddInt32(&msg, fd, from_string<google::protobuf::int32>(child_value));
						}
						else
						{
							reflection->SetInt32(&msg, fd, from_string<google::protobuf::int32>(child_value));
						}

						break;
						
						// uint32, varint on the wire
					case FieldDescriptor::TYPE_UINT32:
						// uint32, exactly four bytes on the wire.
					case FieldDescriptor::TYPE_FIXED32:
						if(fd->is_repeated())
						{
							reflec
最低0.47元/天 解锁文章
WEIWODUMO
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
protobuf转换为json
09-23
protobuf转换为json，原版中存在bug，使用时候修复了原版的bug
protobuf与json转换小结
10-19
总之，protobuf与JSON之间的转换是通过特定的库和工具实现的，例如Google的`protobuf-java-format`，它解决了protobuf对象的非标准类型与JSON要求的字符串键之间的不兼容性。在实际项目中，正确地进行这种转换对于...
protobuf/json/xml/binary/Thrift数据交换
weixin_34235105的博客
03-07 123
一条消息数据，用protobuf序列化后的大小是json的10分之一，xml格式的20分之一，是二进制序列化的10分之一，总体看来ProtoBuf的优势还是很明显的 protobuf是google提供的一个开源序列化框架，类似于XML，JSON这样的数据表示语言，详情访问protobuf的google官方网站 protobuf在google中是一个比较核心的基础库，作为分布式运算涉及到大量的不...
XML、Json、Protobuf序列化协议
最新发布
m0_73537205的博客
05-22 933
来源：json、xml、protobuf性能对比。
互联网传输：从XML到protcolbuffer
wangzhezhilu001的专栏
08-26 227
1.概述 2.最基础的传输格式：XML 3.另一种广泛的传输格式：JSON 4.最新的格式：protocolbuffer 5.结论
protobuf & xml浅见
weixin_30444105的博客
10-20 128
XML格式，那么多tag，一眼就看出来再怎么好的解析器，效率也好不到哪去，比纯粹binary的raw格式效率肯定差太远。本质上是明文字符串，在网络上传输量也大，因此传输效率也不高，当做配置文件用比较好，不仅给人看直观，层次结构也比较清晰。十几年前，各路大神，大软件商都齐声高歌我们完全兼容支持XML。原谅我Don Box大神的<<Essential XML>>这书我只看了看封...
根据proto文件配合tinyxml2自动解析xml
auccy的博客
08-18 826
使用Xml文件每次解析起来都很麻烦，一直想实现一个根据配置自动解析Xml的功能，迟迟没有好的方案，正好最近在看Protobuf相关的知识，发现Protobuf的一些特性可以用来实现自动解析Xml，便使用Protobuf的相关特性配合tinyxml2，根据proto配置文件实现了Xml的自动解析功能。 自动解析的实现流程： 1.根据xml文件配置proto文件.proto文件是什么 ...
源代码以及protobuf文件转换工具
12-30
protobuf，全称Protocol Buffers，是Google开发的一种数据序列化协议，用于结构化数据的串行化，类似于XML、JSON，但更小、更快、更简单。它允许你定义数据结构，然后使用特殊生成的源代码轻松地在各种数据流之间...
Protobuf工具 Google官方协议转换工具
12-23
Protobuf提供的是一种高效、跨平台且语言无关的数据编码格式，可以替代XML或JSON等传统数据交换格式，以更小的体积和更快的速度进行数据传输。 **协议转换工具——protoc** `protoc`是Google官方提供的协议编译器...
protobuf 3.11版本，静态编译
04-28
protobuf是Protocol Buffers的简称，它是Google开发的一种数据序列化协议，用于结构化数据的序列化，类似于XML、JSON，但更小、更快、更简单。protobuf 3.11版本是一个稳定且广泛使用的版本，提供了许多改进和新特性...
protobuf C++库
05-09
与XML和JSON相比，protobuf在数据体积、解析速度和易用性方面具有优势，尤其适用于网络通信和大规模数据存储。但在人类可读性和灵活性上，XML和JSON更胜一筹。 总结，protobuf C++库是一个强大的工具，它简化了结构...
protobuf转cs的工具（ProtoGen）
08-17
protobuf转cs的工具，有需要的可以下载使用，结合命令行就可以转换proto文件了
.proto 各种语言转换
10-17
该文档讲述了在windows系统下，如何实现一键从git下载protobuf 3.6.1，编译，最后使用编译工具将.proto文件转换成Java，c#，Python等各种语言的文件，以便进行协议开发
ProtoBuf 替代XML的又一种选择
Pipi0714的专栏
07-04 3478
protobuf 是google公司的开源项目，功能与xml类似。由于最近需要传递数据，知道了对象串行化但是使用xml或二进制(BinaryFormat)后的数据都非常大，冗余数据大。找资料发现了protobuf他只是将值+他的属性进行串行化。这样大大减少了串行化后的空间大小（满足本人的需要，需要将数据写到卡上） 编写proto文件然后使用proto工具将它proto文件转换成C++或者C
一文搞懂XML、Json、Protobuf序列化协议
Jiangtagong的博客
08-13 2836
网络传输协议，简称为传送协议（Communications Protocol），是指计算机通信的共用语言。目前最为普遍的计算机通信为网络通信，因此“传送协议”一般是指计算机通信的传送协议，比如TCP/IP等。然而，传送协议也存在计算机的其他形式通信，例如：面向对象编程里面对象之间的通信；操作系统内不同进程之间的通信，都需要一个传送协议，以确保通信双方能够正常交流！常用的网络传输数据格式有：xml、json、protobuf等。 一、为什么需要序列化和反序列？ name 姓名，如：Mike...
Protobuf、XML、Json序列化等跨平台不同语言之间 数据交换函数调用等 通用接口协议
chenhao0568的专栏
11-05 575
一、场景 C++ 订单 —>接口编码 —> 网络 —> 接口解码 —> Java 订单 还可以更广泛一些，比如android调用c接口，只用一个jni接口来建立通道，其它所有接口都通过这个通道来传数据相互调用，再也不用写很多个接口了。 A语言—>数据封解包—>通道 —>数据封解包 —>B语言 如何实现远程函数的调用？ 发送结构：包名，函数名，方法，参数，返回值。 接收处理：反射调用，返回返回值。 二、成熟方案：Pr...
protocol buff to xml json
linuxheik的专栏
10-11 577
http://code.google.com/p/protobuf-java-format/
protobuf，xml，json序列化后与解析时间的对比
u012437323的专栏
03-07 1149
今天做了下这三种序列化的对比，主要是从序列化后的大小和解释时间的对比：从图中可以得出同一文件序列化后的文件大小是xml>json>proto，解析时间为xml>json>proto; 其中protobuf的解析时间明显要小于json和xml
深入 ProtoBuf - 简介（转发）
fengjiji的专栏
07-04 268
本文转自：https://www.jianshu.com/p/a24c88c0526a 最近在开发中遇到了ProtoBuf，在网上看到这个系列文章，本篇是系列文章的第一篇，转发一下，并在此感谢原创作者的付出。 深入 ProtoBuf - 简介 之前在网络通信和通用数据交换等应用场景中经常使用的技术是 JSON 或 XML，而在最近的开发中接触到了 Google 的 ProtoBuf。 在查阅相关资料学习 ProtoBuf 以及研读其源码之后，发现其在效率、兼容性等方面非常出色。在以后的项目技术选型中，尤其是
反射技巧：Model与XML的自动转换实现
"该资源主要介绍如何利用C#中的反射机制将Model对象与XML文档进行相互转换，实现数据的便捷存储和读取。" 在.NET框架中，反射是一种强大的机制，它允许程序在运行时检查自身的信息，如类型、成员、属性等，并能动态...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值