AGS: AGS engine for ScummVM

common/ptr.h

@@ -38,16 +38,16 @@ namespace Common {
  * @{
  */
 
-class SharedPtrDeletionInternal {
+class BasePtrDeletionInternal {
 public:
-	virtual ~SharedPtrDeletionInternal() {}
+	virtual ~BasePtrDeletionInternal() {}
 };
 
 template<class T>
-class SharedPtrDeletionImpl : public SharedPtrDeletionInternal {
+class BasePtrDeletionImpl : public BasePtrDeletionInternal {
 public:
-	SharedPtrDeletionImpl(T *ptr) : _ptr(ptr) {}
-	~SharedPtrDeletionImpl() {
+	BasePtrDeletionImpl(T *ptr) : _ptr(ptr) {}
+	~BasePtrDeletionImpl() {
 		STATIC_ASSERT(sizeof(T) > 0, SharedPtr_cannot_delete_incomplete_type);
 		delete _ptr;
 	}
@@ -56,15 +56,180 @@ class SharedPtrDeletionImpl : public SharedPtrDeletionInternal {
 };
 
 template<class T, class DL>
-class SharedPtrDeletionDeleterImpl : public SharedPtrDeletionInternal {
+class BasePtrDeletionDeleterImpl : public BasePtrDeletionInternal {
 public:
-	SharedPtrDeletionDeleterImpl(T *ptr, DL d) : _ptr(ptr), _deleter(d) {}
-	~SharedPtrDeletionDeleterImpl() { _deleter(_ptr); }
+	BasePtrDeletionDeleterImpl(T *ptr, DL d) : _ptr(ptr), _deleter(d) {}
+	~BasePtrDeletionDeleterImpl() { _deleter(_ptr); }
 private:
 	T *_ptr;
 	DL _deleter;
 };
 
+/**
+ * A base class for both SharedPtr and WeakPtr.
+ *
+ * This base class encapsulates the logic for the reference counter
+ * used by both.
+ */
+template<class T>
+class BasePtr : public SafeBool<BasePtr<T> > {
+#if !defined(__GNUC__) || GCC_ATLEAST(3, 0)
+	template<class T2> friend class BasePtr;
+#endif
+public:
+	typedef int RefValue;
+	typedef T ValueType;
+	typedef T *PointerType;
+	typedef T &ReferenceType;
+
+	BasePtr() : _refCount(nullptr), _deletion(nullptr), _pointer(nullptr) {
+	}
+
+	explicit BasePtr(nullptr_t) : _refCount(nullptr), _deletion(nullptr), _pointer(nullptr) {
+	}
+
+	template<class T2>
+	explicit BasePtr(T2 *p) : _refCount(new RefValue(1)), _deletion(new BasePtrDeletionImpl<T2>(p)), _pointer(p) {
+	}
+
+	template<class T2, class DL>
+	BasePtr(T2 *p, DL d) : _refCount(new RefValue(1)), _deletion(new BasePtrDeletionDeleterImpl<T2, DL>(p, d)), _pointer(p) {
+	}
+
+	BasePtr(const BasePtr &r) : _refCount(r._refCount), _deletion(r._deletion), _pointer(r._pointer) {
+		if (_refCount)
+			++(*_refCount);
+	}
+	template<class T2>
+	BasePtr(const BasePtr<T2> &r) : _refCount(r._refCount), _deletion(r._deletion), _pointer(r._pointer) {
+		if (_refCount) ++(*_refCount);
+	}
+
+	~BasePtr() {
+		decRef();
+	}
+
+	/**
+	 * Implicit conversion operator to bool for convenience, to make
+	 * checks like "if (sharedPtr) ..." possible.
+	 */
+	bool operator_bool() const {
+		return _pointer != nullptr;
+	}
+
+	/**
+	 * Returns the number of references to the assigned pointer.
+	 * This should just be used for debugging purposes.
+	 */
+	RefValue refCount() const {
+		return _refCount ? *_refCount : 0;
+	}
+
+	/**
+	 * Returns whether the referenced object isn't valid
+	 */
+	bool expired() const {
+		return !_refCount;
+	}
+
+	/**
+	 * Checks if the object is the only object refering
+	 * to the assigned pointer. This should just be used for
+	 * debugging purposes.
+	 */
+	bool unique() const {
+		return refCount() == 1;
+	}
+
+	BasePtr &operator=(const BasePtr &r) {
+		reset(r);
+		return *this;
+	}
+
+	template<class T2>
+	BasePtr &operator=(const BasePtr<T2> &r) {
+		reset(r);
+		return *this;
+	}
+
+	/**
+	 * Resets the object to a NULL pointer.
+	 */
+	void reset() {
+		decRef();
+		_deletion = nullptr;
+		_refCount = nullptr;
+		_pointer = nullptr;
+	}
+
+	/**
+	 * Resets the object to the specified pointer
+	 */
+	void reset(const BasePtr &r) {
+		if (r._refCount)
+			++(*r._refCount);
+		decRef();
+
+		_refCount = r._refCount;
+		_deletion = r._deletion;
+		_pointer = r._pointer;
+	}
+
+	/**
+	 * Resets the object to the specified pointer
+	 */
+	template<class T2>
+	void reset(const BasePtr<T2> &r) {
+		if (r._refCount)
+			++(*r._refCount);
+		decRef();
+
+		_refCount = r._refCount;
+		_deletion = r._deletion;
+		_pointer = r._pointer;
+	}
+
+	/**
+	 * Resets the object to the specified pointer
+	 */
+	void reset(T *ptr) {
+		reset(BasePtr<T>(ptr));
+	}
+
+protected:
+	RefValue *_refCount;
+	BasePtrDeletionInternal *_deletion;
+	PointerType _pointer;
+protected:
+	/**
+	 * Decrements the reference count to the stored pointer, and deletes it if
+	 * there are no longer any references to it
+	 */
+	void decRef() {
+		if (_refCount) {
+			--(*_refCount);
+			if (!*_refCount) {
+				delete _refCount;
+				delete _deletion;
+				_deletion = nullptr;
+				_refCount = nullptr;
+				_pointer = nullptr;
+			}
+		}
+	}
+
+	/**
+	 * Increments the reference count to the stored pointer
+	 */
+	void incRef() {
+		if (_refCount)
+			++*_refCount;
+	}
+};
+
+template<class T>
+class WeakPtr;
+
 /**
  * A simple shared pointer implementation modelled after boost.
  *
@@ -84,7 +249,7 @@ class SharedPtrDeletionDeleterImpl : public SharedPtrDeletionInternal {
  * as for a normal pointer. If you need to access the plain pointer value
  * itself later on use the get method. The class also supplies a operator
  * ->, which does the same as the -> operator on a normal pointer.
- *
+ * 
  * Be sure you are using new to initialize the pointer you want to manage.
  * If you do not use new for allocating, you have to supply a deleter as
  * second parameter when creating a SharedPtr object. The deleter has to
@@ -107,123 +272,87 @@ class SharedPtrDeletionDeleterImpl : public SharedPtrDeletionInternal {
  * a plain pointer is only possible via SharedPtr::get.
  */
 template<class T>
-class SharedPtr : public SafeBool<SharedPtr<T> > {
-#if !defined(__GNUC__) || GCC_ATLEAST(3, 0)
-	template<class T2> friend class SharedPtr;
-#endif
+class SharedPtr : public BasePtr<T> {
 public:
-	typedef int RefValue;
-	typedef T ValueType;
-	typedef T *PointerType;
-	typedef T &ReferenceType;
+	using ReferenceType = typename BasePtr<T>::ReferenceType;
+	using PointerType = typename BasePtr<T>::PointerType;
 
-	SharedPtr() : _refCount(nullptr), _deletion(nullptr), _pointer(nullptr) {}
-
-	template<class T2>
-	explicit SharedPtr(T2 *p) : _refCount(new RefValue(1)), _deletion(new SharedPtrDeletionImpl<T2>(p)), _pointer(p) {}
+	SharedPtr() : BasePtr<T>() {
+	}
 
-	template<class T2, class DL>
-	SharedPtr(T2 *p, DL d) : _refCount(new RefValue(1)), _deletion(new SharedPtrDeletionDeleterImpl<T2, DL>(p, d)), _pointer(p) {}
+	SharedPtr(nullptr_t) : BasePtr<T>() {
+	}
 
-	SharedPtr(const SharedPtr &r) : _refCount(r._refCount), _deletion(r._deletion), _pointer(r._pointer) { if (_refCount) ++(*_refCount); }
 	template<class T2>
-	SharedPtr(const SharedPtr<T2> &r) : _refCount(r._refCount), _deletion(r._deletion), _pointer(r._pointer) { if (_refCount) ++(*_refCount); }
-
-	~SharedPtr() { decRef(); }
+	explicit SharedPtr(T2 *p) : BasePtr<T>(p) {
+	}
 
-	SharedPtr &operator=(const SharedPtr &r) {
-		if (r._refCount)
-			++(*r._refCount);
-		decRef();
+	template<class T2, class DL>
+	SharedPtr(T2 *p, DL d) : BasePtr<T>(p, d) {
+	}
 
-		_refCount = r._refCount;
-		_deletion = r._deletion;
-		_pointer = r._pointer;
+	SharedPtr(const SharedPtr<T> &r) : BasePtr<T>(r) {
+	}
 
-		return *this;
+	SharedPtr(const WeakPtr<T> &r) : BasePtr<T>(r) {
 	}
 
 	template<class T2>
-	SharedPtr &operator=(const SharedPtr<T2> &r) {
-		if (r._refCount)
-			++(*r._refCount);
-		decRef();
-
-		_refCount = r._refCount;
-		_deletion = r._deletion;
-		_pointer = r._pointer;
-
-		return *this;
+	SharedPtr(const SharedPtr<T2> &r) : BasePtr<T>(r) {
 	}
 
-	ReferenceType operator*() const { assert(_pointer); return *_pointer; }
-	PointerType operator->() const { assert(_pointer); return _pointer; }
+	T &operator*() const { assert(this->_pointer); return *this->_pointer; }
+	T *operator->() const { assert(this->_pointer); return this->_pointer; }
 
 	/**
 	 * Returns the plain pointer value. Be sure you know what you
 	 * do if you are continuing to use that pointer.
 	 *
 	 * @return the pointer the SharedPtr object manages
 	 */
-	PointerType get() const { return _pointer; }
+	PointerType get() const { return this->_pointer; }
 
-	/**
-	 * Implicit conversion operator to bool for convenience, to make
-	 * checks like "if (sharedPtr) ..." possible.
-	 */
-	bool operator_bool() const { return _pointer != nullptr; }
+	template<class T2>
+	bool operator==(const SharedPtr<T2> &r) const {
+		return this->_pointer == r.get();
+	}
 
-	/**
-	 * Checks if the SharedPtr object is the only object refering
-	 * to the assigned pointer. This should just be used for
-	 * debugging purposes.
-	 */
-	bool unique() const { return refCount() == 1; }
+	template<class T2>
+	bool operator!=(const SharedPtr<T2> &r) const {
+		return this->_pointer != r.get();
+	}
+};
 
-	/**
-	 * Resets the SharedPtr object to a NULL pointer.
-	 */
-	void reset() {
-		decRef();
-		_deletion = nullptr;
-		_refCount = nullptr;
-		_pointer = nullptr;
+/**
+ * Implements a smart pointer that holds a non-owning ("weak") refrence to
+ * a pointer. It needs to be converted to a SharedPtr to access it.
+ */
+template<class T>
+class WeakPtr : public BasePtr<T> {
+public:
+	WeakPtr() : BasePtr<T>() {
+	}
+
+	WeakPtr(nullptr_t) : BasePtr<T>() {
 	}
 
 	template<class T2>
-	bool operator==(const SharedPtr<T2> &r) const {
-		return _pointer == r.get();
+	explicit WeakPtr(T2 *p) : BasePtr<T>(p) {
+	}
+
+	WeakPtr(const BasePtr<T> &r) : BasePtr<T>(r) {
 	}
 
 	template<class T2>
-	bool operator!=(const SharedPtr<T2> &r) const {
-		return _pointer != r.get();
+	WeakPtr(const BasePtr<T2> &r) : BasePtr<T>(r) {
 	}
 
 	/**
-	 * Returns the number of references to the assigned pointer.
-	 * This should just be used for debugging purposes.
+	 * Creates a SharedPtr that manages the referenced object
 	 */
-	RefValue refCount() const { return _refCount ? *_refCount : 0; }
-#if !defined(__GNUC__) || GCC_ATLEAST(3, 0)
-private:
-#endif
-	void decRef() {
-		if (_refCount) {
-			--(*_refCount);
-			if (!*_refCount) {
-				delete _refCount;
-				delete _deletion;
-				_deletion = nullptr;
-				_refCount = nullptr;
-				_pointer = nullptr;
-			}
-		}
+	SharedPtr<T> lock() const {
+		return SharedPtr<T>(*this);
 	}
-
-	RefValue *_refCount;
-	SharedPtrDeletionInternal *_deletion;
-	PointerType _pointer;
 };
 
 template <typename T>