it_bus/binary_nillable_type.h

#ifndef _IT_BUS_BINARY_NILLABLE_TYPE_H_
#define _IT_BUS_BINARY_NILLABLE_TYPE_H_

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

#include <it_bus/api_defines.h>
#include <it_bus/nillable.h>
#include <it_bus/binary_buffer_nillable.h>
#include <it_bus/binary_type.h>
#include <it_bus/qname.h>
#include <it_bus/complex_type_writer.h>
#include <it_bus/complex_type_reader.h>
#include <it_schema_model/w3c_constants.h>

namespace IT_Bus
{
    template <const QName* TYPE>
    class BinaryOutParamNillable: public Nillable
    {
      public:
        BinaryOutParamNillable(
            const BinaryOutParamNillable& other
        );

        BinaryOutParamNillable(
            IT_Bus::BinaryBufferNillable& other
        );

        virtual ~BinaryOutParamNillable();

        BinaryOutParamNillable&
        operator=(
            const BinaryOutParamNillable& other
        );

        AnyType&
        copy(
            const AnyType& other
        );

        virtual const QName&
        get_type() const;

        virtual Boolean
        is_nil() const;

        virtual void
        set_nil();
        
        virtual void 
        write_value(
            const QName& name,
            ComplexTypeWriter& writer
        ) const throw((SerializationException));

        virtual void
        read_value(
            const QName& name,
            ComplexTypeReader& reader
        ) throw((DeserializationException));

        virtual const IT_Bus::BinaryBufferNillable&
        get() const throw((NoDataException));
        
        virtual IT_Bus::BinaryBufferNillable&
        get() throw((NoDataException));
        
        virtual void
        set(
            const IT_Bus::BinaryBufferNillable& data
        );

        virtual void
        reset();

      private:

        typedef BinaryOutParamNillable ThisType; // needed for DYNAMIC_CAST macro
        IT_Bus::BinaryBufferNillable&      m_data;
    };


    template <const QName* TYPE>
    class BinaryInParamNillable: public Nillable
    {
      public:
        BinaryInParamNillable(
            const BinaryInParamNillable& other
        );

        BinaryInParamNillable(
            const IT_Bus::BinaryBufferNillable& other
        );

        virtual ~BinaryInParamNillable();

        BinaryInParamNillable&
        operator=(
            const BinaryInParamNillable& other
        );

        AnyType&
        copy(
            const AnyType& other
        );

        virtual const QName&
        get_type() const;

        virtual Boolean
        is_nil() const;

        virtual void 
        write_value(
            const QName& name,
            ComplexTypeWriter& writer
        ) const throw((SerializationException));

        virtual void
        read_value(
            const QName& name,
            ComplexTypeReader& reader
        ) throw((DeserializationException));

        virtual const IT_Bus::BinaryBufferNillable&
        get() const throw((NoDataException));
        
   
      private:
        typedef BinaryInParamNillable ThisType; // needed for DYNAMIC_CAST macro
        const IT_Bus::BinaryBufferNillable&      m_data;
    };


    template <const QName* TYPE>
    BinaryOutParamNillable<TYPE>::BinaryOutParamNillable(
        const BinaryOutParamNillable& other
    ) 
        :m_data(other.m_data)
    {
        // Complete.
    }

    template <const QName* TYPE>
    BinaryOutParamNillable<TYPE>::BinaryOutParamNillable(
         IT_Bus::BinaryBufferNillable& data
    ) 
        :m_data(data)
    {
        // Complete.
    }

    template <const QName* TYPE>
    BinaryOutParamNillable<TYPE>::~BinaryOutParamNillable()
    {
        // Complete.
    }

    template <const QName* TYPE>
    BinaryOutParamNillable<TYPE>&
    BinaryOutParamNillable<TYPE>::operator=(
        const BinaryOutParamNillable<TYPE>& other
    ) 
    {
        if (other.is_nil())
        {
            reset();
        }
        else
        {
            set(other.get());
        }
        return *this;
    }

    template <const QName* TYPE>
    AnyType&
    BinaryOutParamNillable<TYPE>::copy(
        const AnyType& rhs
    ) 
    {
        const ThisType& other = IT_DYNAMIC_CAST(const ThisType&, rhs);
        *this = other;
        return *this;
    }

    template <const QName* TYPE>
    const QName&
    BinaryOutParamNillable<TYPE>::get_type() const
    {
        return *TYPE;
    }

    template <const QName* TYPE>
    IT_Bus::Boolean
    BinaryOutParamNillable<TYPE>::is_nil() const
    {
        return  m_data.is_nil();
    }

    template <const QName* TYPE>
    void
    BinaryOutParamNillable<TYPE>::set_nil() 
    {
        m_data.set_nil();
    }

    template <const QName* TYPE>
    void
    BinaryOutParamNillable<TYPE>::write_value(
        const QName& element_name,
        ComplexTypeWriter& writer
    ) const throw((SerializationException)) 
    {
        if (is_nil())
        {
            throw SerializationException("Attempt to write nil value");
        }
        else 
        {
            if ( *TYPE == IT_W3CConstants::NT_SCHEMA_BASE64 )
            {
                Base64BinaryInParam in_param(m_data.get());
                writer.write(element_name, in_param);
            }
            else
            {
                HexBinaryInParam in_param(m_data.get());
                writer.write(element_name, in_param);
            }
        }

    }

    template <const QName* TYPE>
    void
    BinaryOutParamNillable<TYPE>::read_value(
        const QName& name,
        ComplexTypeReader& reader
    ) throw((DeserializationException))
    {
        if ( *TYPE == IT_W3CConstants::NT_SCHEMA_BASE64 )
        {
            Base64Binary out_param;
            reader.read(name, out_param);
            m_data.set(out_param);
        }
        else
        {
            HexBinary out_param;
            reader.read(name, out_param);
            m_data.set(out_param);
        }
    }

    template <const QName* TYPE>
    IT_Bus::BinaryBufferNillable&
    BinaryOutParamNillable<TYPE>::get() throw((NoDataException))
    {
        if (is_nil())
        {
            throw NoDataException("Nillable value has no data");
        }
        return m_data;
    }

    template <const QName* TYPE>
    const IT_Bus::BinaryBufferNillable&
    BinaryOutParamNillable<TYPE>::get() const throw((NoDataException))
    {
        if (is_nil())
        {
            throw NoDataException("Nillable value has no data");
        }
        return m_data;
    }

    template <const QName* TYPE>
    void
    BinaryOutParamNillable<TYPE>::set(
        const IT_Bus::BinaryBufferNillable& data
    )
    {
        m_data = data;
    }

    template <const QName* TYPE>
    void
    BinaryOutParamNillable<TYPE>::reset()
    {
         m_data.reset();   
    }

    template <const QName* TYPE>
    BinaryInParamNillable<TYPE>::BinaryInParamNillable(
        const BinaryInParamNillable& other
    ) 
        :m_data(other.m_data)
    {
        // Complete.
    }

    template <const QName* TYPE>
    BinaryInParamNillable<TYPE>::BinaryInParamNillable(
         const IT_Bus::BinaryBufferNillable& data
    ) 
        :m_data(data)
    {
        // Complete.
    }

    template <const QName* TYPE>
    BinaryInParamNillable<TYPE>::~BinaryInParamNillable()
    {
        // Complete.
    }

    template <const QName* TYPE>
    BinaryInParamNillable<TYPE>&
    BinaryInParamNillable<TYPE>::operator=(
        const BinaryInParamNillable<TYPE>& other
    ) 
    {
        if (other.is_nil())
        {
            this->reset();
        }
        else
        {
            BinaryInParamNillable<TYPE>::set(other.get());
        }
        return *this;
    }

    template <const QName* TYPE>
    AnyType&
    BinaryInParamNillable<TYPE>::copy(
        const AnyType& rhs
    ) 
    {
        const ThisType& other = IT_DYNAMIC_CAST(const ThisType&, rhs);
        *this = other;
        return *this;
    }

    template <const QName* TYPE>
    const QName&
    BinaryInParamNillable<TYPE>::get_type() const
    {
        return *TYPE;
    }

    template <const QName* TYPE>
    IT_Bus::Boolean
    BinaryInParamNillable<TYPE>::is_nil() const
    {
        return  m_data.is_nil();
    }

    template <const QName* TYPE>
    const IT_Bus::BinaryBufferNillable&
    BinaryInParamNillable<TYPE>::get() const throw((NoDataException))
    {
        if (is_nil())
        {
            throw NoDataException("Nillable value has no data");
        }
        return m_data;
    }
}

#endif  

---