1

/* $Id$ */

     2

     5

#ifndef COUNTEDPTR_HPP

     6

#define COUNTEDPTR_HPP

     7

     8

#if 1 // reenable when needed

     9

/** @file CCountedPtr - smart pointer implementation */

    10

    11

/** CCountedPtr - simple reference counting smart pointer.

    12

 *

    13

 *     One of the standard ways how to maintain object's lifetime.

    14

 *

    15

 *     See http://ootips.org/yonat/4dev/smart-pointers.html for more

    16

 *   general info about smart pointers.

    17

 *

    18

 *     This class implements ref-counted pointer for objects/interfaces that

    19

 *   support AddRef() and Release() methods.

    20

 */

    21

template <class Tcls_>

    22

class CCountedPtr {

    23

	/** redefine the template argument to make it visible for derived classes */

    24

public:

    25

	typedef Tcls_ Tcls;

    26

    27

protected:

    28

	/** here we hold our pointer to the target */

    29

	Tcls* m_pT;

    30

    31

public:

    32

	/** default (NULL) construct or construct from a raw pointer */

    33

	FORCEINLINE CCountedPtr(Tcls* pObj = NULL) : m_pT(pObj) {AddRef();};

    34

    35

	/** copy constructor (invoked also when initializing from another smart ptr) */

    36

	FORCEINLINE CCountedPtr(const CCountedPtr& src) : m_pT(src.m_pT) {AddRef();};

    37

    38

	/** destructor releasing the reference */

    39

	FORCEINLINE ~CCountedPtr() {Release();};

    40

    41

protected:

    42

	/** add one ref to the underlaying object */

    43

	FORCEINLINE void AddRef() {if (m_pT != NULL) m_pT->AddRef();}

    44

    45

public:

    46

	/** release smart pointer (and decrement ref count) if not null */

    47

	FORCEINLINE void Release() {if (m_pT != NULL) {m_pT->Release(); m_pT = NULL;}}

    48

    49

	/** dereference of smart pointer - const way */

    50

	FORCEINLINE const Tcls* operator -> () const {assert(m_pT != NULL); return m_pT;};

    51

    52

	/** dereference of smart pointer - non const way */

    53

	FORCEINLINE Tcls* operator -> () {assert(m_pT != NULL); return m_pT;};

    54

    55

	/** raw pointer casting operator - const way */

    56

	FORCEINLINE operator const Tcls*() const {assert(m_pT == NULL); return m_pT;}

    57

    58

	/** raw pointer casting operator - non-const way */

    59

	FORCEINLINE operator Tcls*() {return m_pT;}

    60

    61

	/** operator & to support output arguments */

    62

	FORCEINLINE Tcls** operator &() {assert(m_pT == NULL); return &m_pT;}

    63

    64

	/** assignment operator from raw ptr */

    65

	FORCEINLINE CCountedPtr& operator = (Tcls* pT) {Assign(pT); return *this;}

    66

    67

	/** assignment operator from another smart ptr */

    68

	FORCEINLINE CCountedPtr& operator = (const CCountedPtr& src) {Assign(src.m_pT); return *this;}

    69

    70

	/** assignment operator helper */

    71

	FORCEINLINE void Assign(Tcls* pT);

    72

    73

	/** one way how to test for NULL value */

    74

	FORCEINLINE bool IsNull() const {return m_pT == NULL;}

    75

    76

	/** another way how to test for NULL value */

    77

	//FORCEINLINE bool operator == (const CCountedPtr& sp) const {return m_pT == sp.m_pT;}

    78

    79

	/** yet another way how to test for NULL value */

    80

	//FORCEINLINE bool operator != (const CCountedPtr& sp) const {return m_pT != sp.m_pT;}

    81

    82

	/** assign pointer w/o incrementing ref count */

    83

	FORCEINLINE void Attach(Tcls* pT) {Release(); m_pT = pT;}

    84

    85

	/** detach pointer w/o decrementing ref count */

    86

	FORCEINLINE Tcls* Detach() {Tcls* pT = m_pT; m_pT = NULL; return pT;}

    87

};

    88

    89

template <class Tcls_>

    90

FORCEINLINE void CCountedPtr<Tcls_>::Assign(Tcls* pT)

    91

{

    92

	// if they are the same, we do nothing

    93

	if (pT != m_pT) {

    94

		if (pT) pT->AddRef();        // AddRef new pointer if any

    95

		Tcls* pTold = m_pT;          // save original ptr

    96

		m_pT = pT;                   // update m_pT to new value

    97

		if (pTold) pTold->Release(); // release old ptr if any

    98

	}

    99

}

   100

   101

/**

   102

 * Adapter wrapper for CCountedPtr like classes that can't be used directly by stl

   103

 * collections as item type. For example CCountedPtr has overloaded operator & which

   104

 * prevents using CCountedPtr in stl collections (i.e. std::list<CCountedPtr<MyType> >)

   105

 */

   106

template <class T> struct AdaptT {

   107

	T m_t;

   108

   109

	/** construct by wrapping the given object */

   110

	AdaptT(const T &t)

   111

		: m_t(t)

   112

	{}

   113

   114

	/** assignment operator */

   115

	T& operator = (const T &t)

   116

	{

   117

		m_t = t;

   118

		return t;

   119

	}

   120

   121

	/** type-cast operator (used when AdaptT is used instead of T) */

   122

	operator T& ()

   123

	{

   124

		return m_t;

   125

	}

   126

   127

	/** const type-cast operator (used when AdaptT is used instead of const T) */

   128

	operator const T& () const

   129

	{

   130

		return m_t;

   131

	}

   132

};

   133

   134

   135

/** Simple counted object. Use it as base of your struct/class if you want to use

   136

 *  basic reference counting. Your struct/class will destroy and free itself when

   137

 *  last reference to it is released (using Relese() method). The initial reference

   138

 *  count (when it is created) is zero (don't forget AddRef() at least one time if

   139

 *  not using CCountedPtr<T>.

   140

 *

   141

 *  @see misc/countedobj.cpp for implementation.

   142

 */

   143

struct SimpleCountedObject {

   144

	int32 m_ref_cnt;

   145

   146

	SimpleCountedObject()

   147

		: m_ref_cnt(0)

   148

	{}

   149

   150

	virtual ~SimpleCountedObject()

   151

	{};

   152

   153

	virtual int32 AddRef();

   154

	virtual int32 Release();

   155

	virtual void FinalRelease() {};

   156

};

   157

   158

   159

   160

   161

#endif /* 0 */

   162

#endif /* COUNTEDPTR_HPP */