X-Git-Url: http://git.tdb.fi/?p=libs%2Fcore.git;a=blobdiff_plain;f=source%2Fcore%2Frefptr.h;h=79401dce5be40094a9f55212c0c3fb4abd8f7dc9;hp=dd07256d79d45ca1fa1ff558eacab32ca925ed79;hb=HEAD;hpb=cfc8e0b7b15ea505bd6a6a9599cbc5ce1e316963 diff --git a/source/core/refptr.h b/source/core/refptr.h index dd07256..1a164c1 100644 --- a/source/core/refptr.h +++ b/source/core/refptr.h @@ -1,15 +1,23 @@ -/* $Id$ - -This file is part of libmspcore -Copyright © 2006-2007 Mikko Rasa, Mikkosoft Productions -Distributed under the LGPL -*/ - #ifndef MSP_CORE_REFPTR_H_ #define MSP_CORE_REFPTR_H_ namespace Msp { +struct RefCounts +{ + enum + { + KEEP = 1U<<(sizeof(unsigned)*8-1) + }; + + unsigned count = 0; + unsigned weak_count = 0; +}; + +template +class WeakPtr; + + /** A reference counting smart pointer. When the last RefPtr for the data gets destroyed, the data is deleted as well. @@ -17,68 +25,199 @@ destroyed, the data is deleted as well. template class RefPtr { + template friend class RefPtr; + template friend class WeakPtr; + +private: + T *data = nullptr; + RefCounts *counts = nullptr; + public: - RefPtr(): data(0), count(0) { } - RefPtr(T *d): data(d), count(0) { if(data) count=new unsigned(1); } - RefPtr(const RefPtr &p): data(p.data), count(p.count) { incref(); } - RefPtr &operator=(const RefPtr &p) - { - decref(); - data=p.data; - count=p.count; - incref(); - return *this; - } - + RefPtr() = default; + RefPtr(T *d): data(d), counts(data ? new RefCounts : nullptr) { incref(); } +private: + 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 + the template version */ + RefPtr(const RefPtr &p): data(p.data), counts(p.counts) { incref(); } + + template + RefPtr(const RefPtr &p): data(p.data), counts(p.counts) { incref(); } + + template + RefPtr(const WeakPtr &p): data(p.get()), counts(data ? p.counts : nullptr) { incref(); } + ~RefPtr() { decref(); } - /** - Makes the RefPtr release its reference of the data. Note that if there are - other RefPtrs left with the same data, it might still get deleted - automatically. - */ - T *release() - { - T *d=data; - data=0; - decref(); - count=0; - return d; - } + RefPtr &operator=(T *); + + // Likewise for the assignment operator + RefPtr &operator=(const RefPtr &p) { return assign(p); } - T *get() const { return data; } - T &operator*() const { return *data; } + template + RefPtr &operator=(const RefPtr &p) { return assign(p); } + + template + RefPtr &operator=(const WeakPtr &p) { return assign(RefPtr(p)); } + +private: + template + RefPtr &assign(const RefPtr &); + +public: + /** Makes the RefPtr release its reference of the data without deleting it. + Note that if there are other RefPtrs left with the same data, it might + still get deleted automatically. */ + T *release(); + + /** Marks the data to not be deleted. This affects all RefPtrs with the + same data. */ + void keep() { if(counts) counts->count |= RefCounts::KEEP; } + + 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); } template - static RefPtr cast_dynamic(const RefPtr &p) { return RefPtr(dynamic_cast(p.data), p.count); } + static RefPtr cast_dynamic(const RefPtr &p) + { return RefPtr(dynamic_cast(p.data), p.counts); } + +private: + void incref() { if(counts) ++counts->count; } + void decref(); +}; + + +template +class WeakPtr +{ template friend class RefPtr; + template friend class WeakPtr; + +private: + T *data = nullptr; + RefCounts *counts = nullptr; + +public: + WeakPtr() = default; private: - T *data; - unsigned *count; + 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 + WeakPtr(const WeakPtr &p): data(p.get()), counts(data ? p.counts : nullptr) { incref(); } + + template + WeakPtr(const RefPtr &p): data(p.data), counts(p.counts) { incref(); } + + WeakPtr &operator=(const WeakPtr &p) { return assign(p); } + + template + WeakPtr &operator=(const WeakPtr &p) { return assign(p); } + + template + WeakPtr &operator=(const RefPtr &p) { return assign(WeakPtr(p)); } + +private: + template + WeakPtr &assign(const WeakPtr &); + + T *get() const { return (counts && counts->count ? data : nullptr); } + void incref() { if(counts) ++counts->weak_count; } + void decref(); +}; + + +template +RefPtr &RefPtr::operator=(T *d) +{ + decref(); + data = d; + counts = (d ? new RefCounts : nullptr); + incref(); + return *this; +} + +template +template +RefPtr &RefPtr::assign(const RefPtr &p) +{ + if(static_cast(&p)==this) + return *this; - RefPtr(T *d, unsigned *c): data(d), count(c) { incref(); } + decref(); + data = p.data; + counts = p.counts; + incref(); + return *this; +} - void incref() +template +T *RefPtr::release() +{ + T *d = data; + data = nullptr; + decref(); + counts = nullptr; + return d; +} + +template +void RefPtr::decref() +{ + if(!counts) return; + --counts->count; + if(!counts->count) { - if(!count) return; - ++*count; + delete data; + data = nullptr; } + else if(counts->count==RefCounts::KEEP) + data = nullptr; + else + return; - void decref() + if(!counts->weak_count) { - if(!count) return; - --*count; - if(!*count) - { - delete data; - delete count; - data=0; - count=0; - } + delete counts; + counts = nullptr; } -}; +} + + +template +template +WeakPtr &WeakPtr::assign(const WeakPtr &p) +{ + if(&p==this) + return *this; + + decref(); + data = p.get(); + counts = (data ? p.counts : nullptr); + incref(); + return *this; +} + +template +void WeakPtr::decref() +{ + if(!counts) return; + --counts->weak_count; + if(!counts->weak_count && (!counts->count || counts->count==RefCounts::KEEP)) + { + delete counts; + data = nullptr; + counts = nullptr; + } +} } // namespace Msp