1

/* $Id$ */

     2

     3

#ifndef COUNTEDPTR_HPP

     4

#define COUNTEDPTR_HPP

     5

     6

#if 0 // reenable when needed

     7

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

     8

     9

/** CCountedPtr - simple reference counting smart pointer.

    10

 *

    11

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

    12

 *

    13

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

    14

 *   general info about smart pointers.

    15

 *

    16

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

    17

 *   support AddRef() and Release() methods.

    18

 */

    19

template <class Tcls_>

    20

class CCountedPtr {

    21

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

    22

public:

    23

	typedef Tcls_ Tcls;

    24

    25

protected:

    26

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

    27

	Tcls* m_pT;

    28

    29

public:

    30

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

    31

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

    32

    33

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

    34

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

    35

    36

	/** destructor releasing the reference */

    37

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

    38

    39

protected:

    40

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

    41

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

    42

    43

public:

    44

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

    45

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

    46

    47

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

    48

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

    49

    50

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

    51

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

    52

    53

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

    54

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

    55

    56

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

    57

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

    58

    59

	/** operator & to support output arguments */

    60

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

    61

    62

	/** assignment operator from raw ptr */

    63

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

    64

    65

	/** assignment operator from another smart ptr */

    66

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

    67

    68

	/** assignment operator helper */

    69

	FORCEINLINE void Assign(Tcls* pT);

    70

    71

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

    72

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

    73

    74

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

    75

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

    76

    77

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

    78

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

    79

    80

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

    81

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

    82

    83

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

    84

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

    85

};

    86

    87

template <class Tcls_>

    88

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

    89

{

    90

	// if they are the same, we do nothing

    91

	if (pT != m_pT) {

    92

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

    93

		Tcls* pTold = m_pT;          // save original ptr

    94

		m_pT = pT;                   // update m_pT to new value

    95

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

    96

	}

    97

}

    98

    99

#endif /* 0 */

   100

#endif /* COUNTEDPTR_HPP */