it_bus/reflect/value_ref.h

#ifndef _IT_REFLECT_VALUE_REF_CXX_
#define _IT_REFLECT_VALUE_REF_CXX_

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

#include <it_bus/reflect/value_ref_base.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 ValueRef :
        public IT_Reflect::ValueRefBase<T>,
        public IT_Bus::AnySimpleType
    {
      public:
        ValueRef(
            const T& value
        ) IT_THROW_DECL(());

        ValueRef(
            const T* value
        ) IT_THROW_DECL(());

        ~ValueRef() IT_THROW_DECL(());
        
        virtual const IT_Bus::AnyType& 
        get_reflected() const IT_THROW_DECL(());

        virtual IT_Bus::AnyType& 
        get_reflected() IT_THROW_DECL(());
        
        // AnySimpleType functions
        //
        
        virtual const IT_Bus::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
        read(
            const IT_Bus::QName& name,
            IT_Bus::ComplexTypeReader& reader
        ) IT_THROW_DECL((IT_Bus::DeserializationException));

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

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

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

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

        virtual IT_Bus::AnyType*
        clone() const IT_THROW_DECL((ReflectException));
    };


    // Template function definitions
    //
    
    template <class T>
    ValueRef<T>::ValueRef(
        const T& value
    ) IT_THROW_DECL(())
        :
        ValueRefBase<T>(IT_CONST_CAST(T*, &value))
    {
        // Complete.
    }

    template <class T>
    ValueRef<T>::ValueRef(
        const T* value
    ) IT_THROW_DECL(())
        :
        ValueRefBase<T>(IT_CONST_CAST(T*, value))
    {
        // Complete.
    }

    template <class T>
    ValueRef<T>::~ValueRef() IT_THROW_DECL(())
    {
        // Complete
    }
    
    template <class T>
    const IT_Bus::AnyType& 
    ValueRef<T>::get_reflected() const IT_THROW_DECL(())
    {
        return *this;
    }

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

    // AnySimpleType function definitions
    //

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

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

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

    template <class T>
    void
    ValueRef<T>::read(
        const IT_Bus::QName& name,
        IT_Bus::ComplexTypeReader& reader
    ) IT_THROW_DECL((IT_Bus::DeserializationException))
    {
        reader.read(name, *this->m_value);
    }

    template <class T>
    void
    ValueRef<T>::write(
        const IT_Bus::QName& name,
        IT_Bus::ComplexTypeWriter& writer
    ) const IT_THROW_DECL((IT_Bus::SerializationException))
    {
        writer.write(name, *this->m_value);
    }

    template <class T>
    void
    ValueRef<T>::read_value(
        IT_Bus::AnySimpleTypeReader& reader
    ) IT_THROW_DECL((IT_Bus::DeserializationException))
    {
        reader.read(*this->m_value);
    }

    template <class T>
    void
    ValueRef<T>::write_value(
        IT_Bus::AnySimpleTypeWriter& writer
    ) const IT_THROW_DECL((IT_Bus::SerializationException))
    {
        writer.write(*this->m_value);
    }

    template <class T>
    IT_Bus::AnyType&
    ValueRef<T>::copy(
        const IT_Bus::AnyType & rhs
    )
    {
        const ValueRef<T>* other = IT_DYNAMIC_CAST(const ValueRef<T>*, &rhs);
        if (other)
        {
            *this->m_value = *other->m_value;
        }
        return *this;
    }
    
    template <class T>
    IT_Bus::AnyType*
    ValueRef<T>::clone() const IT_THROW_DECL((ReflectException))
    {
        return new ValueRef<T>(this->m_value);
    }
}

#endif  

---