Objectarx 对XDATA 进行封装

枫叶棋语

1. #pragma once
   
2. #include <acdb.h>
   
3. #include <acedads.h>
   
4. #include <AcString.h>
   
5. #include <acutads.h>
   
6. #include <adsdef.h>
   
7. #include <cstdint>
   
8. #include <dbhandle.h>
   
9. #include <dbObject.h>
   
10. #include <gepnt2d.h>
    
11. #include <gepnt3d.h>
    
12. #include <gevec2d.h>
    
13. #include <gevec3d.h>
    
14. 
    
15. class Xdata {
    
16. public:
    
17. 
    
18.   ~Xdata() {
    
19.     clear();
    
20.   }
    
21. 
    
22.   Xdata(const AcString& appName) : appName(appName) {
    
23.     acdbRegApp(appName); // 注册应用名
    
24.     pRb = createRegAppNode(appName);
    
25.     pTail = pRb;
    
26.   }
    
27. 
    
28. 
    
29.   void write(AcDbObject* pObj) {
    
30.     if (pRb == nullptr || pRb->restype != Code::RegAppCode) {
    
31.       auto head = createRegAppNode(appName);
    
32.       head->rbnext = pRb;
    
33.       pRb = head;
    
34.     }
    
35.     pObj->setXData(pRb);
    
36.   }
    
37. 
    
38.   void read(AcDbObject* pObj) {
    
39.     clear();
    
40.     resbuf* xdata = pObj->xData(appName);
    
41.     if (!xdata) {
    
42.       this->pRb = nullptr;
    
43.       return;
    
44.     };
    
45.     copyResbufChain(xdata, &pRb, &pTail);
    
46.   }
    
47. 
    
48.   void print() {
    
49.     if (pRb == nullptr) {
    
50.       acutPrintf(L"\nNo Xdata for AppName [%s].\n", appName);
    
51.     }
    
52.     resbuf* next = pRb;
    
53.     //int flag = 0;
    
54.     while (true) {
    
55.       if (next == nullptr)
    
56.         return;
    
57.       printNode(next);
    
58.       next = next->rbnext;
    
59.     }
    
60.   }
    
61. 
    
62.   //------------------------------
    
63.   // 数据添加方法
    
64.   //------------------------------
    
65.   void addLayerName(const AcString& name) {
    
66.     ads_u_val val;
    
67.     val.setString(name);
    
68.     addNode(Code::LayerCode, val);
    
69.   }
    
70. 
    
71.   void addString(const AcString& str) {
    
72.     ads_u_val val;
    
73.     val.setString(str);
    
74.     addNode(Code::WstrCode, val);
    
75.   }
    
76. 
    
77.   void addInt16(short num) {
    
78.     ads_u_val val;
    
79.     val.setShort(num);
    
80.     addNode(Code::Int16Code, val);
    
81.   }
    
82. 
    
83.   void addInt32(int32_t num) {
    
84.     ads_u_val val;
    
85.     val.setInt32(num);
    
86.     addNode(Code::Int32Code, val);
    
87.   }
    
88. 
    
89.   void addDouble(double num) {
    
90.     ads_u_val val;
    
91.     val.setDouble(num);
    
92.     addNode(Code::DoubleCode, val);
    
93.   }
    
94.   void addDist(double dist) {
    
95.     ads_u_val val;
    
96.     val.setDouble(dist);
    
97.     addNode(Code::DistCode, val);
    
98.   }
    
99. 
    
100.   void addScale(double scale) {
     
101.     ads_u_val val;
     
102.     val.setDouble(scale);
     
103.     addNode(Code::ScaleCode, val);
     
104.   }
     
105. 
     
106.   void addArray(double arr[3]) {
     
107.     ads_u_val val;
     
108.     val.setArray(arr[0], arr[1], arr[2]);
     
109.     addNode(Code::ArrayCode, val);
     
110.   }
     
111. 
     
112.   void addPoint2d(const AcGePoint2d& pt) {
     
113.     ads_u_val val;
     
114.     val.setArray(pt.x, pt.y, 0);
     
115.     addNode(Code::PointCode, val);
     
116.   }
     
117. 
     
118.   void addPoint3d(const AcGePoint3d& pt) {
     
119.     ads_u_val val;
     
120.     val.setArray(pt.x, pt.y, pt.z);
     
121.     addNode(Code::PointCode, val);
     
122.   }
     
123. 
     
124.   void addDisp2d(const AcGeVector2d& vec) {
     
125.     ads_u_val val;
     
126.     val.setArray(vec.x, vec.y, 0);
     
127.     addNode(Code::DispCode, val);
     
128.   }
     
129. 
     
130.   void addDisp3d(const AcGeVector3d& vec) {
     
131.     ads_u_val val;
     
132.     val.setArray(vec.x, vec.y, vec.z);
     
133.     addNode(Code::DispCode, val);
     
134.   }
     
135. 
     
136.   void addDirect2d(const AcGeVector2d& vec) {
     
137.     ads_u_val val;
     
138.     val.setArray(vec.x, vec.y, 0);
     
139.     addNode(Code::DirCode, val);
     
140.   }
     
141.   void addDirect3d(const AcGeVector3d& vec) {
     
142.     ads_u_val val;
     
143.     val.setArray(vec.x, vec.y, vec.z);
     
144.     addNode(Code::DirCode, val);
     
145.   }
     
146. 
     
147.   void addHandle(const AcDbHandle& handle) {
     
148.     ads_u_val val;
     
149.     val.mn64data = handle.get64BitVal(); // 核心改动：使用原始字节写入
     
150.     addNode(Code::HandleCode, val);
     
151.   }
     
152.   void clear() {
     
153.     resbuf* curr = pRb;
     
154.     while (curr) {
     
155.       resbuf* next = curr->rbnext;
     
156.       switch (curr->restype) {  // 去掉了rbinary处理
     
157.       case Code::RegAppCode:
     
158.       case Code::WstrCode:
     
159.       case Code::LayerCode:
     
160.         curr->releaseString();
     
161.         break;
     
162.       }
     
163.       delete curr;
     
164.       curr = next;
     
165.     }
     
166.     pRb = pTail = nullptr;
     
167.   }
     
168.   resbuf* createRegAppNode(const AcString& name) {
     
169.     resbuf* node = new resbuf();
     
170.     node->restype = AcDb::kDxfRegAppName;
     
171.     node->setValue(name);
     
172.     node->rbnext = nullptr;
     
173.     return node;
     
174.   }
     
175. protected:
     
176.   //------------------------------
     
177.   // 内存管理核心方法
     
178.   //------------------------------
     
179.   resbuf* pRb = nullptr;
     
180.   resbuf* pTail = nullptr;
     
181.   AcString appName;
     
182. 
     
183.   void copyResbufChain(const resbuf* src, resbuf** dstHead, resbuf** dstTail) {
     
184.     resbuf* prev = nullptr;
     
185.     for (const resbuf* curr = src; curr; curr = curr->rbnext) {
     
186.       resbuf* node = new resbuf();
     
187.       node->restype = curr->restype;
     
188. 
     
189.       switch (curr->restype) { // 移除了rbinary处理
     
190.       case Code::RegAppCode:
     
191.       case Code::LayerCode:
     
192.       case Code::WstrCode:
     
193.         node->setValue(curr->resval.rstring);
     
194.         break;
     
195.       default:
     
196.         node->resval = curr->resval;
     
197.       }
     
198.       node->rbnext = nullptr;
     
199.       if (prev) prev->rbnext = node;
     
200.       else *dstHead = node;
     
201. 
     
202.       prev = node;
     
203.     }
     
204.     *dstTail = prev;
     
205.   }
     
206. 
     
207.   //------------------------------
     
208.   // 工具方法
     
209.   //------------------------------
     
210. 
     
211. 
     
212.   //添加节点
     
213.   void addNode(short restype, const ads_u_val& val) {
     
214.     resbuf* node = new resbuf();
     
215.     node->restype = restype;
     
216. 
     
217.     switch (restype) {
     
218.     case Code::RegAppCode:
     
219.     case Code::LayerCode:
     
220.     case Code::WstrCode:
     
221.       node->setValue(val.rstring);
     
222.       break;
     
223.     default:
     
224.       node->resval = val;
     
225.     }
     
226. 
     
227.     if (pTail) {
     
228.       pTail->rbnext = node;
     
229.       pTail = node;
     
230.     }
     
231.     else {
     
232.       pRb = pTail = node;
     
233.     }
     
234.   }
     
235. 
     
236.   //打印坐标
     
237.   void printPoint(const double* point) {
     
238.     acutPrintf(L"(%.2f, %.2f, %.2f)\n", point[0], point[1], point[2]);
     
239.   }
     
240. 
     
241.   // 打印节点
     
242.   void printNode(resbuf* pNode) {
     
243.     if (pNode == nullptr) {
     
244.       acutPrintf(L"空节点");
     
245.       return;
     
246.     }
     
247.     switch (pNode->restype) {
     
248.     case Code::RegAppCode:
     
249.       acutPrintf(L"[AppName] %s\n", pNode->resval.rstring);
     
250.       break;
     
251. 
     
252.     case Code::LayerCode:
     
253.       acutPrintf(L"[LayerName] %s\n", pNode->resval.rstring);
     
254.       break;
     
255. 
     
256.     case Code::WstrCode:
     
257.       acutPrintf(L"[AcString] %s\n", pNode->resval.rstring);
     
258.       break;
     
259. 
     
260.     case Code::Int16Code:
     
261.       acutPrintf(L"[int16] %d\n", pNode->resval.rint);
     
262.       break;
     
263. 
     
264.     case Code::Int32Code:
     
265.       acutPrintf(L"[int32] %ld\n", pNode->resval.rlong);
     
266.       break;
     
267. 
     
268.     case Code::DoubleCode:
     
269.       acutPrintf(L"[double] %.3f\n", pNode->resval.rreal);
     
270.       break;
     
271. 
     
272.     case Code::ArrayCode:
     
273.     case Code::PointCode:
     
274.     case Code::DispCode:
     
275.     case Code::DirCode:
     
276.       acutPrintf(L"[int16] %d\n:", pNode->restype);
     
277.       printPoint(pNode->resval.rpoint);
     
278.       break;
     
279.     case Code::HandleCode:
     
280.       // 直接输出64位无符号整型
     
281.       acutPrintf(L"[句柄] %I64u\n", pNode->resval.mn64data); // 修改此处格式说明符
     
282.       break;
     
283.     case Code::DistCode:
     
284.       acutPrintf(L"[距离] %.3f\n", pNode->resval.rreal);
     
285.       break;
     
286.     case Code::ScaleCode:
     
287.       acutPrintf(L"[比例] %.3f\n", pNode->resval.rreal);
     
288.       break;
     
289.     default:
     
290.       acutPrintf(L"[未知类型:%d] \n", pNode->restype);
     
291.       break;
     
292.     }
     
293.   }
     
294. 
     
295. 
     
296.   enum Code :short
     
297.   {
     
298.     RegAppCode = 1001,  // Xdata 的 application name(组码1001)
     
299.     WstrCode = 1000,    // ASCII 字符串的最大长度为 255 个字节（组码 1000）
     
300.     LayerCode = 1003,   // 图层名（组码 1003）
     
301.     ArrayCode = 1010,   // 3 个实数（组码 1010）
     
302.     PointCode = 1011,   // 三维世界空间位置（组码 1011）
     
303.     DispCode = 1012,    // 三维世界空间位移（组码 1012）
     
304.     DirCode = 1013,     // 三维世界空间方向（组码 1013）
     
305.     DoubleCode = 1040,  // 实数（组码 1040）
     
306.     DistCode = 1041,    // 距离（组码 1041）
     
307.     ScaleCode = 1042,   // 比例因子（组码 1042）
     
308.     Int16Code = 1070,   // 一个 16 位整数（组码 1070）
     
309.     Int32Code = 1071,   // 一个 32 位有符号长整数（组码 1071）
     
310.     HandleCode = 1005   //一个句柄（组码1005）
     
311.   };
     
312. 
     
313. };

复制代码

xiaolong1487

学习了，谢谢分享，这个门槛有点高，学一段时间，又丢了，学不会。