---

oscl_refcounter.h

Go to the documentation of this file.

// -*- c++ -*-
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

//                   O S C L _ R E F C O U N T E R

// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

#ifndef OSCL_REFCOUNTER_H_INCLUDED
#define OSCL_REFCOUNTER_H_INCLUDED

#ifndef OSCL_ASSERT_H_INCLUDED
#include "oscl_assert.h"
#endif

#ifndef OSCL_DEFALLOC_H_INCLUDED
#include "oscl_defalloc.h"
#endif

class OsclRefCounter
{
    public:
        virtual void addRef() = 0;

        virtual void removeRef() = 0;

        virtual uint32 getCount() = 0;

        virtual ~OsclRefCounter() {}
};


class OsclRefCounterDA : public OsclRefCounter
{
    public:

        OsclRefCounterDA(OsclAny *p, OsclDestructDealloc *dealloc):
                ptr(p), deallocator(dealloc), refcnt(1)
        {
            OSCL_ASSERT(ptr != NULL && deallocator != NULL);
        }

        virtual ~OsclRefCounterDA() {}

        void addRef()
        {
            ++refcnt;
        }

        void removeRef()
        {
            if (--refcnt == 0)
            {
                if (ptr == this)
                {
                    // buffer is part of the refcounter
                    deallocator->destruct_and_dealloc(this);
                }
                else
                {
                    // delete the buffer and the refcounter object
                    deallocator->destruct_and_dealloc(ptr);
                    delete(this);
                }
            }
        }

        uint32 getCount()
        {
            return refcnt;
        }

    private:
        OsclRefCounterDA();
        OsclRefCounterDA(const OsclRefCounterDA& x);
        OsclRefCounterDA& operator=(const OsclRefCounterDA& x);

        OsclAny *ptr;
        OsclDestructDealloc *deallocator;
        uint32 refcnt;
};


template<class DeallocType>
class OsclRefCounterSA : public OsclRefCounter
{
    public:
        OsclRefCounterSA(OsclAny *p) :
                ptr(p), refcnt(1)
        {
            OSCL_ASSERT(ptr != NULL);
        }

        virtual ~OsclRefCounterSA() {}

        void addRef()
        {
            ++refcnt;
        }

        void removeRef()
        {
            if (--refcnt == 0)
            {
                if (ptr == this)
                {

                    // buffer is part of the refcounter
                    DeallocType deallocator;
                    deallocator.destruct_and_dealloc(this);
                }
                else
                {

                    // delete the buffer and the recounter object
                    DeallocType deallocator;
                    deallocator.destruct_and_dealloc(ptr);
                    delete(this);
                }
            }
        }

        uint32 getCount()
        {
            return refcnt;
        }

    private:
        OsclRefCounterSA();
        OsclRefCounterSA(const OsclRefCounterSA<DeallocType>& x);
        OsclRefCounterSA<DeallocType>& operator=(const OsclRefCounterSA<DeallocType>& x);

        OsclAny *ptr;
        uint32 refcnt;
};

template<class LockType>
class OsclRefCounterMTDA : public OsclRefCounter
{
    public:

        OsclRefCounterMTDA(OsclAny *p, OsclDestructDealloc *dealloc) :
                ptr(p), deallocator(dealloc), refcnt(1)
        {
            OSCL_ASSERT(ptr != NULL && deallocator != NULL);
        }

        virtual ~OsclRefCounterMTDA() {}

        void addRef()
        {
            lock.Lock();
            ++refcnt;
            lock.Unlock();
        }

        void removeRef()
        {
            lock.Lock();
            if (--refcnt == 0)
            {
                if (ptr == this)
                {

                    // buffer is part of the refcounter
                    deallocator->destruct_and_dealloc(this);
                }
                else
                {
                    // delete the buffer and the refcounter object
                    deallocator->destruct_and_dealloc(ptr);
                    delete(this);
                }
            }
            else
            {
                lock.Unlock();
            }
        }

        uint32 getCount()
        {
            return refcnt;
        }

    private:
        OsclRefCounterMTDA();
        OsclRefCounterMTDA(const OsclRefCounterMTDA<LockType>& x);
        OsclRefCounterMTDA<LockType>& operator=(const OsclRefCounterMTDA<LockType>& x);

        OsclAny *ptr;
        OsclDestructDealloc *deallocator;
        LockType lock;
        uint32 refcnt;
};


template<class DeallocType, class LockType>
class OsclRefCounterMTSA : public OsclRefCounter
{
    public:
        OsclRefCounterMTSA(OsclAny *p) :
                ptr(p), refcnt(1)
        {
            OSCL_ASSERT(ptr != NULL);
        }

        virtual ~OsclRefCounterMTSA() {}

        void addRef()
        {
            lock.Lock();
            ++refcnt;
            lock.Unlock();
        }

        void removeRef()
        {
            lock.Lock();
            if (--refcnt == 0)
            {
                if (ptr == this)
                {
                    // buffer is part of the refcounter
                    DeallocType deallocator;
                    deallocator.destruct_and_dealloc(this);
                }
                else
                {

                    // delete the buffer and the recounter object
                    DeallocType deallocator;
                    deallocator.destruct_and_dealloc(ptr);
                    delete(this);
                }
            }
            else
            {
                lock.Unlock();
            }
        }

        uint32 getCount()
        {
            return refcnt;
        }

    private:
        OsclRefCounterMTSA();
        OsclRefCounterMTSA(const OsclRefCounterMTSA<DeallocType, LockType>& x);
        OsclRefCounterMTSA<DeallocType, LockType>& operator=(const OsclRefCounterMTSA<DeallocType, LockType>& x);

        OsclAny *ptr;
        LockType lock;
        uint32 refcnt;
};

template<class DefAlloc>
class Oscl_DefAllocWithRefCounter: public OsclRefCounter, public DefAlloc
{
    public:
        static Oscl_DefAllocWithRefCounter* New()
        {
            DefAlloc alloc;
            OsclAny* p = alloc.ALLOCATE(sizeof(Oscl_DefAllocWithRefCounter));
            return new(p) Oscl_DefAllocWithRefCounter();
        }

        void Delete()
        {
            removeRef();
        }

        void addRef()
        {
            refcount++;
        }

        void removeRef()
        {
            --refcount;
            if (refcount == 0)
                DefAlloc::deallocate(this);
        }

        uint32 getCount()
        {
            return refcount;
        }

    private:
        Oscl_DefAllocWithRefCounter(): refcount(1)
        {}
        uint32 refcount;
};

#endif

---