it_bus/reflect/nillable_raw_ptr_impl_t.h

#ifndef _IT_REFLECT_NILLABLE_RAW_PTR_IMPL_T_H_
#define _IT_REFLECT_NILLABLE_RAW_PTR_IMPL_T_H_

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

#include <it_bus/reflect/nillable.h>

namespace IT_Reflect
{
    template <class T>
    class NillableRawPtrImplT  : public virtual Nillable
    {
      public:
        NillableRawPtrImplT(
            const T*& data
        ) throw(());

        virtual ~NillableRawPtrImplT() throw(());

        virtual IT_Bus::Boolean
        get_is_nil() const throw(());

        virtual void
        set_is_nil() throw(());
        
        virtual const Reflection*
        get_value() const throw((ReflectException));

        virtual Reflection*
        use_value() throw((ReflectException));

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

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

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

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

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

      protected:
        T& check_data();
        T*& m_data;
    };

    template <class T>
    NillableRawPtrImplT<T>::NillableRawPtrImplT(
        const T*& data
    ) throw(())
        :
        m_data(IT_CONST_CAST(T*&, data))
    {
        // Complete.
    }

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

    template <class T>
    T&
    NillableRawPtrImplT<T>::check_data()
    {
        if (this->m_data == 0)
        {
            throw IT_Reflect::ReflectException("Attempt to use nil value");
        }
        return *this->m_data;
    }
    
    template <class T>
    IT_Bus::Boolean
    NillableRawPtrImplT<T>::get_is_nil(
    ) const throw(())
    {
        return this->m_data == 0;
    }

    template <class T>
    void
    NillableRawPtrImplT<T>::set_is_nil(
    ) throw(())
    {
        delete this->m_data;
        this->m_data = 0;
    }

    template <class T>
    const Reflection*
    NillableRawPtrImplT<T>::get_value(
    ) const throw((ReflectException))
    {
        return get_is_nil() ? 0 : Traits<T>::get_reflection(*this->m_data);
    }

    template <class T>
    Reflection*
    NillableRawPtrImplT<T>::use_value(
    ) throw((ReflectException))
    {
        if (get_is_nil())
        {
            this->m_data = new T;
        }
        return Traits<T>::get_reflection(*this->m_data);
    }

    template <class T>
    const IT_Bus::QName&
    NillableRawPtrImplT<T>::get_type_name(
    ) const throw(())
    {
        return check_data().get_type();
    }

    template <class T>
    IT_Bus::AnyType::Kind
    NillableRawPtrImplT<T>::get_type_kind(
    ) const throw(())
    {
        return check_data().get_kind();
    }

    template <class T>
    const IT_Bus::AnyType&
    NillableRawPtrImplT<T>::get_reflected(
    ) const throw(())
    {
        return check_data();
    }

    template <class T>
    IT_Bus::AnyType&
    NillableRawPtrImplT<T>::get_reflected(
    ) throw(())
    {
        return check_data();
    }

    template <class T>
    IT_Bus::AnyType*
    NillableRawPtrImplT<T>::clone(
    ) const throw((ReflectException))
    {
        return Traits<T>::clone(check_data());
    }
}

        
#endif  

---