irc/ArchBlackmann/Reli.h

   1 // Reli.h
   2 // lots of code here is (c) Bartosz Milewski, 1996, www.relisoft.com
   3 // The rest is (C) 2002-2004 Royce Mitchell III
   4 // and released under the LGPL & BSD licenses
   5
   6 #ifndef __RELI_H
   7 #define __RELI_H
   8
   9 ////////////////////////////////////////////////////////////////////////////////
  10 // Assert
  11
  12 #undef Assert
  13 #ifdef NDEBUG
  14         #define Assert(exp)     ((void)0)
  15 #else
  16         void _wassert (char* szExpr, char* szFile, int line);
  17         #define Assert(exp) (void)( (exp) || (_wassert(#exp, __FILE__, __LINE__), 0) )
  18 #endif  /* NDEBUG */
  19
  20 ////////////////////////////////////////////////////////////////////////////////
  21 // Swap
  22
  23 template <class T>
  24 void Swap(T a,T b)
  25 {
  26         T t = a;
  27         a = b;
  28         b = t;
  29 }
  30
  31 ////////////////////////////////////////////////////////////////////////////////
  32 // Uncopyable - base class disabling copy ctors
  33 class Uncopyable
  34 {
  35 public:
  36         Uncopyable(){} // need a default ctor
  37 private:
  38         Uncopyable ( const Uncopyable& );
  39         const Uncopyable& operator = ( const Uncopyable& );
  40 };
  41
  42 ////////////////////////////////////////////////////////////////////////////////
  43 // SPtr - Smart Pointer's must be passed by reference or const reference
  44
  45 template <class T>
  46 class SPtr : public Uncopyable
  47 {
  48 public:
  49         virtual ~SPtr () { Destroy(); }
  50         T * operator->() { return _p; }
  51         T const * operator->() const { return _p; }
  52         operator T&() { Assert(_p); return *_p; }
  53         operator const T&() const { Assert(_p); return *_p; }
  54         void Acquire ( SPtr<T>& t ) { Destroy(); Swap(_p,t._p); }
  55         void Destroy() { if ( _p ) { delete _p; _p = 0; } }
  56 protected:
  57         SPtr (): _p (0) {}
  58         explicit SPtr (T* p): _p (p) {}
  59         T * _p;
  60 private:
  61         operator T* () { return _p; }
  62 };
  63
  64 #define DECLARE_SPTR(cls,init,init2) \
  65 class S##cls : public SPtr<cls> \
  66 { \
  67 public: \
  68         S##cls ( cls* p ) : SPtr<cls>(p) {} \
  69         explicit S##cls init : SPtr<cls> (new cls init2) {} \
  70 };
  71 /* Example Usage of DECLARE_SPTR:
  72 class MyClass
  73 {
  74 public: // can be protected
  75         MyClass ( int i )
  76         {
  77                 ...
  78         }
  79         ...
  80 }; DECLARE_SPTR(MyClass,(int i),(i))
  81 SMyClass ptr(i);
  82 */
  83 #define DECLARE_SPTRV(cls) typedef SPtr<cls> S##cls;
  84 /* Example Usage of DECLARE_SPTRV:
  85 class MyAbstractClass
  86 {
  87 public: // can be protected
  88         MyAbstractClass ( int i )
  89         {
  90                 ...
  91         }
  92         void MyPureVirtFunc() = 0;
  93         ...
  94 }; DECLARE_SPTRV(MyAbstractClass)
  95 SMyAbstractClass ptr ( new MySubClass(i) );
  96 */
  97
  98 #define DECLARE_PTR(cls,init,init2) \
  99         class Ptr : public SPtr<cls> \
 100         { \
 101                 Ptr(cls* p) : SPtr<cls> ( p ) \
 102                 { \
 103                 } \
 104                 Ptr init : SPtr<cls> ( new cls init2 ) {} \
 105         };
 106 /* Example Usage of DECLARE_PTR:
 107 class MyClass
 108 {
 109         DECLARE_PTR(MyClass,(int i),(i))
 110 public: // can be protected
 111         MyClass ( int i )
 112         {
 113                 ...
 114         }
 115         void MyPureVirtFunc() = 0;
 116         ...
 117 };
 118 MyClass::Ptr ptr ( i );
 119 */
 120
 121 #define DECLARE_PTRV(cls) \
 122         class Ptr : public SPtr<cls> \
 123         { \
 124                 Ptr(cls* p) : SPtr<cls> ( p ) \
 125                 { \
 126                 } \
 127         };
 128 /* Example Usage of DECLARE_PTRV:
 129 class MyAbstractClass
 130 {
 131         DECLARE_PTRV(MyAbstractClass)
 132 public: // can be protected
 133         MyAbstractClass ( int i )
 134         {
 135                 ...
 136         }
 137         void MyPureVirtFunc() = 0;
 138         ...
 139 };
 140 MyAbstractClass::Ptr ptr ( new MySubClass(i) );
 141 */
 142
 143 #endif//__RELI_H