00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028 #ifndef MRPT_COBJECT_H
00029 #define MRPT_COBJECT_H
00030
00031 #include <mrpt/utils/utils_defs.h>
00032 #include <mrpt/utils/safe_pointers.h>
00033
00034 namespace mrpt
00035 {
00036 namespace utils
00037 {
00038
00039
00040
00041 class BASE_IMPEXP CObject;
00042
00043
00044
00045
00046 class BASE_IMPEXP CObjectPtr : public stlplus::smart_ptr_clone<CObject>
00047 {
00048 typedef stlplus::smart_ptr_clone<CObject> BASE;
00049 public:
00050 inline CObjectPtr() : BASE() {}
00051 explicit inline CObjectPtr(const CObject& data) : BASE(data) {}
00052 explicit inline CObjectPtr(CObject* data) : BASE(data) { }
00053 inline CObjectPtr& operator=(const CObject& data) { BASE::operator=(data); return *this; }
00054 inline CObjectPtr& operator=(const CObjectPtr& r) { BASE::operator=(r); return *this; }
00055 };
00056
00057
00058
00059 struct BASE_IMPEXP TRuntimeClassId
00060 {
00061 const char* className;
00062
00063 mrpt::utils::CObject* (*ptrCreateObject)();
00064
00065 const TRuntimeClassId* (*getBaseClass)();
00066
00067
00068 mrpt::utils::CObject* createObject() const;
00069 bool derivedFrom(const TRuntimeClassId* pBaseClass) const;
00070 bool derivedFrom(const char* pBaseClass_name) const;
00071
00072 };
00073
00074
00075
00076 typedef safe_ptr<TRuntimeClassId> TRuntimeClassIdPtr;
00077
00078
00079
00080
00081
00082 void BASE_IMPEXP registerClass(const mrpt::utils::TRuntimeClassId* pNewClass);
00083
00084
00085
00086 void BASE_IMPEXP registerClassCustomName(const char*customName, const TRuntimeClassId* pNewClass);
00087
00088
00089
00090
00091 std::vector<const mrpt::utils::TRuntimeClassId*> BASE_IMPEXP getAllRegisteredClasses();
00092
00093
00094
00095
00096 const TRuntimeClassId BASE_IMPEXP * findRegisteredClass(const std::string &className);
00097
00098
00099
00100
00101 #define CLASS_ID(class_name) static_cast<const mrpt::utils::TRuntimeClassId*>(&class_name::class##class_name)
00102
00103
00104
00105 #define CLASS_ID_NAMESPACE(class_name,namespaceName) static_cast<const mrpt::utils::TRuntimeClassId*>(&namespaceName::class_name::class##class_name)
00106
00107
00108
00109 #define CLASS_ID_TEMPLATE(class_name,T) static_cast<const mrpt::utils::TRuntimeClassId*>(& template <class T> class_name<T>::class##class_name)
00110
00111
00112 #define IS_CLASS( ptrObj, class_name ) ((ptrObj)->GetRuntimeClass()==CLASS_ID(class_name))
00113
00114
00115 #define IS_DERIVED( ptrObj, class_name ) ((ptrObj)->GetRuntimeClass()->derivedFrom(CLASS_ID(class_name)))
00116
00117
00118 struct BASE_IMPEXP CLASSINIT
00119 {
00120 CLASSINIT(const mrpt::utils::TRuntimeClassId* pNewClass)
00121 {
00122 registerClass(pNewClass);
00123 }
00124 };
00125
00126
00127
00128
00129
00130
00131
00132 class BASE_IMPEXP CObject
00133 {
00134 protected:
00135 static mrpt::utils::TRuntimeClassId* _GetBaseClass();
00136 public:
00137 static const mrpt::utils::TRuntimeClassId classCObject;
00138
00139
00140 virtual const mrpt::utils::TRuntimeClassId* GetRuntimeClass() const
00141 {
00142 return CLASS_ID(CObject);
00143 }
00144
00145
00146 virtual CObject *duplicate() const = 0;
00147
00148
00149 inline mrpt::utils::CObjectPtr duplicateGetSmartPtr() const { return mrpt::utils::CObjectPtr( this->duplicate() ); }
00150
00151
00152 inline CObject *clone() const { return duplicate(); }
00153
00154 virtual ~CObject() { }
00155
00156 };
00157
00158
00159
00160 #define DEFINE_MRPT_OBJECT(class_name) \
00161 \
00162 \
00163 protected: \
00164 static const mrpt::utils::TRuntimeClassId* _GetBaseClass(); \
00165 static mrpt::utils::CLASSINIT _init_##class_name;\
00166 public: \
00167 \
00168 typedef class_name##Ptr SmartPtr; \
00169 static mrpt::utils::TRuntimeClassId class##class_name; \
00170 static const mrpt::utils::TRuntimeClassId *classinfo; \
00171 virtual const mrpt::utils::TRuntimeClassId* GetRuntimeClass() const; \
00172 static mrpt::utils::CObject* CreateObject(); \
00173 static class_name##Ptr Create(); \
00174 virtual mrpt::utils::CObject *duplicate() const; \
00175 \
00176 public: \
00177 EIGEN_MAKE_ALIGNED_OPERATOR_NEW \
00178
00179
00180
00181 #define DEFINE_MRPT_OBJECT_PRE_CUSTOM_BASE_LINKAGE(class_name, base_name, _LINKAGE_ ) \
00182 DEFINE_MRPT_OBJECT_PRE_CUSTOM_BASE_LINKAGE2(class_name, base_name, _LINKAGE_ class_name)
00183
00184
00185 #define DEFINE_MRPT_OBJECT_PRE_CUSTOM_BASE_NO_LINKAGE(class_name, base_name) \
00186 DEFINE_MRPT_OBJECT_PRE_CUSTOM_BASE_LINKAGE2(class_name, base_name, class_name)
00187
00188
00189
00190 #define DEFINE_MRPT_OBJECT_PRE_CUSTOM_BASE_LINKAGE2(class_name, base_name, class_name_LINKAGE_ ) \
00191 class class_name_LINKAGE_; \
00192 \
00193 struct class_name_LINKAGE_##Ptr : public base_name##Ptr \
00194 { \
00195 inline class_name##Ptr() : base_name##Ptr(static_cast<base_name*>(NULL)) { } \
00196 inline explicit class_name##Ptr(class_name* p) : base_name##Ptr( reinterpret_cast<base_name*>(p) ) { } \
00197 inline explicit class_name##Ptr(const base_name##Ptr & p) : base_name##Ptr(p) { ASSERTMSG_( p->GetRuntimeClass()->derivedFrom(#class_name),::mrpt::format("Wrong typecasting of smart pointers: %s -> %s",p->GetRuntimeClass()->className, #class_name) ) } \
00198 inline explicit class_name##Ptr(const mrpt::utils::CObjectPtr & p) : base_name##Ptr(p) { ASSERTMSG_( p->GetRuntimeClass()->derivedFrom(#class_name),::mrpt::format("Wrong typecasting of smart pointers: %s -> %s",p->GetRuntimeClass()->className, #class_name) ) } \
00199 inline void setFromPointerDoNotFreeAtDtor(const class_name* p) { this->set(const_cast<mrpt::utils::CObject*>(reinterpret_cast<const mrpt::utils::CObject*>(p))); m_holder->increment(); } \
00200 \
00201 inline class_name * pointer() { return reinterpret_cast<class_name*>(base_name##Ptr::pointer()); } \
00202 \
00203 inline const class_name * pointer() const { return reinterpret_cast<const class_name*>(base_name##Ptr::pointer()); } \
00204 inline class_name* operator ->(void) { return reinterpret_cast<class_name*>( base_name##Ptr::operator ->() ); } \
00205 inline const class_name* operator ->(void) const { return reinterpret_cast<const class_name*>( base_name##Ptr::operator ->() ); } \
00206 inline class_name& operator *(void) { return *reinterpret_cast<class_name*>( base_name##Ptr::operator ->() ); } \
00207 inline const class_name& operator *(void) const { return *reinterpret_cast<const class_name*>( base_name##Ptr::operator ->() ); } \
00208 };
00209
00210
00211
00212 #define DEFINE_MRPT_OBJECT_PRE_CUSTOM_LINKAGE(class_name,_LINKAGE_) \
00213 DEFINE_MRPT_OBJECT_PRE_CUSTOM_LINKAGE2(class_name, _LINKAGE_ class_name)
00214
00215
00216 #define DEFINE_MRPT_OBJECT_PRE_NO_LINKAGE(class_name) \
00217 DEFINE_MRPT_OBJECT_PRE_CUSTOM_LINKAGE2(class_name, class_name)
00218
00219
00220
00221 #define DEFINE_MRPT_OBJECT_PRE_CUSTOM_LINKAGE2(class_name,class_name_LINKAGE_) \
00222 class class_name_LINKAGE_; \
00223 \
00224 struct class_name_LINKAGE_##Ptr : public mrpt::utils::CObjectPtr \
00225 { \
00226 inline class_name##Ptr() : mrpt::utils::CObjectPtr(static_cast<mrpt::utils::CObject*>(NULL)) { } \
00227 inline explicit class_name##Ptr(class_name* p) : mrpt::utils::CObjectPtr( reinterpret_cast<mrpt::utils::CObject*>(p) ) { } \
00228 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) ) } \
00229 inline void setFromPointerDoNotFreeAtDtor(const class_name* p) { this->set(const_cast<mrpt::utils::CObject*>(reinterpret_cast<const mrpt::utils::CObject*>(p))); m_holder->increment(); } \
00230 \
00231 inline class_name * pointer() { return reinterpret_cast<class_name*>(mrpt::utils::CObjectPtr::pointer()); } \
00232 \
00233 inline const class_name * pointer() const { return reinterpret_cast<const class_name*>(mrpt::utils::CObjectPtr::pointer()); } \
00234 inline class_name* operator ->(void) { return reinterpret_cast<class_name*>( mrpt::utils::CObjectPtr::operator ->() ); } \
00235 inline const class_name* operator ->(void) const { return reinterpret_cast<const class_name*>( mrpt::utils::CObjectPtr::operator ->() ); } \
00236 inline class_name& operator *(void) { return *reinterpret_cast<class_name*>( mrpt::utils::CObjectPtr::operator ->() ); } \
00237 inline const class_name& operator *(void) const { return *reinterpret_cast<const class_name*>( mrpt::utils::CObjectPtr::operator ->() ); } \
00238 };
00239
00240
00241
00242 #define DEFINE_MRPT_OBJECT_PRE_CUSTOM_BASE(class_name, base_name) \
00243 DEFINE_MRPT_OBJECT_PRE_CUSTOM_BASE_LINKAGE(class_name, base_name, BASE_IMPEXP )
00244
00245
00246
00247 #define DEFINE_MRPT_OBJECT_PRE(class_name) \
00248 DEFINE_MRPT_OBJECT_PRE_CUSTOM_LINKAGE(class_name, BASE_IMPEXP ) // This macro is valid for classes within mrpt-core only.
00249
00250
00251
00252 #define IMPLEMENTS_MRPT_OBJECT(class_name, base,NameSpace) \
00253 mrpt::utils::CObject* NameSpace::class_name::CreateObject() \
00254 { return static_cast<mrpt::utils::CObject*>( new NameSpace::class_name ); } \
00255 NameSpace::class_name##Ptr NameSpace::class_name::Create() \
00256 { return NameSpace::class_name##Ptr( new NameSpace::class_name ); } \
00257 const mrpt::utils::TRuntimeClassId* NameSpace::class_name::_GetBaseClass() \
00258 { return CLASS_ID(base); } \
00259 mrpt::utils::TRuntimeClassId NameSpace::class_name::class##class_name = { \
00260 #class_name, NameSpace::class_name::CreateObject, &class_name::_GetBaseClass }; \
00261 const mrpt::utils::TRuntimeClassId *NameSpace::class_name::classinfo = & NameSpace::class_name::class##class_name; \
00262 const mrpt::utils::TRuntimeClassId* NameSpace::class_name::GetRuntimeClass() const \
00263 { return CLASS_ID_NAMESPACE(class_name,NameSpace); } \
00264 mrpt::utils::CLASSINIT NameSpace::class_name::_init_##class_name(CLASS_ID(base)); \
00265 mrpt::utils::CObject * NameSpace::class_name::duplicate() const \
00266 { return static_cast<mrpt::utils::CObject*>( new NameSpace::class_name(*this) ); }
00267
00268
00269
00270
00271 #define DEFINE_VIRTUAL_MRPT_OBJECT(class_name) \
00272 \
00273 \
00274 protected: \
00275 static const mrpt::utils::TRuntimeClassId* _GetBaseClass(); \
00276 public: \
00277 static const mrpt::utils::TRuntimeClassId class##class_name; \
00278 virtual const mrpt::utils::TRuntimeClassId* GetRuntimeClass() const; \
00279 friend class mrpt::utils::CStream; \
00280 \
00281
00282
00283
00284
00285 #define IMPLEMENTS_VIRTUAL_MRPT_OBJECT(class_name, base_class_name,NameSpace) \
00286 const mrpt::utils::TRuntimeClassId* class_name::_GetBaseClass() \
00287 { return CLASS_ID(base_class_name); } \
00288 const mrpt::utils::TRuntimeClassId class_name::class##class_name = { \
00289 #class_name, NULL, &class_name::_GetBaseClass }; \
00290 const mrpt::utils::TRuntimeClassId* class_name::GetRuntimeClass() const \
00291 { return CLASS_ID(class_name); }
00292
00293
00294
00295 }
00296 }
00297
00298
00299 namespace std
00300 {
00301
00302
00303 template <typename T,typename C, typename COUNTER>
00304 inline bool operator == ( const stlplus::smart_ptr_base<T,C,COUNTER>&a,const stlplus::smart_ptr_base<T,C,COUNTER>&b) {
00305 return a.aliases(b);
00306 }
00307
00308
00309 template <typename T,typename C, typename COUNTER>
00310 inline bool operator != ( const stlplus::smart_ptr_base<T,C,COUNTER>&a,const stlplus::smart_ptr_base<T,C,COUNTER>&b) {
00311 return !a.aliases(b);
00312 }
00313 }
00314
00315 #endif