From 5e73dce0e71791b87e5b096a890578eefcc26639 Mon Sep 17 00:00:00 2001
From: KUDr <kudr@openttd.org>
Date: Sat, 27 May 2006 16:12:16 +0000
Subject: (svn r4987) Feature: Merged YAPF into trunk. Thanks to devs for
 continuous support and users for testing.

---
 yapf/countedptr.hpp | 99 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 99 insertions(+)
 create mode 100644 yapf/countedptr.hpp

(limited to 'yapf/countedptr.hpp')

diff --git a/yapf/countedptr.hpp b/yapf/countedptr.hpp
new file mode 100644
index 000000000..7d9f61fc2
--- /dev/null
+++ b/yapf/countedptr.hpp
@@ -0,0 +1,99 @@
+/* $Id$ */
+
+#ifndef COUNTEDPTR_HPP
+#define COUNTEDPTR_HPP
+
+/** @file CCountedPtr - smart pointer implementation */
+
+/** CCountedPtr - simple reference counting smart pointer.
+*
+*     One of the standard ways how to maintain object's lifetime.
+*
+*     See http://ootips.org/yonat/4dev/smart-pointers.html for more
+*   general info about smart pointers.
+*
+*     This class implements ref-counted pointer for objects/interfaces that
+*   support AddRef() and Release() methods.
+*/
+template <class Tcls_>
+class CCountedPtr {
+	/** redefine the template argument to make it visible for derived classes */
+public:
+	typedef Tcls_ Tcls;
+
+protected:
+	/** here we hold our pointer to the target */
+	Tcls* m_pT;
+
+public:
+	/** default (NULL) construct or construct from a raw pointer */
+	FORCEINLINE CCountedPtr(Tcls* pObj = NULL) : m_pT(pObj) {AddRef();};
+
+	/** copy constructor (invoked also when initializing from another smart ptr) */
+	FORCEINLINE CCountedPtr(const CCountedPtr& src) : m_pT(src.m_pT) {AddRef();};
+
+	/** destructor releasing the reference */
+	FORCEINLINE ~CCountedPtr() {Release();};
+
+protected:
+	/** add one ref to the underlaying object */
+	FORCEINLINE void AddRef() {if (m_pT != NULL) m_pT->AddRef();}
+
+public:
+	/** release smart pointer (and decrement ref count) if not null */
+	FORCEINLINE void Release() {if (m_pT != NULL) {m_pT->Release(); m_pT = NULL;}}
+
+	/** dereference of smart pointer - const way */
+	FORCEINLINE const Tcls* operator -> () const {assert(m_pT != NULL); return m_pT;};
+
+	/** dereference of smart pointer - non const way */
+	FORCEINLINE Tcls* operator -> () {assert(m_pT != NULL); return m_pT;};
+
+	/** raw pointer casting operator - const way */
+	FORCEINLINE operator const Tcls*() const {assert(m_pT == NULL); return m_pT;}
+
+	/** raw pointer casting operator - non-const way */
+	FORCEINLINE operator Tcls*() {assert(m_pT == NULL); return m_pT;}
+
+	/** operator & to support output arguments */
+	FORCEINLINE Tcls** operator &() {assert(m_pT == NULL); return &m_pT;}
+
+	/** assignment operator from raw ptr */
+	FORCEINLINE CCountedPtr& operator = (Tcls* pT) {Assign(pT); return *this;}
+
+	/** assignment operator from another smart ptr */
+	FORCEINLINE CCountedPtr& operator = (CCountedPtr& src) {Assign(src.m_pT); return *this;}
+
+	/** assignment operator helper */
+	FORCEINLINE void Assign(Tcls* pT);
+
+	/** one way how to test for NULL value */
+	FORCEINLINE bool IsNull() const {return m_pT == NULL;}
+
+	/** another way how to test for NULL value */
+	FORCEINLINE bool operator == (const CCountedPtr& sp) const {return m_pT == sp.m_pT;}
+
+	/** yet another way how to test for NULL value */
+	FORCEINLINE bool operator != (const CCountedPtr& sp) const	{return m_pT != sp.m_pT;}
+
+	/** assign pointer w/o incrementing ref count */
+	FORCEINLINE void Attach(Tcls* pT) {Release(); m_pT = pT;}
+
+	/** detach pointer w/o decrementing ref count */
+	FORCEINLINE Tcls* Detach() {Tcls* pT = m_pT; m_pT = NULL; return pT;}
+};
+
+template <class Tcls_>
+FORCEINLINE void CCountedPtr<Tcls_>::Assign(Tcls* pT)
+{
+	// if they are the same, we do nothing
+	if (pT != m_pT) {
+		if (pT) 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) pTold->Release(); // release old ptr if any
+	}
+}
+
+
+#endif /* COUNTEDPTR_HPP */
-- 
cgit v1.2.3-70-g09d2