ICode9

精准搜索请尝试: 精确搜索
首页 > 编程语言> 文章详细

C++反序列化--一种基于class infomation反射库的反序列化数据结构

2022-08-21 18:03:09  阅读:208  来源: 互联网

标签:Node insert -- C++ dict cpp 序列化 root


序列化与反序列化概念:

将程序的某些数据存储在内存中,然后将其写入某个文件或是将它传输到网络中的另一台计算机上以实现通讯。这个将程序数据转化成能被存储并传输的格式的过程被称为“序列化”(Serialization),而它的还原过程则可被称为“反序列化”(De-serialization).

详见: C++与序列化 CSDN博客_c++ 序列化

反射:

维基百科的定义:反射是指计算机程序在运行时可以访问、检测和修改它本身状态或行为的一种能力。 有点抽象,实际上反射就是程序在运行时动态获取对象信息以及调用对象方法的能力。可以对比java的运行期反射机制,C++没有自带的反射机制,需要依赖外部库来实现。

ProtoBuff

Boost.Serialization

Boost.Serialization可以创建或重建程序中的等效结构,并保存为二进制数据、文本数据、XML或者有用户自定义的其他文件。该库具有以下吸引人的特性

Serialization - Tutorial (boost.org)

MFC Serialization

Windows平台下可使用MFC中的序列化方法。MFC对CObject 类中的序列化提供内置支持。

.Net Framework

.NET的运行时环境用来支持用户定义类型的流化的机制。它在此过程中,先将对象的公共字段和私有字段以及类的名称(包括类所在的程序集)转换为字节流,然后再把字节流写入数据流。在随后对对象进行反序列化时,将创建出与原对象完全相同的副本。

QJSON

www.json.org

由于Bytestream指令流中可以包含各种依赖嵌入式底层结构的数据格式以及排布方式,我们可以提供自定义的Bytestream数据格式与配套的序列化/反序列化引擎,包括存储数据格式的C++数据结构以及writer()/reader()/parser()等一系列API。

 

 

Codec指令流驱动序列化/反序列化引擎:

 

 

 

 Bytestream数据格式的Header包含ABIcode,反映了C++类对象的原始内存排布信息,以及classhash来映射对应的reflection容器,寻找对应的class反射文件。

常规的JSON文件格式,考虑一种包含多种基础数据类型的数据结构:

C++直接操作python的dict模块需要使用pybind11操作库,实际工程实践中可能会需要交叉编译,我们直接定义一种数据结构通过模拟并操作dict数据结构,配合反射库的生成文件来解析并读取Bytestream中的C++ class info,参考N叉树:

 1 class cpp_dict{
 2 public:
 3 std::unordered_mapstd::string,std::stringMap0;//basic converted type
 4 std::unordered_mapstd::string,std::uint64_tMap1;//basic converted type
 5 vectorstd::uint32_thash;
 6 std::unordered_setstd::uint32_tenum_values;
 7 vector<cpp_dict*>Node;
 8 std::uint32_t count;
 9 bool flag;
10 public: 11 cpp_dict(){ 12 this->Node.resize(1,nullptr); 13 this->hash.resize(4,0); 14 this->flag=true; 15 } 16 }

基础API包括插入操作,包括成员变量独立插入,自底向上构造插入(insert_test_1b1()),BFS插入与DFS插入(按照指定的Node track);待实现API为删除和匹配操作:

 1 class cpp_dict{
 2 public:
 3 std::unordered_map<std::string,std::string>Map0;//basic converted type
 4 std::unordered_map<std::string,std::uint64_t>Map1;//basic converted type
 5 vector<std::uint32_t>hash;
 6 std::unordered_set<std::uint32_t>enum_values;
 7 vector<cpp_dict*>Node;
 8 std::uint32_t count;
 9 bool flag;
10 public:
11 cpp_dict(){
12     this->Node.resize(1,nullptr);
13     this->hash.resize(4,0);
14     this->flag=true;
15 }
16 
17 void insert_str(string key,string str)
18 {
19     this->Map0[key]=str;
20 }
21 void insert_int(string key,std::uint64_t x)
22 {
23     this->Map1[key]=x;
24 }
25 void insert_hash(vector<std::uint32_t>& vec)
26 {
27     for(int i=0;i<vec.size();i++)
28     {
29         this->hash[i]=vec[i];
30     }
31 }
32 void insert_set(vector<std::uint32_t>& set_vec)
33 {
34     for(auto x:set_vec)
35     {
36         this->enum_values.insert(x);
37     }
38 }
39 void insert_test_1b1(cpp_dict* tar)//add cpp_dict* one by one
40 {
41     if(!this->Node[0]){
42         this->Node[0]=tar;
43     }else{
44         this->Node.push_back(tar);
45     }
46     return;
47 }
48 void insert_cpp_dict_BFS(vector<cpp_dict*>& temp)//add cpp_dict* to current Node
49 {
50     int idx=0;
51     if(!this->Node[0]){
52         this->Node.pop_back();
53     }
54     for(int i=0;i<temp.size();i++){
55         this->Node.push_back(temp[i]);
56         cout<<"*insert success!*"<<endl;
57     }
58     return;
59 }
60 void insert_cpp_dict_DFS(cpp_dict* cur, cpp_dict* Temp, vector<int>& track)//add cpp_dict* Temp to next Node, track index 
61 {
62     for(int i=0;i<track.size();i++){
63         if(cur->Node.size()==0){
64             cur->Node.push_back(Temp);
65             return;
66         }else{
67             if((!cur->Node[track[i]] && i<track.size()-1) || (track[i]>= cur->Node.size())){
68                 cout<<"*insert error!*"<<endl;
69                 return;
70             }else{
71                 cout<<track[i]<<"# ";
72                 if(i==track.size()-1){
73                     cur->Node[track[i]]=Temp;
74                     cout<<"*insert success!*"<<endl;
75                     return;
76                 }
77                 cur=cur->Node[track[i]];
78             }
79         }
80     }
81     return;
82 }
83 void erase();
84 void find();
85 };

测试函数包含成员变量打印,以及节点深度测试:

 1 void print_info(string blank, cpp_dict* cur)
 2 {
 3     for(auto p:cur->Map0){
 4         cout<<blank<<p.first<<":"<<p.second<<endl;
 5     }
 6     for(auto p:cur->Map1){
 7         cout<<blank<<p.first<<":"<<p.second<<endl;
 8     }
 9     cout<<blank<<"hash:["<<endl;
10     int k=0;
11     for(auto x:cur->hash){
12         k++;
13         if(k==cur->hash.size()){
14             cout<<blank<<" "<<x<<endl;
15             break;
16         }
17         cout<<blank<<" "<<x<<","<<endl;
18     }
19     cout<<blank<<"]"<<endl;
20     k=0;
21     cout<<blank<<"enum_values:{";
22     for(auto x:cur->enum_values){
23         k++;
24         if(k==cur->enum_values.size()){
25             cout<<blank<<x;
26             break;
27         }
28         cout<<blank<<" "<<x<<",";
29     }
30     cout<<"}"<<endl;
31     cout<<blank<<"count:"<<cur->count<<endl;
32     cout<<blank<<"flag:"<<cur->flag<<endl;
33     cout<<blank<<"members:["<<endl;
34     return;
35 }
36 void search(cpp_dict* cur,int dep,string blank)//DFS search
37 {
38     if(!cur || cur->Node.size()==0){
39         cout<<blank<<"/current depth:"<<dep<<"/ "<<endl;
40         return;
41     }else{
42         print_info(blank,cur);
43         for(auto x:cur->Node){
44             search(x,dep+1,blank+"  ");
45         }
46         cout<<blank<<"]"<<endl;
47     }
48     return;
49 }

测试主函数(实现了三层节点嵌套):

 1 int main() {
 2     cpp_dict* root=new cpp_dict();
 3     cpp_dict* temp=new cpp_dict();
 4     cpp_dict* base=root;
 5 
 6     temp->insert_str("name", "temp");
 7     temp->insert_int("offset", 0);
 8     temp->insert_int("test_node", 0);
 9     vector<std::uint32_t>vec={1,1,1,1};
10     vector<std::uint32_t>set_vec={0};
11     root->insert_hash(vec);
12     root->insert_set(set_vec);
13     //search(temp,0,"");
14     root->insert_str("name", "root");
15     root->insert_int("offset", 1);
16 
17     vector<cpp_dict*>Temp;
18     Temp.push_back(temp);
19     cpp_dict* temp1=new cpp_dict();
20     temp1->insert_str("name", "temp1");
21     temp1->insert_int("test_node", 1);
22     temp1->insert_int("offset", 0);
23     temp1->insert_int("test_node", 0);
24     Temp.push_back(temp1);
25 
26     //root=root->Node[0];
27     //root->insert_test_1b1(temp1);
28     //insert_test(root,Temp);
29 
30     //root->insert_cpp_dict_BFS(Temp);
31     
32     cpp_dict* temp2=new cpp_dict();
33     temp2->insert_str("name", "temp2");
34     temp1->insert_test_1b1(temp2);
35     temp->insert_test_1b1(temp1);
36     root->insert_test_1b1(temp);
37 
38     vector<int>track={0,0,0};
39     //root->insert_cpp_dict_DFS(root,temp2,track);
40     //root->insert_test(root,Temp);
41     cout<<"{"<<endl;
42     search(base,0,"");
43     cout<<"}"<<endl;
44     return 0;
45 }

打印:

{
name:root
offset:1
hash:[
 1,
 1,
 1,
 1
]
enum_values:{0}
count:0
flag:1
members:[
  name:temp
  test_node:0
  offset:0
  hash:[
   0,
   0,
   0,
   0
  ]
  enum_values:{}
  count:0
  flag:1
  members:[
    name:temp1
    offset:0
    test_node:0
    hash:[
     0,
     0,
     0,
     0
    ]
    enum_values:{}
    count:0
    flag:1
    members:[
      name:temp2
      hash:[
       0,
       0,
       0,
       0
      ]
      enum_values:{}
      count:0
      flag:1
      members:[
        /current depth:4/ 
      ]
    ]
  ]
]
}

结果符合预期,注意深度是4,考虑到了最底层的空节点。

 

标签:Node,insert,--,C++,dict,cpp,序列化,root
来源: https://www.cnblogs.com/Desh/p/16610433.html

本站声明: 1. iCode9 技术分享网(下文简称本站)提供的所有内容,仅供技术学习、探讨和分享;
2. 关于本站的所有留言、评论、转载及引用,纯属内容发起人的个人观点,与本站观点和立场无关;
3. 关于本站的所有言论和文字,纯属内容发起人的个人观点,与本站观点和立场无关;
4. 本站文章均是网友提供,不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属;如您发现该文章侵犯了您的权益,可联系我们第一时间进行删除;
5. 本站为非盈利性的个人网站,所有内容不会用来进行牟利,也不会利用任何形式的广告来间接获益,纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

专注分享技术,共同学习,共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有