it_bus/type_list_t.h

#ifndef _IT_BUS_TYPE_LIST_T_H_
#define _IT_BUS_TYPE_LIST_T_H_

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

#include <it_bus/type_list.h>
#include <it_bus/min_max_list_t.h>

namespace IT_Reflect
{
    template <class ListT, class T>
    class TypeListImplT;
}
    
namespace IT_Bus
{
    template<typename T>
    class TypeListT : public MinMaxListT<T>, public virtual TypeList
    {
      public:
        typedef IT_Reflect::TypeListImplT<TypeListT<T>, T>
        IT_ReflectionType;

        TypeListT(
            const size_t min_occurs,
            const size_t max_occurs,
            const size_t list_size
        ) : MinMaxListT<T>(min_occurs, max_occurs, list_size)
        {
        }

        TypeListT(
            const T & elem,
            const size_t min_occurs,
            const size_t max_occurs,
            const size_t list_size
        ) : MinMaxListT<T>(elem, min_occurs, max_occurs, list_size)
        {
        }

        virtual void
        read_type(
            size_t pos,
            ComplexTypeReader & reader
        ) IT_THROW_DECL((DeserializationException))
        {
            MinMaxListT<T>::read_list_member(pos, QName::EMPTY_QNAME, reader);
        }

        virtual void
        write_type(
            size_t pos,
            ComplexTypeWriter & writer
        ) const IT_THROW_DECL((SerializationException))
        {
            MinMaxListT<T>::write_list_member(pos, QName::EMPTY_QNAME, writer);
        }

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

        size_t
        get_max_occurs() const
        {
            return MinMaxListT<T>::get_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();
        }

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

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

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

#endif  

---