src/misc/countedptr.hpp

   1 /*
   2  * This file is part of OpenTTD.
   3  * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
   4  * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   5  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
   6  */
   7
   8 /** @file countedptr.hpp CCountedPtr - smart pointer implementation. */
   9
  10 #ifndef COUNTEDPTR_HPP
  11 #define COUNTEDPTR_HPP
  12
  13 /**
  14  * CCountedPtr - simple reference counting smart pointer.
  15  *
  16  *     One of the standard ways how to maintain object's lifetime.
  17  *
  18  *     See http://ootips.org/yonat/4dev/smart-pointers.html for more
  19  *   general info about smart pointers.
  20  *
  21  *     This class implements ref-counted pointer for objects/interfaces that
  22  *   support AddRef() and Release() methods.
  23  */
  24 template <class Tcls_>
  25 class CCountedPtr {
  26         /** redefine the template argument to make it visible for derived classes */
  27 public:
  28         typedef Tcls_ Tcls;
  29
  30 protected:
  31         /** here we hold our pointer to the target */
  32         Tcls *m_pT;
  33
  34 public:
  35         /** default (nullptr) construct or construct from a raw pointer */
  36         inline CCountedPtr(Tcls *pObj = nullptr) : m_pT(pObj)
  37         {
  38                 AddRef();
  39         }
  40
  41         /** copy constructor (invoked also when initializing from another smart ptr) */
  42         inline CCountedPtr(const CCountedPtr &src) : m_pT(src.m_pT)
  43         {
  44                 AddRef();
  45         }
  46
  47         /** destructor releasing the reference */
  48         inline ~CCountedPtr()
  49         {
  50                 Release();
  51         }
  52
  53 protected:
  54         /** add one ref to the underlying object */
  55         inline void AddRef()
  56         {
  57                 if (m_pT != nullptr) m_pT->AddRef();
  58         }
  59
  60 public:
  61         /** release smart pointer (and decrement ref count) if not null */
  62         inline void Release()
  63         {
  64                 if (m_pT != nullptr) {
  65                         Tcls *pT = m_pT;
  66                         m_pT = nullptr;
  67                         pT->Release();
  68                 }
  69         }
  70
  71         /** dereference of smart pointer - const way */
  72         inline const Tcls *operator->() const
  73         {
  74                 assert(m_pT != nullptr);
  75                 return m_pT;
  76         }
  77
  78         /** dereference of smart pointer - non const way */
  79         inline Tcls *operator->()
  80         {
  81                 assert(m_pT != nullptr);
  82                 return m_pT;
  83         }
  84
  85         /** raw pointer casting operator - const way */
  86         inline operator const Tcls*() const
  87         {
  88                 assert(m_pT == nullptr);
  89                 return m_pT;
  90         }
  91
  92         /** raw pointer casting operator - non-const way */
  93         inline operator Tcls*()
  94         {
  95                 return m_pT;
  96         }
  97
  98         /** operator & to support output arguments */
  99         inline Tcls** operator&()
 100         {
 101                 assert(m_pT == nullptr);
 102                 return &m_pT;
 103         }
 104
 105         /** assignment operator from raw ptr */
 106         inline CCountedPtr& operator=(Tcls *pT)
 107         {
 108                 Assign(pT);
 109                 return *this;
 110         }
 111
 112         /** assignment operator from another smart ptr */
 113         inline CCountedPtr& operator=(const CCountedPtr &src)
 114         {
 115                 Assign(src.m_pT);
 116                 return *this;
 117         }
 118
 119         /** assignment operator helper */
 120         inline void Assign(Tcls *pT);
 121
 122         /** one way how to test for nullptr value */
 123         inline bool IsNull() const
 124         {
 125                 return m_pT == nullptr;
 126         }
 127
 128         /** assign pointer w/o incrementing ref count */
 129         inline void Attach(Tcls *pT)
 130         {
 131                 Release();
 132                 m_pT = pT;
 133         }
 134
 135         /** detach pointer w/o decrementing ref count */
 136         inline Tcls *Detach()
 137         {
 138                 Tcls *pT = m_pT;
 139                 m_pT = nullptr;
 140                 return pT;
 141         }
 142 };
 143
 144 template <class Tcls_>
 145 inline void CCountedPtr<Tcls_>::Assign(Tcls *pT)
 146 {
 147         /* if they are the same, we do nothing */
 148         if (pT != m_pT) {
 149                 if (pT != nullptr) pT->AddRef();        // AddRef new pointer if any
 150                 Tcls *pTold = m_pT;                  // save original ptr
 151                 m_pT = pT;                           // update m_pT to new value
 152                 if (pTold != nullptr) pTold->Release(); // release old ptr if any
 153         }
 154 }
 155
 156 /**
 157  * Adapter wrapper for CCountedPtr like classes that can't be used directly by stl
 158  * collections as item type. For example CCountedPtr has overloaded operator & which
 159  * prevents using CCountedPtr in stl collections (i.e. std::list<CCountedPtr<MyType> >)
 160  */
 161 template <class T> struct AdaptT {
 162         T m_t;
 163
 164         /** construct by wrapping the given object */
 165         AdaptT(const T &t)
 166                 : m_t(t)
 167         {}
 168
 169         /** assignment operator */
 170         T& operator = (const T &t)
 171         {
 172                 m_t = t;
 173                 return t;
 174         }
 175
 176         /** type-cast operator (used when AdaptT is used instead of T) */
 177         operator T& ()
 178         {
 179                 return m_t;
 180         }
 181
 182         /** const type-cast operator (used when AdaptT is used instead of const T) */
 183         operator const T& () const
 184         {
 185                 return m_t;
 186         }
 187 };
 188
 189 /**
 190  * Simple counted object. Use it as base of your struct/class if you want to use
 191  *  basic reference counting. Your struct/class will destroy and free itself when
 192  *  last reference to it is released (using Release() method). The initial reference
 193  *  count (when it is created) is zero (don't forget AddRef() at least one time if
 194  *  not using CCountedPtr<T>.
 195  *
 196  *  @see misc/countedobj.cpp for implementation.
 197  */
 198 struct SimpleCountedObject {
 199         int32_t m_ref_cnt;
 200
 201         SimpleCountedObject()
 202                 : m_ref_cnt(0)
 203         {}
 204
 205         virtual ~SimpleCountedObject()
 206         {}
 207
 208         virtual int32_t AddRef();
 209         virtual int32_t Release();
 210         virtual void FinalRelease() {};
 211 };
 212
 213 #endif /* COUNTEDPTR_HPP */