The MRPT project: CSerializable.h Source File

Go to the documentation of this file.
00001 /* +---------------------------------------------------------------------------+
00002    |          The Mobile Robot Programming Toolkit (MRPT) C++ library          |
00003    |                                                                           |
00004    |                   http://mrpt.sourceforge.net/                            |
00005    |                                                                           |
00006    |   Copyright (C) 2005-2010  University of Malaga                           |
00007    |                                                                           |
00008    |    This software was written by the Machine Perception and Intelligent    |
00009    |      Robotics Lab, University of Malaga (Spain).                          |
00010    |    Contact: Jose-Luis Blanco  <jlblanco@ctima.uma.es>                     |
00011    |                                                                           |
00012    |  This file is part of the MRPT project.                                   |
00013    |                                                                           |
00014    |     MRPT is free software: you can redistribute it and/or modify          |
00015    |     it under the terms of the GNU General Public License as published by  |
00016    |     the Free Software Foundation, either version 3 of the License, or     |
00017    |     (at your option) any later version.                                   |
00018    |                                                                           |
00019    |   MRPT is distributed in the hope that it will be useful,                 |
00020    |     but WITHOUT ANY WARRANTY; without even the implied warranty of        |
00021    |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         |
00022    |     GNU General Public License for more details.                          |
00023    |                                                                           |
00024    |     You should have received a copy of the GNU General Public License     |
00025    |     along with MRPT.  If not, see <http://www.gnu.org/licenses/>.         |
00026    |                                                                           |
00027    +---------------------------------------------------------------------------+ */
00028 #ifndef  CSERIALIZABLE_H
00029 #define  CSERIALIZABLE_H
00030 
00031 #include <mrpt/utils/utils_defs.h>
00032 #include <mrpt/utils/CStream.h>
00033 #include <mrpt/utils/safe_pointers.h>
00034 
00035 /*---------------------------------------------------------------
00036         Class
00037   ---------------------------------------------------------------*/
00038 namespace mrpt
00039 {
00040         /** Classes for serialization, sockets, ini-file manipulation, streams, list of properties-values, timewatch, extensions to STL.
00041           */
00042         namespace utils
00043         {
00044                 class MRPTDLLIMPEXP CSerializable;
00045                 /** A smart pointer to a CRenderizable object */
00046                 typedef stlplus::smart_ptr_clone<CSerializable> CSerializablePtr;
00047 
00048                 /** A structure that holds runtime class type information. Use CLASS_ID(<class_name>) to get a reference to the class_name's TRuntimeClassId descriptor.
00049                   */
00050                 struct MRPTDLLIMPEXP TRuntimeClassId
00051                 {
00052                         const char*                     className;
00053                         int                             objectSize;
00054                         /** Create an object of the related class, or NULL if it is virtual.
00055                           */
00056                         CSerializable*                  (*ptrCreateObject)();
00057                         /** Gets the base class runtime id.
00058                           */
00059                         const TRuntimeClassId*          (*getBaseClass)();
00060 
00061                         // Operations
00062                         CSerializable*          createObject() const;
00063                         bool                            derivedFrom(const TRuntimeClassId* pBaseClass) const;
00064                         bool                            derivedFrom(const char* pBaseClass_name) const;
00065 
00066                         // Implementation
00067                         void                                    writeTo(mrpt::utils::CStream& out) const;
00068                         static const TRuntimeClassId* loadFrom(mrpt::utils::CStream& in);
00069                 };
00070 
00071                 /** A wrapper class for a "TRuntimeClassId *", well-defined with respect to copy operators and constructors.
00072                   */
00073                 typedef safe_ptr<TRuntimeClassId> TRuntimeClassIdPtr;
00074 
00075                 /** Register a class into the MRPT internal list of "CSerializable" descendents.
00076                   *  Used internally in the macros DEFINE_SERIALIZABLE, etc...
00077                   * \sa getAllRegisteredClasses
00078                   */
00079                 void MRPTDLLIMPEXP registerClass(const mrpt::utils::TRuntimeClassId* pNewClass);
00080 
00081                 /** Returns a list with all the classes registered in the system through mrpt::utils::registerClass.
00082                   * \sa registerClass, findRegisteredClass
00083                   */
00084                 std::vector<const mrpt::utils::TRuntimeClassId*> MRPTDLLIMPEXP getAllRegisteredClasses();
00085 
00086                 /** Return info about a given class by its name, or NULL if the class is not registered
00087                   * \sa registerClass, getAllRegisteredClasses
00088                   */
00089                 const TRuntimeClassId MRPTDLLIMPEXP * findRegisteredClass(const std::string &className);
00090 
00091 
00092                 /** Access to runtime class ID for a defined class name.
00093                   */
00094                 #define CLASS_ID(class_name) static_cast<const mrpt::utils::TRuntimeClassId*>(&class_name::class##class_name)
00095 
00096                 /** Access to runtime class ID for a defined class name.
00097                   */
00098                 #define CLASS_ID_NAMESPACE(class_name,namespaceName) static_cast<const mrpt::utils::TRuntimeClassId*>(&namespaceName::class_name::class##class_name)
00099 
00100                 /** Access to runtime class ID for a defined template class name.
00101                   */
00102                 #define CLASS_ID_TEMPLATE(class_name,T) static_cast<const mrpt::utils::TRuntimeClassId*>(& template <class T> class_name<T>::class##class_name)
00103 
00104                 /** Evaluates to true if the given pointer to an object (derived from mrpt::utils::CSerializable) is of the given class.
00105                   */
00106                 #define IS_CLASS( ptrObj, class_name )  ((ptrObj)->GetRuntimeClass()==CLASS_ID(class_name))
00107 
00108                 /** 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.
00109                   */
00110                 #define IS_DERIVED( ptrObj, class_name )  ((ptrObj)->GetRuntimeClass()->derivedFrom(CLASS_ID(class_name)))
00111 
00112                 /** Auxiliary structure used for CSerializable runtime class ID support.
00113                   */
00114                 struct MRPTDLLIMPEXP CLASSINIT
00115                 {
00116                         CLASSINIT(const mrpt::utils::TRuntimeClassId* pNewClass)
00117                         {
00118                                 registerClass(pNewClass);
00119                         }
00120                 };
00121 
00122 
00123                 /** The virtual base class which provides a unified interface for all persistent objects in MRPT.
00124                  *   For each class named <code>CMyClass</code>, a new type named <code>CMyClassPtr</code> will be created as a smart pointer suitable for
00125                  *    keeping referencing count smart pointers to objects of that class. By default the base class of all these smart pointers is CSerializablePtr.
00126                  *       Refer to the tutorial about <a href="http://babel.isa.uma.es/mrpt/index.php/Serialization" >serialization</a> in the wiki.
00127                  * \sa CStream
00128                  */
00129                 class MRPTDLLIMPEXP CSerializable
00130                 {
00131                 protected:
00132                         static  mrpt::utils::TRuntimeClassId* _GetBaseClass();
00133                 public:
00134                         static const mrpt::utils::TRuntimeClassId classCSerializable;
00135                         friend class mrpt::utils::CStream;
00136 
00137                         /** Returns information about the class of an object in runtime.
00138                           */
00139                         virtual const mrpt::utils::TRuntimeClassId* GetRuntimeClass() const;
00140 
00141                         /** Returns a copy of the object, independtly of its class.
00142                           */
00143                         virtual CSerializable *duplicate() const = 0;
00144 
00145                         /** Cloning interface for smart pointers */
00146                         CSerializable *clone() const { return duplicate(); }
00147 
00148                         virtual ~CSerializable();
00149 
00150                 protected:
00151                          /** Introduces a pure virtual method responsible for writing to a CStream.
00152                           *  This can not be used directly be users, instead use "stream << object;"
00153                           *   for writing it to a stream.
00154                           * \param out The output binary stream where object must be dumped.
00155                           * \param getVersion If NULL, the object must be dumped. If not, only the
00156                           *             version of the object dump must be returned in this pointer. This enables
00157                           *     the versioning of objects dumping and backward compatibility with previously
00158                           *     stored data.
00159                           *     \exception std::exception On any error, see CStream::WriteBuffer
00160                           * \sa CStream
00161                           */
00162                         virtual void  writeToStream(mrpt::utils::CStream &out, int *getVersion) const = 0;
00163 
00164                          /** Introduces a pure virtual method responsible for loading from a CStream
00165                           *  This can not be used directly be users, instead use "stream >> object;"
00166                           *   for reading it from a stream or "stream >> object_ptr;" if the class is
00167                           *   unknown apriori.
00168                           * \param in The input binary stream where the object data must read from.
00169                           * \param version The version of the object stored in the stream: use this version
00170                           *                number in your code to know how to read the incoming data.
00171                           *     \exception std::exception On any error, see CStream::ReadBuffer
00172                           * \sa CStream
00173                           */
00174                         virtual void  readFromStream(mrpt::utils::CStream &in, int version) = 0;
00175                 }; // End of class def.
00176 
00177 
00178                 /** @name Non-streaming serialization functions
00179                 @{ */
00180 
00181                 /** Used to pass MRPT objects into a CORBA-like object (strings). See doc about "Integration with BABEL".
00182                  * \param o The object to be serialized.
00183                  * \return The string containing the binay version of object.
00184                  * \sa StringToObject, <a href="http://babel.isa.uma.es/mrpt/index.php/Integration_with_BABEL">Integration with BABEL</a>
00185                  */
00186                 std::string MRPTDLLIMPEXP ObjectToString(const CSerializable *o);
00187 
00188                 /** Used to pass CORBA-like objects (strings) into a MRPT object.
00189                  * \param str An string generated with ObjectToString
00190                  * \param obj A currently empty pointer, where a pointer to the newly created object will be stored.
00191                  * \exception None On any internal exception, this function returns NULL.
00192                  * \sa ObjectToString, <a href="http://babel.isa.uma.es/mrpt/index.php/Integration_with_BABEL">Integration with BABEL</a>
00193                  */
00194                 void MRPTDLLIMPEXP StringToObject(const std::string &str, CSerializablePtr &obj);
00195 
00196                 /** Converts (serializes) an MRPT object into an array of bytes.
00197                  * \param o The object to be serialized.
00198                  * \param out_vector The vector which at return will contain the data. Size will be set automatically.
00199                  * \sa OctetVectorToObject, ObjectToString
00200                  */
00201                 void MRPTDLLIMPEXP ObjectToOctetVector(const CSerializable *o, vector_byte & out_vector);
00202 
00203                 /** Converts back (de-serializes) a sequence of binary data into a MRPT object, without prior information about the object's class.
00204                  * \param in_data The serialized input data representing the object.
00205                  * \param obj The newly created object will be stored in this smart pointer.
00206                  * \exception None On any internal exception, this function returns a NULL pointer.
00207                  * \sa ObjectToOctetVector, StringToObject
00208                  */
00209                 void MRPTDLLIMPEXP OctetVectorToObject(const vector_byte & in_data, CSerializablePtr &obj);
00210 
00211                 /** Converts (serializes) an MRPT object into an array of bytes within a std::string, without codifying to avoid NULL characters.
00212                  *  This is therefore more efficient than ObjectToString
00213                  * \param o The object to be serialized.
00214                  * \param out_vector The string which at return will contain the data. Size will be set automatically.
00215                  * \sa RawStringToObject, ObjectToOctetVector
00216                  */
00217                 void MRPTDLLIMPEXP ObjectToRawString(const CSerializable *o, std::string & out_str);
00218 
00219                 /** Converts back (de-serializes) a sequence of binary data within a std::string into a MRPT object, without prior information about the object's class.
00220                  * \param in_data The serialized input data representing the object.
00221                  * \param obj The newly created object will be stored in this smart pointer.
00222                  * \exception None On any internal exception, this function returns a NULL pointer.
00223                  * \sa ObjectToRawString
00224                  */
00225                 void MRPTDLLIMPEXP RawStringToObject(const std::string & in_str, CSerializablePtr &obj);
00226 
00227                 /** @} */
00228 
00229 
00230 
00231                 /** @name Conversion of type to string at compile time
00232                   * IMPORTANT: See also the implementation of Serialization for STL containers in mrpt/utils/stl_extensions.h
00233                 @{ */
00234 
00235                 /** A template to obtain the type of its argument as a string at compile time.
00236                   *  It works with all classes derived from  CSerializable, plus many specializations for the plain data types (bool, double, uint8_t, etc...)
00237                   *   For example:
00238                   *  \code
00239                   *     cout << TTypeName<double>::get() << endl;                          // "double"
00240                   *     cout << TTypeName<CPose2D>::get() << endl;                         // "CPose2D"
00241                   *     cout << TTypeName<mrpt::slam::COccupancyGridMap2D>::get() << endl; // "COccupancyGridMap2D"
00242                   *  \endcode
00243                   */
00244                 template<typename T>
00245                 struct TTypeName
00246                 {
00247                         static std::string get() {
00248                                 return std::string( T::classinfo->className );
00249                         }
00250                 };
00251 
00252                 #define MRPT_DECLARE_TTYPENAME(_TYPE) \
00253                         template<> struct TTypeName <_TYPE > { \
00254                                 static std::string get() { return std::string(#_TYPE); } };
00255 
00256                 #define MRPT_DECLARE_TTYPENAME_PTR(_TYPE) \
00257                         template<> struct TTypeName <_TYPE##Ptr> { \
00258                         static std::string get() { return TTypeName<_TYPE>::get(); }    };
00259 
00260                 MRPT_DECLARE_TTYPENAME(bool)
00261                 MRPT_DECLARE_TTYPENAME(double)
00262                 MRPT_DECLARE_TTYPENAME(float)
00263                 MRPT_DECLARE_TTYPENAME(uint64_t)
00264                 MRPT_DECLARE_TTYPENAME(int64_t)
00265                 MRPT_DECLARE_TTYPENAME(uint32_t)
00266                 MRPT_DECLARE_TTYPENAME(int32_t)
00267                 MRPT_DECLARE_TTYPENAME(uint16_t)
00268                 MRPT_DECLARE_TTYPENAME(int16_t)
00269                 MRPT_DECLARE_TTYPENAME(uint8_t)
00270                 MRPT_DECLARE_TTYPENAME(int8_t)
00271 
00272                 MRPT_DECLARE_TTYPENAME(std::string)
00273 
00274                 #define MRPT_DECLARE_TTYPENAME_CONTAINER(_CONTAINER) \
00275                         template< typename V > \
00276                         struct TTypeName <_CONTAINER<V> > { \
00277                                 static std::string get() { \
00278                                         return std::string( #_CONTAINER )+std::string("<")+std::string( TTypeName<V>::get() ) + std::string(">"); \
00279                                 } \
00280                         };
00281 
00282                 MRPT_DECLARE_TTYPENAME_CONTAINER( std::vector )
00283                 MRPT_DECLARE_TTYPENAME_CONTAINER( std::deque )
00284                 MRPT_DECLARE_TTYPENAME_CONTAINER( std::list )
00285                 MRPT_DECLARE_TTYPENAME_CONTAINER( std::set )
00286 
00287                 // These ones act as a "translation" between vector_XXX types and their base classes:
00288                 #define MRPT_DECLARE_TTYPENAME_MAP_FOR_VECTOR(_CONT) \
00289                         template<> struct TTypeName <_CONT> : TTypeName<std::vector<_CONT::value_type> > { };
00290 
00291                 MRPT_DECLARE_TTYPENAME_MAP_FOR_VECTOR(vector_signed_byte )
00292                 MRPT_DECLARE_TTYPENAME_MAP_FOR_VECTOR(vector_signed_word)
00293                 MRPT_DECLARE_TTYPENAME_MAP_FOR_VECTOR(vector_int)
00294                 MRPT_DECLARE_TTYPENAME_MAP_FOR_VECTOR(vector_long)
00295                 MRPT_DECLARE_TTYPENAME_MAP_FOR_VECTOR(vector_float)
00296                 MRPT_DECLARE_TTYPENAME_MAP_FOR_VECTOR(vector_double)
00297                 MRPT_DECLARE_TTYPENAME_MAP_FOR_VECTOR(vector_byte)
00298                 MRPT_DECLARE_TTYPENAME_MAP_FOR_VECTOR(vector_word)
00299                 MRPT_DECLARE_TTYPENAME_MAP_FOR_VECTOR(vector_uint)
00300 
00301         #if MRPT_WORD_SIZE!=32  // If it's 32 bit, size_t <=> uint32_t
00302                 MRPT_DECLARE_TTYPENAME_MAP_FOR_VECTOR(vector_size_t)
00303         #endif
00304 
00305 
00306                 #define MRPT_DECLARE_TTYPENAME_CONTAINER_ASSOC(_CONTAINER) \
00307                         template< typename K, typename V > \
00308                         struct TTypeName <_CONTAINER<K,V> > { \
00309                                 static std::string get() { \
00310                                         return std::string( #_CONTAINER )+std::string("<")+std::string( TTypeName<K>::get() )+ std::string(",")+std::string( TTypeName<V>::get() )+std::string(">"); \
00311                                 } \
00312                         };
00313 
00314                 MRPT_DECLARE_TTYPENAME_CONTAINER_ASSOC( std::map )
00315                 MRPT_DECLARE_TTYPENAME_CONTAINER_ASSOC( std::multimap )
00316 
00317 
00318                 template< typename T1, typename T2 >
00319                 struct TTypeName <std::pair<T1,T2> >    {
00320                         static std::string get() {
00321                                 return std::string("std::pair<")+std::string( TTypeName<T1>::get() )+ std::string(",")+std::string( TTypeName<T2>::get() )+std::string(">");
00322                         }
00323                 };
00324 
00325                 /** @} */
00326 
00327 
00328                 /** This declaration must be inserted in all CSerializable classes definition, within the class declaration.
00329                   */
00330                 #define DEFINE_SERIALIZABLE(class_name) \
00331                 protected: \
00332                         static  const mrpt::utils::TRuntimeClassId* _GetBaseClass(); \
00333                         static mrpt::utils::CLASSINIT _init_##class_name;\
00334                         void  writeToStream(mrpt::utils::CStream &out, int *getVersion) const;\
00335                         void  readFromStream(mrpt::utils::CStream &in, int version);\
00336                 public: \
00337                         typedef class_name##Ptr SmartPtr; \
00338                         static  mrpt::utils::TRuntimeClassId  class##class_name; \
00339                         static  const mrpt::utils::TRuntimeClassId *classinfo; \
00340                         virtual const mrpt::utils::TRuntimeClassId* GetRuntimeClass() const; \
00341                         static  CSerializable* CreateObject(); \
00342                         static class_name##Ptr Create(); \
00343                         virtual CSerializable *duplicate() const;
00344 
00345                 /**  This declaration must be inserted in all CSerializable classes definition, before the class declaration.
00346                   */
00347                 #define DEFINE_SERIALIZABLE_PRE_CUSTOM_LINKAGE(class_name,_LINKAGE_) \
00348                         class class_name; \
00349                         struct _LINKAGE_ class_name##Ptr : public mrpt::utils::CSerializablePtr \
00350                         { \
00351                                 class_name##Ptr() : mrpt::utils::CSerializablePtr(static_cast<mrpt::utils::CSerializable*>(NULL)) { } \
00352                                 explicit class_name##Ptr(class_name* p) : mrpt::utils::CSerializablePtr( reinterpret_cast<mrpt::utils::CSerializable*>(p) ) { } \
00353                                 explicit class_name##Ptr(const mrpt::utils::CSerializablePtr & p) : mrpt::utils::CSerializablePtr(p)  \
00354                                 {  ASSERTMSG_( p->GetRuntimeClass()->derivedFrom(#class_name),::mrpt::format("Wrong typecasting of smart pointers: %s -> %s",p->GetRuntimeClass()->className, #class_name) )  } \
00355                                 void setFromPointerDoNotFreeAtDtor(const class_name* p) { \
00356                                         this->set(const_cast<mrpt::utils::CSerializable*>(reinterpret_cast<const mrpt::utils::CSerializable*>(p))); m_holder->increment(); \
00357                                 } \
00358                                 class_name * pointer() { return reinterpret_cast<class_name*>(mrpt::utils::CSerializablePtr::pointer()); } \
00359                                 const class_name * pointer() const { return reinterpret_cast<const class_name*>(mrpt::utils::CSerializablePtr::pointer()); } \
00360                                 class_name* operator ->(void) { return reinterpret_cast<class_name*>( mrpt::utils::CSerializablePtr::operator ->() ); } \
00361                                 const class_name* operator ->(void) const { return reinterpret_cast<const class_name*>( mrpt::utils::CSerializablePtr::operator ->() ); } \
00362                                 class_name& operator *(void) { return *reinterpret_cast<class_name*>( mrpt::utils::CSerializablePtr::operator ->() ); } \
00363                                 const class_name& operator *(void) const { return *reinterpret_cast<const class_name*>( mrpt::utils::CSerializablePtr::operator ->() ); } \
00364                         };\
00365                         _LINKAGE_ ::mrpt::utils::CStream& operator>>(mrpt::utils::CStream& in, class_name##Ptr &pObj);
00366 
00367 
00368                 /**  This declaration must be inserted in all CSerializable classes definition, before the class declaration.
00369                   */
00370                 #define DEFINE_SERIALIZABLE_PRE(class_name) \
00371                         DEFINE_SERIALIZABLE_PRE_CUSTOM_LINKAGE(class_name, MRPTDLLIMPEXP )
00372 
00373                 /**  This declaration must be inserted in all CSerializable classes definition, before the class declaration.
00374                   */
00375                 #define DEFINE_SERIALIZABLE_PRE_CUSTOM_BASE_LINKAGE(class_name, base_name, _LINKAGE_ ) \
00376                         class class_name; \
00377                         struct _LINKAGE_ class_name##Ptr : public base_name##Ptr \
00378                         { \
00379                                 class_name##Ptr() : base_name##Ptr(static_cast<base_name*>(NULL)) { } \
00380                                 explicit class_name##Ptr(class_name* p) : base_name##Ptr( reinterpret_cast<base_name*>(p) ) { } \
00381                                 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) )  } \
00382                                 explicit class_name##Ptr(const mrpt::utils::CSerializablePtr & 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) )  } \
00383                                 class_name * pointer() { return reinterpret_cast<class_name*>(base_name##Ptr::pointer()); } \
00384                                 const class_name * pointer() const { return reinterpret_cast<const class_name*>(base_name##Ptr::pointer()); } \
00385                                 class_name* operator ->(void) { return reinterpret_cast<class_name*>( base_name##Ptr::operator ->() ); } \
00386                                 const class_name* operator ->(void) const { return reinterpret_cast<const class_name*>( base_name##Ptr::operator ->() ); } \
00387                                 class_name& operator *(void) { return *reinterpret_cast<class_name*>( base_name##Ptr::operator ->() ); } \
00388                                 const class_name& operator *(void) const { return *reinterpret_cast<const class_name*>( base_name##Ptr::operator ->() ); } \
00389                         }; \
00390                         _LINKAGE_ ::mrpt::utils::CStream& operator>>(mrpt::utils::CStream& in, class_name##Ptr &pObj);
00391 
00392 
00393                 /**  This declaration must be inserted in all CSerializable classes definition, before the class declaration.
00394                   */
00395                 #define DEFINE_SERIALIZABLE_PRE_CUSTOM_BASE(class_name, base_name) \
00396                         DEFINE_SERIALIZABLE_PRE_CUSTOM_BASE_LINKAGE(class_name, base_name, MRPTDLLIMPEXP )
00397 
00398                 /** This must be inserted in all CSerializable classes implementation files:
00399                   */
00400                 #define IMPLEMENTS_SERIALIZABLE(class_name, base,NameSpace) \
00401                         mrpt::utils::CSerializable* NameSpace::class_name::CreateObject() \
00402                                 { return static_cast<mrpt::utils::CSerializable*>( new NameSpace::class_name ); } \
00403                         NameSpace::class_name##Ptr NameSpace::class_name::Create() \
00404                                 { return NameSpace::class_name##Ptr( new NameSpace::class_name ); } \
00405                         const mrpt::utils::TRuntimeClassId* NameSpace::class_name::_GetBaseClass() \
00406                                 { return CLASS_ID(base); } \
00407                         mrpt::utils::TRuntimeClassId NameSpace::class_name::class##class_name = { \
00408                                 #class_name, sizeof(class NameSpace::class_name), NameSpace::class_name::CreateObject, \
00409                                         &class_name::_GetBaseClass }; \
00410                         const mrpt::utils::TRuntimeClassId *NameSpace::class_name::classinfo = & NameSpace::class_name::class##class_name; \
00411                         const mrpt::utils::TRuntimeClassId* NameSpace::class_name::GetRuntimeClass() const \
00412                         { return CLASS_ID_NAMESPACE(class_name,NameSpace); } \
00413                         mrpt::utils::CLASSINIT NameSpace::class_name::_init_##class_name(CLASS_ID(base)); \
00414                         mrpt::utils::CStream& NameSpace::operator>>(mrpt::utils::CStream& in, NameSpace::class_name##Ptr &pObj) \
00415                         { pObj = NameSpace::class_name##Ptr( in.ReadObject() ); return in; } \
00416                         mrpt::utils::CSerializable * NameSpace::class_name::duplicate() const \
00417                         { return static_cast<mrpt::utils::CSerializable*>( new NameSpace::class_name(*this) ); }
00418 
00419 
00420                 /** This declaration must be inserted in virtual CSerializable classes definition:
00421                   */
00422                 #define DEFINE_VIRTUAL_SERIALIZABLE(class_name) \
00423                 protected: \
00424                         static const mrpt::utils::TRuntimeClassId* _GetBaseClass(); \
00425                 public: \
00426                         static const mrpt::utils::TRuntimeClassId class##class_name; \
00427                         virtual const mrpt::utils::TRuntimeClassId* GetRuntimeClass() const; \
00428                         friend class mrpt::utils::CStream; \
00429 
00430                 /** This must be inserted as implementation of some required members for
00431                   *  virtual CSerializable classes:
00432                   */
00433                 #define IMPLEMENTS_VIRTUAL_SERIALIZABLE(class_name, base_class_name,NameSpace) \
00434                         const mrpt::utils::TRuntimeClassId* class_name::_GetBaseClass() \
00435                                 { return CLASS_ID(base_class_name); } \
00436                         const mrpt::utils::TRuntimeClassId class_name::class##class_name = { \
00437                                 #class_name, sizeof(class class_name), NULL, \
00438                                         &class_name::_GetBaseClass }; \
00439                         const mrpt::utils::TRuntimeClassId* class_name::GetRuntimeClass() const \
00440                                 { return CLASS_ID(class_name); } \
00441                         mrpt::utils::CStream& NameSpace::operator>>(mrpt::utils::CStream& in, class_name##Ptr &pObj) \
00442                         { pObj = class_name##Ptr( in.ReadObject() ); return in; }
00443 
00444 
00445         } // End of namespace
00446 } // End of namespace
00447 
00448 // I want these operators to reside in std so STL algorithms can always find them.
00449 namespace std
00450 {
00451         /**  This operator enables comparing two smart pointers with "==" to test whether they point to the same object.
00452           */
00453         template <typename T,typename C>
00454         bool operator == ( const stlplus::smart_ptr_base<T,C>&a,const stlplus::smart_ptr_base<T,C>&b) {
00455                 return a.aliases(b);
00456         }
00457         /**  This operator enables comparing two smart pointers with "!=" to test whether they don't point to the same object.
00458           */
00459         template <typename T,typename C>
00460         bool operator != ( const stlplus::smart_ptr_base<T,C>&a,const stlplus::smart_ptr_base<T,C>&b) {
00461                 return !a.aliases(b);
00462         }
00463 }
00464 
00465 #endif