it_bus/nillable_ptr.h

#ifndef _IT_BUS_NILLABLE_PTR_H_
#define _IT_BUS_NILLABLE_PTR_H_

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

#include <it_bus/nillable.h>
#include <it_bus/complex_type_reader.h>
#include <it_bus/complex_type_writer.h>
#include <it_cal/auto_ptr.h>

namespace IT_Bus
{
    template <class T>
    class NillablePtr : public Nillable, public IT_AutoPtr<T>
    {
      public:
        
        NillablePtr();

        NillablePtr(
            const NillablePtr& other
        );

        NillablePtr(
            T* data
        );
        
        virtual ~NillablePtr();

        NillablePtr&
        operator=(
            const NillablePtr&
        );

        AnyType&
        copy(
            const AnyType& other
        );

        void
        set(
            const T* data
        );

        virtual const QName&
        get_type() const;

        virtual Boolean
        is_nil() const;

        virtual void
        set_nil();

        virtual void 
        write_value(
            const QName& name,
            ComplexTypeWriter& writer
        ) const throw((SerializationException));

        virtual void
        read_value(
            const QName& name,
            ComplexTypeReader& reader
        ) throw((DeserializationException));

      private:
        typedef NillablePtr ThisType; // needed for DYNAMIC_CAST macro
    };


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

    template <class T>
    NillablePtr<T>::NillablePtr(
        const NillablePtr<T>& other
    ) 
        :
        IT_AutoPtr<T>(IT_CONST_CAST(NillablePtr<T>&, other))
    {
        // Complete.
    }

    template <class T>
    NillablePtr<T>::NillablePtr(
        T* data
    ) 
        :
        IT_AutoPtr<T>(data)
    {
        // Complete.
    }

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

    template <class T>
    NillablePtr<T>&
    NillablePtr<T>::operator=(
        const NillablePtr<T>& other
    ) 
    {
        if (other.is_nil())
        {
            this->reset();
        }
        else
        {
            this->reset(new T);
            *this->get() = *other;
        }
        return *this;
    }

    template <class T>
    AnyType&
    NillablePtr<T>::copy(
        const AnyType& rhs
    ) 
    {
        const ThisType& other = IT_DYNAMIC_CAST(const ThisType&, rhs);
        return *this = other;
    }

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

    template <class T>
    Boolean
    NillablePtr<T>::is_nil() const
    {
        return this->get() == 0;
    }

    template <class T>
    void
    NillablePtr<T>::set_nil() 
    {
        this->reset();
    }

    template <class T>
    void
    NillablePtr<T>::write_value(
        const QName& name,
        ComplexTypeWriter& writer
    ) const throw((SerializationException)) 
    {
        if (is_nil())
        {
            throw SerializationException("Attempt to write nil value");
        }
        writer.write(name, *this->get());
    }

    template <class T>
    void
    NillablePtr<T>::read_value(
        const QName& name,
        ComplexTypeReader& reader
    ) throw((DeserializationException))
    {
        if (this->get() == 0)
        {
            this->reset(new T);
        }
        reader.read(name, *this->get());
    }

    template <class T>
    void
    NillablePtr<T>::set(
        const T* data
    )
    {
        if (this->get() == 0 ) 
        {
            if (data != 0)
            {
                reset(new T(*data));
            }
        }
        else 
        {
            if ( data != 0 )
            {
                *this->get() = *data;
            }
            else
            {
                this->reset();
            }
        }
    }
}

#endif  

---