it_bus/reflect/nillable_ptr_impl_t.h

#ifndef _IT_REFLECT_NILLABLE_PTR_IMPL_T_H_
#define _IT_REFLECT_NILLABLE_PTR_IMPL_T_H_

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

#include <it_bus/reflect/nillable.h>
#include <it_bus/reflect/reflection_impl.h>

namespace IT_Reflect

{
    template <class NillableT, class T>
    class NillablePtrImplT : public virtual ReflectionImpl
    {
      public:
        NillablePtrImplT(
            const NillableT* data
        ) throw(());

        virtual ~NillablePtrImplT() 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 IT_Bus::AnyType*
        clone() const throw(());

        void reset(
            T* value
        );

      protected:
        IT_Bus::AnyType&
        get_data() const throw(());

      private:
        NillableT* m_data;
    };
    

    template <class NillableT, class T>
    NillablePtrImplT<NillableT, T>::NillablePtrImplT(
        const NillableT* data
    ) throw(())
        :
        m_data(data)
    {
        // Complete.
    }

    template <class NillableT, class T>
    NillablePtrImplT<NillableT, T>::~NillablePtrImplT(
    ) throw(())
    {
        // Complete.
    }

    template <class NillableT, class T>
    IT_Bus::Boolean
    NillablePtrImplT<NillableT, T>::get_is_nil(
    ) const throw(())
    {
        return this->m_data->is_nil();
    }

    template <class NillableT, class T>
    void
    NillablePtrImplT<NillableT, T>::set_is_nil(
    ) throw(())
    {
        this->m_data->set_nil();
    }

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

    template <class NillableT, class T>
    Reflection*
    NillablePtrImplT<NillableT, T>::use_value(
    ) throw((ReflectException))
    {
        if (get_is_nil())
        {
            this->m_data->reset(new T);
        }
        return Traits<T>::get_reflection(*this->m_data->get());
    }

    template <class NillableT, class T>
    IT_Bus::AnyType*
    NillablePtrImplT<NillableT,T>::clone() const throw(())
    {
        return new NillableT(*m_data);
    }
    
    template <class NillableT, class T>
    void
    NillablePtrImplT<NillableT,T>::reset(
        T* value
    )
    {
        m_data = value;
    }
    
    template <class NillableT, class T>
    IT_Bus::AnyType&
    NillablePtrImplT<NillableT,T>::get_data() const throw(())
    {
        return *m_data;
    }
}


#endif  

---