it_bus/array_t.h

#ifndef _IT_BUS_ARRAY_T_H_
#define _IT_BUS_ARRAY_T_H_

// @Copyright 2003 IONA Technologies, Plc. All Rights Reserved.
//

#include <it_bus/sequence_complex_type.h>
#include <it_bus/element_list_t.h>

namespace IT_Bus
{
    template<typename T>
    class ArrayT : public SequenceComplexType
    {

      public:

        ArrayT()
        {
        }

        operator const IT_Vector<T> &() const
        {
            return get_element_list();
        }


        operator IT_Vector<T> &()
        {
            return get_element_list();
        }


        typename IT_Vector<T>::ConstReference
        operator[](
            const size_t pos
        ) const
        {
            return get_element_list()[pos];
        }


        typename IT_Vector<T>::Reference
        operator[](
            const size_t pos
        )
        {
            return get_element_list()[pos];
        }


        typename IT_Vector<T>::Iterator
        begin()
        {
            return get_element_list().begin();
        }


        typename IT_Vector<T>::ConstIterator
        begin() const
        {
            return get_element_list().begin();
        }


        typename IT_Vector<T>::Iterator
        end()
        {
            return get_element_list().end();
        }


        typename IT_Vector<T>::ConstIterator
        end() const
        {
            return get_element_list().end();
        }


        typename IT_Vector<T>::ReverseIterator
        rbegin()
        {
            return get_element_list().rbegin();
        }


        typename IT_Vector<T>::ConstReverseIterator
        rbegin() const
        {
            return get_element_list().rbegin();
        }


        typename IT_Vector<T>::ReverseIterator
        rend()
        {
            return get_element_list().rend();
        }


        typename IT_Vector<T>::ConstReverseIterator
        rend() const
        {
            return get_element_list().rend();
        }


        typename IT_Vector<T>::SizeType
        size() const
        {
            return get_element_list().get_size();
        }


        typename IT_Vector<T>::SizeType
        get_size() const
        {
            return get_element_list().get_size();
        }


        void
        set_size(
            typename IT_Vector<T>::SizeType sz
        )
        {
            get_element_list().set_size(sz);
        }


        typename IT_Vector<T>::SizeType
        capacity() const
        {
            return get_element_list().capacity();
        }


        IT_Bool
        empty() const
        {
            return get_element_list().empty();
        }


        typename IT_Vector<T>::Reference
        front()
        {
            return get_element_list().front();
        }


        typename IT_Vector<T>::ConstReference
        front() const
        {
            return get_element_list().front();
        }


        typename IT_Vector<T>::Reference
        back()
        {
            return get_element_list().back();
        }


        typename IT_Vector<T>::ConstReference
        back() const
        {
            return get_element_list().back();
        }


        void
        push_back(
            const T&             item,
            IT_ExceptionHandler& /*eh*/ = IT_EXCEPTION_HANDLER
        )
        {
            get_element_list().push_back(item);
        }


        typename IT_Vector<T>::Iterator
        insert(
            typename IT_Vector<T>::Iterator pos,
            const T&                        item,
            IT_ExceptionHandler&            eh = IT_EXCEPTION_HANDLER
        )
        {
            return get_element_list().insert(pos, item, eh);
        }


        void
        insert(
            typename IT_Vector<T>::Iterator pos,
            typename IT_Vector<T>::SizeType n,
            const T&                        init_val = T(),
            IT_ExceptionHandler&            eh       = IT_EXCEPTION_HANDLER
        )
        {
            get_element_list().insert(pos, n, init_val, eh);
        }


        void
        insert(
            typename IT_Vector<T>::Iterator pos,
            const T*                        first,
            const T*                        last,
            IT_ExceptionHandler&            eh = IT_EXCEPTION_HANDLER
        )
        {
            get_element_list().insert(pos, first, last, eh);
        }


        void
        pop_back()
        {
            get_element_list().pop_back();
        }


        typename IT_Vector<T>::Iterator
        erase(
            typename IT_Vector<T>::Iterator pos,
            IT_ExceptionHandler&            eh = IT_EXCEPTION_HANDLER
        )
        {
            return get_element_list().erase(pos, eh);
        }


        typename IT_Vector<T>::Iterator
        erase(
            typename IT_Vector<T>::Iterator first,
            typename IT_Vector<T>::Iterator last,
            IT_ExceptionHandler&            eh = IT_EXCEPTION_HANDLER
        )
        {
            return get_element_list().erase(first, last, eh);
        }


        virtual IT_Bus::AnyType &
        copy(const IT_Bus::AnyType & rhs) = 0;

    protected:
        virtual const ElementListT<T> &
        get_element_list() const = 0;

        virtual ElementListT<T> &
        get_element_list() = 0;

    };
}

#endif  

---