Main MRPT website > C++ reference for MRPT 1.5.6
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:
17 #include <mrpt/otherlibs/stlplus/smart_ptr.hpp>
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  */
32  class BASE_IMPEXP CObjectPtr : public stlplus::smart_ptr_clone<CObject>
33  {
34  typedef stlplus::smart_ptr_clone<CObject> BASE;
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  */
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 Ptr; \
160  typedef class_name##Ptr ConstPtr; \
161  _STATIC_LINKAGE_ mrpt::utils::TRuntimeClassId class##class_name; \
162  _STATIC_LINKAGE_ const mrpt::utils::TRuntimeClassId *classinfo; \
163  _VIRTUAL_LINKAGE_ const mrpt::utils::TRuntimeClassId* GetRuntimeClass() const MRPT_OVERRIDE; \
164  _STATIC_LINKAGE_ mrpt::utils::CObject* CreateObject(); \
165  _STATIC_LINKAGE_ class_name##Ptr Create(); \
166  _VIRTUAL_LINKAGE_ mrpt::utils::CObject *duplicate() const MRPT_OVERRIDE; \
167  /*! @} */ \
168  public: \
169  MRPT_MAKE_ALIGNED_OPERATOR_NEW \
170 
171  /** This declaration must be inserted in all CObject classes definition, within the class declaration. */
172  #define DEFINE_MRPT_OBJECT(class_name) \
173  DEFINE_MRPT_OBJECT_CUSTOM_LINKAGE(class_name, static /*none*/, virtual /*none*/)
174 
175  // This macro is a workaround to avoid possibly empty arguments to MACROS (when _LINKAGE_ evals to nothing...)
176  #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)
177  #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)
178 
179  // Use this one when there is NO import/export macro:
180  #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)
181  #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)
182 
183  /** This declaration must be inserted in all CObject classes definition, before the class declaration. */
184  #define DEFINE_MRPT_OBJECT_PRE_CUSTOM_BASE_LINKAGE2(class_name, base_name, class_name_LINKAGE_ ) \
185  class class_name_LINKAGE_; \
186  struct class_name_LINKAGE_##Ptr;
187 
188  /** This declaration must be inserted in all CObject classes definition, after the class declaration. */
189  #define DEFINE_MRPT_OBJECT_POST_CUSTOM_BASE_LINKAGE2(class_name, base_name, class_name_LINKAGE_ ) \
190  /*! The smart pointer type for the associated class */ \
191  struct class_name_LINKAGE_##Ptr : public base_name##Ptr \
192  { \
193  typedef class_name value_type; \
194  inline class_name##Ptr() : base_name##Ptr(static_cast<base_name*>(NULL)) { } \
195  inline explicit class_name##Ptr(class_name* p) : base_name##Ptr( static_cast<base_name*>(p) ) { } \
196  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) ) } \
197  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) ) } \
198  inline void setFromPointerDoNotFreeAtDtor(const class_name* p) { this->set(const_cast<mrpt::utils::CObject*>(static_cast<const mrpt::utils::CObject*>(p))); m_holder->increment(); } \
199  /*! Return the internal plain C++ pointer */ \
200  inline class_name * pointer() { return dynamic_cast<class_name*>(base_name##Ptr::pointer()); } \
201  inline class_name * get() { return this->pointer(); } \
202  /*! Return the internal plain C++ pointer (const) */ \
203  inline const class_name * pointer() const { return dynamic_cast<const class_name*>(base_name##Ptr::pointer()); } \
204  inline const class_name * get() const { return this->pointer(); } \
205  inline class_name* operator ->(void) { return dynamic_cast<class_name*>( base_name##Ptr::operator ->() ); } \
206  inline const class_name* operator ->(void) const { return dynamic_cast<const class_name*>( base_name##Ptr::operator ->() ); } \
207  inline class_name& operator *(void) { return *dynamic_cast<class_name*>( base_name##Ptr::operator ->() ); } \
208  inline const class_name& operator *(void) const { return *dynamic_cast<const class_name*>( base_name##Ptr::operator ->() ); } \
209  };
210 
211 
212  // This macro is a workaround to avoid possibly empty arguments to MACROS (when _LINKAGE_ evals to nothing...)
213  #define DEFINE_MRPT_OBJECT_PRE_CUSTOM_LINKAGE(class_name,_LINKAGE_) DEFINE_MRPT_OBJECT_PRE_CUSTOM_LINKAGE2(class_name, _LINKAGE_ class_name)
214  #define DEFINE_MRPT_OBJECT_POST_CUSTOM_LINKAGE(class_name,_LINKAGE_) DEFINE_MRPT_OBJECT_POST_CUSTOM_LINKAGE2(class_name, _LINKAGE_ class_name)
215 
216  // Use this macro when there is NO export/import macro:
217  #define DEFINE_MRPT_OBJECT_PRE_NO_LINKAGE(class_name) DEFINE_MRPT_OBJECT_PRE_CUSTOM_LINKAGE2(class_name, class_name)
218  #define DEFINE_MRPT_OBJECT_POST_NO_LINKAGE(class_name) DEFINE_MRPT_OBJECT_POST_CUSTOM_LINKAGE2(class_name, class_name)
219 
220  // This one is almost identical to the one above, but without a member:
221  /** This declaration must be inserted in all CObject classes definition, before the class declaration. */
222  #define DEFINE_MRPT_OBJECT_PRE_CUSTOM_LINKAGE2(class_name,class_name_LINKAGE_) \
223  struct class_name_LINKAGE_##Ptr;
224 
225  /** This declaration must be inserted in all CObject classes definition, after the class declaration. */
226  #define DEFINE_MRPT_OBJECT_POST_CUSTOM_LINKAGE2(class_name,class_name_LINKAGE_) \
227  /*! The smart pointer type for the associated class */ \
228  struct class_name_LINKAGE_##Ptr : public mrpt::utils::CObjectPtr \
229  { \
230  inline class_name##Ptr() : mrpt::utils::CObjectPtr(static_cast<mrpt::utils::CObject*>(NULL)) { } \
231  inline explicit class_name##Ptr(class_name* p) : mrpt::utils::CObjectPtr( static_cast<mrpt::utils::CObject*>(p) ) { } \
232  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) ) } \
233  inline void setFromPointerDoNotFreeAtDtor(const class_name* p) { this->set(const_cast<mrpt::utils::CObject*>(static_cast<const mrpt::utils::CObject*>(p))); m_holder->increment(); } \
234  /*! Return the internal plain C++ pointer */ \
235  inline class_name * pointer() { return dynamic_cast<class_name*>(mrpt::utils::CObjectPtr::pointer()); } \
236  /*! Return the internal plain C++ pointer (const) */ \
237  inline const class_name * pointer() const { return dynamic_cast<const class_name*>(mrpt::utils::CObjectPtr::pointer()); } \
238  inline class_name* operator ->(void) { return dynamic_cast<class_name*>( mrpt::utils::CObjectPtr::operator ->() ); } \
239  inline const class_name* operator ->(void) const { return dynamic_cast<const class_name*>( mrpt::utils::CObjectPtr::operator ->() ); } \
240  inline class_name& operator *(void) { return *dynamic_cast<class_name*>( mrpt::utils::CObjectPtr::operator ->() ); } \
241  inline const class_name& operator *(void) const { return *dynamic_cast<const class_name*>( mrpt::utils::CObjectPtr::operator ->() ); } \
242  };
243 
244  /** This declaration must be inserted in all CObject classes definition, before the class declaration.
245  */
246  #define DEFINE_MRPT_OBJECT_PRE_CUSTOM_BASE(class_name, base_name) \
247  DEFINE_MRPT_OBJECT_PRE_CUSTOM_BASE_LINKAGE(class_name, base_name, BASE_IMPEXP )
248 
249  /** This declaration must be inserted in all CObject classes definition, before the class declaration.
250  */
251  #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.
252  #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.
253 
254  /** This must be inserted in all CObject classes implementation files
255  */
256  #define IMPLEMENTS_MRPT_OBJECT(class_name, base,NameSpace) \
257  mrpt::utils::CObject* NameSpace::class_name::CreateObject() \
258  { return static_cast<mrpt::utils::CObject*>( new NameSpace::class_name ); } \
259  NameSpace::class_name##Ptr NameSpace::class_name::Create() \
260  { return NameSpace::class_name##Ptr( new NameSpace::class_name ); } \
261  const mrpt::utils::TRuntimeClassId* NameSpace::class_name::_GetBaseClass() \
262  { return CLASS_ID(base); } \
263  mrpt::utils::TRuntimeClassId NameSpace::class_name::class##class_name = { \
264  #class_name, NameSpace::class_name::CreateObject, &class_name::_GetBaseClass }; \
265  const mrpt::utils::TRuntimeClassId *NameSpace::class_name::classinfo = & NameSpace::class_name::class##class_name; \
266  const mrpt::utils::TRuntimeClassId* NameSpace::class_name::GetRuntimeClass() const \
267  { return CLASS_ID_NAMESPACE(class_name,NameSpace); } \
268  mrpt::utils::CLASSINIT NameSpace::class_name::_init_##class_name(CLASS_ID(base)); \
269  mrpt::utils::CObject * NameSpace::class_name::duplicate() const \
270  { return static_cast<mrpt::utils::CObject*>( new NameSpace::class_name(*this) ); }
271 
272 
273  /** This declaration must be inserted in virtual CSerializable classes definition:
274  */
275  #define DEFINE_VIRTUAL_MRPT_OBJECT(class_name) \
276  /*! @name RTTI stuff */ \
277  /*! @{ */ \
278  protected: \
279  static const mrpt::utils::TRuntimeClassId* _GetBaseClass(); \
280  public: \
281  static const mrpt::utils::TRuntimeClassId class##class_name; \
282  virtual const mrpt::utils::TRuntimeClassId* GetRuntimeClass() const MRPT_OVERRIDE; \
283  friend class mrpt::utils::CStream; \
284  typedef class_name##Ptr Ptr; \
285  typedef class_name##Ptr ConstPtr; \
286  /*! @} */ \
287 
288  /** This must be inserted as implementation of some required members for
289  * virtual CSerializable classes:
290  */
291  #define IMPLEMENTS_VIRTUAL_MRPT_OBJECT(class_name, base_class_name,NameSpace) \
292  const mrpt::utils::TRuntimeClassId* class_name::_GetBaseClass() \
293  { return CLASS_ID(base_class_name); } \
294  const mrpt::utils::TRuntimeClassId class_name::class##class_name = { \
295  #class_name, NULL, &class_name::_GetBaseClass }; \
296  const mrpt::utils::TRuntimeClassId* class_name::GetRuntimeClass() const \
297  { return CLASS_ID(class_name); }
298 
299  /** @} */ // end of RTTI
300 
301  /** Register all pending classes - to be called just before de-serializing an object, for example.
302  * After calling this method, pending_class_registers_modified is set to false until pending_class_registers() is invoked.
303  */
305 
306  } // End of namespace
307 
308 /** Converts a smart pointer Base::Ptr to Derived::Ptr, in a way compatible
309 * with MRPT >=1.5.4 and MRPT 2.x series.
310 * \ingroup mrpt_base_grp
311 */
312 template <typename CAST_TO>
313 struct ptr_cast
314 {
315  template <typename CAST_FROM_PTR>
316  static typename CAST_TO::Ptr from(const CAST_FROM_PTR &ptr)
317  {
318  return typename CAST_TO::Ptr(ptr);
319  }
320 };
321 
322 } // End of namespace
323 
324 // JL: I want these operators to reside in std so STL algorithms can always find them.
325 namespace std
326 {
327  /** This operator enables comparing two smart pointers with "==" to test whether they point to the same object.
328  */
329  template <typename T,typename C, typename COUNTER>
330  inline bool operator == ( const stlplus::smart_ptr_base<T,C,COUNTER>&a,const stlplus::smart_ptr_base<T,C,COUNTER>&b) {
331  return a.aliases(b);
332  }
333  /** This operator enables comparing two smart pointers with "!=" to test whether they don't point to the same object.
334  */
335  template <typename T,typename C, typename COUNTER>
336  inline bool operator != ( const stlplus::smart_ptr_base<T,C,COUNTER>&a,const stlplus::smart_ptr_base<T,C,COUNTER>&b) {
337  return !a.aliases(b);
338  }
339 }
340 
341 #endif
GLboolean GLboolean GLboolean GLboolean a
Definition: glew.h:5406
Auxiliary structure used for CObject-based RTTI.
Definition: CObject.h:109
virtual const mrpt::utils::TRuntimeClassId * GetRuntimeClass() const
Returns information about the class of an object in runtime.
Definition: CObject.h:131
void BASE_IMPEXP registerAllPendingClasses()
Register all pending classes - to be called just before de-serializing an object, for example...
safe_ptr< TRuntimeClassId > TRuntimeClassIdPtr
A wrapper class for a "TRuntimeClassId *", well-defined with respect to copy operators and constructo...
Definition: CObject.h:63
std::vector< const mrpt::utils::TRuntimeClassId * > BASE_IMPEXP getAllRegisteredClasses()
Returns a list with all the classes registered in the system through mrpt::utils::registerClass.
Converts a smart pointer Base::Ptr to Derived::Ptr, in a way compatible with MRPT >=1...
Definition: CObject.h:313
void BASE_IMPEXP registerClassCustomName(const char *customName, const TRuntimeClassId *pNewClass)
Mostly for internal use within mrpt sources, to handle exceptional cases with multiple serialization ...
A smart pointer to a CObject object.
Definition: CObject.h:32
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
CObjectPtr(const CObject &data)
Definition: CObject.h:37
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.
virtual ~CObject()
Definition: CObject.h:145
GLint GLenum GLsizei GLint GLsizei const GLvoid * data
Definition: glew.h:1284
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
GLsizei const GLcharARB ** string
Definition: glew.h:3293
CObject * clone() const
Cloning interface for smart pointers.
Definition: CObject.h:143
GLdouble GLdouble GLdouble r
Definition: glew.h:1311
static CAST_TO::Ptr from(const CAST_FROM_PTR &ptr)
Definition: CObject.h:316
CLASSINIT(const mrpt::utils::TRuntimeClassId *pNewClass)
Definition: CObject.h:111
void BASE_IMPEXP registerClass(const mrpt::utils::TRuntimeClassId *pNewClass)
Register a class into the MRPT internal list of "CSerializable" descendents.
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
GLdouble GLdouble GLdouble b
Definition: glew.h:5092
CObjectPtr(CObject *data)
Definition: CObject.h:38
CObjectPtr & operator=(const CObjectPtr &r)
Definition: CObject.h:40
const char * className
Definition: CObject.h:48
stlplus::smart_ptr_clone< CObject > BASE
Definition: CObject.h:34
CObjectPtr & operator=(const CObject &data)
Definition: CObject.h:39
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 ...
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.6 for MRPT 1.5.6 Git: 4c65e84 Tue Apr 24 08:18:17 2018 +0200 at mar abr 24 08:26:17 CEST 2018