ref_ptr.h

#pragma once
 
#include "ref_counted.h"
 
#include <cgv/defines/assert.h>
#include <cgv/type/cond/is_base_of.h>
#include <cgv/type/cond/has_virtual_destructor.h>
#include <assert.h>
 
#include "lib_begin.h"
 
namespace cgv {
        namespace data {
 
// extern CGV_API bool validate_delete(const void* ptr);
 
template <class T, bool is_ref_counted>
class ref_ptr;
 
class ref_ptr_tag
{
protected:
        void inc_ref_count(const ref_counted* ptr) const
        {
                ptr->set_ref_count(ptr->get_ref_count()+1);
        }
        bool dec_ref_count(const ref_counted* ptr) const
        {
                int count = ptr->get_ref_count();
                if (count > 0) {
                        ptr->set_ref_count(count-1);
                        return count == 1;
                }
                // ERROR: zero ref count decremented
                assert(0);
                return false;
        }
};
 
template <typename T, bool is_ref_counted = false>
class ref_ptr_impl
{
protected:
        friend class ref_ptr_impl<const T, is_ref_counted>;
        struct counter_type 
        {
                counter_type(T* p, int c) : ptr(p), count(c) {}
                T*  ptr;
                int count;
        };
        mutable counter_type* counter;
        void release()
        {
                if (counter) {
                        if (--counter->count == 0) {
                                delete counter->ptr;
                                counter->ptr = 0;
                                delete counter;
                        }
                        counter = 0;
                }
        }
        T*      ref () const        { return counter ? counter->ptr : 0; }
        explicit ref_ptr_impl(T* p = 0) : counter(0) {
                if (p) 
                        counter = new counter_type(p, 1);
        }
        ref_ptr_impl(const ref_ptr_impl<T,false>& r) : counter(r.counter)
        {
                if (counter)
                        ++counter->count;
        }
        template <typename S>
        ref_ptr_impl(const ref_ptr_impl<S,false>& s)
        {
                // ref_ptr conversion only valid if T is base of S
                CGV_DEFINES_ASSERT(type::cond::is_base_of<T,S>::value);
                // and T has a virtual destructor
                CGV_DEFINES_ASSERT(type::cond::has_virtual_destructor<T>::value);
                // after validity checks, set pointer 
                counter = reinterpret_cast<counter_type*>(s.counter);
                // and increment reference count
                if (counter)
                        ++counter->count;
        }
public:
        int get_count() const  { return counter ? counter->count : 0; }
};
 
template <typename T>
class ref_ptr_impl<T,true> : public ref_ptr_tag
{
        T* ptr;
protected:
        void release() {
                if (ptr) { 
                        if (dec_ref_count(ptr)) {
//                              if (validate_delete(ptr))
                                        delete ptr;
                        }
                        ptr = 0; 
                }
        }
        T*      ref () const         { 
                return ptr; 
        }
        explicit ref_ptr_impl(T* p) : ptr(p) {
                if (ptr)
                        inc_ref_count(ptr);
        }
        ref_ptr_impl(const ref_ptr_impl<T,true>& r) : ptr(r.ref())
        {
                if (ptr)
                        inc_ref_count(ptr);
        }
        template <typename S>
        ref_ptr_impl(const ref_ptr_impl<S,true>& s)
        {
                // ref_ptr conversion only valid if T is base of S
                CGV_DEFINES_ASSERT(type::cond::is_base_of<T,S>::value);
                // and T has a virtual destructor
                CGV_DEFINES_ASSERT(type::cond::has_virtual_destructor<T>::value);
                // after validity checks, set pointer with a very bad hack!!
                ptr = static_cast<const ref_ptr<S,true>&>(s).operator->();
                // and increment reference count
                if (ptr)
                        inc_ref_count(ptr);
        }
public:
        // void kill() { ptr = 0; }
        int get_count() const   { 
                return ptr ? ptr->get_ref_count() : 0; 
        }
};
 
template <class T, bool is_ref_counted = type::cond::is_base_of<ref_counted,T>::value>
class ref_ptr : public ref_ptr_impl<T,is_ref_counted>
{
public:
        typedef ref_ptr<T,is_ref_counted> this_type;
        typedef ref_ptr_impl<T,is_ref_counted> base_type;
public:
        ref_ptr(T* p = 0) : base_type(p) {}
        ref_ptr(const this_type& r) : base_type(r) {}
   ~ref_ptr() { 
                this->release();
        }
        template <typename S>
        ref_ptr(const ref_ptr<S,is_ref_counted>& s) : base_type(s) {}
        template <typename S>
        ref_ptr<S,is_ref_counted> up_cast() const {
                // ref_ptr conversion only valid if T is base of S
                CGV_DEFINES_ASSERT(type::cond::is_base_of<T,S>::value);
                // and S has a virtual destructor
                CGV_DEFINES_ASSERT(type::cond::has_virtual_destructor<T>::value);
                // after validity checks, return converted pointer
                return ref_ptr<S,is_ref_counted>(
                                        *reinterpret_cast<const ref_ptr<S,is_ref_counted>*>(this)
                                 );
        }
        this_type& operator = (const this_type& r) {
                if (this == &r)
                        return *this;
                this->release();
                new (this) this_type(r);
                return *this;
        }
        template <typename S>
        this_type& operator = (const ref_ptr<S,is_ref_counted>& r) {
                if (this == (const this_type*)&r)
                        return *this;
                return *this = this_type(r);
        }
        T& operator*() const { 
                return *this->ref();
        }
   T* operator->() const {
                return this->ref();
        }
        bool operator == (const this_type& r) const { 
                return this->ref() == r.ref(); 
        }
        bool operator < (const this_type& r) const { 
                return this->ref() < r.ref(); 
        }
        bool operator != (const this_type& r) const { 
                return this->ref() != r.ref(); 
        }
        bool unique() const {
                return this->get_count() <= 1; 
        }
        bool empty() const { 
                return this->get_count() == 0; 
        }
        operator bool () const {
                return !empty();
        }
        void clear() { 
                this->release();
        }
};
 
        }
}
 
#include <cgv/config/lib_end.h>