---

oscl_queue.h

Go to the documentation of this file.

// -*- c++ -*-



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

//                     O S C L _ Q U E U E
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

#ifndef OSCL_QUEUE_H_INCLUDED
#define OSCL_QUEUE_H_INCLUDED

#ifndef OSCL_BASE_H_INCLUDED
#include "oscl_base.h"
#endif

#ifndef OSCL_MEM_BASIC_FUNCTIONS_H_INCLUDED
#include "oscl_mem_basic_functions.h"
#endif

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

#ifndef OSCL_OPAQUE_TYPE_H_INCLUDED
#include "oscl_opaque_type.h"
#endif

class Oscl_Queue_Base
{
    public:

        uint32 size() const
        {
            return numelems;
        }

        uint32 capacity() const
        {
            return bufsize;
        }

        bool empty() const
        {
            return numelems == 0;
        }

        OSCL_IMPORT_REF void reserve(uint32 n) ;

    protected:

        //for use in default constructor.  vtable is needed so this is a subroutine.
        OSCL_IMPORT_REF void construct(Oscl_Opaque_Type_Alloc* aType);

        //for use in constructor with pre-allocation for "n" elements.
        OSCL_IMPORT_REF void construct(Oscl_Opaque_Type_Alloc* aType, uint32 n) ;

        virtual ~Oscl_Queue_Base()
        {}

        OSCL_IMPORT_REF void destroy();

        OSCL_IMPORT_REF void push(const OsclAny* x) ;

        OSCL_IMPORT_REF void pop() ;

        OSCL_IMPORT_REF void clear() ;

        uint32 numelems;  // number of valid entries in queue
        uint32 bufsize;   // size of elems
        OsclAny* elems;   // array holding the elements
        uint32 sizeof_T;

        uint32 ifront;    // front of queue: removal point
        uint32 irear;     // just before back of queue: increment=>insertion point

    private:

        OsclAny* increment_T(OsclAny* p_T, int32 n) const
        {
            return (OsclAny*)((int32)p_T + n*sizeof_T);
        }

        OsclAny* front()
        {
            return increment_T(elems, ifront);
        }

        Oscl_Opaque_Type_Alloc* pOpaqueType;
};

template<class T, class Alloc>
class Oscl_Queue
            : public Oscl_Queue_Base
            , public Oscl_Opaque_Type_Alloc
{

    public:
        typedef T value_type;
        typedef T* pointer;
        typedef T& reference;
        typedef const T& const_reference;
        typedef uint32 size_type;

        Oscl_Queue() : Oscl_Queue_Base(), Oscl_Opaque_Type_Alloc()
        {
            sizeof_T = sizeof(T);
            Oscl_Queue_Base::construct(this);
        }

        Oscl_Queue(uint32 n) : Oscl_Queue_Base(), Oscl_Opaque_Type_Alloc()
        {
            sizeof_T = sizeof(T);
            Oscl_Queue_Base::construct(this, n);
        }

        virtual ~Oscl_Queue()
        {
            Oscl_Queue_Base::destroy();
        }

        void push(const T& x)
        {
            Oscl_Queue_Base::push(&x);
        }

        reference front()
        {
            OSCL_ASSERT(! empty());
            return (reference)((pointer)elems)[ifront];
        }

        const_reference front() const
        {
            OSCL_ASSERT(! empty());
            return (const_reference)((pointer)elems)[ifront];
        }


        void pop()
        {
            Oscl_Queue_Base::pop();
        }

        reference back()
        {
            OSCL_ASSERT(! empty());
            return (reference)((pointer)elems)[irear];
        }

        const_reference back() const
        {
            OSCL_ASSERT(! empty());
            return (const_reference)((pointer)elems)[irear];
        }

        void clear()
        {
            Oscl_Queue_Base::clear();
        }

    private:
        Alloc defAlloc;

        //from Oscl_Opaque_Type_Alloc
        OsclAny* allocate(const uint32 size)
        {
            return defAlloc.allocate(size);
        }

        //from Oscl_Opaque_Type_Alloc
        void deallocate(OsclAny* p)
        {
            defAlloc.deallocate(p);
        }

        //from Oscl_Opaque_Type_Alloc
        void construct(OsclAny* p, const OsclAny* x)
        {
            OSCL_ASSERT(x);
            new(p) value_type(*((T*)x));
        }

        //from Oscl_Opaque_Type_Alloc
        void destroy(OsclAny* first)
        {
            OSCL_ASSERT(first);
            OSCL_UNUSED_ARG(first);
            //must use "pointer" instead of "T*" here to avoid ADS 1.2 compile error.
            ((pointer)first)->~T();
        }


        /***************************
         * things we don't believe are needed
         * -- private definitions to block implicit ones --
         */

        Oscl_Queue<T, Alloc>& operator=(const Oscl_Queue<T, Alloc>& x)
        {
            // Do we need to copy a queue?  Why...?
            //  .. unless there's a need, let's not bother with the
            //  complexity here..
            // (need something here, we don't want implicit assignment either
            OSCL_UNUSED_ARG(x);
            OSCL_ASSERT(false);
            return *this;
        }

        Oscl_Queue(const Oscl_Queue<T, Alloc>& x)
                : Oscl_Queue_Base(sizeof(T), this, this)
        {
            OSCL_UNUSED_ARG(x);
            OSCL_ASSERT(false);
        }
};  // end class oscl_queue

#endif

---