1

/* $Id$ */

     2

     5

#ifndef  AUTOCOPYPTR_HPP

     6

#define  AUTOCOPYPTR_HPP

     7

     8

#if 0 // reenable when needed

     9

/** CAutoCopyPtrT - kind of CoW (Copy on Write) pointer.

    10

 *  It is non-invasive smart pointer (reference counter is held outside

    11

 *  of Tdata).

    12

 *  When copied, its new copy shares the same underlaying structure Tdata.

    13

 *  When dereferenced, its behaviour depends on 2 factors:

    14

 *     - whether the data is shared (used by more than one pointer)

    15

 *     - type of access (read/write)

    16

 *    When shared pointer is dereferenced for write, new clone of Tdata

    17

 *  is made first.

    18

 *  Can't be used for polymorphic data types (interfaces).

    19

 */

    20

template <class Tdata_>

    21

class CAutoCopyPtrT {

    22

protected:

    23

	typedef Tdata_ Tdata;

    24

    25

	struct CItem {

    26

		int     m_ref_cnt;  ///< reference counter

    27

		Tdata   m_data;     ///< custom data itself

    28

    29

		FORCEINLINE CItem()                  : m_ref_cnt(1)                     {};

    30

		FORCEINLINE CItem(const Tdata& data) : m_ref_cnt(1), m_data(data)       {};

    31

		FORCEINLINE CItem(const CItem& src)  : m_ref_cnt(1), m_data(src.m_data) {};

    32

	};

    33

    34

	mutable CItem* m_pI; ///< points to the ref-counted data

    35

    36

public:

    37

	FORCEINLINE CAutoCopyPtrT() : m_pI(NULL) {};

    38

	FORCEINLINE CAutoCopyPtrT(const Tdata& data) : m_pI(new CItem(data)) {};

    39

	FORCEINLINE CAutoCopyPtrT(const CAutoCopyPtrT& src) : m_pI(src.m_pI) {if (m_pI != NULL) m_pI->m_ref_cnt++;}

    40

	FORCEINLINE ~CAutoCopyPtrT() {if (m_pI == NULL || (--m_pI->m_ref_cnt) > 0) return; delete m_pI; m_pI = NULL;}

    41

    42

	/** data accessor (read only) */

    43

	FORCEINLINE const Tdata& GetDataRO() const {if (m_pI == NULL) m_pI = new CItem(); return m_pI->m_data;}

    44

	/** data accessor (read / write) */

    45

	FORCEINLINE Tdata& GetDataRW() {CloneIfShared(); if (m_pI == NULL) m_pI = new CItem(); return m_pI->m_data;}

    46

    47

	/** clone data if it is shared */

    48

	FORCEINLINE void CloneIfShared()

    49

	{

    50

		if (m_pI != NULL && m_pI->m_ref_cnt > 1) {

    51

			// we share data item with somebody, clone it to become an exclusive owner

    52

			CItem* pNewI = new CItem(*m_pI);

    53

			m_pI->m_ref_cnt--;

    54

			m_pI = pNewI;

    55

		}

    56

	}

    57

    58

	/** assign pointer from the other one (maintaining ref counts) */

    59

	FORCEINLINE void Assign(const CAutoCopyPtrT& src)

    60

	{

    61

		if (m_pI == src.m_pI) return;

    62

		if (m_pI != NULL && (--m_pI->m_ref_cnt) <= 0) delete m_pI;

    63

		m_pI = src.m_pI;

    64

		if (m_pI != NULL) m_pI->m_ref_cnt++;

    65

	}

    66

    67

	/** dereference operator (read only) */

    68

	FORCEINLINE const Tdata* operator -> () const {return &GetDataRO();}

    69

	/** dereference operator (read / write) */

    70

	FORCEINLINE Tdata* operator -> () {return &GetDataRW();}

    71

    72

	/** assignment operator */

    73

	FORCEINLINE CAutoCopyPtrT& operator = (const CAutoCopyPtrT& src) {Assign(src); return *this;}

    74

    75

	/** forwarding 'lower then' operator to the underlaying items */

    76

	FORCEINLINE bool operator < (const CAutoCopyPtrT& other) const

    77

	{

    78

		assert(m_pI != NULL);

    79

		assert(other.m_pI != NULL);

    80

		return (m_pI->m_data) < (other.m_pI->m_data);

    81

	}

    82

};

    83

    84

#endif /* 0 */

    85

#endif /* AUTOCOPYPTR_HPP */