it_bus/any_simple_type_t.h

#ifndef _IT_BUS_ANY_SIMPLE_TYPE_T_CXX_
#define _IT_BUS_ANY_SIMPLE_TYPE_T_CXX_

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

#include <assert.h>
#include <it_bus/any_simple_type.h>
#include <it_bus/any_simple_type_reader.h>
#include <it_bus/any_simple_type_writer.h>
#include <it_bus/complex_type_reader.h>
#include <it_bus/complex_type_writer.h>
#include <it_bus/schema_type_traits.h>
#include <it_bus/reflect/value_ref.h>

namespace IT_Bus
{
    template <class T>
    class AnySimpleTypeBaseT : public AnySimpleType
    {
      public:
        virtual ~AnySimpleTypeBaseT()
            IT_THROW_DECL(());

        virtual const QName&
        get_type() const;

        virtual AnyType::Kind
        get_kind() const;

        virtual IT_Reflect::Reflection*
        get_reflection()
            IT_THROW_DECL(());

        virtual const IT_Reflect::Reflection*
        get_reflection() const
            IT_THROW_DECL(());
        
        virtual void 
        write(
            const QName& name,
            ComplexTypeWriter& writer
        ) const IT_THROW_DECL((SerializationException));

        virtual void
        write_value(
            AnySimpleTypeWriter& writer
        ) const IT_THROW_DECL((SerializationException));

        virtual const T&
        get_value() const = 0;
    };

    template <class T>
    class AnySimpleTypeT : public AnySimpleTypeBaseT<T>
    {
      public:
        AnySimpleTypeT()
            IT_THROW_DECL(());

        AnySimpleTypeT(
            const T& value
        ) IT_THROW_DECL(());

        virtual ~AnySimpleTypeT()
            IT_THROW_DECL(());

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

        virtual void
        read_value(
            AnySimpleTypeReader& reader
        ) IT_THROW_DECL((DeserializationException));

        virtual
        AnyType&
        copy(
            const AnyType & rhs
        );

        virtual const T&
        get_value() const;

        T&
        get_value();

      private:
        T m_value;
    };

    template <class T>
    class AnySimpleTypeRefT : public AnySimpleTypeBaseT<T>
    {
      public:
        AnySimpleTypeRefT(
            T& value
        ) IT_THROW_DECL(());

        virtual ~AnySimpleTypeRefT()
            IT_THROW_DECL(());

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

        virtual void
        read_value(
            AnySimpleTypeReader& reader
        ) IT_THROW_DECL((DeserializationException));

        virtual
        AnyType&
        copy(
            const AnyType & rhs
        );

        virtual const T&
        get_value() const;

        T&
        get_value();

      private:
        T& m_value;
    };

    template <class T>
    class AnySimpleTypeConstRefT : public AnySimpleTypeBaseT<T>
    {
      public:
        AnySimpleTypeConstRefT(
            const T& value
        ) IT_THROW_DECL(());

        virtual ~AnySimpleTypeConstRefT()
            IT_THROW_DECL(());

        // DO NOT CALL. This class is immutable.
        //
        virtual void
        read(
            const QName& name,
            ComplexTypeReader& reader
        ) IT_THROW_DECL((DeserializationException));

        // DO NOT CALL. This class is immutable.
        //
        virtual void
        read_value(
            AnySimpleTypeReader& reader
        ) IT_THROW_DECL((DeserializationException));

        // DO NOT CALL. This class is immutable.
        //
        virtual
        AnyType&
        copy(
            const AnyType & rhs
        );

        virtual const T&
        get_value() const;

      private:
        const T& m_value;
    };

    // --------------------------------------------------------------------
    // AnySimpleTypeBaseT method implementation
    // --------------------------------------------------------------------

    template <class T>
    inline
    AnySimpleTypeBaseT<T>::~AnySimpleTypeBaseT() IT_THROW_DECL(())
    {
        // Complete.
    }

    template <class T>
    inline const QName&
    AnySimpleTypeBaseT<T>::get_type() const
    {
        return SchemaTypeTraits<T>::type_name();
    }

    template <class T>
    inline AnyType::Kind
    AnySimpleTypeBaseT<T>::get_kind() const
    {
        return AnyType::BUILT_IN;
    }

    template <class T>
    inline IT_Reflect::Reflection*
    AnySimpleTypeBaseT<T>::get_reflection() IT_THROW_DECL(())
    {
        return new IT_Reflect::ValueRef<T>(get_value());
    }
    
    template <class T>
    inline const IT_Reflect::Reflection*
    AnySimpleTypeBaseT<T>::get_reflection() const IT_THROW_DECL(())
    {
        return new IT_Reflect::ValueRef<T>(get_value());
    }

    template <class T>
    inline void
    AnySimpleTypeBaseT<T>::write(
        const QName& name,
        ComplexTypeWriter& writer
    ) const IT_THROW_DECL((SerializationException))
    {
        writer.write(name, get_value());
    }

    template <class T>
    inline void
    AnySimpleTypeBaseT<T>::write_value(
        AnySimpleTypeWriter& writer
    ) const IT_THROW_DECL((SerializationException))
    {
        writer.write(get_value());
    }

    // --------------------------------------------------------------------
    // AnySimpleTypeT method implementation
    // --------------------------------------------------------------------

    template <class T>
    inline
    AnySimpleTypeT<T>::AnySimpleTypeT() IT_THROW_DECL(()) 
    {
        // Complete.
    }

    template <class T>
    inline
    AnySimpleTypeT<T>::AnySimpleTypeT(
        const T& value
    ) IT_THROW_DECL(()) :
        m_value(value)
    {
        // Complete.
    }

    template <class T>
    inline
    AnySimpleTypeT<T>::~AnySimpleTypeT() IT_THROW_DECL(())
    {
        // Complete.
    }

    template <class T>
    inline void
    AnySimpleTypeT<T>::read(
        const QName& name,
        ComplexTypeReader& reader
    ) IT_THROW_DECL((DeserializationException))
    {
        reader.read(name, get_value());
    }

    template <class T>
    inline void
    AnySimpleTypeT<T>::read_value(
        AnySimpleTypeReader& reader
    ) IT_THROW_DECL((DeserializationException))
    {
        reader.read(get_value());
    }

    template <class T>
    inline AnyType&
    AnySimpleTypeT<T>::copy(
        const AnyType & rhs
    )
    {
        const AnySimpleTypeBaseT<T>* tmp =
            IT_DYNAMIC_CAST(const AnySimpleTypeBaseT<T>*, &rhs);
        if (tmp != 0)
        {
            m_value = tmp->get_value();
        }
        else
        {
            IT_Reflect::copy(*this, rhs);
        }

        return *this;
    }

    template <class T>
    inline const T&
    AnySimpleTypeT<T>::get_value() const
    {
        return m_value;
    }

    template <class T>
    inline T&
    AnySimpleTypeT<T>::get_value()
    {
        return m_value;
    }

    // --------------------------------------------------------------------
    // AnySimpleTypeRefT method implementation
    // --------------------------------------------------------------------

    template <class T>
    inline
    AnySimpleTypeRefT<T>::AnySimpleTypeRefT(
        T& value
    ) IT_THROW_DECL(()) :
        m_value(value)
    {
        // Complete.
    }

    template <class T>
    inline
    AnySimpleTypeRefT<T>::~AnySimpleTypeRefT() IT_THROW_DECL(())
    {
        // Complete.
    }

    template <class T>
    inline void
    AnySimpleTypeRefT<T>::read(
        const QName& name,
        ComplexTypeReader& reader
    ) IT_THROW_DECL((DeserializationException))
    {
        reader.read(name, get_value());
    }

    template <class T>
    inline void
    AnySimpleTypeRefT<T>::read_value(
        AnySimpleTypeReader& reader
    ) IT_THROW_DECL((DeserializationException))
    {
        reader.read(get_value());
    }

    template <class T>
    inline AnyType&
    AnySimpleTypeRefT<T>::copy(
        const AnyType & rhs
    )
    {
        const AnySimpleTypeBaseT<T>* tmp =
            IT_DYNAMIC_CAST(const AnySimpleTypeBaseT<T>*, &rhs);
        assert(tmp != 0);

        m_value = tmp->get_value();
        return *this;
    }

    template <class T>
    inline const T&
    AnySimpleTypeRefT<T>::get_value() const
    {
        return m_value;
    }

    template <class T>
    inline T&
    AnySimpleTypeRefT<T>::get_value()
    {
        return m_value;
    }

    // --------------------------------------------------------------------
    // AnySimpleTypeConstRefT method implementation
    // --------------------------------------------------------------------

    template <class T>
    inline
    AnySimpleTypeConstRefT<T>::AnySimpleTypeConstRefT(
        const T& value
    ) IT_THROW_DECL(()) :
        m_value(value)
    {
        // Complete.
    }

    template <class T>
    inline
    AnySimpleTypeConstRefT<T>::~AnySimpleTypeConstRefT() IT_THROW_DECL(())
    {
        // Complete.
    }

    template <class T>
    inline void
    AnySimpleTypeConstRefT<T>::read(
        const QName& /*name*/,
        ComplexTypeReader& /*reader*/
    ) IT_THROW_DECL((DeserializationException))
    {
        throw DeserializationException(
            "AnySimpleTypeConstRefT<T>::read() not supported"
        );
    }

    template <class T>
    inline void
    AnySimpleTypeConstRefT<T>::read_value(
        AnySimpleTypeReader& /*reader*/
    ) IT_THROW_DECL((DeserializationException))
    {
        throw DeserializationException(
            "AnySimpleTypeConstRefT<T>::read_value() not supported"
        );
    }

    template <class T>
    inline AnyType&
    AnySimpleTypeConstRefT<T>::copy(
        const AnyType & /*rhs*/
    )
    {
        throw Exception(
            "AnySimpleTypeConstRefT<T>::copy() not supported"
        );
        IT_UNREACHABLE_RETURN(*this);
    }

    template <class T>
    inline const T&
    AnySimpleTypeConstRefT<T>::get_value() const
    {
        return m_value;
    }
}


#endif  

---