Add move semantics to Variant

[libs/core.git] / source / core / refptr.h

diff --git a/source/core/refptr.h b/source/core/refptr.h
index 28666ea816380e0547205a1f6d83b14da0e13016..1a164c1a90eafe69d3eab755b971400ff1f3e275 100644 (file)
--- a/source/core/refptr.h
+++ b/source/core/refptr.h
@@ -10,11 +10,13 @@ struct RefCounts
                KEEP = 1U<<(sizeof(unsigned)*8-1)
        };
 
-       unsigned count;
-
-       RefCounts(): count(0) { }
+       unsigned count = 0;
+       unsigned weak_count = 0;
 };
 
+template<typename T>
+class WeakPtr;
+
 
 /**
 A reference counting smart pointer.  When the last RefPtr for the data gets
@@ -24,16 +26,17 @@ template<typename T>
 class RefPtr
 {
        template<typename U> friend class RefPtr;
+       template<typename U> friend class WeakPtr;
 
 private:
-       T *data;
-       RefCounts *counts;
+       T *data = nullptr;
+       RefCounts *counts = nullptr;
 
 public:
-       RefPtr(): data(0), counts(0) { }
-       RefPtr(T *d): data(d), counts(data ? new RefCounts : 0) { incref(); }
+       RefPtr() = default;
+       RefPtr(T *d): data(d), counts(data ? new RefCounts : nullptr) { incref(); }
 private:
-       RefPtr(T *d, RefCounts *c): data(d), counts(d ? c : 0) { incref(); }
+       RefPtr(T *d, RefCounts *c): data(d), counts(d ? c : nullptr) { incref(); }
 
 public:
        /* Must have this or the compiler will generate a default copy-c'tor despite
@@ -43,6 +46,9 @@ public:
        template<typename U>
        RefPtr(const RefPtr<U> &p): data(p.data), counts(p.counts) { incref(); }
 
+       template<typename U>
+       RefPtr(const WeakPtr<U> &p): data(p.get()), counts(data ? p.counts : nullptr) { incref(); }
+
        ~RefPtr() { decref(); }
 
        RefPtr &operator=(T *);
@@ -53,6 +59,9 @@ public:
        template<typename U>
        RefPtr &operator=(const RefPtr<U> &p) { return assign(p); }
 
+       template<typename U>
+       RefPtr &operator=(const WeakPtr<U> &p) { return assign(RefPtr(p)); }
+
 private:
        template<typename U>
        RefPtr &assign(const RefPtr<U> &);
@@ -70,7 +79,7 @@ public:
        T *get() const { return data; }
        T &operator*() const { return *data; }
        T *operator->() const { return data; }
-       operator bool() const { return data!=0; }
+       explicit operator bool() const { return data; }
 
        unsigned refcount() const { return (data ? counts->count : 0); }
 
@@ -84,12 +93,54 @@ private:
 };
 
 
+template<typename T>
+class WeakPtr
+{
+       template<typename U> friend class RefPtr;
+       template<typename U> friend class WeakPtr;
+
+private:
+       T *data = nullptr;
+       RefCounts *counts = nullptr;
+
+public:
+       WeakPtr() = default;
+private:
+       WeakPtr(T *d, RefCounts *c): data(d), counts(d ? c : nullptr) { incref(); }
+
+public:
+       WeakPtr(const WeakPtr &p): data(p.get()), counts(data ? p.counts : nullptr) { incref(); }
+
+       template<typename U>
+       WeakPtr(const WeakPtr<U> &p): data(p.get()), counts(data ? p.counts : nullptr) { incref(); }
+
+       template<typename U>
+       WeakPtr(const RefPtr<U> &p): data(p.data), counts(p.counts) { incref(); }
+
+       WeakPtr &operator=(const WeakPtr &p) { return assign(p); }
+
+       template<typename U>
+       WeakPtr &operator=(const WeakPtr<U> &p) { return assign(p); }
+
+       template<typename U>
+       WeakPtr &operator=(const RefPtr<U> &p) { return assign(WeakPtr(p)); }
+
+private:
+       template<typename U>
+       WeakPtr &assign(const WeakPtr<U> &);
+
+       T *get() const { return (counts && counts->count ? data : nullptr); }
+       void incref() { if(counts) ++counts->weak_count; }
+       void decref();
+};
+
+
 template<typename T>
 RefPtr<T> &RefPtr<T>::operator=(T *d)
 {
        decref();
        data = d;
-       counts = (d ? new RefCounts : 0);
+       counts = (d ? new RefCounts : nullptr);
        incref();
        return *this;
 }
@@ -98,6 +149,9 @@ template<typename T>
 template<typename U>
 RefPtr<T> &RefPtr<T>::assign(const RefPtr<U> &p)
 {
+       if(static_cast<const void *>(&p)==this)
+               return *this;
+
        decref();
        data = p.data;
        counts = p.counts;
@@ -109,9 +163,9 @@ template<typename T>
 T *RefPtr<T>::release()
 {
        T *d = data;
-       data = 0;
+       data = nullptr;
        decref();
-       counts = 0;
+       counts = nullptr;
        return d;
 }
 
@@ -123,15 +177,45 @@ void RefPtr<T>::decref()
        if(!counts->count)
        {
                delete data;
-               delete counts;
-               data = 0;
-               counts = 0;
+               data = nullptr;
        }
        else if(counts->count==RefCounts::KEEP)
+               data = nullptr;
+       else
+               return;
+
+       if(!counts->weak_count)
+       {
+               delete counts;
+               counts = nullptr;
+       }
+}
+
+
+template<typename T>
+template<typename U>
+WeakPtr<T> &WeakPtr<T>::assign(const WeakPtr<U> &p)
+{
+       if(&p==this)
+               return *this;
+
+       decref();
+       data = p.get();
+       counts = (data ? p.counts : nullptr);
+       incref();
+       return *this;
+}
+
+template<typename T>
+void WeakPtr<T>::decref()
+{
+       if(!counts) return;
+       --counts->weak_count;
+       if(!counts->weak_count && (!counts->count || counts->count==RefCounts::KEEP))
        {
                delete counts;
-               data = 0;
-               counts = 0;
+               data = nullptr;
+               counts = nullptr;
        }
 }