it_bus/nillable_value_base.h

#ifndef _IT_BUS_NILLABLE_VALUE_BASE_H_
#define _IT_BUS_NILLABLE_VALUE_BASE_H_

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

#include <it_bus/any_type.h>
#include <it_bus/nillable.h>
#include <it_bus/complex_type_reader.h>
#include <it_bus/complex_type_writer.h>
#include <it_bus/no_data_exception.h>
#include <it_bus/schema_type_traits.h>

namespace IT_Reflect
{
    template <class NillableT, class T>
    class NillableValueImplT;
}

namespace IT_Bus
{
    template <class T>
    class NillableValueBase : public Nillable
    {
      public:
        typedef T ValueType;

        typedef IT_Reflect::NillableValueImplT<NillableValueBase<T>, T>
        IT_ReflectionType;

        friend class IT_Reflect::NillableValueImplT<NillableValueBase<T>, T>;

        static const QName&
        get_static_type();
        
        virtual ~NillableValueBase();

        virtual 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 IT_THROW_DECL((SerializationException));

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

        virtual const T&
        get() const IT_THROW_DECL((NoDataException));
        
        virtual T&
        get() IT_THROW_DECL((NoDataException));
        
        virtual void
        set(
            const T& data
        );

        virtual void
        set(
            const T *data
        );

        virtual void
        reset();

        NillableValueBase();

        NillableValueBase(
            const NillableValueBase& other
        );

        NillableValueBase(
            const T& other
        );

        NillableValueBase(
            const T *other
        );

        NillableValueBase&
        operator=(
            const NillableValueBase& other
        );

      private:

        typedef NillableValueBase ThisType; // needed for DYNAMIC_CAST macro
        Boolean m_is_nil;
        T       m_data;
    };

    template<class T>
    const QName&
    NillableValueBase<T>::get_static_type()
    {
        return SchemaTypeTraits<T>::type_name();
    }

    template <class T>
    NillableValueBase<T>::NillableValueBase() 
        :
        m_is_nil(IT_TRUE)
    {
        // Complete.
    }

    template <class T>
    NillableValueBase<T>::NillableValueBase(
        const NillableValueBase<T>& other
    ) 
        :
        m_is_nil(other.m_is_nil),
        m_data(other.m_data)
    {
        // Complete.
    }


    template <class T>
    NillableValueBase<T>::NillableValueBase(
        const T& data
    ) 
        :
        m_is_nil(IT_FALSE),
        m_data(data)
    {
        // Complete.
    }
    
    template <class T>
    NillableValueBase<T>::NillableValueBase(
        const T *data
    ) 
    {
        set(data);
    }

    template <class T>
    NillableValueBase<T>::~NillableValueBase()
    {
        // Complete.
    }

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

    template <class T>
    AnyType&
    NillableValueBase<T>::copy(
        const AnyType& rhs
    ) 
    {
        if (dynamic_cast<const Nillable&>(rhs).is_nil())
        {
            set_nil();
        }
        else
        {
            IT_Reflect::Copier<ThisType>::copy(*this, rhs);
        }
        return *this;
    }

    template <class T>
    IT_Bus::Boolean
    NillableValueBase<T>::is_nil() const
    {
        return m_is_nil;
    }

    template <class T>
    void
    NillableValueBase<T>::set_nil() 
    {
        reset();
    }

    template <class T>
    void
    NillableValueBase<T>::write_value(
        const QName& element_name,
        ComplexTypeWriter& writer
    ) const IT_THROW_DECL((SerializationException)) 
    {
        if (is_nil())
        {
            throw SerializationException("Attempt to write nil value");
        }
        writer.write(element_name, m_data);
    }

    template <class T>
    void
    NillableValueBase<T>::read_value(
        const QName& name,
        ComplexTypeReader& reader
    ) IT_THROW_DECL((DeserializationException))
    {
        reader.read(name, m_data);
        m_is_nil = IT_FALSE;
    }

    template <class T>    
    T&
    NillableValueBase<T>::get() IT_THROW_DECL((NoDataException))
    {
        if (is_nil())
        {
            throw NoDataException("Nillable value has no data");
        }
        return m_data;
    }

    template <class T>    
    const T&
    NillableValueBase<T>::get() const IT_THROW_DECL((NoDataException))
    {
        if (is_nil())
        {
            throw NoDataException("Nillable value has no data");
        }
        return m_data;
    }

    template <class T>
    void
    NillableValueBase<T>::set(
        const T& data
    )
    {
        m_is_nil = IT_FALSE;
        m_data = data;
    }
    
    template <class T>
    void
    NillableValueBase<T>::set(
        const T *data
    )
    {
        if (data == 0)
        {
            m_is_nil = IT_TRUE;
        }
        else
        {
            m_is_nil = IT_FALSE;
            m_data = *data;
        }
    }
 
    template <class T>
    void
    NillableValueBase<T>::reset()
    {
        m_is_nil = IT_TRUE;
    }

    template <class T>
    const QName&
    NillableValueBase<T>::get_type() const
    {
        return get_static_type();
    }
}

#endif  

---