countedptr.hpp

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * 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.
 * 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.
 * 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/>.
 */
 
#ifndef COUNTEDPTR_HPP
#define COUNTEDPTR_HPP
 
template <class Tcls_>
class CCountedPtr {
public:
  typedef Tcls_ Tcls;
 
protected:
  Tcls *m_pT;
 
public:
  inline CCountedPtr(Tcls *pObj = nullptr) : m_pT(pObj)
  {
    AddRef();
  }
 
  inline CCountedPtr(const CCountedPtr &src) : m_pT(src.m_pT)
  {
    AddRef();
  }
 
  inline ~CCountedPtr()
  {
    Release();
  }
 
protected:
  inline void AddRef()
  {
    if (m_pT != nullptr) m_pT->AddRef();
  }
 
public:
  inline void Release()
  {
    if (m_pT != nullptr) {
      Tcls *pT = m_pT;
      m_pT = nullptr;
      pT->Release();
    }
  }
 
  inline const Tcls *operator->() const
  {
    assert(m_pT != nullptr);
    return m_pT;
  }
 
  inline Tcls *operator->()
  {
    assert(m_pT != nullptr);
    return m_pT;
  }
 
  inline operator const Tcls*() const
  {
    assert(m_pT == nullptr);
    return m_pT;
  }
 
  inline operator Tcls*()
  {
    return m_pT;
  }
 
  inline Tcls** operator&()
  {
    assert(m_pT == nullptr);
    return &m_pT;
  }
 
  inline CCountedPtr& operator=(Tcls *pT)
  {
    Assign(pT);
    return *this;
  }
 
  inline CCountedPtr& operator=(const CCountedPtr &src)
  {
    Assign(src.m_pT);
    return *this;
  }
 
  inline void Assign(Tcls *pT);
 
  inline bool IsNull() const
  {
    return m_pT == nullptr;
  }
 
  inline void Attach(Tcls *pT)
  {
    Release();
    m_pT = pT;
  }
 
  inline Tcls *Detach()
  {
    Tcls *pT = m_pT;
    m_pT = nullptr;
    return pT;
  }
};
 
template <class Tcls_>
inline void CCountedPtr<Tcls_>::Assign(Tcls *pT)
{
  /* if they are the same, we do nothing */
  if (pT != m_pT) {
    if (pT != nullptr) pT->AddRef();        // AddRef new pointer if any
    Tcls *pTold = m_pT;                  // save original ptr
    m_pT = pT;                           // update m_pT to new value
    if (pTold != nullptr) pTold->Release(); // release old ptr if any
  }
}
 
template <class T> struct AdaptT {
  T m_t;
 
  AdaptT(const T &t)
    : m_t(t)
  {}
 
  T& operator = (const T &t)
  {
    m_t = t;
    return t;
  }
 
  operator T& ()
  {
    return m_t;
  }
 
  operator const T& () const
  {
    return m_t;
  }
};
 
struct SimpleCountedObject {
  int32_t m_ref_cnt;
 
  SimpleCountedObject()
    : m_ref_cnt(0)
  {}
 
  virtual ~SimpleCountedObject()
  {}
 
  virtual int32_t AddRef();
  virtual int32_t Release();
  virtual void FinalRelease() {};
};
 
#endif /* COUNTEDPTR_HPP */