refcount.hpp

Go to the documentation of this file.

// +-------------------------------------------------------------------------+
// |               I__n__t__e__L__i__b           0.6.10 development          |
// | Copyright (c) Andrey Vikt. Stolyarov <crocodil_AT_croco.net> 2000-2007. |
// |                                                                         |
// | This is free software. The library part is available under              |
// |                               GNU LESSER GENERAL PUBLIC LICENSE v.2.1.  |
// | GNU LGPL v2.1 is found in docs/gnu_gpl2.txt,  or at  http://www.gnu.org |
// |     Please see also docs/readme.txt and visit http://www.intelib.org    |
// |                                                                         |
// | !!! THERE IS NO WARRANTY OF ANY KIND, NEITHER EXPRESSED NOR IMPLIED !!! |
// +-------------------------------------------------------------------------+




#ifndef INTELIB_REFCOUNT_HPP_SENTRY
#define INTELIB_REFCOUNT_HPP_SENTRY


class GarbageSafe {
    friend class GarbageSafePointer;
    friend class GarbageSafeConstPointer;

    mutable int RefCount;
    void AddRef() const { RefCount++; }
    void Unlink() const { if((--RefCount)<=0) delete this; }
protected:

    bool CanDie() { return RefCount <= 1; }
public:

    GarbageSafe() { RefCount = 0; }
protected:
    virtual ~GarbageSafe() {}
private:
    void operator =(const GarbageSafe &other) {}
};


class GarbageSafePointer {
    GarbageSafe *p;
public:
    GarbageSafePointer() { p = 0; }

    GarbageSafePointer(const GarbageSafe *pp) 
    { if((p = (GarbageSafe*) pp)) p->AddRef(); }

    GarbageSafePointer(const GarbageSafePointer &other)
    { if((p = other.p)) p->AddRef(); }

    ~GarbageSafePointer() { if(p) { p->Unlink(); p = 0; } }



    GarbageSafePointer& operator =(const GarbageSafePointer &other)
    {
        GarbageSafe *tmp = p; // this is a workaround for the case
        if((p = other.p)) p->AddRef();  // when unlinking p we destroy
        if(tmp) tmp->Unlink(); // the structure our operand belongs to
        return *this;
    }

    GarbageSafePointer& operator =(GarbageSafe *pp)
    {
        GarbageSafe *tmp = p; 
        if((p = pp)) p->AddRef();
        if(tmp) tmp->Unlink(); 
        return *this;
    }

    GarbageSafe* GetPtr() const { return p; }
};


inline bool
operator==(const GarbageSafePointer& op1, const GarbageSafePointer& op2)
{ return op1.GetPtr() == op2.GetPtr(); }

inline bool
operator!=(const GarbageSafePointer& op1, const GarbageSafePointer& op2)
{ return op1.GetPtr() != op2.GetPtr(); }


template <class Tp>
class GenericReference : public GarbageSafePointer {
public:
    GenericReference() {}
    GenericReference(const Tp *tp) : GarbageSafePointer(tp) {}
    GenericReference(const GenericReference &other)
            : GarbageSafePointer(other) {}
    ~GenericReference() {}

    GenericReference& operator=(Tp *tp)
    {
        GarbageSafePointer::operator=(tp);
        return *this;
    }
    GenericReference& operator=(const GenericReference &other)
    {
        GarbageSafePointer::operator=(other);
        return *this;
    }
    Tp* GetPtr() const
        { return static_cast<Tp*>(GarbageSafePointer::GetPtr()); }

    Tp* operator ->() const
        { return GetPtr(); }

    Tp& operator *() const
        { return *(GetPtr()); }

};

#endif //sentry

---