---

oscl_vector.h

Go to the documentation of this file.

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

//                     O S C L _ V E C T O R

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

#ifndef OSCL_VECTOR_H_INCLUDED
#define OSCL_VECTOR_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

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

class Oscl_Vector_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 isn't available in c'tor 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) ;

        //for use in copy constructor.
        OSCL_IMPORT_REF void construct(Oscl_Opaque_Type_Alloc* aType, const Oscl_Vector_Base& x);

        virtual ~Oscl_Vector_Base()
        {}

        OSCL_IMPORT_REF void push_back(const OsclAny* x) ;

        OSCL_IMPORT_REF void pop_back() ;

        OSCL_IMPORT_REF void push_front(const OsclAny* x) ;

        OSCL_IMPORT_REF OsclAny* insert(OsclAny* pos, const OsclAny* x);

        OSCL_IMPORT_REF OsclAny* erase(OsclAny* pos) ;

        OSCL_IMPORT_REF OsclAny* erase(OsclAny* first, OsclAny* last) ;

        //copy vector x into this vector
        OSCL_IMPORT_REF void assign_vector(const Oscl_Vector_Base& x);

        OSCL_IMPORT_REF void destroy();

        uint32 numelems; //number of T items in buffer.
        uint32 bufsize; //available bufsize as number of T-sized items.
        OsclAny* elems; //buffer
        uint32 sizeof_T;

        friend class OsclPriorityQueueBase;

    private:

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

        OsclAny* begin() const
        {
            return elems;
        }

        OsclAny* end() const
        {
            return increment_T(elems, numelems);
        }

        OsclAny* move(OsclAny* first, OsclAny* last, OsclAny* result) ;

        OsclAny* copy(OsclAny* first, OsclAny* last, OsclAny* result) ;

        OsclAny* uninitialized_copy(OsclAny* first, OsclAny* last, OsclAny* result) ;

        //destroy a range of T*
        void destroy(OsclAny* first, OsclAny* last) ;

        Oscl_Opaque_Type_Alloc* pOpaqueType;
};

template<class T, class Alloc>
class Oscl_Vector
            : public Oscl_Vector_Base
            , public Oscl_Opaque_Type_Alloc
{

    public:
        typedef T value_type;
        typedef T* pointer;
        typedef T& reference;
        typedef const T& const_reference;
        typedef T* iterator;
        typedef const T* const_iterator;

        Oscl_Vector() : Oscl_Vector_Base(), Oscl_Opaque_Type_Alloc()
        {
            sizeof_T = sizeof(T);
            Oscl_Vector_Base::construct(this);
        }

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

        Oscl_Vector(const Oscl_Vector<T, Alloc>& x) : Oscl_Vector_Base(), Oscl_Opaque_Type_Alloc()
        {
            sizeof_T = sizeof(T);
            Oscl_Vector_Base::construct(this, x);
        }

        virtual ~Oscl_Vector()
        {
            Oscl_Vector_Base::destroy();
        }

        Oscl_Vector<T, Alloc>& operator=(const Oscl_Vector<T, Alloc>& x)
        {
            if (&x != this)
                Oscl_Vector_Base::assign_vector(x);
            return *this;
        }

        void push_back(const T& x)
        {
            Oscl_Vector_Base::push_back(&x);
        }

        void push_front(const T& x)
        {
            Oscl_Vector_Base::push_front(&x);
        }

        iterator insert(iterator pos, const T& x)
        {
            return (iterator)Oscl_Vector_Base::insert(pos, &x);
        }

        T& operator[](uint32 n)
        {
            return (*(begin() + n));
        }

        const T& operator[](uint32 n) const
        {
            return (*(begin() + n));
        }

        T& front()
        {
            return *begin();
        }

        const T& front() const
        {
            return *begin();
        }

        T& back()
        {
            return (*(end() - 1));
        }

        const T& back() const
        {
            return (*(end() - 1));
        }

        void pop_back()
        {
            OSCL_ASSERT(numelems);
            numelems--;
            destroy(end());
        }

        void clear()
        {
            Oscl_Vector_Base::erase(begin(), end());
        }

        void destroy()
        {
            Oscl_Vector_Base::destroy();
        }

        iterator begin() const
        {
            return (pointer)elems;
        }

        iterator end() const
        {
            return (pointer)elems + numelems;
        }

        iterator erase(iterator pos)
        {
            return (iterator)Oscl_Vector_Base::erase(pos);
        }

        iterator erase(iterator first, iterator last)
        {
            return (iterator)Oscl_Vector_Base::erase(first, last);
        }

    private:

        Alloc defAlloc;

        //from Oscl_Opaque_Type_Alloc
        OsclAny* allocate(const uint32 size)
        {
            //prevent zero-size allocations since some allocators don't handle this
            return (size) ? defAlloc.ALLOCATE(size) : NULL;
        }

        //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);
            //note: must use "pointer" instead of "T*" here to avoid ADS 1.2 compile error.
            ((pointer)first)->~T();
        }

};


#endif

---