xml 与 protobuf之间的转换

最新推荐文章于 2024-09-19 14:59:13 发布
最新推荐文章于 2024-09-19 14:59:13 发布
阅读量6.3k 收藏 2
点赞数 2
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/WEIWODUMO/article/details/50433938
这段代码展示了如何使用C++将TinyXML解析的XML数据转换为protobuf消息，以及将protobuf消息转换回XML。它利用了protobuf的反射API来处理各种字段类型，并支持不同的字符编码。 
#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())
						{
							reflection->AddUInt32(&msg, fd, from_string<google::protobuf::uint32>(child_value));
						}
						else
						{
							reflection->SetUInt32(&msg, fd, from_string<google::protobuf::uint32>(child_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>(child_value));
						}
						else
						{
							reflection->SetInt64(&msg, fd, from_string<google::protobuf::int64>(child_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>(child_value));
						}
						else
						{
							reflection->SetUInt64(&msg, fd, from_string<google::protobuf::uint64>(child_value));
						}

						break;

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

						break;

						// UTF-8 text.
					case FieldDescriptor::TYPE_STRING:
						// Arbitrary byte array.
					case FieldDescriptor::TYPE_BYTES:
						if(fd->is_repeated())
						{
							reflection->AddString(&msg, fd, child_value);
						}
						else
						{
							reflection->SetString(&msg, fd, child_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>(child_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_DECLARATION:
		case TiXmlNode::TINYXML_COMMENT:
			//ignore
			break;
		case TiXmlNode::TINYXML_UNKNOWN:
		case TiXmlNode::TINYXML_DOCUMENT:
		case TiXmlNode::TINYXML_TYPECOUNT:
		default:
			assert(0);
			return false;
			break;
		}
	}
	
	//解析XML属性
	if(!parse_xmlattr2proto(node->ToElement(), msg))
	{
		return false;
	}

	return true;
}

bool tinyxml2proto(const std::string& xml, google::protobuf::Message& msg)
{
	TiXmlDocument doc;
	doc.Parse(xml.c_str());
	TiXmlElement* root_ele = doc.RootElement();
	if(!root_ele)
	{
		return false;
	}

	const google::protobuf::Reflection* reflection = msg.GetReflection();
	const google::protobuf::Descriptor* des = msg.GetDescriptor();
	const google::protobuf::FieldDescriptor* fd = des->FindFieldByName(INTER_PROTO_TINYXML_NAME);
	if(fd && !fd->is_repeated() && (fd->type() == FieldDescriptor::TYPE_STRING || fd->type() == FieldDescriptor::TYPE_BYTES))
	{
		reflection->SetString(&msg, fd, root_ele->ValueStr());
	}

	if(!parse_xml2proto_msg(root_ele, msg))
	{
		return false;
	}

	return true;
} 

//---------------------------------------------------------------------------------------------------------
static inline bool is_attribute(const std::string& str)
{
	if(str.size() > INTER_PROTO_TINYXML_ATTR_SIZE && str.substr(0, INTER_PROTO_TINYXML_ATTR_SIZE) == INTER_PROTO_TINYXML_ATTR)
	{
		return true;
	}

	return false;
}

static inline std::string get_attribute_name(const std::string& str)
{
	assert(is_attribute(str));
	return str.substr(INTER_PROTO_TINYXML_ATTR_SIZE);
}

static inline bool is_text(const std::string& str)
{
	return str == INTER_PROTO_TINYXML_VALUE;
}

static bool proto_fd2xml_attr(const google::protobuf::Message& msg, const google::protobuf::FieldDescriptor* fd, TiXmlElement* element, const std::string& name)
{
	const google::protobuf::Reflection* reflection = msg.GetReflection();
	switch(fd->type())
	{
		// double, exactly eight bytes on the wire.
	case FieldDescriptor::TYPE_DOUBLE:
		if(fd->is_repeated())
		{
			if(reflection->FieldSize(msg, fd) > 0)
			{
				element->SetAttribute(name, to_string(reflection->GetRepeatedDouble(msg, fd, 0)));
			}
		}
		else
		{
			element->SetAttribute(name, to_string(reflection->GetDouble(msg, fd)));
		}

		break;

		// float, exactly four bytes on the wire.
	case FieldDescriptor::TYPE_FLOAT:
		if(fd->is_repeated())
		{
			if(reflection->FieldSize(msg, fd) > 0)
			{
				element->SetAttribute(name, to_string(reflection->GetRepeatedFloat(msg, fd, 0)));
			}
		}
		else
		{
			element->SetAttribute(name, to_string(reflection->GetFloat(msg, fd)));
		}

		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())
		{
			if(reflection->FieldSize(msg, fd) > 0)
			{
				element->SetAttribute(name, to_string(reflection->GetRepeatedInt32(msg, fd, 0)));
			}
		}
		else
		{
			element->SetAttribute(name, to_string(reflection->GetInt32(msg, fd)));
		}

		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())
		{
			if(reflection->FieldSize(msg, fd) > 0)
			{
				element->SetAttribute(name, to_string(reflection->GetRepeatedUInt32(msg, fd, 0)));
			}
		}
		else
		{
			element->SetAttribute(name, to_string(reflection->GetUInt32(msg, fd)));
		}

		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())
		{
			if(reflection->FieldSize(msg, fd) > 0)
			{
				element->SetAttribute(name, to_string(reflection->GetRepeatedInt64(msg, fd, 0)));
			}
		}
		else
		{
			element->SetAttribute(name, to_string(reflection->GetInt64(msg, fd)));
		}

		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())
		{
			if(reflection->FieldSize(msg, fd) > 0)
			{
				element->SetAttribute(name, to_string(reflection->GetRepeatedUInt64(msg, fd, 0)));
			}
		}
		else
		{
			element->SetAttribute(name, to_string(reflection->GetUInt64(msg, fd)));
		}

		break;

		// bool, varint on the wire.
	case FieldDescriptor::TYPE_BOOL:
		if(fd->is_repeated())
		{
			if(reflection->FieldSize(msg, fd) > 0)
			{
				element->SetAttribute(name, to_string(reflection->GetRepeatedBool(msg, fd, 0)));
			}
		}
		else
		{
			element->SetAttribute(name, to_string(reflection->GetBool(msg, fd)));
		}

		break;

		// UTF-8 text.
	case FieldDescriptor::TYPE_STRING:
		// Arbitrary byte array.
	case FieldDescriptor::TYPE_BYTES:
		if(fd->is_repeated())
		{
			if(reflection->FieldSize(msg, fd) > 0)
			{
				element->SetAttribute(name, reflection->GetRepeatedString(msg, fd, 0));
			}
		}
		else
		{
			element->SetAttribute(name, reflection->GetString(msg, fd));
		}

		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:
		if(fd->is_repeated())
		{
			if(reflection->FieldSize(msg, fd) > 0)
			{
				element->SetAttribute(name, to_string(reflection->GetRepeatedEnum(msg, fd, 0)->number()));
			}
		}
		else
		{
			element->SetAttribute(name, to_string(reflection->GetEnum(msg, fd)->number()));
		}

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

	return true;
}

static bool proto_fd2xml_text(const google::protobuf::Message& msg, const google::protobuf::FieldDescriptor* fd, TiXmlElement* element)
{
	const google::protobuf::Reflection* reflection = msg.GetReflection();
	switch(fd->type())
	{
		// double, exactly eight bytes on the wire.
	case FieldDescriptor::TYPE_DOUBLE:
		if(fd->is_repeated())
		{
			for(int count = 0; count < reflection->FieldSize(msg, fd); ++count)
			{
				TiXmlText* temp_text = new TiXmlText(to_string(reflection->GetRepeatedDouble(msg, fd, count)));
				element->LinkEndChild(temp_text);
			}
		}
		else
		{
			TiXmlText* temp_text = new TiXmlText(to_string(reflection->GetDouble(msg, fd)));
			element->LinkEndChild(temp_text);
		}

		break;

		// float, exactly four bytes on the wire.
	case FieldDescriptor::TYPE_FLOAT:
		if(fd->is_repeated())
		{
			for(int count = 0; count < reflection->FieldSize(msg, fd); ++count)
			{
				TiXmlText* temp_text = new TiXmlText(to_string(reflection->GetRepeatedFloat(msg, fd, count)));
				element->LinkEndChild(temp_text);
			}
		}
		else
		{
			TiXmlText* temp_text = new TiXmlText(to_string(reflection->GetFloat(msg, fd)));
			element->LinkEndChild(temp_text);
		}

		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())
		{
			for(int count = 0; count < reflection->FieldSize(msg, fd); ++count)
			{
				TiXmlText* temp_text = new TiXmlText(to_string(reflection->GetRepeatedInt32(msg, fd, count)));
				element->LinkEndChild(temp_text);
			}
		}
		else
		{
			TiXmlText* temp_text = new TiXmlText(to_string(reflection->GetInt32(msg, fd)));
			element->LinkEndChild(temp_text);
		}

		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())
		{
			for(int count = 0; count < reflection->FieldSize(msg, fd); ++count)
			{
				TiXmlText* temp_text = new TiXmlText(to_string(reflection->GetRepeatedUInt32(msg, fd, count)));
				element->LinkEndChild(temp_text);
			}
		}
		else
		{
			TiXmlText* temp_text = new TiXmlText(to_string(reflection->GetUInt32(msg, fd)));
			element->LinkEndChild(temp_text);
		}

		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())
		{
			for(int count = 0; count < reflection->FieldSize(msg, fd); ++count)
			{
				TiXmlText* temp_text = new TiXmlText(to_string(reflection->GetRepeatedInt64(msg, fd, count)));
				element->LinkEndChild(temp_text);
			}
		}
		else
		{
			TiXmlText* temp_text = new TiXmlText(to_string(reflection->GetInt64(msg, fd)));
			element->LinkEndChild(temp_text);
		}

		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())
		{
			for(int count = 0; count < reflection->FieldSize(msg, fd); ++count)
			{
				TiXmlText* temp_text = new TiXmlText(to_string(reflection->GetRepeatedUInt64(msg, fd, count)));
				element->LinkEndChild(temp_text);
			}
		}
		else
		{
			TiXmlText* temp_text = new TiXmlText(to_string(reflection->GetUInt64(msg, fd)));
			element->LinkEndChild(temp_text);
		}

		break;

		// bool, varint on the wire.
	case FieldDescriptor::TYPE_BOOL:
		if(fd->is_repeated())
		{
			for(int count = 0; count < reflection->FieldSize(msg, fd); ++count)
			{
				TiXmlText* temp_text = new TiXmlText(to_string(reflection->GetRepeatedBool(msg, fd, count)));
				element->LinkEndChild(temp_text);
			}
		}
		else
		{
			TiXmlText* temp_text = new TiXmlText(to_string(reflection->GetBool(msg, fd)));
			element->LinkEndChild(temp_text);
		}

		break;

		// UTF-8 text.
	case FieldDescriptor::TYPE_STRING:
		// Arbitrary byte array.
	case FieldDescriptor::TYPE_BYTES:
		if(fd->is_repeated())
		{
			for(int count = 0; count < reflection->FieldSize(msg, fd); ++count)
			{
				TiXmlText* temp_text = new TiXmlText(reflection->GetRepeatedString(msg, fd, count));
				element->LinkEndChild(temp_text);
			}
		}
		else
		{
			TiXmlText* temp_text = new TiXmlText(reflection->GetString(msg, fd));
			element->LinkEndChild(temp_text);
		}

		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:
		if(fd->is_repeated())
		{
			for(int count = 0; count < reflection->FieldSize(msg, fd); ++count)
			{
				TiXmlText* temp_text = new TiXmlText(to_string(reflection->GetRepeatedEnum(msg, fd, count)->number()));
				element->LinkEndChild(temp_text);
			}
		}
		else
		{
			TiXmlText* temp_text = new TiXmlText(to_string(reflection->GetEnum(msg, fd)->number()));
			element->LinkEndChild(temp_text);
		}

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

	return true;
}

static bool proto_msg2xml(const google::protobuf::Message& msg, TiXmlElement* element)
{
	assert(element);
	const google::protobuf::Reflection* reflection = msg.GetReflection();
	assert(reflection);
	const google::protobuf::Descriptor* des = msg.GetDescriptor();
	assert(des);
	for(int count = 0; count < des->field_count(); ++count)
	{
		const google::protobuf::FieldDescriptor* fd = des->field(count);
		assert(fd);
		std::string key = fd->name();
		//没有设置的非repeated字段不组装进xml
		if(key == INTER_PROTO_TINYXML_NAME || (!fd->is_repeated() && !reflection->HasField(msg, fd)))
		{
			continue;
		}
		
		if(is_attribute(key))
		{
			if(!proto_fd2xml_attr(msg, fd, element, get_attribute_name(key)))
			{
				return false;
			}
		}
		else if(is_text(key))
		{
			if(!proto_fd2xml_text(msg, fd, element))
			{
				return false;
			}
		}
		else
		{
			switch(fd->type())
			{
				// double, exactly eight bytes on the wire.
			case FieldDescriptor::TYPE_DOUBLE:
				if(fd->is_repeated())
				{
					for(int count = 0; count < reflection->FieldSize(msg, fd); ++count)
					{
						TiXmlElement* temp_ele = new TiXmlElement(key);
						TiXmlText* temp_text = new TiXmlText(to_string(reflection->GetRepeatedDouble(msg, fd, count)));
						temp_ele->LinkEndChild(temp_text);
						element->LinkEndChild(temp_ele);
					}
				}
				else
				{
					TiXmlElement* temp_ele = new TiXmlElement(key);
					TiXmlText* temp_text = new TiXmlText(to_string(reflection->GetDouble(msg, fd)));
					temp_ele->LinkEndChild(temp_text);
					element->LinkEndChild(temp_ele);
				}

				break;

				// float, exactly four bytes on the wire.
			case FieldDescriptor::TYPE_FLOAT:
				if(fd->is_repeated())
				{
					for(int count = 0; count < reflection->FieldSize(msg, fd); ++count)
					{
						TiXmlElement* temp_ele = new TiXmlElement(key);
						TiXmlText* temp_text = new TiXmlText(to_string(reflection->GetRepeatedFloat(msg, fd, count)));
						temp_ele->LinkEndChild(temp_text);
						element->LinkEndChild(temp_ele);
					}
				}
				else
				{
					TiXmlElement* temp_ele = new TiXmlElement(key);
					TiXmlText* temp_text = new TiXmlText(to_string(reflection->GetFloat(msg, fd)));
					temp_ele->LinkEndChild(temp_text);
					element->LinkEndChild(temp_ele);
				}

				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())
				{
					for(int count = 0; count < reflection->FieldSize(msg, fd); ++count)
					{
						TiXmlElement* temp_ele = new TiXmlElement(key);
						TiXmlText* temp_text = new TiXmlText(to_string(reflection->GetRepeatedInt32(msg, fd, count)));
						temp_ele->LinkEndChild(temp_text);
						element->LinkEndChild(temp_ele);
					}
				}
				else
				{
					TiXmlElement* temp_ele = new TiXmlElement(key);
					TiXmlText* temp_text = new TiXmlText(to_string(reflection->GetInt32(msg, fd)));
					temp_ele->LinkEndChild(temp_text);
					element->LinkEndChild(temp_ele);
				}

				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())
				{
					for(int count = 0; count < reflection->FieldSize(msg, fd); ++count)
					{
						TiXmlElement* temp_ele = new TiXmlElement(key);
						TiXmlText* temp_text = new TiXmlText(to_string(reflection->GetRepeatedUInt32(msg, fd, count)));
						temp_ele->LinkEndChild(temp_text);
						element->LinkEndChild(temp_ele);
					}
				}
				else
				{
					TiXmlElement* temp_ele = new TiXmlElement(key);
					TiXmlText* temp_text = new TiXmlText(to_string(reflection->GetUInt32(msg, fd)));
					temp_ele->LinkEndChild(temp_text);
					element->LinkEndChild(temp_ele);
				}

				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())
				{
					for(int count = 0; count < reflection->FieldSize(msg, fd); ++count)
					{
						TiXmlElement* temp_ele = new TiXmlElement(key);
						TiXmlText* temp_text = new TiXmlText(to_string(reflection->GetRepeatedInt64(msg, fd, count)));
						temp_ele->LinkEndChild(temp_text);
						element->LinkEndChild(temp_ele);
					}
				}
				else
				{
					TiXmlElement* temp_ele = new TiXmlElement(key);
					TiXmlText* temp_text = new TiXmlText(to_string(reflection->GetInt64(msg, fd)));
					temp_ele->LinkEndChild(temp_text);
					element->LinkEndChild(temp_ele);
				}

				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())
				{
					for(int count = 0; count < reflection->FieldSize(msg, fd); ++count)
					{
						TiXmlElement* temp_ele = new TiXmlElement(key);
						TiXmlText* temp_text = new TiXmlText(to_string(reflection->GetRepeatedUInt64(msg, fd, count)));
						temp_ele->LinkEndChild(temp_text);
						element->LinkEndChild(temp_ele);
					}
				}
				else
				{
					TiXmlElement* temp_ele = new TiXmlElement(key);
					TiXmlText* temp_text = new TiXmlText(to_string(reflection->GetUInt64(msg, fd)));
					temp_ele->LinkEndChild(temp_text);
					element->LinkEndChild(temp_ele);
				}

				break;

				// bool, varint on the wire.
			case FieldDescriptor::TYPE_BOOL:
				if(fd->is_repeated())
				{
					for(int count = 0; count < reflection->FieldSize(msg, fd); ++count)
					{
						TiXmlElement* temp_ele = new TiXmlElement(key);
						TiXmlText* temp_text = new TiXmlText(to_string(reflection->GetRepeatedBool(msg, fd, count)));
						temp_ele->LinkEndChild(temp_text);
						element->LinkEndChild(temp_ele);
					}
				}
				else
				{
					TiXmlElement* temp_ele = new TiXmlElement(key);
					TiXmlText* temp_text = new TiXmlText(to_string(reflection->GetBool(msg, fd)));
					temp_ele->LinkEndChild(temp_text);
					element->LinkEndChild(temp_ele);
				}

				break;

				// UTF-8 text.
			case FieldDescriptor::TYPE_STRING:
				// Arbitrary byte array.
			case FieldDescriptor::TYPE_BYTES:
				if(fd->is_repeated())
				{
					for(int count = 0; count < reflection->FieldSize(msg, fd); ++count)
					{
						TiXmlElement* temp_ele = new TiXmlElement(key);
						TiXmlText* temp_text = new TiXmlText(reflection->GetRepeatedString(msg, fd, count));
						temp_ele->LinkEndChild(temp_text);
						element->LinkEndChild(temp_ele);
					}
				}
				else
				{
					TiXmlElement* temp_ele = new TiXmlElement(key);
					TiXmlText* temp_text = new TiXmlText(reflection->GetString(msg, fd));
					temp_ele->LinkEndChild(temp_text);
					element->LinkEndChild(temp_ele);
				}

				break;

				// Tag-delimited message.  Deprecated.
			case FieldDescriptor::TYPE_GROUP:
				// Length-delimited message.
			case FieldDescriptor::TYPE_MESSAGE:
				if(fd->is_repeated())
				{
					for(int count = 0; count < reflection->FieldSize(msg, fd); ++count)
					{
						TiXmlElement* temp_ele = new TiXmlElement(key);
						if(!proto_msg2xml(reflection->GetRepeatedMessage(msg, fd, count), temp_ele))
						{
							delete temp_ele;
							return false;
						}

						element->LinkEndChild(temp_ele);
					}
				}
				else
				{
					TiXmlElement* temp_ele = new TiXmlElement(key);
				//宏用于解决宏定义与函数名冲突
				#pragma push_macro("GetMessage")
				#undef GetMessage
					if(!proto_msg2xml(reflection->GetMessage(msg, fd), temp_ele))
					{
						delete temp_ele;
						return false;
					}

				#pragma pop_macro("GetMessage")
					element->LinkEndChild(temp_ele);
				}

				break;

				// Enum, varint on the wire
			case FieldDescriptor::TYPE_ENUM:
				if(fd->is_repeated())
				{
					for(int count = 0; count < reflection->FieldSize(msg, fd); ++count)
					{
						TiXmlElement* temp_ele = new TiXmlElement(key);
						TiXmlText* temp_text = new TiXmlText(to_string(reflection->GetRepeatedEnum(msg, fd, count)->number()));
						temp_ele->LinkEndChild(temp_text);
						element->LinkEndChild(temp_ele);
					}
				}
				else
				{
					TiXmlElement* temp_ele = new TiXmlElement(key);
					TiXmlText* temp_text = new TiXmlText(to_string(reflection->GetEnum(msg, fd)->number()));
					temp_ele->LinkEndChild(temp_text);
					element->LinkEndChild(temp_ele);
				}

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

	return true;
}

bool proto2tinyxml(const google::protobuf::Message& msg, std::string& xml, tinyxml_type type/* = TINYXML_UTF8*/)
{
	TiXmlDocument doc;
	TiXmlDeclaration *declaration = NULL;
	if(type == TINYXML_GB2312)
	{
		declaration = new TiXmlDeclaration("1.0", "gb2312", "yes");
	}
	else if(type == TINYXML_UTF8)
	{
		declaration = new TiXmlDeclaration("1.0", "utf-8", "yes");
	}

	if(declaration)
	{
		doc.LinkEndChild(declaration);
	}
	
	const google::protobuf::Descriptor* des = msg.GetDescriptor();
	const google::protobuf::FieldDescriptor* fd = des->FindFieldByName(INTER_PROTO_TINYXML_NAME);
	if(!fd || fd->is_repeated() || (fd->type() != FieldDescriptor::TYPE_STRING && fd->type() != FieldDescriptor::TYPE_BYTES))
	{
		assert(0);
		return false;
	}
	
	const google::protobuf::Reflection* reflection = msg.GetReflection();
	TiXmlElement* root_ele = new TiXmlElement(reflection->GetString(msg, fd));
	doc.LinkEndChild(root_ele);
	if(!proto_msg2xml(msg, root_ele))
	{
		return false;
	}

	// Declare a printer    
	TiXmlPrinter printer;
	// attach it to the document you want to convert in to a std::string 
	doc.Accept(&printer);
	// Create a std::string and copy your document data in to the string    
	xml = printer.Str();
	return true;
} 
#ifndef _INTER_PROTO_CMARKUP_H_
#define _INTER_PROTO_CMARKUP_H_

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

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

enum cmarkup_type
{
	CMARKUP_GB2312,
	CMARKUP_UTF8,
};

bool proto2cmarkup(const google::protobuf::Message& msg, std::string& xml, cmarkup_type type = CMARKUP_GB2312);

#endif //_INTER_PROTO_CMARKUP_H_

#include "InterProtoCmarkup.h"
#include "Markup.h"
#include "google/protobuf/descriptor.h"
#include "utils/utils.h"

#define INTER_PROTO_CMARKUP_NAME		"_name"
#define INTER_PROTO_CMARKUP_VALUE		"_value"
#define INTER_PROTO_CMARKUP_ATTR		"_attr_"
#define INTER_PROTO_CMARKUP_ATTR_SIZE	6

using namespace google::protobuf;

template<class T>
static T get_xml_field(CMarkup& doc, bool& get_ok)
{
	if(!doc.IntoElem())
	{
		get_ok = false;
		return T();
	}

	while(doc.FindNode())
	{
		if(doc.GetNodeType() == CMarkup::MNT_TEXT)
		{
			get_ok = true;
			T ret = from_string<T>(string_trim(doc.GetData(), " \r\n\t\""));
			doc.OutOfElem();
			return ret;
		}
	}

	doc.OutOfElem();
	get_ok = false;
	return T();
}

template<>
static std::string get_xml_field<std::string>(CMarkup& doc, bool& get_ok)
{
	if(!doc.IntoElem())
	{
		get_ok = false;
		return "";
	}

	while(doc.FindNode())
	{
		if(doc.GetNodeType() == CMarkup::MNT_TEXT)
		{
			get_ok = true;
			std::string ret = string_trim(doc.GetData(), " \r\n\t\"");
			doc.OutOfElem();
			return ret;
		}
	}

	doc.OutOfElem();
	get_ok = false;
	return "";
}

template<>
static bool get_xml_field<bool>(CMarkup& doc, bool& get_ok)
{
	if(!doc.IntoElem())
	{
		get_ok = false;
		return false;
	}

	while(doc.FindNode())
	{
		if(doc.GetNodeType() == CMarkup::MNT_TEXT)
		{
			get_ok = true;
			bool ret = (bool)from_string<int>(string_trim(doc.GetData(), " \r\n\t\""));
			doc.OutOfElem();
			return ret;
		}
	}

	doc.OutOfElem();
	get_ok = false;
	return false;
}

static bool parse_xmlattr2proto(CMarkup& doc, google::protobuf::Message& msg)
{
	//解析XML文件
	const google::protobuf::Reflection* reflection = msg.GetReflection();
	const google::protobuf::Descriptor* des = msg.GetDescriptor();
	int attr_count = 0;
#pragma warning(push)
#pragma warning(disable:4127)
	while(true)
	{
#pragma warning(pop)
		std::string name = doc.GetAttribName(attr_count);
		if(name.empty())
		{
			break;
		}
		std::string value = doc.GetAttrib(name);
		const google::protobuf::FieldDescriptor* fd = des->FindFieldByName(INTER_PROTO_CMARKUP_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;
			}
		}

		++attr_count;
	}

	return true;
}

static bool parse_xml2proto_msg(CMarkup& doc, google::protobuf::Message& msg)
{
	assert(doc.GetNodeType() == CMarkup::MNT_ELEMENT);
	if(!doc.IntoElem())
	{
		assert(0);
		return false;
	}

	//解析XML文件
	const google::protobuf::Reflection* reflection = msg.GetReflection();
	const google::protobuf::Descriptor* des = msg.GetDescriptor();
	while(doc.FindNode())
	{
		switch(doc.GetNodeType())
		{
		case CMarkup::MNT_ELEMENT:
			{
				std::string tag_name = doc.GetTagName();
				const google::protobuf::FieldDescriptor* fd = des->FindFieldByName(tag_name);
				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>(doc, 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>(doc, 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>(doc, 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>(doc, 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>(doc, 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>(doc, 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>(doc, 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>(doc, 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(doc, *reflection->AddMessage(&msg, fd)))
							{
								return false;
							}
						}
						else
						{
							if(!parse_xml2proto_msg(doc, *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>(doc, 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 CMarkup::MNT_TEXT:
			{
				const google::protobuf::FieldDescriptor* fd = des->FindFieldByName(INTER_PROTO_CMARKUP_VALUE);
				if(fd)
				{
					std::string child_value = string_trim(doc.GetData(), " \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())
						{
							reflection->AddUInt32(&msg, fd, from_string<google::protobuf::uint32>(child_value));
						}
						else
						{
							reflection->SetUInt32(&msg, fd, from_string<google::protobuf::uint32>(child_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>(child_value));
						}
						else
						{
							reflection->SetInt64(&msg, fd, from_string<google::protobuf::int64>(child_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>(child_value));
						}
						else
						{
							reflection->SetUInt64(&msg, fd, from_string<google::protobuf::uint64>(child_value));
						}

						break;

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

						break;

						// UTF-8 text.
					case FieldDescriptor::TYPE_STRING:
						// Arbitrary byte array.
					case FieldDescriptor::TYPE_BYTES:
						if(fd->is_repeated())
						{
							reflection->AddString(&msg, fd, child_value);
						}
						else
						{
							reflection->SetString(&msg, fd, child_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>(child_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 CMarkup::MNT_TEXT_AND_WHITESPACE:
		case CMarkup::MNT_CDATA_SECTION:
		case CMarkup::MNT_PROCESSING_INSTRUCTION:
			assert(0);
			return false;
			break;
		case CMarkup::MNT_WHITESPACE:
		case CMarkup::MNT_COMMENT:
			//ignore
			break;
		case CMarkup::MNT_DOCUMENT_TYPE:
		case CMarkup::MNT_EXCLUDE_WHITESPACE:
		case CMarkup::MNT_LONE_END_TAG:
		case CMarkup::MNT_NODE_ERROR:
		default:
			assert(0);
			return false;
			break;
		}
	}

	doc.OutOfElem();
	//解析XML属性
	if(!parse_xmlattr2proto(doc, msg))
	{
		return false;
	}

	return true;
}

bool cmarkup2proto(const std::string& xml, google::protobuf::Message& msg)
{
	CMarkup doc(xml);
	bool find_ok = doc.FindElem();
	if(!find_ok)
	{
		return false;
	}
	
	const google::protobuf::Reflection* reflection = msg.GetReflection();
	const google::protobuf::Descriptor* des = msg.GetDescriptor();
	const google::protobuf::FieldDescriptor* fd = des->FindFieldByName(INTER_PROTO_CMARKUP_NAME);
	if(fd && !fd->is_repeated() && (fd->type() == FieldDescriptor::TYPE_STRING || fd->type() == FieldDescriptor::TYPE_BYTES))
	{
		reflection->SetString(&msg, fd, doc.GetTagName());
	}

	if(!parse_xml2proto_msg(doc, msg))
	{
		return false;
	}

	return true;
} 

//---------------------------------------------------------------------------------------------------------
static inline bool is_attribute(const std::string& str)
{
	if(str.size() > INTER_PROTO_CMARKUP_ATTR_SIZE && str.substr(0, INTER_PROTO_CMARKUP_ATTR_SIZE) == INTER_PROTO_CMARKUP_ATTR)
	{
		return true;
	}

	return false;
}

static inline std::string get_attribute_name(const std::string& str)
{
	assert(is_attribute(str));
	return str.substr(INTER_PROTO_CMARKUP_ATTR_SIZE);
}

static inline bool is_text(const std::string& str)
{
	return str == INTER_PROTO_CMARKUP_VALUE;
}

static bool proto_fd2xml_attr(const google::protobuf::Message& msg, const google::protobuf::FieldDescriptor* fd, CMarkup& doc, const std::string& name)
{
	//先定位主元素才可以进行属性操作
	if(!doc.OutOfElem())
	{
		return false;
	}

	const google::protobuf::Reflection* reflection = msg.GetReflection();
	switch(fd->type())
	{
		// double, exactly eight bytes on the wire.
	case FieldDescriptor::TYPE_DOUBLE:
		if(fd->is_repeated())
		{
			if(reflection->FieldSize(msg, fd) > 0)
			{
				doc.AddAttrib(name, to_string(reflection->GetRepeatedDouble(msg, fd, 0)));
			}
		}
		else
		{
			doc.AddAttrib(name, to_string(reflection->GetDouble(msg, fd)));
		}

		break;

		// float, exactly four bytes on the wire.
	case FieldDescriptor::TYPE_FLOAT:
		if(fd->is_repeated())
		{
			if(reflection->FieldSize(msg, fd) > 0)
			{
				doc.AddAttrib(name, to_string(reflection->GetRepeatedFloat(msg, fd, 0)));
			}
		}
		else
		{
			doc.AddAttrib(name, to_string(reflection->GetFloat(msg, fd)));
		}

		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())
		{
			if(reflection->FieldSize(msg, fd) > 0)
			{
				doc.AddAttrib(name, to_string(reflection->GetRepeatedInt32(msg, fd, 0)));
			}
		}
		else
		{
			doc.AddAttrib(name, to_string(reflection->GetInt32(msg, fd)));
		}

		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())
		{
			if(reflection->FieldSize(msg, fd) > 0)
			{
				doc.AddAttrib(name, to_string(reflection->GetRepeatedUInt32(msg, fd, 0)));
			}
		}
		else
		{
			doc.AddAttrib(name, to_string(reflection->GetUInt32(msg, fd)));
		}

		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())
		{
			if(reflection->FieldSize(msg, fd) > 0)
			{
				doc.AddAttrib(name, to_string(reflection->GetRepeatedInt64(msg, fd, 0)));
			}
		}
		else
		{
			doc.AddAttrib(name, to_string(reflection->GetInt64(msg, fd)));
		}

		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())
		{
			if(reflection->FieldSize(msg, fd) > 0)
			{
				doc.AddAttrib(name, to_string(reflection->GetRepeatedUInt64(msg, fd, 0)));
			}
		}
		else
		{
			doc.AddAttrib(name, to_string(reflection->GetUInt64(msg, fd)));
		}

		break;

		// bool, varint on the wire.
	case FieldDescriptor::TYPE_BOOL:
		if(fd->is_repeated())
		{
			if(reflection->FieldSize(msg, fd) > 0)
			{
				doc.AddAttrib(name, to_string(reflection->GetRepeatedBool(msg, fd, 0)));
			}
		}
		else
		{
			doc.AddAttrib(name, to_string(reflection->GetBool(msg, fd)));
		}

		break;

		// UTF-8 text.
	case FieldDescriptor::TYPE_STRING:
		// Arbitrary byte array.
	case FieldDescriptor::TYPE_BYTES:
		if(fd->is_repeated())
		{
			if(reflection->FieldSize(msg, fd) > 0)
			{
				doc.AddAttrib(name, reflection->GetRepeatedString(msg, fd, 0));
			}
		}
		else
		{
			doc.AddAttrib(name, reflection->GetString(msg, fd));
		}

		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:
		if(fd->is_repeated())
		{
			if(reflection->FieldSize(msg, fd) > 0)
			{
				doc.AddAttrib(name, reflection->GetRepeatedEnum(msg, fd, 0)->number());
			}
		}
		else
		{
			doc.AddAttrib(name, reflection->GetEnum(msg, fd)->number());
		}

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

	//重新进入tag
	doc.IntoElem();
	return true;
}

static bool proto_fd2xml_text(const google::protobuf::Message& msg, const google::protobuf::FieldDescriptor* fd, CMarkup& doc)
{
	//先定位主元素才可以进行数据操作
	if(!doc.OutOfElem())
	{
		return false;
	}

	const google::protobuf::Reflection* reflection = msg.GetReflection();
	switch(fd->type())
	{
		// double, exactly eight bytes on the wire.
	case FieldDescriptor::TYPE_DOUBLE:
		if(fd->is_repeated())
		{
			for(int count = 0; count < reflection->FieldSize(msg, fd); ++count)
			{
				doc.SetData(to_string(reflection->GetRepeatedDouble(msg, fd, count)));
			}
		}
		else
		{
			doc.SetData(to_string(reflection->GetDouble(msg, fd)));
		}

		break;

		// float, exactly four bytes on the wire.
	case FieldDescriptor::TYPE_FLOAT:
		if(fd->is_repeated())
		{
			for(int count = 0; count < reflection->FieldSize(msg, fd); ++count)
			{
				doc.SetData(to_string(reflection->GetRepeatedFloat(msg, fd, count)));
			}
		}
		else
		{
			doc.SetData(to_string(reflection->GetFloat(msg, fd)));
		}

		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())
		{
			for(int count = 0; count < reflection->FieldSize(msg, fd); ++count)
			{
				doc.SetData(to_string(reflection->GetRepeatedInt32(msg, fd, count)));
			}
		}
		else
		{
			doc.SetData(to_string(reflection->GetInt32(msg, fd)));
		}

		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())
		{
			for(int count = 0; count < reflection->FieldSize(msg, fd); ++count)
			{
				doc.SetData(to_string(reflection->GetRepeatedUInt32(msg, fd, count)));
			}
		}
		else
		{
			doc.SetData(to_string(reflection->GetUInt32(msg, fd)));
		}

		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())
		{
			for(int count = 0; count < reflection->FieldSize(msg, fd); ++count)
			{
				doc.SetData(to_string(reflection->GetRepeatedInt64(msg, fd, count)));
			}
		}
		else
		{
			doc.SetData(to_string(reflection->GetInt64(msg, fd)));
		}

		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())
		{
			for(int count = 0; count < reflection->FieldSize(msg, fd); ++count)
			{
				doc.SetData(to_string(reflection->GetRepeatedUInt64(msg, fd, count)));
			}
		}
		else
		{
			doc.SetData(to_string(reflection->GetUInt64(msg, fd)));
		}

		break;

		// bool, varint on the wire.
	case FieldDescriptor::TYPE_BOOL:
		if(fd->is_repeated())
		{
			for(int count = 0; count < reflection->FieldSize(msg, fd); ++count)
			{
				doc.SetData(to_string(reflection->GetRepeatedBool(msg, fd, count)));
			}
		}
		else
		{
			doc.SetData(to_string(reflection->GetBool(msg, fd)));
		}

		break;

		// UTF-8 text.
	case FieldDescriptor::TYPE_STRING:
		// Arbitrary byte array.
	case FieldDescriptor::TYPE_BYTES:
		if(fd->is_repeated())
		{
			for(int count = 0; count < reflection->FieldSize(msg, fd); ++count)
			{
				doc.SetData(reflection->GetRepeatedString(msg, fd, count));
			}
		}
		else
		{
			doc.SetData(reflection->GetString(msg, fd));
		}

		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:
		if(fd->is_repeated())
		{
			for(int count = 0; count < reflection->FieldSize(msg, fd); ++count)
			{
				doc.SetData(reflection->GetRepeatedEnum(msg, fd, count)->number());
			}
		}
		else
		{
			doc.SetData(reflection->GetEnum(msg, fd)->number());
		}

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

	//重新进入tag
	doc.IntoElem();
	return true;
}

static bool proto_msg2xml(const google::protobuf::Message& msg, CMarkup& doc, const std::string& name)
{
	//增加tag
	doc.AddElem(name);
	//进入新增tag
	doc.IntoElem();

	const google::protobuf::Reflection* reflection = msg.GetReflection();
	assert(reflection);
	const google::protobuf::Descriptor* des = msg.GetDescriptor();
	assert(des);
	for(int count = 0; count < des->field_count(); ++count)
	{
		const google::protobuf::FieldDescriptor* fd = des->field(count);
		assert(fd);
		std::string key = fd->name();
		//没有设置的非repeated字段不组装进xml
		if(key == INTER_PROTO_CMARKUP_NAME || (!fd->is_repeated() && !reflection->HasField(msg, fd)))
		{
			continue;
		}
		
		if(is_attribute(key))
		{
			if(!proto_fd2xml_attr(msg, fd, doc, get_attribute_name(key)))
			{
				return false;
			}
		}
		else if(is_text(key))
		{
			if(!proto_fd2xml_text(msg, fd, doc))
			{
				return false;
			}
		}
		else
		{
			switch(fd->type())
			{
				// double, exactly eight bytes on the wire.
			case FieldDescriptor::TYPE_DOUBLE:
				if(fd->is_repeated())
				{
					for(int count = 0; count < reflection->FieldSize(msg, fd); ++count)
					{
						doc.AddElem(key, to_string(reflection->GetRepeatedDouble(msg, fd, count)));
					}
				}
				else
				{
					doc.AddElem(key, to_string(reflection->GetDouble(msg, fd)));
				}

				break;

				// float, exactly four bytes on the wire.
			case FieldDescriptor::TYPE_FLOAT:
				if(fd->is_repeated())
				{
					for(int count = 0; count < reflection->FieldSize(msg, fd); ++count)
					{
						doc.AddElem(key, to_string(reflection->GetRepeatedFloat(msg, fd, count)));
					}
				}
				else
				{
					doc.AddElem(key, to_string(reflection->GetFloat(msg, fd)));
				}

				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())
				{
					for(int count = 0; count < reflection->FieldSize(msg, fd); ++count)
					{
						doc.AddElem(key, to_string(reflection->GetRepeatedInt32(msg, fd, count)));
					}
				}
				else
				{
					doc.AddElem(key, to_string(reflection->GetInt32(msg, fd)));
				}

				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())
				{
					for(int count = 0; count < reflection->FieldSize(msg, fd); ++count)
					{
						doc.AddElem(key, to_string(reflection->GetRepeatedUInt32(msg, fd, count)));
					}
				}
				else
				{
					doc.AddElem(key, to_string(reflection->GetUInt32(msg, fd)));
				}

				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())
				{
					for(int count = 0; count < reflection->FieldSize(msg, fd); ++count)
					{
						doc.AddElem(key, to_string(reflection->GetRepeatedInt64(msg, fd, count)));
					}
				}
				else
				{
					doc.AddElem(key, to_string(reflection->GetInt64(msg, fd)));
				}

				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())
				{
					for(int count = 0; count < reflection->FieldSize(msg, fd); ++count)
					{
						doc.AddElem(key, to_string(reflection->GetRepeatedUInt64(msg, fd, count)));
					}
				}
				else
				{
					doc.AddElem(key, to_string(reflection->GetUInt64(msg, fd)));
				}

				break;

				// bool, varint on the wire.
			case FieldDescriptor::TYPE_BOOL:
				if(fd->is_repeated())
				{
					for(int count = 0; count < reflection->FieldSize(msg, fd); ++count)
					{
						doc.AddElem(key, to_string(reflection->GetRepeatedBool(msg, fd, count)));
					}
				}
				else
				{
					doc.AddElem(key, to_string(reflection->GetBool(msg, fd)));
				}

				break;

				// UTF-8 text.
			case FieldDescriptor::TYPE_STRING:
				// Arbitrary byte array.
			case FieldDescriptor::TYPE_BYTES:
				if(fd->is_repeated())
				{
					for(int count = 0; count < reflection->FieldSize(msg, fd); ++count)
					{
						doc.AddElem(key, reflection->GetRepeatedString(msg, fd, count));
					}
				}
				else
				{
					doc.AddElem(key, reflection->GetString(msg, fd));
				}

				break;

				// Tag-delimited message.  Deprecated.
			case FieldDescriptor::TYPE_GROUP:
				// Length-delimited message.
			case FieldDescriptor::TYPE_MESSAGE:
				if(fd->is_repeated())
				{
					for(int count = 0; count < reflection->FieldSize(msg, fd); ++count)
					{
						if(!proto_msg2xml(reflection->GetRepeatedMessage(msg, fd, count), doc, key))
						{
							return false;
						}
					}
				}
				else
				{
					//宏用于解决宏定义与函数名冲突
#pragma push_macro("GetMessage")
#undef GetMessage
					if(!proto_msg2xml(reflection->GetMessage(msg, fd), doc, key))
					{
						return false;
					}

#pragma pop_macro("GetMessage")
				}

				break;

				// Enum, varint on the wire
			case FieldDescriptor::TYPE_ENUM:
				if(fd->is_repeated())
				{
					for(int count = 0; count < reflection->FieldSize(msg, fd); ++count)
					{
						doc.AddElem(key, reflection->GetRepeatedEnum(msg, fd, count)->number());
					}
				}
				else
				{
					doc.AddElem(key, reflection->GetEnum(msg, fd)->number());
				}

				break;
			default:
				assert(0);
				return false;
				break;
			}
		}
	}
	
	doc.OutOfElem();
	return true;
}

bool proto2cmarkup(const google::protobuf::Message& msg, std::string& xml, cmarkup_type type/* = CMARKUP_GB2312*/)
{
	CMarkup doc;
	if(type == CMARKUP_GB2312)
	{
		doc.SetDoc("<?xml version=\"1.0\" encoding=\"gb2312\"?>\r\n");			//设置xml头
	}
	else if(type == CMARKUP_UTF8)
	{
		doc.SetDoc("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n");			//设置xml头
	}

	const google::protobuf::Descriptor* des = msg.GetDescriptor();
	const google::protobuf::FieldDescriptor* fd = des->FindFieldByName(INTER_PROTO_CMARKUP_NAME);
	if(!fd || fd->is_repeated() || (fd->type() != FieldDescriptor::TYPE_STRING && fd->type() != FieldDescriptor::TYPE_BYTES))
	{
		assert(0);
		return false;
	}

	const google::protobuf::Reflection* reflection = msg.GetReflection();
	if(!proto_msg2xml(msg, doc, reflection->GetString(msg, fd)))
	{
		return false;
	}

	xml = doc.GetDoc();
	return true;
}



WEIWODUMO
关注
Golang结构体序列化：JSON_XML_Protobuf对比
Golang编程笔记的博客
06-17 1005
在软件开发中，我们常常需要将程序中的数据进行存储或者传输。比如，我们开发了一个游戏，要把玩家的信息保存到文件里，或者把这些信息发送给服务器。这时候就需要把程序里的数据转换一种格式，这个过程就是序列化。我们这篇文章的目的就是要比较在Golang里，用JSON、XML和Protobuf这三种方式来进行结构体序列化的优缺点，让大家能根据不同的场景选择最合适的方法。首先，我们会了解一些基本概念，就像盖房子要先打地基一样。然后分别认识JSON、XML和Protobuf，看看它们长什么样，有什么特点。
protobuf与json转换小结
10-19
总之，protobuf与JSON之间的转换是通过特定的库和工具实现的，例如Google的`protobuf-java-format`，它解决了protobuf对象的非标准类型与JSON要求的字符串键之间的不兼容性。在实际项目中，正确地进行这种转换对于...
ProtoBuf使用指南
刻舟人的博客
09-19 1250
ProtoBuf是一种结构数据序列化方法，它可用于（数据）通信协议、数据存储等。 序列化是指将结构数据或对象转换成能够被存储和传输（例如网络传输）的格式，同时应当要保证这个序列化结果在之后（可能在另一个计算环境中）能够被重建回原来的结构数据或对象。
protobuf转换为json
09-23
protobuf转换为json，原版中存在bug，使用时候修复了原版的bug
protobuf/json/xml/binary/Thrift数据交换
weixin_34235105的博客
03-07 155
一条消息数据，用protobuf序列化后的大小是json的10分之一，xml格式的20分之一，是二进制序列化的10分之一，总体看来ProtoBuf的优势还是很明显的 protobuf是google提供的一个开源序列化框架，类似于XML，JSON这样的数据表示语言，详情访问protobuf的google官方网站 protobuf在google中是一个比较核心的基础库，作为分布式运算涉及到大量的不...
互联网传输：从XML到protcolbuffer
wangzhezhilu001的专栏
08-26 346
1.概述 2.最基础的传输格式：XML 3.另一种广泛的传输格式：JSON 4.最新的格式：protocolbuffer 5.结论
protobuf & xml浅见
weixin_30444105的博客
10-20 158
XML格式，那么多tag，一眼就看出来再怎么好的解析器，效率也好不到哪去，比纯粹binary的raw格式效率肯定差太远。本质上是明文字符串，在网络上传输量也大，因此传输效率也不高，当做配置文件用比较好，不仅给人看直观，层次结构也比较清晰。十几年前，各路大神，大软件商都齐声高歌我们完全兼容支持XML。原谅我Don Box大神的<<Essential XML>>这书我只看了看封...
java序列化/反序列化之xml、protobuf、protostuff 的比较与使用例子
weixin_33835690的博客
04-25 264
目录 1、背景 2、测试 　　2.1、环境 　　2.2、工具 　　2.3、说明 　　2.4、结果 　　2.5、结论 3、xml简单教程 　　3.1、准备 　　3.2、代码　 4、protobuf简单教程 　　4.1、快速入门 　　　　1、下载.exe编译器 　　　　2、编写.proto文件 　　　　3、利用编译器编译.proto文件生成javabean 　　　　4、...
源代码以及protobuf文件转换工具
12-30
protobuf，全称Protocol Buffers，是Google开发的一种数据序列化协议，用于结构化数据的串行化，类似于XML、JSON，但更小、更快、更简单。它允许你定义数据结构，然后使用特殊生成的源代码轻松地在各种数据流之间...
Protobuf工具 Google官方协议转换工具
12-23
Protobuf提供的是一种高效、跨平台且语言无关的数据编码格式，可以替代XML或JSON等传统数据交换格式，以更小的体积和更快的速度进行数据传输。 **协议转换工具——protoc** `protoc`是Google官方提供的协议编译器...
protobuf转cs的工具（ProtoGen）
08-17
protobuf转cs的工具，有需要的可以下载使用，结合命令行就可以转换proto文件了
.proto 各种语言转换
10-17
该文档讲述了在windows系统下，如何实现一键从git下载protobuf 3.6.1，编译，最后使用编译工具将.proto文件转换成Java，c#，Python等各种语言的文件，以便进行协议开发
protobuf-net.Core.xml
最新发布
11-14
protobuf-net的核心功能是将各种.NET数据结构转换为Protocol Buffers格式，并能够将这些格式的数据再还原回.NET的数据结构。这种序列化方式在多种编程语言中都有对应的实现，而protobuf-net是其.NET版本的实现。当...
根据proto文件配合tinyxml2自动解析xml
auccy的博客
08-18 982
使用Xml文件每次解析起来都很麻烦，一直想实现一个根据配置自动解析Xml的功能，迟迟没有好的方案，正好最近在看Protobuf相关的知识，发现Protobuf的一些特性可以用来实现自动解析Xml，便使用Protobuf的相关特性配合tinyxml2，根据proto配置文件实现了Xml的自动解析功能。 自动解析的实现流程： 1.根据xml文件配置proto文件.proto文件是什么 ...
protocol buff to xml json
linuxheik的专栏
10-11 631
http://code.google.com/p/protobuf-java-format/
ProtoBuf 替代XML的又一种选择
Pipi0714的专栏
07-04 3533
protobuf 是google公司的开源项目，功能与xml类似。由于最近需要传递数据，知道了对象串行化但是使用xml或二进制(BinaryFormat)后的数据都非常大，冗余数据大。找资料发现了protobuf他只是将值+他的属性进行串行化。这样大大减少了串行化后的空间大小（满足本人的需要，需要将数据写到卡上） 编写proto文件然后使用proto工具将它proto文件转换成C++或者C
一文搞懂XML、Json、Protobuf序列化协议
Jiangtagong的博客
08-13 3370
网络传输协议，简称为传送协议（Communications Protocol），是指计算机通信的共用语言。目前最为普遍的计算机通信为网络通信，因此“传送协议”一般是指计算机通信的传送协议，比如TCP/IP等。然而，传送协议也存在计算机的其他形式通信，例如：面向对象编程里面对象之间的通信；操作系统内不同进程之间的通信，都需要一个传送协议，以确保通信双方能够正常交流！常用的网络传输数据格式有：xml、json、protobuf等。 一、为什么需要序列化和反序列？ name 姓名，如：Mike...
Protobuf、XML、Json序列化等跨平台不同语言之间 数据交换函数调用等 通用接口协议
chenhao0568的专栏
11-05 673
一、场景 C++ 订单 —>接口编码 —> 网络 —> 接口解码 —> Java 订单 还可以更广泛一些，比如android调用c接口，只用一个jni接口来建立通道，其它所有接口都通过这个通道来传数据相互调用，再也不用写很多个接口了。 A语言—>数据封解包—>通道 —>数据封解包 —>B语言 如何实现远程函数的调用？ 发送结构：包名，函数名，方法，参数，返回值。 接收处理：反射调用，返回返回值。 二、成熟方案：Pr...
protobuf，xml，json序列化后与解析时间的对比
u012437323的专栏
03-07 1224
今天做了下这三种序列化的对比，主要是从序列化后的大小和解释时间的对比：从图中可以得出同一文件序列化后的文件大小是xml>json>proto，解析时间为xml>json>proto; 其中protobuf的解析时间明显要小于json和xml
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值