it_bus/reflect/value_impl_t.h

#ifndef _IT_REFLECT_VALUE_IMPL_T_CXX_
#define _IT_REFLECT_VALUE_IMPL_T_CXX_

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

#include <it_bus/reflect/value.h>
#include <it_bus/schema_type_traits.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>

namespace IT_Reflect
{
    template <class T>
    class ValueImplT :
        public IT_Reflect::Value<T>,
        public IT_Bus::AnySimpleType
    {
      public:
        ValueImplT() throw(());

        ValueImplT(
            const T& value
        ) throw(());

        ~ValueImplT() throw(());

        ValueImplT&
        operator= (
            const T& value
        ) throw(());

        operator T&() throw(());

        operator const T&() const throw(());

        virtual const T&
        get_value() const throw(());
        
        virtual T&
        get_value() throw(());

        virtual void
        set_value(
            const T& value
        ) throw(());

        virtual const IT_Bus::QName&
        get_type_name() const throw(());

        virtual IT_Bus::AnyType::Kind
        get_type_kind() const throw(());

        BuiltInType::ValueKind
        get_value_kind() const throw(());

        virtual IT_Bus::AnyType*
        clone() const throw((ReflectException));

        virtual const IT_Bus::AnyType& 
        get_reflected() const throw(());

        virtual IT_Bus::AnyType& 
        get_reflected() throw(());
        
        void
        copy(
            const IT_Reflect::BuiltInType* other
        ) throw((ReflectException));

        virtual IT_Bus::Boolean
        equals(
            const IT_Reflect::BuiltInType* other
        ) const throw(());


        // AnySimpleType functions
        //
        
        virtual const IT_Bus::QName&
        get_type() const;

        virtual AnyType::Kind
        get_kind() const;

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

        virtual const IT_Reflect::Reflection*
        get_reflection() const throw(());
        
        virtual void
        read(
            const IT_Bus::QName& name,
            IT_Bus::ComplexTypeReader& reader
        ) throw((IT_Bus::DeserializationException));

        virtual void 
        write(
            const IT_Bus::QName& name,
            IT_Bus::ComplexTypeWriter& writer
        ) const throw((IT_Bus::SerializationException));

        virtual void
        read_value(
            IT_Bus::AnySimpleTypeReader& reader
        ) throw((IT_Bus::DeserializationException));

        virtual void 
        write_value(
            IT_Bus::AnySimpleTypeWriter& writer
        ) const throw((IT_Bus::SerializationException));

        virtual
        IT_Bus::AnyType&
        copy(
            const IT_Bus::AnyType & rhs
        );

      private:
        T m_data;
    };


    // Template function definitions
    //
    
    template <class T>
    ValueImplT<T>::ValueImplT() throw(())
    {
        // Complete.
    }

    template <class T>
    ValueImplT<T>::ValueImplT(
        const T& value
    ) throw(())
        :
        m_data(IT_CONST_CAST(T&, value))
    {
        // Complete.
    }

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

    template <class T>
    ValueImplT<T>&
    ValueImplT<T>::operator=(
        const T& data
    ) throw(())
    {
        m_data = data;
        return *this;
    }

    template <class T>
    ValueImplT<T>::operator T&() throw(())
    {
        return m_data;
    }

    template <class T>
    ValueImplT<T>::operator const T&() const throw(())
    {
        return m_data;
    }

    template <class T>
    const T&
    ValueImplT<T>::get_value() const throw(())
    {
        return m_data;
    }

    template <class T>
    T&
    ValueImplT<T>::get_value() throw(())
    {
        return m_data;
    }

    template <class T>
    void
    ValueImplT<T>::set_value(
        const T& value
    ) throw(())
    {
        m_data = value;
    }

    template <class T>
    const IT_Bus::QName&
    ValueImplT<T>::get_type_name(
    ) const throw(())
    {
        return IT_Bus::SchemaTypeTraits<T>::type_name();
    }

    template <class T>
    IT_Bus::AnyType::Kind
    ValueImplT<T>::get_type_kind(
    ) const throw(())
    {
        return IT_Bus::AnyType::BUILT_IN;
    }

    template <class T>
    const IT_Bus::AnyType& 
    ValueImplT<T>::get_reflected() const throw(())
    {
        return *this;
    }

    template <class T>
    IT_Bus::AnyType& 
    ValueImplT<T>::get_reflected() throw(())
    {
        return *this;
    }

    template <class T>
    IT_Bus::AnyType*
    ValueImplT<T>::clone() const throw((ReflectException))
    {
        return new ValueImplT<T>(m_data);
    }
    // AnySimpleType function definitions
    //

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

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

    template <class T>
    IT_Reflect::Reflection*
    ValueImplT<T>::get_reflection() throw(())
    {
        this->_add_ref();
        return this;
    }
    
    template <class T>
    const IT_Reflect::Reflection*
    ValueImplT<T>::get_reflection() const throw(())
    {
        this->_add_ref();
        return this;
    }

    template <class T>
    void
    ValueImplT<T>::read(
        const IT_Bus::QName& name,
        IT_Bus::ComplexTypeReader& reader
    ) throw((IT_Bus::DeserializationException))
    {
        reader.read(name, this->m_data);
    }

    template <class T>
    void
    ValueImplT<T>::write(
        const IT_Bus::QName& name,
        IT_Bus::ComplexTypeWriter& writer
    ) const throw((IT_Bus::SerializationException))
    {
        writer.write(name, this->m_data);
    }

    template <class T>
    void
    ValueImplT<T>::read_value(
        IT_Bus::AnySimpleTypeReader& reader
    ) throw((IT_Bus::DeserializationException))
    {
        reader.read(this->m_data);
    }

    template <class T>
    void
    ValueImplT<T>::write_value(
        IT_Bus::AnySimpleTypeWriter& writer
    ) const throw((IT_Bus::SerializationException))
    {
        writer.write(this->m_data);
    }

    template <class T>
    IT_Bus::AnyType&
    ValueImplT<T>::copy(
        const IT_Bus::AnyType & rhs
    )
    {
        m_data = IT_DYNAMIC_CAST(const ValueImplT<T>&, rhs).m_data;
        return *this;
    }
    
    template <class T>
    void
    ValueImplT<T>::copy(
        const IT_Reflect::BuiltInType* other
    ) throw((ReflectException))
    {
        const IT_Reflect::Value<T>* value =
            IT_DYNAMIC_CAST(const IT_Reflect::Value<T>*, other);
        if (value == 0)
        {
            throw ReflectException(get_type_name(), other->get_type_name());
        }
        this->m_data = value->get_value();
    }

    template <class T>
    IT_Bus::Boolean
    ValueImplT<T>::equals(
        const IT_Reflect::BuiltInType* other
    ) const throw(())
    {
        const IT_Reflect::Value<T>* value =
            IT_DYNAMIC_CAST(const IT_Reflect::Value<T>*, other);
        if (value == 0)
        {
            return IT_FALSE;
        }
        return this->m_data == value->get_value();
    }

    template <class T>
    BuiltInType::ValueKind
    ValueImplT<T>::get_value_kind() const throw(())
    {
        return BuiltInType::ValueKind(IT_Bus::SchemaTypeTraits<T>::value_kind);
    }
}

#endif  

---