it_bus/soap_enc_array_t.h

#ifndef _IT_BUS_SOAP_ENC_ARRAY_T_H_
#define _IT_BUS_SOAP_ENC_ARRAY_T_H_

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

#include <it_cal/cal.h>
#include <it_bus/qname.h>
#include <it_bus/soap_enc_array.h>
#include <it_bus/element_list_t.h>
#include <it_bus/complex_type_reader.h>
#include <it_bus/complex_type_writer.h>

namespace IT_Bus
{
    class SoapEncArrayCoordinate : public ArrayCoordinate
    {
      public:
        SoapEncArrayCoordinate(
            size_t dimensions,
            const size_t coords[]
        ) :
            m_dimensions(dimensions)
        {
            size_t* p = new size_t[m_dimensions];
            memcpy(p, coords, sizeof(size_t) * m_dimensions);
            m_coords.reset(p);
        }

        SoapEncArrayCoordinate(
            const SoapEncArrayCoordinate& rhs
        ) :
            m_dimensions(rhs.m_dimensions)
        {
            m_coords.reset(new size_t[m_dimensions]);
            for (size_t idx = 0; idx < m_dimensions; idx++)
            {
                m_coords[idx] = rhs[idx];
            }
        }

        SoapEncArrayCoordinate(
            size_t dimensions
        ) :
            m_dimensions(dimensions)
        {
            size_t* p = new size_t[m_dimensions];
            memset(p, 0, sizeof(size_t) * m_dimensions);
            m_coords.reset(p);
        }

        SoapEncArrayCoordinate&
        operator=(
            const ArrayCoordinate& rhs
        )
        {
            if (this != &rhs)
            {
                size_t sz = rhs.get_number_dimensions();
                if (m_dimensions != sz)
                {
                    m_dimensions = sz;
                    m_coords.reset(new size_t[m_dimensions]);
                }
                for (size_t i = 0; i < sz; ++i)
                {
                    m_coords[i] = rhs[i];
                }
            }
            return *this;
        }

        virtual const size_t
        get_number_dimensions() const
        {
            return m_dimensions;
        }

        virtual const size_t&
        operator[] (
            size_t idx
        ) const
        {
            return m_coords[idx];
        }

        virtual size_t&
        operator[] (
            size_t idx
        )
        {
            return m_coords[idx];
        }

      protected:
        IT_AutoArrayPtr<size_t> m_coords;
        size_t                  m_dimensions;
    };


    template<typename T>
    class SoapEncArrayT : public SoapEncArray
    {

        typedef SoapEncArrayT<T> ThisType;

      public:

        SoapEncArrayT(size_t dimensions)
         : m_data(IT_Bus::QName::ITEM_QNAME, size_t(0), size_t(-1)),
           m_array_extents(dimensions)
        {
            m_defined_elements = new unsigned char[1];
            m_defined_elements[0] = 0;
        }

        SoapEncArrayT(size_t dimensions, const size_t extents[])
         :  m_data(IT_Bus::QName::ITEM_QNAME, size_t(0), size_t(-1)),
            m_array_extents(dimensions, extents)
        {
            m_defined_elements = 0;
            set_extents(m_array_extents);
        }

        SoapEncArrayT(const IT_Bus::SoapEncArrayCoordinate & array_extents)
         :  m_data(IT_Bus::QName::ITEM_QNAME, size_t(0), size_t(-1)),
            m_array_extents(array_extents)
        {
            m_defined_elements = 0;
            set_extents(array_extents);
        }

        SoapEncArrayT(const SoapEncArrayT<T> & rhs)
         :  m_data(IT_Bus::QName::ITEM_QNAME, size_t(0), size_t(-1)),
            m_array_extents(rhs.m_array_extents)
        {
            m_data.set_size(0);
            m_defined_elements = 0;
            set_extents(rhs.get_extents());

            size_t idx;
            for (idx = 0; idx < m_data.get_size(); idx++)
            {
                m_data[idx] = rhs.m_data[idx];
            }

            for (idx = 0; idx < ((m_data.get_size() >> 3) + 1); idx++)
            {
                m_defined_elements[idx] = rhs.m_defined_elements[idx];
            }
        }

        virtual ~SoapEncArrayT()
        {
            delete [] m_defined_elements;
        }

        virtual void
        read(
            const QName& name,
            ComplexTypeReader& reader
        ) IT_THROW_DECL((IT_Bus::DeserializationException))
        {
            reader.read_soap_enc_array(name, *this);
        }

        virtual void
        write(
            const QName& name,
            ComplexTypeWriter& writer
        ) const IT_THROW_DECL((IT_Bus::SerializationException))
        {
            writer.write_soap_enc_array(name, *this);
        }

        const size_t
        get_offset(
            const ArrayCoordinate & position
        ) const
        {
            size_t offset = position[0];
            for (size_t idx = 1; idx < m_array_extents.get_number_dimensions(); idx++)
            {
                offset *= m_array_extents[idx];
                offset += position[idx];
            }
            return offset;
        }

        const size_t
        get_offset(
            const String & coords
        ) const
        {
            SoapEncArrayCoordinate coordinate(m_array_extents.get_number_dimensions());

            String dimensions = coords.substr(1, coords.length() - 2);

            unsigned int comma_count = 0;
            String tmp_string = dimensions;

            size_t start = 0;
            size_t end = dimensions.find(',', start);
            while (end != String::npos)
            {
                comma_count++;
                start = end + 1;
                end = dimensions.find(',', start);
            }

            size_t idx = 0;
            start = 0;
            end = dimensions.find(',', start);
            while (end != String::npos)
            {
                coordinate[idx] = atoi(dimensions.substr(start, end - start).c_str());
                idx++;
                start = end + 1;
                end = dimensions.find(',', start);
            }
            coordinate[idx] = atoi(dimensions.substr(start).c_str());

            return get_offset(coordinate);
        }


        const T &
        operator[](
            size_t offset
        ) const
        {
            return m_data[offset];
        }

        T &
        operator[](
            size_t offset
        )
        {
            unsigned char mask = (unsigned char) (offset & 7);
            mask = ((unsigned char)1) << mask;

            *(m_defined_elements + (offset >> 3)) |= mask;

            return m_data[offset];
        }


        const T &
        operator[](
            int offset
        ) const
        {
            return m_data[offset];
        }

        T &
        operator[](
            int offset
        )
        {
            unsigned char mask = (unsigned char) (offset & 7);
            mask = ((unsigned char)1) << mask;

            *(m_defined_elements + (offset >> 3)) |= mask;

            return m_data[offset];
        }

        const T &
        operator[](
            const ArrayCoordinate & position
        ) const
        {
            return m_data[get_offset(position)];
        }

        T &
        operator[](
            const ArrayCoordinate & position
        )
        {
            size_t offset = get_offset(position);

            unsigned char mask = (unsigned char) (offset & 7);
            mask = ((unsigned char)1) << mask;

            *(m_defined_elements + (offset >> 3)) |= mask;

            return m_data[offset];
        }

        const T &
        operator[](
            const IT_Bus::SoapEncArrayCoordinate & position
        ) const
        {
            return m_data[get_offset(position)];
        }

        T &
        operator[](
            const IT_Bus::SoapEncArrayCoordinate & position
        )
        {
            size_t offset = get_offset(position);

            unsigned char mask = (unsigned char) (offset & 7);
            mask = ((unsigned char)1) << mask;

            *(m_defined_elements + (offset >> 3)) |= mask;

            return m_data[offset];
        }

        const T &
        operator[](
            const size_t coords[]
        ) const
        {
            IT_Bus::SoapEncArrayCoordinate position(m_array_extents.get_number_dimensions(),coords);
            return m_data[get_offset(position)];
        }

        T &
        operator[](
            const size_t coords[]
        )
        {
            IT_Bus::SoapEncArrayCoordinate position(m_array_extents.get_number_dimensions(),coords);
            size_t offset = get_offset(position);

            unsigned char mask = (unsigned char) (offset & 7);
            mask = ((unsigned char)1) << mask;

            *(m_defined_elements + (offset >> 3)) |= mask;

            return m_data[offset];
        }

        const T &
        operator[](
            const String & position
        ) const
        {
            return m_data[get_offset(position)];
        }

        T &
        operator[](
            const String & position
        )
        {
            size_t offset = get_offset(position);

            unsigned char mask = (unsigned char) (offset & 7);
            mask = ((unsigned char)1) << mask;

            *(m_defined_elements + (offset >> 3)) |= mask;

            return m_data[offset];
        }


        virtual void
        write_position(
            ArrayCoordinate & position,
            ComplexTypeWriter & writer
        ) const IT_THROW_DECL((SerializationException))
        {
            writer.write(QName::ITEM_QNAME, (*this)[position]);
        }

        virtual void
        read_position(
            ComplexTypeReader & reader,
            ArrayCoordinate & position
        ) IT_THROW_DECL((DeserializationException)) 
        {
            size_t offset = get_offset(position);
            T & item = m_data[offset];

            reader.read(QName::ITEM_QNAME, item);
            unsigned char mask = (unsigned char) (offset & 7);
            mask = ((unsigned char)1) << mask;

            offset >>= 3;
            *(m_defined_elements + offset) |= mask;
        }

        virtual void
        write_contents(
            ComplexTypeWriter & writer
        ) const IT_THROW_DECL((SerializationException))
        {
            writer.write_element_list(m_data.get_item_name(), m_data);
        }
        
        virtual void
        read_contents(
            ComplexTypeReader & reader
        ) IT_THROW_DECL((DeserializationException))
        {
            reader.read_element_list(m_data.get_item_name(), m_data);
        }

        virtual bool
        is_empty(
            const ArrayCoordinate & position
        ) const
        {
            size_t offset = get_offset(position);

            unsigned char mask = (unsigned char) (offset & 7);
            mask = ((unsigned char)1) << mask;

            offset >>= 3;
            return ((*(m_defined_elements + offset) & mask) == 0);
        }


        virtual bool
        is_empty(
            const IT_Bus::SoapEncArrayCoordinate & position
        ) const
        {
            return is_empty(IT_STATIC_CAST(const ArrayCoordinate &, position));
        }

        virtual bool
        is_empty(
            const size_t coords[]
        ) const
        {
            IT_Bus::SoapEncArrayCoordinate position(m_array_extents.get_number_dimensions(),coords);
            return is_empty(IT_STATIC_CAST(const ArrayCoordinate &, position));
        }


        virtual void
        set_empty(
            const ArrayCoordinate & position
        )
        {
            size_t offset = get_offset(position);

            unsigned char mask = (unsigned char) (offset & 7);
            mask = ((unsigned char)1) << mask;
            mask = !mask;

            offset >>= 3;
            *(m_defined_elements + offset) &= mask;
        }

        virtual void
        set_empty(
            const IT_Bus::SoapEncArrayCoordinate & position
        )
        {
            set_empty(IT_STATIC_CAST(const ArrayCoordinate &, position));
        }

        virtual void
        set_empty(
            const size_t coords[]
        )
        {
            IT_Bus::SoapEncArrayCoordinate position(m_array_extents.get_number_dimensions(),coords);
            set_empty(IT_STATIC_CAST(const ArrayCoordinate &, position));
        }

        virtual const ArrayCoordinate &
        get_extents() const
        {
            return m_array_extents;
        }

        virtual void
        set_extents(
            const ArrayCoordinate & extents
        )
        {
            m_data.set_size(0);
            delete [] m_defined_elements;

            size_t raw_size = extents[0];
            for (size_t idx = 1; idx < m_array_extents.get_number_dimensions(); idx++)
            {
                raw_size *= extents[idx];
            }

            if (raw_size != 0)
            {
                m_data.set_size(raw_size);
                m_defined_elements = new unsigned char[(raw_size >> 3) + 1];
                memset(m_defined_elements, 0, (raw_size >> 3) + 1);
            }
            else
            {
                m_data.set_size(0);
                m_defined_elements = new unsigned char[1];
                m_defined_elements[0] = 0;
            }
            m_array_extents = extents;
        }

        SoapEncArrayT<T> &
        operator=(
            const SoapEncArrayT<T> & rhs
        )
        {
            set_extents(rhs.m_array_extents);
            size_t idx;
            for (idx = 0; idx < m_data.get_size(); idx++)
            {
                m_data[idx] = rhs.m_data[idx];
            }

            for (idx = 0; idx < ((m_data.get_size() >> 3) + 1); idx++)
            {
                m_defined_elements[idx] = rhs.m_defined_elements[idx];
            }
            return * this;
        }

        AnyType &
        operator= (
            const AnyType & assign
        )
        {
            const ThisType & rhs = IT_DYNAMIC_CAST(const ThisType &, assign);
            *this = rhs;

            return *this;
        }

        const ElementList &
        get_element_list() const
        {
            return m_data;
        }

        ElementList &
        get_element_list()
        {
            return m_data;
        }

      protected:

        IT_Bus::ElementListT<T>  m_data;

        unsigned char * m_defined_elements;
        SoapEncArrayCoordinate m_array_extents;
    };
}

#endif  

---