it_bus/min_max_list_t.h

#ifndef _IT_BUS_MIN_MAX_LIST_T_H_
#define _IT_BUS_MIN_MAX_LIST_T_H_

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

#include <it_dsa/vector.h>
#include <it_bus/complex_type_reader.h>
#include <it_bus/complex_type_writer.h>
#include <it_bus/deserialization_exception.h>

namespace IT_Bus
{
    template<typename T>
    class MinMaxListT : public IT_Vector<T>
    {
      public:
        MinMaxListT(
            const size_t min_occurs,
            const size_t max_occurs,
            const size_t list_size
        ) :
            m_min_occurs(min_occurs),
            m_max_occurs(max_occurs)
        {
            if (list_size > 0)
            {
                this->insert(this->end(), list_size, T());
            }
        }

        MinMaxListT(
            const T & elem,
            const size_t min_occurs,
            const size_t max_occurs,
            const size_t list_size
        ) :
            m_min_occurs(min_occurs),
            m_max_occurs(max_occurs)
        {
            if (list_size > 0)
            {
                this->insert(this->end(), list_size, elem);
            }
        }

        size_t
        get_min_occurs() const
        {
            return m_min_occurs;
        }

        void
        set_min_occurs(
            size_t min_occurs
        )
        {
            m_min_occurs = min_occurs;
        }

        size_t
        get_max_occurs() const
        {
            return m_max_occurs;
        }

        void
        set_max_occurs(
            size_t max_occurs
        )
        {
            m_max_occurs = max_occurs;
        }

        void
        set_size(
            size_t new_size
        )
        {
            if (m_max_occurs != UINT_MAX && new_size > m_max_occurs)
            {
                throw DeserializationException(
                    "Invalid size specified for MinMaxListT::set_size().  Value is greater than maxOccurs."
                );
            }

            if (new_size < m_min_occurs)
            {
                throw DeserializationException(
                    "Invalid size specified for MinMaxListT::set_size().  Value is less than minOccurs."
                );
            }

            while (this->size() > new_size)
            {
                this->pop_back();
            }

            
            if (this->size() < new_size)
            {
                this->insert(this->end(), new_size - this->size(), T());
            }
        }

        size_t
        get_size() const
        {
            return this->size();
        }

        void
        read_list_member(
            size_t pos,
            const QName & member_name,
            ComplexTypeReader & reader
        ) throw((DeserializationException))
        {
            if (m_max_occurs != UINT_MAX && pos >= m_max_occurs)
            {
                throw DeserializationException(
                    "maxOccurs limit hit when deserializing array."
                );
            }

            if (pos >= this->size())
            {
                this->insert(this->end(), pos  + 1 - this->size(), T());
            }
        
            reader.read(member_name, this->operator[](pos));
        }


        void
        write_list_member(
            size_t pos,
            const QName & member_name,
            ComplexTypeWriter & writer
        ) const throw((SerializationException))
        {
            writer.write(member_name, this->operator[](pos));
        }

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

        MinMaxListT&
        operator=(
            const MinMaxListT & rhs
        )
        {
            m_min_occurs = rhs.m_min_occurs;
            m_max_occurs = rhs.m_max_occurs;

            *this = IT_DYNAMIC_CAST(const IT_Vector<T>&, rhs);
            return *this;
        }

      private:
        size_t m_min_occurs;
        size_t m_max_occurs;
    };
}

#endif  

---