it_bus/reflect/value_ref_base.h

#ifndef _IT_REFLECT_VALUE_REF_BASE_CXX_
#define _IT_REFLECT_VALUE_REF_BASE_CXX_

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

#include <it_bus/reflect/value.h>
#include <it_bus/schema_type_traits.h>

namespace IT_Reflect
{
    template <class T>
    class ValueRefBase : public IT_Reflect::Value<T>
    {
      public:
        ValueRefBase(
            const T& value
        ) throw(());

        ValueRefBase(
            const T* value
        ) throw(());

        ~ValueRefBase() 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 void
        duplicate(
            const IT_Reflect::BuiltInType* other
        ) throw((ReflectException));

        virtual void
        reset(
            const T* new_value
        ) const throw(());
        
      protected:
        T* m_value;
    };


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

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

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

    template <class T>
    const T&
    ValueRefBase<T>::get_value() const throw(())
    {
        return *m_value;
    }

    template <class T>
    T&
    ValueRefBase<T>::get_value() throw(())
    {
        return *m_value;
    }

    template <class T>
    void
    ValueRefBase<T>::set_value(
        const T& value
    ) throw(())
    {
        *m_value = value;
    }

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

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

    template <class T>
    void
    ValueRefBase<T>::duplicate(
        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_value = value->get_value();
    }

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

    template <class T>
    void
    ValueRefBase<T>::reset(
        const T* new_value
    ) const throw(())
    {
        IT_CONST_CAST(ValueRefBase<T>*, this)->m_value =
            IT_CONST_CAST(T*, new_value);
    }
}

#endif  

---