Main MRPT website > C++ reference for MRPT 1.5.3
CObject.h
Go to the documentation of this file.
1 /* +---------------------------------------------------------------------------+
2  | Mobile Robot Programming Toolkit (MRPT) |
3  | http://www.mrpt.org/ |
4  | |
5  | Copyright (c) 2005-2017, Individual contributors, see AUTHORS file |
6  | See: http://www.mrpt.org/Authors - All rights reserved. |
7  | Released under BSD License. See details in http://www.mrpt.org/License |
8  +---------------------------------------------------------------------------+ */
9 #ifndef MRPT_COBJECT_H
10 #define MRPT_COBJECT_H
11 
12 #include <mrpt/system/memory.h>
14 #include <vector>
15 
16 // STL+ library:
18 
19 namespace mrpt
20 {
21  namespace utils
22  {
23  /** @name RTTI classes and functions
24  @{ */
25 
27 
28  /** A smart pointer to a CObject object
29  * \note Declared as a class instead of a typedef to avoid multiple defined symbols when linking dynamic libs.
30  * \ingroup mrpt_base_grp
31  */
33  {
35  public:
36  inline CObjectPtr() : BASE() {}
37  explicit inline CObjectPtr(const CObject& data) : BASE(data) {}
38  explicit inline CObjectPtr(CObject* data) : BASE(data) { }
39  inline CObjectPtr& operator=(const CObject& data) { BASE::operator=(data); return *this; }
40  inline CObjectPtr& operator=(const CObjectPtr& r) { BASE::operator=(r); return *this; }
41  };
42 
43  /** A structure that holds runtime class type information. Use CLASS_ID(<class_name>) to get a reference to the class_name's TRuntimeClassId descriptor.
44  * \ingroup mrpt_base_grp
45  */
47  {
48  const char* className;
49  /** Create an object of the related class, or NULL if it is virtual. */
50  mrpt::utils::CObject* (*ptrCreateObject)();
51  /** Gets the base class runtime id. */
52  const TRuntimeClassId* (*getBaseClass)();
53 
54  // Operations
55  mrpt::utils::CObject* createObject() const;
56  bool derivedFrom(const TRuntimeClassId* pBaseClass) const;
57  bool derivedFrom(const char* pBaseClass_name) const;
58 
59  };
60 
61  /** A wrapper class for a "TRuntimeClassId *", well-defined with respect to copy operators and constructors. \ingroup mrpt_base_grp
62  */
64 
65  /** Register a class into the MRPT internal list of "CSerializable" descendents.
66  * Used internally in the macros DEFINE_SERIALIZABLE, etc...
67  * \sa getAllRegisteredClasses
68  */
70 
71  /** Mostly for internal use within mrpt sources, to handle exceptional cases with multiple serialization names for backward compatibility (CMultiMetricMaps, CImage,...)
72  */
73  void BASE_IMPEXP registerClassCustomName(const char*customName, const TRuntimeClassId* pNewClass);
74 
75  /** Returns a list with all the classes registered in the system through mrpt::utils::registerClass.
76  * \sa registerClass, findRegisteredClass
77  */
78  std::vector<const mrpt::utils::TRuntimeClassId*> BASE_IMPEXP getAllRegisteredClasses();
79 
80  /** Like getAllRegisteredClasses(), but filters the list to only include children clases of a given base one.
81  * \sa getAllRegisteredClasses(), getAllRegisteredClassesChildrenOf() */
82  std::vector<const TRuntimeClassId*> BASE_IMPEXP getAllRegisteredClassesChildrenOf(const TRuntimeClassId* parent_id);
83 
84  /** Return info about a given class by its name, or NULL if the class is not registered
85  * \sa registerClass, getAllRegisteredClasses
86  */
87  const TRuntimeClassId BASE_IMPEXP * findRegisteredClass(const std::string &className);
88 
89 
90  /** Access to runtime class ID for a defined class name.
91  */
92  #define CLASS_ID(class_name) static_cast<const mrpt::utils::TRuntimeClassId*>(&class_name::class##class_name)
93 
94  /** Access to runtime class ID for a defined class name.
95  */
96  #define CLASS_ID_NAMESPACE(class_name,namespaceName) static_cast<const mrpt::utils::TRuntimeClassId*>(&namespaceName::class_name::class##class_name)
97 
98  /** Access to runtime class ID for a defined template class name.
99  */
100  #define CLASS_ID_TEMPLATE(class_name,T) static_cast<const mrpt::utils::TRuntimeClassId*>(& template <class T> class_name<T>::class##class_name)
101 
102  /** Evaluates to true if the given pointer to an object (derived from mrpt::utils::CSerializable) is of the given class. */
103  #define IS_CLASS( ptrObj, class_name ) ((ptrObj)->GetRuntimeClass()==CLASS_ID(class_name))
104 
105  /** Evaluates to true if the given pointer to an object (derived from mrpt::utils::CSerializable) is an instance of the given class or any of its derived classes. */
106  #define IS_DERIVED( ptrObj, class_name ) ((ptrObj)->GetRuntimeClass()->derivedFrom(CLASS_ID(class_name)))
107 
108  /** Auxiliary structure used for CObject-based RTTI. \ingroup mrpt_base_grp */
110  {
112  {
113  registerClass(pNewClass);
114  }
115  };
116 
117 
118  /** The virtual base class of all MRPT classes with a unified RTTI system.
119  * For each class named <code>CMyClass</code>, a new type named <code>CMyClassPtr</code> will be created as a smart pointer suitable for
120  * keeping referencing count smart pointers to objects of that class. By default the base class of all these smart pointers is CObjectPtr.
121  * \sa mrpt::utils::CSerializable \ingroup mrpt_base_grp
122  */
124  {
125  protected:
126  static mrpt::utils::TRuntimeClassId* _GetBaseClass();
127  public:
129 
130  /** Returns information about the class of an object in runtime. */
132  {
133  return CLASS_ID(CObject);
134  }
135 
136  /** Returns a copy of the object, indepently of its class. */
137  virtual CObject *duplicate() const = 0;
138 
139  /** Returns a copy of the object, indepently of its class, as a smart pointer (the newly created object will exist as long as any copy of this smart pointer). */
140  inline mrpt::utils::CObjectPtr duplicateGetSmartPtr() const { return mrpt::utils::CObjectPtr( this->duplicate() ); }
141 
142  /** Cloning interface for smart pointers */
143  inline CObject *clone() const { return duplicate(); }
144 
145  virtual ~CObject() { }
146 
147  }; // End of class def.
148 
149 
150  /** Just like DEFINE_MRPT_OBJECT but with DLL export/import linkage keywords. Note: The replication of macro arguments is to avoid errors with empty macro arguments */
151  #define DEFINE_MRPT_OBJECT_CUSTOM_LINKAGE(class_name, _STATIC_LINKAGE_, _VIRTUAL_LINKAGE_) \
152  /*! @name RTTI stuff */ \
153  /*! @{ */ \
154  protected: \
155  _STATIC_LINKAGE_ const mrpt::utils::TRuntimeClassId* _GetBaseClass(); \
156  _STATIC_LINKAGE_ mrpt::utils::CLASSINIT _init_##class_name;\
157  public: \
158  /*! A typedef for the associated smart pointer */ \
159  typedef class_name##Ptr SmartPtr; \
160  _STATIC_LINKAGE_ mrpt::utils::TRuntimeClassId class##class_name; \
161  _STATIC_LINKAGE_ const mrpt::utils::TRuntimeClassId *classinfo; \
162  _VIRTUAL_LINKAGE_ const mrpt::utils::TRuntimeClassId* GetRuntimeClass() const MRPT_OVERRIDE; \
163  _STATIC_LINKAGE_ mrpt::utils::CObject* CreateObject(); \
164  _STATIC_LINKAGE_ class_name##Ptr Create(); \
165  _VIRTUAL_LINKAGE_ mrpt::utils::CObject *duplicate() const MRPT_OVERRIDE; \
166  /*! @} */ \
167  public: \
168  MRPT_MAKE_ALIGNED_OPERATOR_NEW \
169 
170  /** This declaration must be inserted in all CObject classes definition, within the class declaration. */
171  #define DEFINE_MRPT_OBJECT(class_name) \
172  DEFINE_MRPT_OBJECT_CUSTOM_LINKAGE(class_name, static /*none*/, virtual /*none*/)
173 
174  // This macro is a workaround to avoid possibly empty arguments to MACROS (when _LINKAGE_ evals to nothing...)
175  #define DEFINE_MRPT_OBJECT_PRE_CUSTOM_BASE_LINKAGE(class_name, base_name, _LINKAGE_ ) DEFINE_MRPT_OBJECT_PRE_CUSTOM_BASE_LINKAGE2(class_name, base_name, _LINKAGE_ class_name)
176  #define DEFINE_MRPT_OBJECT_POST_CUSTOM_BASE_LINKAGE(class_name, base_name, _LINKAGE_ ) DEFINE_MRPT_OBJECT_POST_CUSTOM_BASE_LINKAGE2(class_name, base_name, _LINKAGE_ class_name)
177 
178  // Use this one when there is NO import/export macro:
179  #define DEFINE_MRPT_OBJECT_PRE_CUSTOM_BASE_NO_LINKAGE(class_name, base_name) DEFINE_MRPT_OBJECT_PRE_CUSTOM_BASE_LINKAGE2(class_name, base_name, class_name)
180  #define DEFINE_MRPT_OBJECT_POST_CUSTOM_BASE_NO_LINKAGE(class_name, base_name) DEFINE_MRPT_OBJECT_POST_CUSTOM_BASE_LINKAGE2(class_name, base_name, class_name)
181 
182  /** This declaration must be inserted in all CObject classes definition, before the class declaration. */
183  #define DEFINE_MRPT_OBJECT_PRE_CUSTOM_BASE_LINKAGE2(class_name, base_name, class_name_LINKAGE_ ) \
184  class class_name_LINKAGE_; \
185  struct class_name_LINKAGE_##Ptr;
186 
187  /** This declaration must be inserted in all CObject classes definition, after the class declaration. */
188  #define DEFINE_MRPT_OBJECT_POST_CUSTOM_BASE_LINKAGE2(class_name, base_name, class_name_LINKAGE_ ) \
189  /*! The smart pointer type for the associated class */ \
190  struct class_name_LINKAGE_##Ptr : public base_name##Ptr \
191  { \
192  typedef class_name value_type; \
193  inline class_name##Ptr() : base_name##Ptr(static_cast<base_name*>(NULL)) { } \
194  inline explicit class_name##Ptr(class_name* p) : base_name##Ptr( static_cast<base_name*>(p) ) { } \
195  inline explicit class_name##Ptr(const base_name##Ptr & p) : base_name##Ptr(p) { if(!p.null()) ASSERTMSG_( p->GetRuntimeClass()->derivedFrom(#class_name),::mrpt::format("Wrong typecasting of smart pointers: %s -> %s",p->GetRuntimeClass()->className, #class_name) ) } \
196  inline explicit class_name##Ptr(const mrpt::utils::CObjectPtr & p) : base_name##Ptr(p) { if(!p.null())ASSERTMSG_( p->GetRuntimeClass()->derivedFrom(#class_name),::mrpt::format("Wrong typecasting of smart pointers: %s -> %s",p->GetRuntimeClass()->className, #class_name) ) } \
197  inline void setFromPointerDoNotFreeAtDtor(const class_name* p) { this->set(const_cast<mrpt::utils::CObject*>(static_cast<const mrpt::utils::CObject*>(p))); m_holder->increment(); } \
198  /*! Return the internal plain C++ pointer */ \
199  inline class_name * pointer() { return dynamic_cast<class_name*>(base_name##Ptr::pointer()); } \
200  /*! Return the internal plain C++ pointer (const) */ \
201  inline const class_name * pointer() const { return dynamic_cast<const class_name*>(base_name##Ptr::pointer()); } \
202  inline class_name* operator ->(void) { return dynamic_cast<class_name*>( base_name##Ptr::operator ->() ); } \
203  inline const class_name* operator ->(void) const { return dynamic_cast<const class_name*>( base_name##Ptr::operator ->() ); } \
204  inline class_name& operator *(void) { return *dynamic_cast<class_name*>( base_name##Ptr::operator ->() ); } \
205  inline const class_name& operator *(void) const { return *dynamic_cast<const class_name*>( base_name##Ptr::operator ->() ); } \
206  };
207 
208 
209  // This macro is a workaround to avoid possibly empty arguments to MACROS (when _LINKAGE_ evals to nothing...)
210  #define DEFINE_MRPT_OBJECT_PRE_CUSTOM_LINKAGE(class_name,_LINKAGE_) DEFINE_MRPT_OBJECT_PRE_CUSTOM_LINKAGE2(class_name, _LINKAGE_ class_name)
211  #define DEFINE_MRPT_OBJECT_POST_CUSTOM_LINKAGE(class_name,_LINKAGE_) DEFINE_MRPT_OBJECT_POST_CUSTOM_LINKAGE2(class_name, _LINKAGE_ class_name)
212 
213  // Use this macro when there is NO export/import macro:
214  #define DEFINE_MRPT_OBJECT_PRE_NO_LINKAGE(class_name) DEFINE_MRPT_OBJECT_PRE_CUSTOM_LINKAGE2(class_name, class_name)
215  #define DEFINE_MRPT_OBJECT_POST_NO_LINKAGE(class_name) DEFINE_MRPT_OBJECT_POST_CUSTOM_LINKAGE2(class_name, class_name)
216 
217  // This one is almost identical to the one above, but without a member:
218  /** This declaration must be inserted in all CObject classes definition, before the class declaration. */
219  #define DEFINE_MRPT_OBJECT_PRE_CUSTOM_LINKAGE2(class_name,class_name_LINKAGE_) \
220  struct class_name_LINKAGE_##Ptr;
221 
222  /** This declaration must be inserted in all CObject classes definition, after the class declaration. */
223  #define DEFINE_MRPT_OBJECT_POST_CUSTOM_LINKAGE2(class_name,class_name_LINKAGE_) \
224  /*! The smart pointer type for the associated class */ \
225  struct class_name_LINKAGE_##Ptr : public mrpt::utils::CObjectPtr \
226  { \
227  inline class_name##Ptr() : mrpt::utils::CObjectPtr(static_cast<mrpt::utils::CObject*>(NULL)) { } \
228  inline explicit class_name##Ptr(class_name* p) : mrpt::utils::CObjectPtr( static_cast<mrpt::utils::CObject*>(p) ) { } \
229  inline explicit class_name##Ptr(const mrpt::utils::CObjectPtr & p) : mrpt::utils::CObjectPtr(p) { ASSERTMSG_( p->GetRuntimeClass()->derivedFrom(#class_name),::mrpt::format("Wrong typecasting of smart pointers: %s -> %s",p->GetRuntimeClass()->className, #class_name) ) } \
230  inline void setFromPointerDoNotFreeAtDtor(const class_name* p) { this->set(const_cast<mrpt::utils::CObject*>(static_cast<const mrpt::utils::CObject*>(p))); m_holder->increment(); } \
231  /*! Return the internal plain C++ pointer */ \
232  inline class_name * pointer() { return dynamic_cast<class_name*>(mrpt::utils::CObjectPtr::pointer()); } \
233  /*! Return the internal plain C++ pointer (const) */ \
234  inline const class_name * pointer() const { return dynamic_cast<const class_name*>(mrpt::utils::CObjectPtr::pointer()); } \
235  inline class_name* operator ->(void) { return dynamic_cast<class_name*>( mrpt::utils::CObjectPtr::operator ->() ); } \
236  inline const class_name* operator ->(void) const { return dynamic_cast<const class_name*>( mrpt::utils::CObjectPtr::operator ->() ); } \
237  inline class_name& operator *(void) { return *dynamic_cast<class_name*>( mrpt::utils::CObjectPtr::operator ->() ); } \
238  inline const class_name& operator *(void) const { return *dynamic_cast<const class_name*>( mrpt::utils::CObjectPtr::operator ->() ); } \
239  };
240 
241  /** This declaration must be inserted in all CObject classes definition, before the class declaration.
242  */
243  #define DEFINE_MRPT_OBJECT_PRE_CUSTOM_BASE(class_name, base_name) \
244  DEFINE_MRPT_OBJECT_PRE_CUSTOM_BASE_LINKAGE(class_name, base_name, BASE_IMPEXP )
245 
246  /** This declaration must be inserted in all CObject classes definition, before the class declaration.
247  */
248  #define DEFINE_MRPT_OBJECT_PRE(class_name) DEFINE_MRPT_OBJECT_PRE_CUSTOM_LINKAGE(class_name, BASE_IMPEXP ) // This macro is valid for classes within mrpt-base only.
249  #define DEFINE_MRPT_OBJECT_POST(class_name) DEFINE_MRPT_OBJECT_POST_CUSTOM_LINKAGE(class_name, BASE_IMPEXP ) // This macro is valid for classes within mrpt-base only.
250 
251  /** This must be inserted in all CObject classes implementation files
252  */
253  #define IMPLEMENTS_MRPT_OBJECT(class_name, base,NameSpace) \
254  mrpt::utils::CObject* NameSpace::class_name::CreateObject() \
255  { return static_cast<mrpt::utils::CObject*>( new NameSpace::class_name ); } \
256  NameSpace::class_name##Ptr NameSpace::class_name::Create() \
257  { return NameSpace::class_name##Ptr( new NameSpace::class_name ); } \
258  const mrpt::utils::TRuntimeClassId* NameSpace::class_name::_GetBaseClass() \
259  { return CLASS_ID(base); } \
260  mrpt::utils::TRuntimeClassId NameSpace::class_name::class##class_name = { \
261  #class_name, NameSpace::class_name::CreateObject, &class_name::_GetBaseClass }; \
262  const mrpt::utils::TRuntimeClassId *NameSpace::class_name::classinfo = & NameSpace::class_name::class##class_name; \
263  const mrpt::utils::TRuntimeClassId* NameSpace::class_name::GetRuntimeClass() const \
264  { return CLASS_ID_NAMESPACE(class_name,NameSpace); } \
265  mrpt::utils::CLASSINIT NameSpace::class_name::_init_##class_name(CLASS_ID(base)); \
266  mrpt::utils::CObject * NameSpace::class_name::duplicate() const \
267  { return static_cast<mrpt::utils::CObject*>( new NameSpace::class_name(*this) ); }
268 
269 
270  /** This declaration must be inserted in virtual CSerializable classes definition:
271  */
272  #define DEFINE_VIRTUAL_MRPT_OBJECT(class_name) \
273  /*! @name RTTI stuff */ \
274  /*! @{ */ \
275  protected: \
276  static const mrpt::utils::TRuntimeClassId* _GetBaseClass(); \
277  public: \
278  static const mrpt::utils::TRuntimeClassId class##class_name; \
279  virtual const mrpt::utils::TRuntimeClassId* GetRuntimeClass() const MRPT_OVERRIDE; \
280  friend class mrpt::utils::CStream; \
281  /*! @} */ \
282 
283  /** This must be inserted as implementation of some required members for
284  * virtual CSerializable classes:
285  */
286  #define IMPLEMENTS_VIRTUAL_MRPT_OBJECT(class_name, base_class_name,NameSpace) \
287  const mrpt::utils::TRuntimeClassId* class_name::_GetBaseClass() \
288  { return CLASS_ID(base_class_name); } \
289  const mrpt::utils::TRuntimeClassId class_name::class##class_name = { \
290  #class_name, NULL, &class_name::_GetBaseClass }; \
291  const mrpt::utils::TRuntimeClassId* class_name::GetRuntimeClass() const \
292  { return CLASS_ID(class_name); }
293 
294  /** @} */ // end of RTTI
295 
296  /** Register all pending classes - to be called just before de-serializing an object, for example.
297  * After calling this method, pending_class_registers_modified is set to false until pending_class_registers() is invoked.
298  */
300 
301  } // End of namespace
302 } // End of namespace
303 
304 // JL: I want these operators to reside in std so STL algorithms can always find them.
305 namespace std
306 {
307  /** This operator enables comparing two smart pointers with "==" to test whether they point to the same object.
308  */
309  template <typename T,typename C, typename COUNTER>
311  return a.aliases(b);
312  }
313  /** This operator enables comparing two smart pointers with "!=" to test whether they don't point to the same object.
314  */
315  template <typename T,typename C, typename COUNTER>
317  return !a.aliases(b);
318  }
319 }
320 
321 #endif
Auxiliary structure used for CObject-based RTTI.
Definition: CObject.h:109
bool operator!=(const CArray< T, N > &x, const CArray< T, N > &y)
Definition: CArray.h:285
std::vector< const mrpt::utils::TRuntimeClassId * > BASE_IMPEXP getAllRegisteredClasses()
Returns a list with all the classes registered in the system through mrpt::utils::registerClass.
void BASE_IMPEXP registerClass(const mrpt::utils::TRuntimeClassId *pNewClass)
Register a class into the MRPT internal list of "CSerializable" descendents.
safe_ptr< TRuntimeClassId > TRuntimeClassIdPtr
A wrapper class for a "TRuntimeClassId *", well-defined with respect to copy operators and constructo...
Definition: CObject.h:63
virtual const mrpt::utils::TRuntimeClassId * GetRuntimeClass() const
Returns information about the class of an object in runtime.
Definition: CObject.h:131
STL namespace.
A smart pointer to a CObject object.
Definition: CObject.h:32
CObjectPtr(const CObject &data)
Definition: CObject.h:37
void BASE_IMPEXP registerAllPendingClasses()
Register all pending classes - to be called just before de-serializing an object, for example...
mrpt::utils::CObjectPtr duplicateGetSmartPtr() const
Returns a copy of the object, indepently of its class, as a smart pointer (the newly created object w...
Definition: CObject.h:140
static std::string data()
Definition: exprtk.hpp:37697
virtual ~CObject()
Definition: CObject.h:145
static const mrpt::utils::TRuntimeClassId classCObject
Definition: CObject.h:128
#define CLASS_ID(class_name)
Access to runtime class ID for a defined class name.
Definition: CObject.h:92
This is the global namespace for all Mobile Robot Programming Toolkit (MRPT) libraries.
void BASE_IMPEXP registerClassCustomName(const char *customName, const TRuntimeClassId *pNewClass)
Mostly for internal use within mrpt sources, to handle exceptional cases with multiple serialization ...
bool operator==(const CArray< T, N > &x, const CArray< T, N > &y)
Definition: CArray.h:277
std::vector< const TRuntimeClassId * > BASE_IMPEXP getAllRegisteredClassesChildrenOf(const TRuntimeClassId *parent_id)
Like getAllRegisteredClasses(), but filters the list to only include children clases of a given base ...
bool aliases(const smart_ptr_base< T, C, COUNTER > &) const
CLASSINIT(const mrpt::utils::TRuntimeClassId *pNewClass)
Definition: CObject.h:111
A structure that holds runtime class type information.
Definition: CObject.h:46
The virtual base class of all MRPT classes with a unified RTTI system.
Definition: CObject.h:123
CObjectPtr(CObject *data)
Definition: CObject.h:38
CObjectPtr & operator=(const CObjectPtr &r)
Definition: CObject.h:40
const TRuntimeClassId BASE_IMPEXP * findRegisteredClass(const std::string &className)
Return info about a given class by its name, or NULL if the class is not registered.
const char * className
Definition: CObject.h:48
CObject * clone() const
Cloning interface for smart pointers.
Definition: CObject.h:143
stlplus::smart_ptr_clone< CObject > BASE
Definition: CObject.h:34
CObjectPtr & operator=(const CObject &data)
Definition: CObject.h:39
A wrapper class for pointers that can be safely copied with "=" operator without problems.
Definition: safe_pointers.h:64



Page generated by Doxygen 1.8.13 for MRPT 1.5.3 at Tue Aug 22 01:03:35 UTC 2017