it_bus/var.h

#ifndef _IT_BUS_VAR_H_
#define _IT_BUS_VAR_H_

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

#include <it_cal/cal.h>

namespace IT_Bus
{
    template <class T>
    class Var
    {
      public:
        Var(
            T* ptr
        ) throw(()) :
            m_ptr(ptr)
        {}

        Var(
            const Var<T>& ptr
        ) throw(()) :
            m_ptr(ptr.m_ptr)
        {
            if (m_ptr != 0)
            {
                m_ptr->_add_ref();
            }
        }

        Var()
            throw(()) :
                m_ptr(0)
        {}

        ~Var()
            throw(())
        {
            if (m_ptr != 0)
            {
                m_ptr->_remove_ref();
            }
        }

        T*
        operator->() const
            throw(())
        {
            return m_ptr;
        }

        T&
        operator*() const
            throw(())
        {
            return *m_ptr;
        }

        T*
        get() const
            throw(())
        {
            return m_ptr;
        }

        T*
        release() 
            throw(())
        {
            T* tmp = m_ptr;
            m_ptr = 0;
            return tmp;
        }

        Var<T>&
        operator=(
            const Var<T>& ptr
        ) throw(())
        {
            if (m_ptr != ptr.m_ptr)
            {
                if (m_ptr != 0)
                {
                    m_ptr->_remove_ref();
                }
                m_ptr = ptr.m_ptr;
                if (m_ptr != 0)
                {
                    m_ptr->_add_ref();
                }
            }
            return *this;
        }

        Var<T>&
        operator=(
            T* ptr
        ) throw(())
        {
            if (m_ptr != 0)
            {
                m_ptr->_remove_ref();
            }

            m_ptr = ptr;
            return *this;
        }

        operator T*() const
        {
            return get();
        }

      private:
        T* m_ptr;
    };

    template <class T, class U>
    T*
    dynamic_cast_var(
        Var<U>& var
    )
    {
        T* t_ptr = IT_DYNAMIC_CAST(T*, var.get());
        if (t_ptr != 0)
        {
            t_ptr->_add_ref();
        }
        return t_ptr;
    }

    template <class T, class U>
    T*
    static_cast_var(
        Var<U>& var
    )
    {
        T* t_ptr = IT_STATIC_CAST(T*, var.get());
        if (t_ptr != 0)
        {
            t_ptr->_add_ref();
        }
        return t_ptr;
    }
    
    template <class T, class U>
    T*
    const_cast_var(
        Var<U>& var
    )
    {
        T* t_ptr = IT_STATIC_CAST(T*, var.get());
        if (t_ptr != 0)
        {
            t_ptr->_add_ref();
        }
        return t_ptr;
    }
    
    template <class T, class U>
    T*
    dynamic_cast_var(
        U* ptr
    )
    {
        Var<U> u(ptr);          // Take ownership
        return dynamic_cast_var<T>(u);
    }

    template <class T, class U>
    T*
    static_cast_var(
        U* ptr
    )
    {
        return IT_STATIC_CAST(T*, ptr);
    }
    
    template <class T, class U>
    T*
    const_cast_var(
        U* ptr
    )
    {
        return IT_CONST_CAST(T*, ptr);
    }
}

#endif  

---