CORE_Pointers.h

Go to the documentation of this file.

#ifndef CORE_Pointers_H
#define CORE_Pointers_H

#include <boost/shared_array.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/weak_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>



namespace SharedPointer {};
namespace SharedPointerConst {};
namespace SharedVector {};
namespace SharedVectorConst {};
namespace SharedPointerOfSharedVector {};
namespace SharedArray {};
namespace SharedArrayConst {};

namespace WeakArray {};
namespace WeakArrayConst {};
namespace WeakVector {};
namespace WeakVectorConst {};
namespace WeakPointer{};
namespace WeakPointerConst{};



namespace SP = SharedPointer;

namespace SPC = SharedPointerConst;

namespace WP = WeakPointer;

namespace WPC = WeakPointerConst;


namespace WV = WeakVector;
namespace WVC = WeakVectorConst;

namespace SV = SharedVector;



namespace SVC = SharedVectorConst;


namespace SA = SharedArray;
namespace SAC = SharedArrayConst;

namespace WA = WeakArray;
namespace WAC = WeakArrayConst;

struct nullDeleter
{
  void operator()(void const *) const {}
};


/* template namespace : no */

#define NAME_SPACE_SPTR(X) \
  namespace SharedPointer \
  { \
    typedef SPtr##X X; \
  } \
  namespace WeakPointer \
  { \
    typedef WPtr##X X; \
  } \
  namespace SharedPointerConst \
  { \
    typedef SPtrConst##X X;\
  }                                                     \
  namespace WeakPointerConst                            \
  { \
    typedef WPtrConst##X X; \
  };

#define NAME_SPACE_SVPTR(X) \
  namespace SharedVector \
  { \
    typedef SVPtr##X X; \
  } \
  namespace SharedVectorConst                   \
  { \
    typedef SVPtrConst##X X; \
  } \
  namespace SharedArray                        \
  { \
    typedef SAPtr##X X; \
  } \
  namespace SharedArrayConst                    \
  { \
    typedef SAPtrConst##X X; \
  } \
  namespace WeakVector                  \
  { \
    typedef WVPtr##X X; \
  } \
  namespace WeakVectorConst                             \
  {                                             \
    typedef WVPtrConst##X X;                            \
  } \
  namespace WeakArray                           \
  { \
    typedef WAPtr##X X; \
  } \
  namespace WeakArrayConst                              \
  {                                             \
    typedef WAPtrConst##X X;                            \
  };
  



#define TYPEDEF_SPTR(X) \
  typedef boost::weak_ptr<X>  WPtr##X;           \
  typedef boost::shared_ptr<X> SPtr##X;                     \
  typedef boost::shared_ptr<const X> SPtrConst##X;          \
  typedef boost::weak_ptr<const X> WPtrConst##X;            \
  NAME_SPACE_SPTR(X)


#define TYPEDEF_SAPTR(X)                        \
  typedef boost::shared_array<X> X##SAPtr ;     \
  NAME_SPACE_SAPTR(X)



#define DEFINE_SPTR(X) \
  class X; \
  TYPEDEF_SPTR(X)


#define DEFINE_SAPTR(X) \
  class X; \
  TYPEDEF_SAPTR(X)

#define USE_THIS(X,Y)\
  SP_OBJECT(X)

#define SP_OBJECT(X)\
  public:\
                                               \
  void getSharedPointer(SP::X& p){\
    SP::CORE_Object r;                          \
    CORE_Object::getSharedPointer(r);           \
    p=boost::dynamic_pointer_cast<X>(r);        \
  };\
                                                        \
  void getSharedPointer(SPC::X& p) const{               \
    SPC::CORE_Object r;\
    CORE_Object::getSharedPointer(r);           \
    p=boost::dynamic_pointer_cast<const X>(r);                          \
  }; \
  private:                                      \
                                                \
  inline SP::X getThis() {                      \
    SP::X p;\
    getSharedPointer(p);\
    return p;                           \
  };    \
                                                \
  inline SPC::X getThis() const {                                       \
    SPC::X p;                                                           \
    getSharedPointer(p);                                                \
    return p;   \
  };\
  public:
  

/* \brief cast the shared pointer of class U to T
 */
template<class T, class U> 
static boost::shared_ptr<T> dynamic_sp_cast(boost::shared_ptr<U> const & r) {
  return boost::dynamic_pointer_cast<T>(r);
};

                                                
 

#endif /* CORE_Pointers_H */