IPSDK  4_1_0_2
IPSDK : Image Processing Software Development Kit
DataItemNodeHdrMacrosDetails.h
Go to the documentation of this file.
1 // DataItemNodeHdrMacrosDetails.h:
3 // -------------------------------
4 //
14 
15 #ifndef __IPSDKBASEDATA_DATAITEMNODEHDRMACROSDETAILS_H__
16 #define __IPSDKBASEDATA_DATAITEMNODEHDRMACROSDETAILS_H__
17 
18 #include <IPSDKBaseData/DataItem/Node/BaseDataItemNode.h>
19 #include <IPSDKBaseData/DataItem/NodeColl/DataItemNodeColl.h>
20 #include <IPSDKBaseData/DataItem/Leaf/DataItemLeaf.h>
21 #include <IPSDKBaseData/DataItem/Leaf/DataItemEnumLeaf.h>
22 #include <IPSDKBaseData/DataItem/LeafColl/DataItemLeafColl.h>
23 #include <IPSDKBaseData/DataItem/Map/DataItemMap.h>
24 #include <IPSDKUtil/Tools/ObjectBaseInfoHdrMacros.h>
25 #include <boost/preprocessor/seq.hpp>
26 #include <boost/utility/enable_if.hpp>
27 #include <boost/type_traits/is_same.hpp>
28 #include <boost/mpl/less.hpp>
29 #include <boost/mpl/greater_equal.hpp>
30 #include <boost/smart_ptr/make_shared_object.hpp>
31 
34 
35 namespace ipsdk {
36  template <typename T>
37  class SerializationOItem;
38  template <typename T>
39  SerializationOItem<T>
40  make_oitem(const std::string& itemName, const T& value);
41  template <typename T>
42  class SerializationIItem;
43  template <typename T>
44  SerializationIItem<T>
45  make_iitem(const std::string& itemName, T& value);
46  class LogMessageFormater;
47 }
48 namespace boost
49 {
50  template <typename Mutex>
51  class lock_guard;
52 }
53 
56 
59 #define IPSDK_NODE_DATA_ACCESS_MACRO(r, infoSeq, idx, childElem) \
60 public: \
61  struct BOOST_PP_SEQ_ELEM(1, childElem) { \
62  BOOST_PP_CAT(IPSDK_NODE_DATA_INFO_, \
63  BOOST_PP_SEQ_ELEM(0, childElem))( \
64  BOOST_PP_SEQ_ELEM(1, infoSeq), \
65  BOOST_PP_SEQ_ELEM(0, infoSeq), \
66  childElem); \
67  static const ipsdk::eDataItemType::domain g_itemType = \
68  NodeType::g_itemType; \
69  }; \
70 public: \
71  template <typename DelayImpl> \
72  struct ChildNodeToIdx<BOOST_PP_SEQ_ELEM(1, childElem), DelayImpl> { \
73  static const ipsdk::ipUInt32 g_childNodeIdx = idx; \
74  }; \
75  template <typename DelayImpl> \
76  struct IdxToChildNode<idx, DelayImpl> { \
77  typedef BOOST_PP_SEQ_ELEM(1, childElem) ChildNodeType; \
78  }; \
79  template <typename DelayImpl> \
80  struct ChildNodeInfo<BOOST_PP_SEQ_ELEM(1, childElem), DelayImpl> \
81  { \
82  typedef BOOST_PP_SEQ_ELEM(0, infoSeq) DataItemType; \
83  BOOST_PP_CAT(IPSDK_NODE_DATA_INFO_, \
84  BOOST_PP_SEQ_ELEM(0, childElem))( \
85  BOOST_PP_SEQ_ELEM(1, infoSeq), \
86  BOOST_PP_SEQ_ELEM(0, infoSeq), \
87  childElem); \
88  }; \
89  template <typename ChildNode> \
90  inline typename boost::enable_if_c< \
91  boost::is_same<ChildNode, BOOST_PP_SEQ_ELEM(1, childElem)>::value, \
92  const typename ChildNodeInfo<ChildNode>::NodeType&>::type \
93  getNode() const { \
94  return BOOST_PP_CAT(_node, BOOST_PP_SEQ_ELEM(1, childElem))._node; \
95  } \
96  template <typename ChildNode> \
97  inline typename boost::enable_if_c< \
98  boost::is_same<ChildNode, BOOST_PP_SEQ_ELEM(1, childElem)>::value, \
99  typename ChildNodeInfo<ChildNode>::NodeType&>::type \
100  getNode() { \
101  return BOOST_PP_CAT(_node, BOOST_PP_SEQ_ELEM(1, childElem))._node; \
102  } \
103  BOOST_PP_CAT(IPSDK_NODE_DATA_ACCESS_, BOOST_PP_SEQ_ELEM(0, childElem))( \
104  childElem, BOOST_PP_SEQ_ELEM(0, infoSeq)); \
105  BOOST_PP_CAT(IPSDK_NODE_DATA_GET_DEFAULT_, \
106  BOOST_PP_IF(BOOST_PP_EQUAL(BOOST_PP_SEQ_SIZE(childElem), 4), \
107  BOOST_PP_SEQ_ELEM(0, childElem), \
108  NONE)) \
109  (BOOST_PP_SEQ_ELEM(1, childElem), \
110  BOOST_PP_SEQ_ELEM(BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(childElem)), \
111  childElem));
112 
115 #define IPSDK_NODE_DATA_GET_DEFAULT_NONE(childName, defaultValue)
116 
119 #define IPSDK_NODE_DATA_FIND_NODE_MACRO(r, infoSeq, childElem) \
120  if (BOOST_PP_SEQ_ELEM(0, infoSeq) == \
121  BOOST_PP_STRINGIZE(BOOST_PP_SEQ_ELEM(1, childElem))) { \
122  const ItemInfoStr& itemInfoStr = \
123  ChildNodeInfo<BOOST_PP_SEQ_ELEM(1, childElem)>:: \
124  getItemInfoStr<BOOST_PP_SEQ_ELEM(1, infoSeq)>(); \
125  ItemInfoPtr pItemInfo(boost::make_shared<ItemInfo>( \
126  BOOST_PP_CAT(_node, BOOST_PP_SEQ_ELEM(1, childElem))._node, \
127  itemInfoStr._itemName, itemInfoStr._itemToolTip)); \
128  return pItemInfo; \
129  }
130 
133 #define IPSDK_NODE_DATA_DECLARE_NODE_MACRO(r, itemName, childElem) \
134  NodeAccessor<ChildNodeInfo<BOOST_PP_SEQ_ELEM(1, childElem)>::NodeType> \
135  BOOST_PP_CAT(_node, BOOST_PP_SEQ_ELEM(1, childElem));
136 
139 #define IPSDK_NODE_DATA_ENUM_NAMES_MACRO(r, _, childElem) \
140  g_itemNames.insert(BOOST_PP_STRINGIZE(BOOST_PP_SEQ_ELEM(1, childElem)));
141 
144 #define IPSDK_NODE_DATA_INIT_MACRO(r, _, childElem) \
145  BOOST_PP_EXPR_IF(BOOST_PP_EQUAL(BOOST_PP_SEQ_SIZE(childElem), 4), \
146  BOOST_PP_CAT(IPSDK_NODE_DATA_INIT_, BOOST_PP_SEQ_ELEM(0, childElem)) \
147  (BOOST_PP_SEQ_ELEM(1, childElem), \
148  BOOST_PP_SEQ_ELEM(BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(childElem)), \
149  childElem)));
150 
153 #define IPSDK_NODE_DATA_WRITE_MACRO(r, _, childElem) \
154  BOOST_PP_CAT(IPSDK_NODE_DATA_WRITE_, BOOST_PP_SEQ_ELEM(0, childElem)) \
155  (BOOST_PP_SEQ_ELEM(1, childElem))
156 
159 #define IPSDK_NODE_DATA_READ_MACRO(r, _, childElem) \
160  BOOST_PP_CAT(IPSDK_NODE_DATA_READ_, BOOST_PP_SEQ_ELEM(0, childElem)) \
161  (BOOST_PP_SEQ_ELEM(1, childElem))
162 
165 #define IPSDK_NODE_DATA_COPY_MACRO(r, _, childElem) \
166  BOOST_PP_CAT(_node, BOOST_PP_SEQ_ELEM(1, childElem))._node = \
167  pObject->BOOST_PP_CAT(_node, BOOST_PP_SEQ_ELEM(1, childElem))._node;
168 
172 #define IPSDK_NODE_DATA_STD_INFO(libraryName, className, childName) \
173  template <typename MsgEnumType> \
174  static const ItemInfoStr& getItemInfoStr() { \
175  boost::lock_guard<boost::mutex> lock(getDataItemNodeMutex()); \
176  static boost::shared_ptr<ItemInfoStr> g_pItemInfoStr; \
177  if (g_pItemInfoStr.get() == 0) { \
178  static std::string g_nameId = BOOST_PP_STRINGIZE(childName); \
179  static std::string g_toolTipId = createMessage(MsgEnumType:: \
180  BOOST_PP_CAT(e, \
181  BOOST_PP_CAT(className, \
182  BOOST_PP_CAT(childName, ToolTipId)))); \
183  g_pItemInfoStr = boost::make_shared<ItemInfoStr>( \
184  g_nameId, g_toolTipId); \
185  } \
186  return *g_pItemInfoStr; \
187  }
188 
191 
194 #define IPSDK_NODE_DATA_TYPE_LEAF(valueType) \
195  ipsdk::DataItemLeaf<valueType>
196 
199 #define IPSDK_NODE_DATA_INFO_LEAF(libraryName, className, childElem) \
200  IPSDK_NODE_DATA_STD_INFO(libraryName, className, BOOST_PP_SEQ_ELEM(1, childElem)); \
201  typedef IPSDK_NODE_DATA_TYPE_LEAF(BOOST_PP_SEQ_ELEM(2, childElem)) NodeType; \
202  typedef IPSDK_NODE_DATA_TYPE_LEAF(BOOST_PP_SEQ_ELEM(2, childElem))::ValueType ValueType;
203 
206 #define IPSDK_NODE_DATA_ACCESS_LEAF(childElem, className) \
207  IPSDK_NODE_DATA_ACCESS_LEAF_MACRO( \
208  BOOST_PP_SEQ_ELEM(1, childElem), \
209  BOOST_PP_SEQ_ELEM(2, childElem), \
210  className)
211 
214 #define IPSDK_NODE_DATA_ACCESS_LEAF_MACRO(childName, valueType, className) \
215  template <typename ChildNode> \
216  inline typename boost::enable_if_c< \
217  boost::is_same<ChildNode, childName>::value, \
218  const typename ChildNodeInfo<ChildNode>::ValueType&>::type \
219  getValue() const { \
220  return BOOST_PP_CAT(_node, childName)._node.getValue(); \
221  } \
222  template <typename ChildNode> \
223  inline typename boost::enable_if_c< \
224  boost::is_same<ChildNode, childName>::value, \
225  typename ChildNodeInfo<ChildNode>::ValueType&>::type \
226  accessValue() { \
227  return BOOST_PP_CAT(_node, childName)._node.accessValue(); \
228  } \
229  template <typename ChildNode> \
230  inline typename boost::enable_if_c< \
231  boost::is_same<ChildNode, childName>::value, \
232  void>::type \
233  setValue(const typename ChildNodeInfo<ChildNode>::ValueType& value) { \
234  BOOST_PP_CAT(_node, childName)._node.setValue(value); \
235  }
236 
239 #define IPSDK_NODE_DATA_INIT_LEAF(childName, defaultValue) \
240  BOOST_PP_CAT(_node, childName)._node.setValue(defaultValue);
241 
244 #define IPSDK_NODE_DATA_GET_DEFAULT_LEAF(childName, defaultValue) \
245  template <typename ChildNode> \
246  inline static typename boost::enable_if_c< \
247  boost::is_same<ChildNode, childName>::value, \
248  typename ChildNodeInfo<ChildNode>::ValueType>::type \
249  getDefault() { return defaultValue;}
250 
253 #define IPSDK_NODE_DATA_READ_LEAF(childName) \
254  ar >> ipsdk::make_iitem(BOOST_PP_STRINGIZE(childName), \
255  BOOST_PP_CAT(_node, childName)._node);
256 
259 #define IPSDK_NODE_DATA_WRITE_LEAF(childName) \
260  ar << ipsdk::make_oitem(BOOST_PP_STRINGIZE(childName), \
261  BOOST_PP_CAT(_node, childName)._node);
262 
265 
268 #define IPSDK_NODE_DATA_TYPE_ENUMLEAF(valueType) \
269  ipsdk::DataItemEnumLeaf<valueType>
270 
273 #define IPSDK_NODE_DATA_INFO_ENUMLEAF(libraryName, className, childElem) \
274  IPSDK_NODE_DATA_STD_INFO(libraryName, className, BOOST_PP_SEQ_ELEM(1, childElem)); \
275  typedef IPSDK_NODE_DATA_TYPE_ENUMLEAF(BOOST_PP_SEQ_ELEM(2, childElem)) NodeType; \
276  typedef IPSDK_NODE_DATA_TYPE_ENUMLEAF(BOOST_PP_SEQ_ELEM(2, childElem))::EnumType ValueType; \
277  static void checkNbParams() { \
278  BOOST_STATIC_ASSERT_MSG(BOOST_PP_SEQ_SIZE(childElem) == 4, \
279  "Enumerates need default value"); \
280  }
281 
284 #define IPSDK_NODE_DATA_ACCESS_ENUMLEAF(childElem, className) \
285  IPSDK_NODE_DATA_ACCESS_ENUMLEAF_MACRO( \
286  BOOST_PP_SEQ_ELEM(1, childElem), \
287  BOOST_PP_SEQ_ELEM(2, childElem), \
288  className)
289 
292 #define IPSDK_NODE_DATA_ACCESS_ENUMLEAF_MACRO(childName, valueType, className) \
293  template <typename ChildNode> \
294  inline typename boost::enable_if_c< \
295  boost::is_same<ChildNode, childName>::value, \
296  const typename ChildNodeInfo<ChildNode>::ValueType>::type \
297  getValue() const { \
298  return BOOST_PP_CAT(_node, childName)._node.getValue(); \
299  } \
300  template <typename ChildNode> \
301  inline typename boost::enable_if_c< \
302  boost::is_same<ChildNode, childName>::value, \
303  void>::type \
304  setValue(const typename ChildNodeInfo<ChildNode>::ValueType& value) { \
305  BOOST_PP_CAT(_node, childName)._node.setValue(value); \
306  }
307 
310 #define IPSDK_NODE_DATA_INIT_ENUMLEAF(childName, defaultValue) \
311  BOOST_PP_CAT(_node, childName)._node.setValue(defaultValue);
312 
315 #define IPSDK_NODE_DATA_GET_DEFAULT_ENUMLEAF(childName, defaultValue) \
316  template <typename ChildNode> \
317  inline static typename boost::enable_if_c< \
318  boost::is_same<ChildNode, childName>::value, \
319  typename ChildNodeInfo<ChildNode>::ValueType>::type \
320  getDefault() { return defaultValue;}
321 
324 #define IPSDK_NODE_DATA_READ_ENUMLEAF(childName) \
325  ar >> ipsdk::make_iitem(BOOST_PP_STRINGIZE(childName), \
326  BOOST_PP_CAT(_node, childName)._node);
327 
330 #define IPSDK_NODE_DATA_WRITE_ENUMLEAF(childName) \
331  ar << ipsdk::make_oitem(BOOST_PP_STRINGIZE(childName), \
332  BOOST_PP_CAT(_node, childName)._node);
333 
336 
339 #define IPSDK_NODE_DATA_TYPE_LEAF_COLL(valueType) \
340  ipsdk::DataItemLeafColl<valueType>
341 
344 #define IPSDK_NODE_DATA_INFO_LEAF_COLL(libraryName, className, childElem) \
345  IPSDK_NODE_DATA_STD_INFO(libraryName, className, BOOST_PP_SEQ_ELEM(1, childElem)); \
346  typedef IPSDK_NODE_DATA_TYPE_LEAF_COLL(BOOST_PP_SEQ_ELEM(2, childElem)) NodeType; \
347  typedef IPSDK_NODE_DATA_TYPE_LEAF_COLL(BOOST_PP_SEQ_ELEM(2, childElem))::ValueType ValueType; \
348  typedef IPSDK_NODE_DATA_TYPE_LEAF_COLL(BOOST_PP_SEQ_ELEM(2, childElem))::CollType CollType;
349 
352 #define IPSDK_NODE_DATA_ACCESS_LEAF_COLL(childElem, className) \
353  IPSDK_NODE_DATA_ACCESS_LEAF_COLL_MACRO( \
354  BOOST_PP_SEQ_ELEM(1, childElem), \
355  BOOST_PP_SEQ_ELEM(2, childElem), \
356  className)
357 
360 #define IPSDK_NODE_DATA_ACCESS_LEAF_COLL_MACRO(childName, valueType, className) \
361  template <typename ChildNode> \
362  inline typename boost::enable_if_c< \
363  boost::is_same<ChildNode, childName>::value, \
364  const typename ChildNodeInfo<ChildNode>::CollType&>::type \
365  getLeafColl() const { \
366  return BOOST_PP_CAT(_node, childName)._node.getColl(); \
367  } \
368  template <typename ChildNode> \
369  inline typename boost::enable_if_c< \
370  boost::is_same<ChildNode, childName>::value, \
371  typename ChildNodeInfo<ChildNode>::CollType&>::type \
372  getLeafColl() { \
373  return BOOST_PP_CAT(_node, childName)._node.getColl(); \
374  } \
375  template <typename ChildNode> \
376  inline typename boost::enable_if_c< \
377  boost::is_same<ChildNode, childName>::value, \
378  bool>::type \
379  isEmpty() const { \
380  return BOOST_PP_CAT(_node, childName)._node.isEmpty(); \
381  } \
382  template <typename ChildNode> \
383  inline typename boost::enable_if_c< \
384  boost::is_same<ChildNode, childName>::value, \
385  ipsdk::ipUInt32>::type \
386  getSize() const { \
387  return BOOST_PP_CAT(_node, childName)._node.getSize(); \
388  } \
389  template <typename ChildNode> \
390  inline typename boost::enable_if_c< \
391  boost::is_same<ChildNode, childName>::value, \
392  void>::type \
393  push_back(const typename ChildNodeInfo<ChildNode>::ValueType& value) { \
394  BOOST_PP_CAT(_node, childName)._node.push_back(value); \
395  } \
396  template <typename ChildNode> \
397  inline typename boost::enable_if_c< \
398  boost::is_same<ChildNode, childName>::value, \
399  void>::type \
400  clear() { \
401  BOOST_PP_CAT(_node, childName)._node.clear(); \
402  }
403 
406 #define IPSDK_NODE_DATA_INIT_LEAF_COLL(childName, defaultValue) \
407  BOOST_PP_CAT(_node, childName)._node.getLeafColl() = defaultValue;
408 
411 #define IPSDK_NODE_DATA_GET_DEFAULT_LEAF_COLL(childName, defaultValue) \
412  template <typename ChildNode> \
413  inline static typename boost::enable_if_c< \
414  boost::is_same<ChildNode, childName>::value, \
415  typename ChildNodeInfo<ChildNode>::ValueType>::type \
416  getDefault() { return defaultValue;}
417 
420 #define IPSDK_NODE_DATA_READ_LEAF_COLL(childName) \
421  ar >> ipsdk::make_iitem(BOOST_PP_STRINGIZE(childName), \
422  BOOST_PP_CAT(_node, childName)._node);
423 
426 #define IPSDK_NODE_DATA_WRITE_LEAF_COLL(childName) \
427  ar << ipsdk::make_oitem(BOOST_PP_STRINGIZE(childName), \
428  BOOST_PP_CAT(_node, childName)._node);
429 
432 
435 #define IPSDK_NODE_DATA_TYPE_NODE(valueType) \
436  valueType
437 
440 #define IPSDK_NODE_DATA_INFO_NODE(libraryName, className, childElem) \
441  IPSDK_NODE_DATA_STD_INFO(libraryName, className, BOOST_PP_SEQ_ELEM(1, childElem)); \
442  typedef IPSDK_NODE_DATA_TYPE_NODE(BOOST_PP_SEQ_ELEM(2, childElem)) NodeType;
443 
446 #define IPSDK_NODE_DATA_ACCESS_NODE(childElem, className) \
447  IPSDK_NODE_DATA_ACCESS_NODE_MACRO( \
448  BOOST_PP_SEQ_ELEM(1, childElem), \
449  BOOST_PP_SEQ_ELEM(2, childElem), \
450  className)
451 
454 #define IPSDK_NODE_DATA_ACCESS_NODE_MACRO(childName, valueType, className)
455 
458 #define IPSDK_NODE_DATA_INIT_NODE(childName, defaultValue) \
459  BOOST_PP_CAT(_node, childName)._node = defaultValue;
460 
463 #define IPSDK_NODE_DATA_GET_DEFAULT_NODE(childName, defaultValue) \
464  template <typename ChildNode> \
465  inline static typename boost::enable_if_c< \
466  boost::is_same<ChildNode, childName>::value, \
467  typename ChildNodeInfo<ChildNode>::ValueType>::type \
468  getDefault() { return defaultValue;}
469 
472 #define IPSDK_NODE_DATA_READ_NODE(childName) \
473  ar >> ipsdk::make_iitem(BOOST_PP_STRINGIZE(childName), \
474  BOOST_PP_CAT(_node, childName)._node);
475 
478 #define IPSDK_NODE_DATA_WRITE_NODE(childName) \
479  ar << ipsdk::make_oitem(BOOST_PP_STRINGIZE(childName), \
480  BOOST_PP_CAT(_node, childName)._node);
481 
484 
487 #define IPSDK_NODE_DATA_TYPE_NODE_COLL(valueType) \
488  ipsdk::DataItemNodeColl<valueType>
489 
492 #define IPSDK_NODE_DATA_INFO_NODE_COLL(libraryName, className, childElem) \
493  IPSDK_NODE_DATA_STD_INFO(libraryName, className, BOOST_PP_SEQ_ELEM(1, childElem)); \
494  typedef IPSDK_NODE_DATA_TYPE_NODE_COLL(BOOST_PP_SEQ_ELEM(2, childElem)) NodeType; \
495  typedef IPSDK_NODE_DATA_TYPE_NODE_COLL(BOOST_PP_SEQ_ELEM(2, childElem))::NodeType CollNodeType; \
496  typedef IPSDK_NODE_DATA_TYPE_NODE_COLL(BOOST_PP_SEQ_ELEM(2, childElem))::NodePtrType CollNodePtrType; \
497  typedef IPSDK_NODE_DATA_TYPE_NODE_COLL(BOOST_PP_SEQ_ELEM(2, childElem))::CollType CollType;
498 
501 #define IPSDK_NODE_DATA_ACCESS_NODE_COLL(childElem, className) \
502  IPSDK_NODE_DATA_ACCESS_NODE_COLL_MACRO( \
503  BOOST_PP_SEQ_ELEM(1, childElem), \
504  BOOST_PP_SEQ_ELEM(2, childElem), \
505  className)
506 
509 #define IPSDK_NODE_DATA_ACCESS_NODE_COLL_MACRO(childName, valueType, className) \
510  template <typename ChildNode> \
511  inline typename boost::enable_if_c< \
512  boost::is_same<ChildNode, childName>::value, \
513  const typename ChildNodeInfo<ChildNode>::CollType&>::type \
514  getNodeColl() const { \
515  return BOOST_PP_CAT(_node, childName)._node.getColl(); \
516  } \
517  template <typename ChildNode> \
518  inline typename boost::enable_if_c< \
519  boost::is_same<ChildNode, childName>::value, \
520  typename ChildNodeInfo<ChildNode>::CollType&>::type \
521  getNodeColl() { \
522  return BOOST_PP_CAT(_node, childName)._node.getColl(); \
523  } \
524  template <typename ChildNode> \
525  inline typename boost::enable_if_c< \
526  boost::is_same<ChildNode, childName>::value, \
527  bool>::type \
528  isEmpty() const { \
529  return BOOST_PP_CAT(_node, childName)._node.isEmpty(); \
530  } \
531  template <typename ChildNode> \
532  inline typename boost::enable_if_c< \
533  boost::is_same<ChildNode, childName>::value, \
534  ipsdk::ipUInt32>::type \
535  getSize() const { \
536  return BOOST_PP_CAT(_node, childName)._node.getSize(); \
537  } \
538  template <typename ChildNode> \
539  inline typename boost::enable_if_c< \
540  boost::is_same<ChildNode, childName>::value, \
541  const typename ChildNodeInfo<ChildNode>::CollNodeType&>::type \
542  getNode(const ipsdk::ipUInt32 nodeIdx) const { \
543  return BOOST_PP_CAT(_node, childName)._node.getNode(nodeIdx); \
544  } \
545  template <typename ChildNode> \
546  inline typename boost::enable_if_c< \
547  boost::is_same<ChildNode, childName>::value, \
548  typename ChildNodeInfo<ChildNode>::CollNodeType&>::type \
549  getNode(const ipsdk::ipUInt32 nodeIdx) { \
550  return BOOST_PP_CAT(_node, childName)._node.getNode(nodeIdx); \
551  } \
552  template <typename ChildNode> \
553  inline typename boost::enable_if_c< \
554  boost::is_same<ChildNode, childName>::value, \
555  void>::type \
556  push_back(const typename ChildNodeInfo<ChildNode>::CollNodePtrType& pItemNode) { \
557  BOOST_PP_CAT(_node, childName)._node.push_back(pItemNode); \
558  } \
559  template <typename ChildNode> \
560  inline typename boost::enable_if_c< \
561  boost::is_same<ChildNode, childName>::value, \
562  void>::type \
563  clear() { \
564  BOOST_PP_CAT(_node, childName)._node.clear(); \
565  }
566 
569 #define IPSDK_NODE_DATA_INIT_NODE_COLL(childName, defaultValue) \
570  BOOST_PP_CAT(_node, childName).getNodeColl() = defaultValue;
571 
574 #define IPSDK_NODE_DATA_GET_DEFAULT_NODE_COLL(childName, defaultValue) \
575  template <typename ChildNode> \
576  inline static typename boost::enable_if_c< \
577  boost::is_same<ChildNode, childName>::value, \
578  typename ChildNodeInfo<ChildNode>::ValueType>::type \
579  getDefault() { return defaultValue;}
580 
583 #define IPSDK_NODE_DATA_READ_NODE_COLL(childName) \
584  ar >> ipsdk::make_iitem(BOOST_PP_STRINGIZE(childName), \
585  static_cast<ipsdk::BaseDataItemNodeColl&>(BOOST_PP_CAT(_node, childName)._node));
586 
589 #define IPSDK_NODE_DATA_WRITE_NODE_COLL(childName) \
590  ar << ipsdk::make_oitem(BOOST_PP_STRINGIZE(childName), \
591  static_cast<const ipsdk::BaseDataItemNodeColl&>(BOOST_PP_CAT(_node, childName)._node));
592 
595 
598 #define IPSDK_NODE_DATA_TYPE_MAP() \
599  ipsdk::DataItemMap
600 
603 #define IPSDK_NODE_DATA_INFO_MAP(libraryName, className, childElem) \
604  IPSDK_NODE_DATA_STD_INFO(libraryName, className, BOOST_PP_SEQ_ELEM(1, childElem)); \
605  typedef IPSDK_NODE_DATA_TYPE_MAP() NodeType;
606 
609 #define IPSDK_NODE_DATA_ACCESS_MAP(childElem, className) \
610  IPSDK_NODE_DATA_ACCESS_MAP_MACRO( \
611  BOOST_PP_SEQ_ELEM(1, childElem), \
612  className)
613 
616 #define IPSDK_NODE_DATA_ACCESS_MAP_MACRO(childName, className) \
617  template <typename ChildNode> \
618  inline typename boost::enable_if_c< \
619  boost::is_same<ChildNode, childName>::value, \
620  const ipsdk::DataItemMap::MapType&>::type \
621  getMap() const { \
622  return BOOST_PP_CAT(_node, childName)._node.getMap(); \
623  } \
624  template <typename ChildNode> \
625  inline typename boost::enable_if_c< \
626  boost::is_same<ChildNode, childName>::value, \
627  bool>::type \
628  isEmpty() const { \
629  return BOOST_PP_CAT(_node, childName)._node.isEmpty(); \
630  } \
631  template <typename ChildNode> \
632  inline typename boost::enable_if_c< \
633  boost::is_same<ChildNode, childName>::value, \
634  ipsdk::ipUInt32>::type \
635  getSize() const { \
636  return BOOST_PP_CAT(_node, childName)._node.getSize(); \
637  } \
638  template <typename ChildNode> \
639  inline typename boost::enable_if_c< \
640  boost::is_same<ChildNode, childName>::value, \
641  bool>::type \
642  existsItem(const std::string& itemName) const { \
643  return BOOST_PP_CAT(_node, childName)._node.existsItem(itemName); \
644  } \
645  template <typename ChildNode> \
646  inline typename boost::enable_if_c< \
647  boost::is_same<ChildNode, childName>::value, \
648  ipsdk::ItemNames>::type \
649  getItemNames() const { \
650  return BOOST_PP_CAT(_node, childName)._node.getItemNames(); \
651  } \
652  template <typename ChildNode> \
653  inline typename boost::enable_if_c< \
654  boost::is_same<ChildNode, childName>::value, \
655  const BaseDataItem&>::type \
656  getMapItem(const std::string& itemName) const { \
657  return BOOST_PP_CAT(_node, childName)._node.getItem(itemName); \
658  } \
659  template <typename ChildNode> \
660  inline typename boost::enable_if_c< \
661  boost::is_same<ChildNode, childName>::value, \
662  BaseDataItem&>::type \
663  getMapItem(const std::string& itemName) { \
664  return BOOST_PP_CAT(_node, childName)._node.getItem(itemName); \
665  } \
666  template <typename ChildNode> \
667  inline typename boost::enable_if_c< \
668  boost::is_same<ChildNode, childName>::value, \
669  void>::type \
670  insertItem(const std::string& itemName, \
671  const ipsdk::DataItemPtr& pItem) { \
672  BOOST_PP_CAT(_node, childName)._node.insertItem(itemName, pItem); \
673  } \
674  template <typename ChildNode> \
675  inline typename boost::enable_if_c< \
676  boost::is_same<ChildNode, childName>::value, \
677  void>::type \
678  removeItem(const std::string& itemName) { \
679  BOOST_PP_CAT(_node, childName)._node.removeItem(itemName); \
680  } \
681  template <typename ChildNode> \
682  inline typename boost::enable_if_c< \
683  boost::is_same<ChildNode, childName>::value, \
684  void>::type \
685  clear() { \
686  BOOST_PP_CAT(_node, childName)._node.clear(); \
687  }
688 
691 #define IPSDK_NODE_DATA_INIT_MAP(childName, defaultValue) \
692  BOOST_PP_CAT(_node, childName)._node = defaultValue;
693 
696 #define IPSDK_NODE_DATA_GET_DEFAULT_MAP(childName, defaultValue) \
697  template <typename ChildNode> \
698  inline static typename boost::enable_if_c< \
699  boost::is_same<ChildNode, childName>::value, \
700  typename ChildNodeInfo<ChildNode>::ValueType>::type \
701  getDefault() { return defaultValue;}
702 
705 #define IPSDK_NODE_DATA_READ_MAP(childName) \
706  ar >> ipsdk::make_iitem(BOOST_PP_STRINGIZE(childName), \
707  BOOST_PP_CAT(_node, childName)._node);
708 
711 #define IPSDK_NODE_DATA_WRITE_MAP(childName) \
712  ar << ipsdk::make_oitem(BOOST_PP_STRINGIZE(childName), \
713  BOOST_PP_CAT(_node, childName)._node);
714 
717 
718 #endif // __IPSDKBASEDATA_DATAITEMNODEHDRMACROSDETAILS_H__
ipsdk
Main namespace for IPSDK library.
Definition: AlgorithmFunctionEfficiency.h:22
ipsdk::make_iitem
SerializationIItem< T > make_iitem(const std::string &itemName, T &value)
template function allowing to dynamically create SerializationIItem
Definition: SerializationIItemUtils.h:28
boost
Definition: DataItemNodeHdrMacrosDetails.h:48
ipsdk::LogMessageFormater
Class alowing to easily format log message and handle id conversions.
Definition: LogMessageFormater.h:37
ObjectBaseInfoHdrMacros.h
Macro allowing to manage object base informations.
ipsdk::SerializationOItem
Item used to format outputs during serialization.
Definition: DataItemNodeHdrMacrosDetails.h:37
ipsdk::make_oitem
SerializationOItem< T > make_oitem(const std::string &itemName, const T &value)
template function allowing to dynamically create SerializationOItem
Definition: SerializationOItemUtils.h:28
boost::lock_guard
Definition: DataItemNodeHdrMacrosDetails.h:51
ipsdk::SerializationIItem
Item used to format inputs during serialization.
Definition: DataItemNodeHdrMacrosDetails.h:42
Generated on Tue Apr 15 2025 16:20:46 for IPSDK by   doxygen 1.8.14