smartptr.h

Go to the documentation of this file.

/*
 * Copyright (C) 2007-2025 Global Graphics Software Ltd. All rights reserved.
 */

 
#ifndef __cplusplus
#error This file is intended for use with C++ only
#endif
 
#ifndef __CSMARTPTR_H
#define __CSMARTPTR_H
 
#include <stddef.h>
 
#include <edl/edlnamespaces.h>
 
_BEGIN_EDL_NAMESPACE
 
#ifdef SWIG
 
#define DECL_SMART_PTR(cls)                             \
    typedef EDL::shared_ptr<cls>        cls##Ptr;       \
    typedef EDL::shared_ptr<const cls>  cls##ConstPtr;
 
#else
 
template <class T>
class shared_ptr
{
public:
 
    shared_ptr (T *src = NULL, bool bAddref = true) : m_ptr(src)
    {
        if (bAddref && m_ptr)
            m_ptr->addRef();
    }
 
    template <class T1>
    shared_ptr (const shared_ptr<T1> &src): m_ptr(src.operator T1 *())
    {
        if (m_ptr)
            m_ptr->addRef();
    }
 
    shared_ptr (const shared_ptr<T> &src): m_ptr(src.operator T *())
    {
        if (m_ptr)
            m_ptr->addRef();
    }
 
    ~shared_ptr()
    {
        if (m_ptr)
            m_ptr->decRef();
    }
 
    template <class T1>
    shared_ptr<T1> getPtr(T1 *fake) const
    {
        return shared_ptr<T1>((T1*)m_ptr, true);
    }
 
    template <class T1>
    shared_ptr<T> &operator=(const shared_ptr<T1> &src)
    {
        if (m_ptr)
            m_ptr->decRef();
        if ((m_ptr = src.operator T1 *()))
            m_ptr->addRef();
        return *this;
    }
 
    shared_ptr<T> &operator=(const shared_ptr<T> &src)
    {
        T * ptr = m_ptr;
        if ((m_ptr = src.m_ptr))
            m_ptr->addRef();
        if (ptr)
            ptr->decRef();
        return *this;
    }
 
    shared_ptr &operator=(T *src)
    {
        if (m_ptr)
            m_ptr->decRef();
        m_ptr = src;
        return *this;
    }
 
    operator T*() const
    {
        return m_ptr;
    }
 
    T* operator->() const
    {
        return m_ptr;
    }
 
    T* get ()
    {
        return m_ptr;
    }
 
protected:
    T* m_ptr;
};
 
template <class T>
class shared_constptr
{
public:
    shared_constptr (): m_ptr(NULL)
    {
    }
    explicit shared_constptr (const T *src): m_ptr((T*)src)
    {
        if (m_ptr)
            m_ptr->addRef();
    }
    explicit shared_constptr (const T *src , bool bAddref): m_ptr((T *)src)
    {
        if (bAddref && m_ptr)
            m_ptr->addRef();
    }
    template <class T1>
    shared_constptr<T1> getConstPtr(T1 *fake)
    {
        return shared_constptr<T1>((T1*)m_ptr, true);
    }
    template <class T1>
    shared_ptr<T1> getPtr(T1 *fake)
    {
        return shared_ptr<T1>((T1*)m_ptr, true);
    }
    shared_ptr<T> unConst()
    {
        return shared_ptr<T>((T*)m_ptr, true);
    }
 
    template <class T1>
    shared_constptr(const shared_constptr<T1> &src): m_ptr((T1 *)(src.operator const T1*()))
    {
        if (m_ptr)
            m_ptr->addRef();
    }
    template <class T1>
    shared_constptr(const shared_ptr<T1> &src): m_ptr(src.operator T1 *())
    {
        if (m_ptr)
            m_ptr->addRef();
    }
    shared_constptr(const shared_constptr<T> &src): m_ptr((T *)(src.operator const T*()))
    {
        if (m_ptr)
            m_ptr->addRef();
    }
    ~shared_constptr()
    {
        if (m_ptr)
            m_ptr->decRef();
    }
 
    shared_constptr&operator=(const shared_ptr<T> &src)
    {
        T * ptr = m_ptr;
        if ((m_ptr = src.operator T *()))
            m_ptr->addRef();
        if (ptr)
            ptr->decRef();
        return *this;
    }
 
    shared_constptr &operator=(const shared_constptr<T> &src)
    {
        T * ptr = m_ptr;
        if ((m_ptr = src.m_ptr))
            m_ptr->addRef();
        if (ptr)
            ptr->decRef();
        return *this;
    }
    shared_constptr &operator=(const T *src)
    {
        if (m_ptr)
            m_ptr->decRef();
        m_ptr = (T *)src;
        return *this;
    }
    operator const T*() const
    {
        return m_ptr;
    }
    const T* operator->() const
    {
        return m_ptr;
    }
 
protected:
    T* m_ptr;
};
 
#define DECL_SMART_PTR(cls) typedef EDL::shared_ptr<cls> cls##Ptr; typedef EDL::shared_constptr<cls>   cls##ConstPtr;
 
#endif
 
#define CSmartPtr EDL::shared_ptr
 
_END_EDL_NAMESPACE
 
#endif // !__CSMARTPTR_H