---

nci/suif/suif2b/common/ref_counter.h

Go to the documentation of this file.

#ifndef __REF_COUNTER_H__
#define __REF_COUNTER_H__

template <class T> class RCPointer {
        T *_x;
    public:
        RCPointer() : _x(NULL) {}
        RCPointer(T * x) : _x(x) {
                if (_x) {
                    _x->inc_refs();
                    }
                }
        RCPointer(const RCPointer &a) : _x(a._x) {
                if (_x) {
                    _x->inc_refs();
                    }
                }

        ~RCPointer() {
                make_null();
                }
        RCPointer &operator =(const RCPointer &a) {
                if (a._x) {
                    a._x->inc_refs();
                    }
                make_null();
                _x = a._x;
                return *this;
                }
        bool operator ==(const RCPointer &x) const {
            return (_x == x._x);
            }

    /*operator bool() const {
        return !is_null();
    }*/
        void make_null() {
            if (_x) {
                if (_x->dec_refs() == 0) {
                    delete _x;
                    }
                }
            _x = 0;
            }

        bool is_null() const {return (!_x);}
        T* get_ptr() const {
                return _x;
                }

        T *operator ->() const {return get_ptr();}
        operator T *() const {return get_ptr();}
        };

template <class T,class P> class DerivedRCPointer : public P {
    public:
        DerivedRCPointer() : P() {}
        DerivedRCPointer(T * x) : P(x) {}
        DerivedRCPointer(const DerivedRCPointer &a) : P(a) {}

        T* get_ptr() const {
            return (T *)P::get_ptr();
            }

        T *operator ->() const {return get_ptr();}
        operator T *() const {return get_ptr();}
    };


class RefCountedClass {
        unsigned long _count;
    public:
        // note that we use zero as a "latch" to detect overflow
        // _count is actually one greater than the reference count
        RefCountedClass() : _count(1) {}
        unsigned long inc_refs() {
                if(_count)_count ++;
                return _count-1;}
        unsigned long dec_refs() {if (_count > 1)--_count;return _count-1;}
        unsigned long ref_count() {return _count -1;}
    };

template <class x> class ref_stack : public simple_stack<x>
    {
    typedef simple_stack<x> SS;
    public:
        ref_stack(unsigned int start_size = 10, 
                  unsigned int expansion_size = 10) 
                : SS(start_size,expansion_size) {}

        void reset() {
                int l = len();
                while (l > 0) {
                    l --;
                    (*this)[l].make_null();
                    }
                SS::reset();
                }
        void set_len(int newlen) {
            int l = len();
            while (l > newlen) {
                l --;
                (*this)[l].make_null();
                }
            SS::set_len(newlen);
            }

        void cut(int len) {
            set_len(len + 1);
            }

        void remove(int p) {
            if (p >= len())
                return;
            x &top = SS::top();
            SS::remove(p);
            top.make_null();
            }
        x pop() {
            x top = SS::top();
            set_len(len()-1);
            return top;
            }
        };

#endif

---