#define SGSharedPtr_HXX
#include "SGReferenced.hxx"
+#include <algorithm>
+
+template<typename T>
+class SGWeakPtr;
/// This class is a pointer proxy doing reference counting on the object
/// it is pointing to.
/// pretty much the same than this one at
/// http://dburns.dhs.org/OSG/Articles/RefPointers/RefPointers.html
-template<typename T>
-class SGWeakPtr;
-
template<typename T>
class SGSharedPtr {
public:
template<typename U>
SGSharedPtr(const SGSharedPtr<U>& p) : _ptr(p.get())
{ get(_ptr); }
+ template<typename U>
+ explicit SGSharedPtr(const SGWeakPtr<U>& p): _ptr(0)
+ { reset(p.lock().get()); }
~SGSharedPtr(void)
- { put(); }
+ { reset(); }
SGSharedPtr& operator=(const SGSharedPtr& p)
- { assign(p.get()); return *this; }
+ { reset(p.get()); return *this; }
template<typename U>
SGSharedPtr& operator=(const SGSharedPtr<U>& p)
- { assign(p.get()); return *this; }
+ { reset(p.get()); return *this; }
template<typename U>
SGSharedPtr& operator=(U* p)
- { assign(p); return *this; }
+ { reset(p); return *this; }
T* operator->(void) const
{ return _ptr; }
{ return _ptr; }
T* release()
{ T* tmp = _ptr; _ptr = 0; T::put(tmp); return tmp; }
+ void reset()
+ { if (!T::put(_ptr)) delete _ptr; _ptr = 0; }
+ void reset(T* p)
+ { SGSharedPtr(p).swap(*this); }
bool isShared(void) const
{ return T::shared(_ptr); }
{ return _ptr != (T*)0; }
void clear()
- { put(); }
- void swap(SGSharedPtr& sharedPtr)
- { T* tmp = _ptr; _ptr = sharedPtr._ptr; sharedPtr._ptr = tmp; }
+ { reset(); }
+ void swap(SGSharedPtr& other)
+ { std::swap(_ptr, other._ptr); }
private:
- void assign(T* p)
- { get(p); put(); _ptr = p; }
void assignNonRef(T* p)
- { put(); _ptr = p; }
+ { reset(); _ptr = p; }
void get(const T* p) const
{ T::get(p); }
- void put(void)
- { if (!T::put(_ptr)) delete _ptr; _ptr = 0; }
// The reference itself.
T* _ptr;
{
return SGSharedPtr<T>( static_cast<T*>(r.get()) );
}
+
+/**
+ * Compare two SGSharedPtr<T> objects for equality.
+ *
+ * @note Only pointer values are compared, not the actual objects they are
+ * pointing at.
+ */
+template<class T, class U>
+bool operator==(const SGSharedPtr<T>& lhs, const SGSharedPtr<U>& rhs)
+{
+ return lhs.get() == rhs.get();
+}
+
+/**
+ * Compare two SGSharedPtr<T> objects for equality.
+ *
+ * @note Only pointer values are compared, not the actual objects they are
+ * pointing at.
+ */
+template<class T, class U>
+bool operator!=(const SGSharedPtr<T>& lhs, const SGSharedPtr<U>& rhs)
+{
+ return lhs.get() != rhs.get();
+}
+
+/**
+ * Compare two SGSharedPtr<T> objects for weak ordering.
+ *
+ * @note Only pointer values are compared, not the actual objects they are
+ * pointing at.
+ * @note This allows using SGSharedPtr as key in associative containers like for
+ * example std::map and std::set.
+ */
+template<class T, class U>
+bool operator<(const SGSharedPtr<T>& lhs, const SGSharedPtr<U>& rhs)
+{
+ return lhs.get() < rhs.get();
+}
#endif