it_bus/nillable_value.h

#ifndef _IT_BUS_NILLABLE_VALUE_H_
#define _IT_BUS_NILLABLE_VALUE_H_

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

#include <it_bus/any_type.h>
#include <it_bus/nillable.h>
#include <it_bus/nillable_value_base.h>

namespace IT_Bus
{
    template <class T>
    class NillableValue : public NillableValueBase<T>
    {
      public:
        NillableValue();

        IT_EXPLICIT NillableValue(
            const T& other
        );

        IT_EXPLICIT NillableValue(
            const T *other
        );

        virtual ~NillableValue();

        NillableValue&
        operator=(
            const NillableValue& other
        );

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

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

        virtual AnyType&
        copy(
            const AnyType& other
        );

        virtual const QName&
        get_type() const;

        NillableValue&
        operator=(
            const T& rhs
        );
        
        NillableValue&
        operator=(
            const T *rhs
        );
    };

    template <class T>
    NillableValue<T>::NillableValue() 
    {
        // Complete.
    }

    template <class T>
    NillableValue<T>::NillableValue(
        const T& data
    ) : NillableValueBase<T>(data)
    {
        // Complete.
    }
    
    template <class T>
    NillableValue<T>::NillableValue(
        const T *data
    ) : NillableValueBase<T>(data)
    {
        // Complete.
    }

    template <class T>
    const QName&
    NillableValue<T>::get_type() const
    {
        return T::get_static_type();
    }

    template <class T>
    NillableValue<T>::~NillableValue()
    {
        //Complete
    }

    template <class T>
    NillableValue<T>&
    NillableValue<T>::operator=(
        const NillableValue<T>& other
    ) 
    {
        NillableValueBase<T>::operator=(other);
        return *this;
    }

    template <class T>
    IT_Reflect::Reflection*
    NillableValue<T>::get_reflection()
        throw((IT_Reflect::ReflectException))
    {
        return this->is_nil() ? 0 : this->get().get_reflection();
    }
    
    template <class T>
    const IT_Reflect::Reflection*
    NillableValue<T>::get_reflection() const
        throw((IT_Reflect::ReflectException))
    {
        return IT_CONST_CAST(NillableValue<T>*, this)->get_reflection();
    }

    template <class T>
    AnyType&
    NillableValue<T>::copy(
        const AnyType& rhs
    ) 
    {
        NillableValueBase<T>::copy(rhs);
        return *this;
    }

    template <class T>
    NillableValue<T>&
    NillableValue<T>::operator=(
        const T& rhs
    )
    {
        NillableValue<T>::set(rhs);
        return *this;
    }

    template <class T>
    NillableValue<T>&
    NillableValue<T>::operator=(
        const T *rhs
    )
    {
        NillableValue<T>::set(rhs);
        return *this;
    }
}

#endif  

---