ref_arr.h

#pragma once
 
#include <cgv/defines/assert.h>
#include <cgv/type/cond/is_base_of.h>
#include <cgv/type/cond/has_virtual_destructor.h>
 
namespace cgv {
    namespace data {
 
template <typename T>
class ref_arr
{
private:
    struct counter_type 
    {
        counter_type(T* a, int c) : arr(a), count(c) {}
        T*  arr;
        int count;
    };
    counter_type* counter;
    T* arr;
    void release()
    {
        if (counter) {
            if (--counter->count == 0) {
                delete [] counter->arr;
                delete counter;
            }
            counter = 0;
        }
        arr = 0;
    }
public:
    explicit ref_arr(T* a = 0, counter_type* c = 0) : counter(c), arr(a) {
        if (!c && a)
            counter = new counter_type(a, 1);
    }
    ref_arr(const ref_arr<T>& ra) : counter(ra.counter), arr(ra.arr)
    {
        if (counter)
            ++counter->count;
    }
   ~ref_arr() { 
        release(); 
    }
    ref_arr<T>& operator = (const ref_arr<T>& ra) {
        if (this == &ra)
            return *this;
        release();
        new (this) ref_arr<T>(ra);
        return *this;
    }
    T* ptr() const {
        return arr;
    }
    T& operator*() const { 
        return *arr;
    }
   T* operator->() const {
        return arr;
    }
    T& operator [] (int i) {
        return arr[i];
    }
    ref_arr<T> operator () (int i) const {
        return ref_arr<T>(arr+i,counter);
    }
    bool operator == (const ref_arr<T>& ra) const { 
        return arr == ra.arr; 
    }
    int get_count() const  { 
        return counter ? counter->count : 0; 
    }
    bool unique() const {
        return get_count() <= 1; 
    }
    bool empty() const { 
        return get_count() == 0; 
    }
    operator bool () const {
        return !empty();
    }
    void clear() { 
        release();
    }
};
 
    }
}