it_bus/element_list_t.h

#ifndef _IT_BUS_ELEMENT_LIST_T_H_
#define _IT_BUS_ELEMENT_LIST_T_H_

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

#include <it_bus/element_list.h>
#include <it_bus/min_max_list_t.h>
#include <it_bus/qname.h>

namespace IT_Reflect
{
    template <class ListT, class T>
    class ElementListImplT;
}

namespace IT_Bus
{
    template<typename T>
    class ElementListT : public MinMaxListT<T>, public virtual ElementList
    {
      public:
        typedef IT_Reflect::ElementListImplT<ElementListT<T>, T>
        IT_ReflectionType;

        ElementListT(
            const QName& item_name,
            const size_t min_occurs,
            const size_t max_occurs,
            const size_t list_size = 0
        ) : MinMaxListT<T>(min_occurs, max_occurs, list_size),
               m_item_name(item_name)
        {
            //Complete
        }

        ElementListT(
            const T & elem,
            const QName& item_name,
            const size_t min_occurs,
            const size_t max_occurs,
            const size_t list_size = 0
        ) : MinMaxListT<T>(elem, min_occurs, max_occurs, list_size),
               m_item_name(item_name)
        {
            //Complete
        }

        ElementListT(
            const size_t min_occurs = 0,
            const size_t max_occurs = 1,
            const size_t list_size = 0,
            const QName& item_name = QName::EMPTY_QNAME
        ) : MinMaxListT<T>(min_occurs, max_occurs, list_size),
            m_item_name(item_name)
        {
            //Complete
        }

        virtual void
        read_element(
            size_t pos,
            ComplexTypeReader & reader
        ) throw((DeserializationException))
        {
            MinMaxListT<T>::read_list_member(pos, m_item_name, reader);
        }

        virtual void
        write_element(
            size_t pos,
            ComplexTypeWriter & writer
        ) const throw((SerializationException))
        {
            MinMaxListT<T>::write_list_member(pos, get_item_name(), writer);
        }

        void
        set_item_name(
            const QName& item_name
        )
        {
            m_item_name = item_name;
        }

        const QName &
        get_item_name() const
        {
            return m_item_name;
        }

        size_t
        get_min_occurs() const
        {
            return MinMaxListT<T>::get_min_occurs();
        }

        void
        set_min_occurs(
            size_t min_occurs
        )
        {
            MinMaxListT<T>::set_min_occurs(min_occurs);
        }

        size_t
        get_max_occurs() const
        {
            return MinMaxListT<T>::get_max_occurs();
        }

        void
        set_max_occurs(
            size_t max_occurs
        )
        {
            MinMaxListT<T>::set_max_occurs(max_occurs);
        }

        void
        set_size(
            size_t new_size
        )
        {
            MinMaxListT<T>::set_size(new_size);
        }

        size_t
        get_size() const
        {
            return MinMaxListT<T>::get_size();
        }

        ElementListT&
        operator=(
            const IT_Vector<T> & rhs
        )
        {
            MinMaxListT<T>::operator=(rhs);
            return *this;
        }

        ElementListT&
        operator=(
            const ElementListT & rhs
        )
        {
            *this = IT_DYNAMIC_CAST(const MinMaxListT<T>&, rhs);
            return *this;
        }

        virtual AnyType&
        copy(
            const AnyType& rhs
        )
        {
            *this = IT_DYNAMIC_CAST(const ElementListT&, rhs);
            return *this;
        }

      private:
        QName m_item_name;
    };
}

#endif  

---