mirror of
https://github.com/reactos/reactos.git
synced 2024-12-27 09:34:43 +00:00
143 lines
3 KiB
C++
143 lines
3 KiB
C++
// Reli.h
|
|
// lots of code here is (c) Bartosz Milewski, 1996, www.relisoft.com
|
|
// The rest is (C) 2002-2004 Royce Mitchell III
|
|
// and released under the LGPL & BSD licenses
|
|
|
|
#ifndef __RELI_H
|
|
#define __RELI_H
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Assert
|
|
|
|
#undef Assert
|
|
#ifdef NDEBUG
|
|
#define Assert(exp) ((void)0)
|
|
#else
|
|
void _wassert (char* szExpr, char* szFile, int line);
|
|
#define Assert(exp) (void)( (exp) || (_wassert(#exp, __FILE__, __LINE__), 0) )
|
|
#endif /* NDEBUG */
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Swap
|
|
|
|
template <class T>
|
|
void Swap(T a,T b)
|
|
{
|
|
T t = a;
|
|
a = b;
|
|
b = t;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Uncopyable - base class disabling copy ctors
|
|
class Uncopyable
|
|
{
|
|
public:
|
|
Uncopyable(){} // need a default ctor
|
|
private:
|
|
Uncopyable ( const Uncopyable& );
|
|
const Uncopyable& operator = ( const Uncopyable& );
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// SPtr - Smart Pointer's must be passed by reference or const reference
|
|
|
|
template <class T>
|
|
class SPtr : public Uncopyable
|
|
{
|
|
public:
|
|
virtual ~SPtr () { Destroy(); }
|
|
T * operator->() { return _p; }
|
|
T const * operator->() const { return _p; }
|
|
operator T&() { Assert(_p); return *_p; }
|
|
operator const T&() const { Assert(_p); return *_p; }
|
|
void Acquire ( SPtr<T>& t ) { Destroy(); Swap(_p,t._p); }
|
|
void Destroy() { if ( _p ) { delete _p; _p = 0; } }
|
|
protected:
|
|
SPtr (): _p (0) {}
|
|
explicit SPtr (T* p): _p (p) {}
|
|
T * _p;
|
|
private:
|
|
operator T* () { return _p; }
|
|
};
|
|
|
|
#define DECLARE_SPTR(cls,init,init2) \
|
|
class S##cls : public SPtr<cls> \
|
|
{ \
|
|
public: \
|
|
S##cls ( cls* p ) : SPtr<cls>(p) {} \
|
|
explicit S##cls init : SPtr<cls> (new cls init2) {} \
|
|
};
|
|
/* Example Usage of DECLARE_SPTR:
|
|
class MyClass
|
|
{
|
|
public: // can be protected
|
|
MyClass ( int i )
|
|
{
|
|
...
|
|
}
|
|
...
|
|
}; DECLARE_SPTR(MyClass,(int i),(i))
|
|
SMyClass ptr(i);
|
|
*/
|
|
#define DECLARE_SPTRV(cls) typedef SPtr<cls> S##cls;
|
|
/* Example Usage of DECLARE_SPTRV:
|
|
class MyAbstractClass
|
|
{
|
|
public: // can be protected
|
|
MyAbstractClass ( int i )
|
|
{
|
|
...
|
|
}
|
|
void MyPureVirtFunc() = 0;
|
|
...
|
|
}; DECLARE_SPTRV(MyAbstractClass)
|
|
SMyAbstractClass ptr ( new MySubClass(i) );
|
|
*/
|
|
|
|
#define DECLARE_PTR(cls,init,init2) \
|
|
class Ptr : public SPtr<cls> \
|
|
{ \
|
|
Ptr(cls* p) : SPtr<cls> ( p ) \
|
|
{ \
|
|
} \
|
|
Ptr init : SPtr<cls> ( new cls init2 ) {} \
|
|
};
|
|
/* Example Usage of DECLARE_PTR:
|
|
class MyClass
|
|
{
|
|
DECLARE_PTR(MyClass,(int i),(i))
|
|
public: // can be protected
|
|
MyClass ( int i )
|
|
{
|
|
...
|
|
}
|
|
void MyPureVirtFunc() = 0;
|
|
...
|
|
};
|
|
MyClass::Ptr ptr ( i );
|
|
*/
|
|
|
|
#define DECLARE_PTRV(cls) \
|
|
class Ptr : public SPtr<cls> \
|
|
{ \
|
|
Ptr(cls* p) : SPtr<cls> ( p ) \
|
|
{ \
|
|
} \
|
|
};
|
|
/* Example Usage of DECLARE_PTRV:
|
|
class MyAbstractClass
|
|
{
|
|
DECLARE_PTRV(MyAbstractClass)
|
|
public: // can be protected
|
|
MyAbstractClass ( int i )
|
|
{
|
|
...
|
|
}
|
|
void MyPureVirtFunc() = 0;
|
|
...
|
|
};
|
|
MyAbstractClass::Ptr ptr ( new MySubClass(i) );
|
|
*/
|
|
|
|
#endif//__RELI_H
|