1 files changed, 31 insertions, 61 deletions

diff --git a/node/SharedPtr.hpp b/node/SharedPtr.hpp
index 1dd3b43d..2f0e50c9 100644
--- a/node/SharedPtr.hpp
+++ b/node/SharedPtr.hpp
@@ -1,6 +1,6 @@
 /*
  * ZeroTier One - Network Virtualization Everywhere
- * Copyright (C) 2011-2016  ZeroTier, Inc.  https://www.zerotier.com/
+ * Copyright (C) 2011-2018  ZeroTier, Inc.  https://www.zerotier.com/
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -14,6 +14,14 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * --
+ *
+ * You can be released from the requirements of the license by purchasing
+ * a commercial license. Buying such a license is mandatory as soon as you
+ * develop commercial closed-source software that incorporates or links
+ * directly against ZeroTier software without disclosing the source code
+ * of your own application.
  */
 
 #ifndef ZT_SHAREDPTR_HPP
@@ -25,41 +33,19 @@
 namespace ZeroTier {
 
 /**
- * Simple reference counted pointer
+ * Simple zero-overhead introspective reference counted pointer
  *
  * This is an introspective shared pointer. Classes that need to be reference
  * counted must list this as a 'friend' and must have a private instance of
- * AtomicCounter called __refCount. They should also have private destructors,
- * since only this class should delete them.
- *
- * Because this is introspective, it is safe to apply to a naked pointer
- * multiple times provided there is always at least one holding SharedPtr.
- *
- * Once C++11 is ubiquitous, this and a few other things like Thread might get
- * torn out for their standard equivalents.
+ * AtomicCounter called __refCount.
  */
 template<typename T>
 class SharedPtr
 {
 public:
-	SharedPtr()
-		throw() :
-		_ptr((T *)0)
-	{
-	}
-
-	SharedPtr(T *obj)
-		throw() :
-		_ptr(obj)
-	{
-		++obj->__refCount;
-	}
-
-	SharedPtr(const SharedPtr &sp)
-		throw() :
-		_ptr(sp._getAndInc())
-	{
-	}
+	SharedPtr() : _ptr((T *)0) {}
+	SharedPtr(T *obj) : _ptr(obj) { ++obj->__refCount; }
+	SharedPtr(const SharedPtr &sp) : _ptr(sp._getAndInc()) {}
 
 	~SharedPtr()
 	{
@@ -90,8 +76,9 @@ public:
 	 *
 	 * @param ptr Naked pointer to assign
 	 */
-	inline void setToUnsafe(T *ptr)
+	inline void set(T *ptr)
 	{
+		zero();
 		++ptr->__refCount;
 		_ptr = ptr;
 	}
@@ -102,21 +89,20 @@ public:
 	 * @param with Pointer to swap with
 	 */
 	inline void swap(SharedPtr &with)
-		throw()
 	{
 		T *tmp = _ptr;
 		_ptr = with._ptr;
 		with._ptr = tmp;
 	}
 
-	inline operator bool() const throw() { return (_ptr != (T *)0); }
-	inline T &operator*() const throw() { return *_ptr; }
-	inline T *operator->() const throw() { return _ptr; }
+	inline operator bool() const { return (_ptr != (T *)0); }
+	inline T &operator*() const { return *_ptr; }
+	inline T *operator->() const { return _ptr; }
 
 	/**
 	 * @return Raw pointer to held object
 	 */
-	inline T *ptr() const throw() { return _ptr; }
+	inline T *ptr() const { return _ptr; }
 
 	/**
 	 * Set this pointer to NULL
@@ -131,45 +117,29 @@ public:
 	}
 
 	/**
-	 * Set this pointer to NULL if this is the only pointer holding the object
-	 *
-	 * @return True if object was deleted and SharedPtr is now NULL (or was already NULL)
+	 * @return Number of references according to this object's ref count or 0 if NULL
 	 */
-	inline bool reclaimIfWeak()
+	inline int references()
 	{
-		if (_ptr) {
-			if (++_ptr->__refCount <= 2) {
-				if (--_ptr->__refCount <= 1) {
-					delete _ptr;
-					_ptr = (T *)0;
-					return true;
-				} else {
-					return false;
-				}
-			} else {
-				return false;
-			}
-		} else {
-			return true;
-		}
+		if (_ptr)
+			return _ptr->__refCount.load();
+		return 0;
 	}
 
-	inline bool operator==(const SharedPtr &sp) const throw() { return (_ptr == sp._ptr); }
-	inline bool operator!=(const SharedPtr &sp) const throw() { return (_ptr != sp._ptr); }
-	inline bool operator>(const SharedPtr &sp) const throw() { return (_ptr > sp._ptr); }
-	inline bool operator<(const SharedPtr &sp) const throw() { return (_ptr < sp._ptr); }
-	inline bool operator>=(const SharedPtr &sp) const throw() { return (_ptr >= sp._ptr); }
-	inline bool operator<=(const SharedPtr &sp) const throw() { return (_ptr <= sp._ptr); }
+	inline bool operator==(const SharedPtr &sp) const { return (_ptr == sp._ptr); }
+	inline bool operator!=(const SharedPtr &sp) const { return (_ptr != sp._ptr); }
+	inline bool operator>(const SharedPtr &sp) const { return (_ptr > sp._ptr); }
+	inline bool operator<(const SharedPtr &sp) const { return (_ptr < sp._ptr); }
+	inline bool operator>=(const SharedPtr &sp) const { return (_ptr >= sp._ptr); }
+	inline bool operator<=(const SharedPtr &sp) const { return (_ptr <= sp._ptr); }
 
 private:
 	inline T *_getAndInc() const
-		throw()
 	{
 		if (_ptr)
 			++_ptr->__refCount;
 		return _ptr;
 	}
-
 	T *_ptr;
 };