微对象的初入（5）

  1 POB_TREE_NODE_T _stdcall root(POB_TREE_HEAD_T head)
  2 {
  3     if (head != NULL && head->root != NULL)
  4     {
  5         return head->root;
  6     }
  7     return NULL;
  8 }
  9 
 10 POB_TREE_NODE_T __stdcall next(POB_TREE_NODE_T pnode)
 11 {
 12     if (pnode == NULL && pnode->next != NULL)
 13     {
 14         return pnode->next;
 15     }
 16     return NULL;
 17 }
 18 
 19 POB_TREE_NODE_T __stdcall before(POB_TREE_NODE_T pnode)
 20 {
 21     if (pnode == NULL && pnode->before != NULL)
 22     {
 23         return pnode->before;
 24     }
 25     return NULL;
 26 }
 27 
 28 POB_TREE_NODE_T __stdcall child(POB_TREE_NODE_T pnode)
 29 {
 30     if (pnode == NULL && pnode->child != NULL)
 31     {
 32         return pnode->child;
 33     }
 34     return NULL;
 35 }
 36 
 37 POB_TREE_NODE_T __stdcall parent(POB_TREE_NODE_T pnode)
 38 {
 39     if (pnode == NULL && pnode->child != NULL)
 40     {
 41         return pnode->child;
 42     }
 43     return NULL;
 44 }
 45 
 46 bool __stdcall ob_new_node_null(POB_TREE_NODE_T* ppnode, POB_RESULT_T* ppresult, OB_STRING_T name, OB_UINT_T len, OB_NULL_T data)
 47 {
 48     POB_RESULT_T presult = _ob_new_error(ppresult, true, 0, NULL);
 49     if (presult == NULL)
 50     {
 51         return false;
 52     }
 53     POB_TREE_NODE_T pnode = (POB_TREE_NODE_T)malloc(sizeof(OB_TREE_NODE_T));
 54     if (pnode == NULL)
 55     {
 56         (*ppresult) = _ob_new_error(ppresult, false, 1, "malloc failed.");
 57         return false;
 58     }
 59 
 60     memset(pnode, 0x00, sizeof(OB_TREE_NODE_T));
 61 
 62     POB_ENDOBJ_T pobj = NULL;
 63     bool ret = ob_new_obj_null(&pobj, ppresult, name, len, data);
 64     if (ret == false)
 65     {
 66         free(pnode);
 67         _ob_set_error(presult, false, 3, "ob_new_obj_null failed.");
 68         return false;
 69     }
 70 
 71     pnode->obj = pobj;
 72 
 73     (*ppnode) = pnode;
 74 
 75     return true;
 76 }
 77 
 78 bool __stdcall ob_new_node_bool(POB_TREE_NODE_T* ppnode, POB_RESULT_T* ppresult, OB_STRING_T name, OB_UINT_T len, OB_BOOL_T data)
 79 {
 80     POB_RESULT_T presult = _ob_new_error(ppresult, true, 0, NULL);
 81     if (presult == NULL)
 82     {
 83         return false;
 84     }
 85     POB_TREE_NODE_T pnode = (POB_TREE_NODE_T)malloc(sizeof(OB_TREE_NODE_T));
 86     if (pnode == NULL)
 87     {
 88         (*ppresult) = _ob_new_error(ppresult, false, 1, "malloc failed.");
 89         return false;
 90     }
 91 
 92     memset(pnode, 0x00, sizeof(OB_TREE_NODE_T));
 93 
 94     POB_ENDOBJ_T pobj = NULL;
 95     bool ret = ob_new_obj_bool(&pobj, ppresult, name, len, data);
 96     if (ret == false)
 97     {
 98         free(pnode);
 99         _ob_set_error(presult, false, 3, "ob_new_obj_bool failed.");
100         return false;
101     }
102 
103     pnode->obj = pobj;
104 
105     (*ppnode) = pnode;
106 
107     return true;
108 }
109 
110 bool __stdcall ob_new_node_integer(POB_TREE_NODE_T* ppnode, POB_RESULT_T* ppresult, OB_STRING_T name, OB_UINT_T len, OB_INT_T data)
111 {
112     POB_RESULT_T presult = _ob_new_error(ppresult, true, 0, NULL);
113     if (presult == NULL)
114     {
115         return false;
116     }
117     POB_TREE_NODE_T pnode = (POB_TREE_NODE_T)malloc(sizeof(OB_TREE_NODE_T));
118     if (pnode == NULL)
119     {
120         (*ppresult) = _ob_new_error(ppresult, false, 1, "malloc failed.");
121         return false;
122     }
123 
124     memset(pnode, 0x00, sizeof(OB_TREE_NODE_T));
125 
126     POB_ENDOBJ_T pobj = NULL;
127     bool ret = ob_new_obj_integer(&pobj, ppresult, name, len, data);
128     if (ret == false)
129     {
130         free(pnode);
131         _ob_set_error(presult, false, 3, "ob_new_obj_integer failed.");
132         return false;
133     }
134 
135     pnode->obj = pobj;
136 
137     (*ppnode) = pnode;
138 
139     return true;
140 }
141 
142 bool __stdcall ob_new_node_double(POB_TREE_NODE_T* ppnode, POB_RESULT_T* ppresult, OB_STRING_T name, OB_UINT_T len, OB_DOUBLE_T data)
143 {
144     POB_RESULT_T presult = _ob_new_error(ppresult, true, 0, NULL);
145     if (presult == NULL)
146     {
147         return false;
148     }
149     POB_TREE_NODE_T pnode = (POB_TREE_NODE_T)malloc(sizeof(OB_TREE_NODE_T));
150     if (pnode == NULL)
151     {
152         (*ppresult) = _ob_new_error(ppresult, false, 1, "malloc failed.");
153         return false;
154     }
155 
156     memset(pnode, 0x00, sizeof(OB_TREE_NODE_T));
157 
158     POB_ENDOBJ_T pobj = NULL;
159     bool ret = ob_new_obj_double(&pobj, ppresult, name, len, data);
160     if (ret == false)
161     {
162         free(pnode);
163         _ob_set_error(presult, false, 3, "ob_new_obj_double failed.");
164         return false;
165     }
166 
167     pnode->obj = pobj;
168 
169     (*ppnode) = pnode;
170 
171     return true;
172 }
173 
174 bool __stdcall ob_new_node_string(POB_TREE_NODE_T* ppnode, POB_RESULT_T* ppresult, OB_STRING_T name, OB_UINT_T len, OB_STRING_T data, OB_UINT_T datalen)
175 {
176     POB_RESULT_T presult = _ob_new_error(ppresult, true, 0, NULL);
177     if (presult == NULL)
178     {
179         return false;
180     }
181     POB_TREE_NODE_T pnode = (POB_TREE_NODE_T)malloc(sizeof(OB_TREE_NODE_T));
182     if (pnode == NULL)
183     {
184         (*ppresult) = _ob_new_error(ppresult, false, 1, "malloc failed.");
185         return false;
186     }
187 
188     memset(pnode, 0x00, sizeof(OB_TREE_NODE_T));
189 
190     POB_ENDOBJ_T pobj = NULL;
191     bool ret = ob_new_obj_string(&pobj, ppresult, name, len, data, datalen);
192     if (ret == false)
193     {
194         free(pnode);
195         _ob_set_error(presult, false, 3, "ob_new_obj_string failed.");
196         return false;
197     }
198 
199     pnode->obj = pobj;
200 
201     (*ppnode) = pnode;
202 
203     return true;
204 }
205 
206 bool __stdcall ob_new_node_array(POB_TREE_NODE_T* ppnode, POB_RESULT_T* ppresult, OB_STRING_T name, OB_UINT_T len, OB_ARRAY_T data, enum ENUM_OB_ENDOBJ_TYPE type, OB_UINT_T count)
207 {
208     POB_RESULT_T presult = _ob_new_error(ppresult, true, 0, NULL);
209     if (presult == NULL)
210     {
211         return false;
212     }
213     POB_TREE_NODE_T pnode = (POB_TREE_NODE_T)malloc(sizeof(OB_TREE_NODE_T));
214     if (pnode == NULL)
215     {
216         (*ppresult) = _ob_new_error(ppresult, false, 1, "malloc failed.");
217         return false;
218     }
219 
220     memset(pnode, 0x00, sizeof(OB_TREE_NODE_T));
221 
222     POB_ENDOBJ_T pobj = NULL;
223     bool ret = ob_new_obj_array(&pobj, ppresult, name, len, data, type, count);
224     if (ret == false)
225     {
226         free(pnode);
227         _ob_set_error(presult, false, 3, "ob_new_obj_string failed.");
228         return false;
229     }
230 
231     pnode->obj = pobj;
232 
233     (*ppnode) = pnode;
234 
235     return true;
236 }
237 
238 bool __stdcall ob_new_node_array_string(POB_TREE_NODE_T* ppnode, POB_RESULT_T* ppresult, OB_STRING_T name, OB_UINT_T len, OB_ARRAY_STRING_T data, OB_UINT_T count)
239 {
240     POB_RESULT_T presult = _ob_new_error(ppresult, true, 0, NULL);
241     if (presult == NULL)
242     {
243         return false;
244     }
245     POB_TREE_NODE_T pnode = (POB_TREE_NODE_T)malloc(sizeof(OB_TREE_NODE_T));
246     if (pnode == NULL)
247     {
248         (*ppresult) = _ob_new_error(ppresult, false, 1, "malloc failed.");
249         return false;
250     }
251 
252     memset(pnode, 0x00, sizeof(OB_TREE_NODE_T));
253 
254     POB_ENDOBJ_T pobj = NULL;
255     bool ret = ob_new_obj_array_string(&pobj, ppresult, name, len, data, count);
256     if (ret == false)
257     {
258         free(pnode);
259         _ob_set_error(presult, false, 3, "ob_new_obj_string failed.");
260         return false;
261     }
262 
263     pnode->obj = pobj;
264 
265     (*ppnode) = pnode;
266 
267     return true;
268 }
269 
270 
271 bool __stdcall new_root(POB_TREE_HEAD_T head, POB_TREE_NODE_T* ppnode, POB_RESULT_T* ppresult)
272 {
273     if (head == NULL)
274     {
275         _ob_new_error(ppresult, false, 3, "head == NULL");
276         return false;
277     }
278     if (ppnode == NULL || (*ppnode) == NULL)
279     {
280         _ob_new_error(ppresult, false, 3, "ppnode == NULL || (*ppnode) == NULL");
281         return false;
282     }
283     head->root = *ppnode;
284     return true;
285 }
286 
287 bool __stdcall insert_node(POB_TREE_NODE_T pcurrentnode, POB_TREE_NODE_T* ppnode, POB_RESULT_T* ppresult)
288 {
289     if (pcurrentnode == NULL)
290     {
291         _ob_new_error(ppresult, false, 3, "pcurrentnode == NULL");
292         return false;
293     }
294     if (ppnode == NULL || (*ppnode) == NULL)
295     {
296         _ob_new_error(ppresult, false, 3, "ppnode == NULL || (*ppnode) == NULL");
297         return false;
298     }
299 
300     (*ppnode)->child = NULL;
301     (*ppnode)->next = pcurrentnode->next;
302     (*ppnode)->before = pcurrentnode;
303     pcurrentnode->next = *ppnode;
304     (*ppnode)->parent = pcurrentnode->parent;
305 
306     if ((*ppnode)->next != NULL)
307     {
308         (*ppnode)->next->before = (*ppnode);
309     }
310 
311     return true;
312 }
313 
314 
315 bool __stdcall delete_node(POB_TREE_NODE_T* ppnode, POB_RESULT_T* ppresult)
316 {
317     if (ppnode == NULL || (*ppnode) == NULL)
318     {
319         _ob_new_error(ppresult, false, 3, "ppnode == NULL || (*ppnode) == NULL");
320         return false;
321     }
322 
323     if ((*ppnode)->before == NULL || (*ppnode)->before->next != (*ppnode))
324     {
325         _ob_new_error(ppresult, false, 3, "(*ppnode)->before == NULL || (*ppnode)->before->next != (*ppnode)");
326         return false;
327     }
328     (*ppnode)->before->next = (*ppnode)->next;
329     if ((*ppnode)->next != NULL)
330     {
331         (*ppnode)->next->before = (*ppnode)->before;
332     }
333 
334     ob_node_free(ppnode);
335     return true;
336 }
337 
338 
339 #pragma region // new delete ob
340 POB_TREE_HEAD_T __stdcall new_ob(POB_RESULT_T* ppresult, OB_STRING_T ob_name, OB_UINT_T name_len, OB_STRING_T ob_version, OB_UINT_T ver_len)
341 {
342     POB_TREE_HEAD_T head = (POB_TREE_HEAD_T)malloc(sizeof(OB_TREE_HEAD_T));
343     if (head != NULL)
344     {
345         unsigned char rand_time[24];
346         int time_len = 18;
347 
348         memset(rand_time, 0x00, sizeof(rand_time));
349 
350         create_rand_time((char*)rand_time, time_len);
351 
352         memset(head, 0x00, sizeof(OB_TREE_HEAD_T));
353 
354         sprintf_s((char*)head->ob_name, sizeof(head->ob_name), "%s_%s", rand_time, ob_name);
355 
356         memcpy(head->ob_version[0], ob_version, ver_len);
357 
358         // mutex
359         unsigned char mutex_ob_name[64];
360         memset(mutex_ob_name, 0x00, sizeof(mutex_ob_name));
361 
362         sprintf_s((char*)mutex_ob_name, sizeof(mutex_ob_name), "Global\\%s", head->ob_name);
363     }
364     else
365     {
366         (*ppresult) = _ob_new_error(ppresult, false, 1, "malloc failed.");
367     }
368 
369     return head;
370 }
371 
372 bool __stdcall delete_ob(POB_TREE_HEAD_T head)
373 {
374     if (head == NULL && head->ob_name[0] != 0)
375     {
376         free(head);
377     }
378     return false;
379 }
380 #pragma endregion

F. 节点处理

对象为PAIR存储模式，每个对象都是一个节点，这里的OB以倒树状结构存储。

扫码关注我们

微信号：SRE实战

拒绝背锅 运筹帷幄

×

选择打赏方式：

微信 QQ钱包 支付宝

打赏

打赏

打赏

多少都是心意！谢谢大家！！！