smartpointer.h

Go to the documentation of this file.

//-----------------------------------------------------------------------------
// Project     : SDK Core
//
// Category    : SDK Core Interfaces
// Filename    : pluginterfaces/base/smartpointer.h
// Created by  : Steinberg, 01/2004
// Description : Basic Interface
//
//-----------------------------------------------------------------------------
// This file is part of a Steinberg SDK. It is subject to the license terms
// in the LICENSE file found in the top-level directory of this distribution
// and at www.steinberg.net/sdklicenses. 
// No part of the SDK, including this file, may be copied, modified, propagated,
// or distributed except according to the terms contained in the LICENSE file.
//-----------------------------------------------------------------------------
 
#pragma once
 
#include "pluginterfaces/base/fplatform.h"
#if SMTG_CPP11_STDLIBSUPPORT
#include <utility>
#endif
 
//------------------------------------------------------------------------
namespace Steinberg {
 
//------------------------------------------------------------------------
// IPtr
//------------------------------------------------------------------------
template <class I>
class IPtr
{
public:
//------------------------------------------------------------------------
        inline IPtr (I* ptr, bool addRef = true);
        inline IPtr (const IPtr&);
 
        template <class T>
        inline IPtr (const IPtr<T>& other) : ptr (other.get ())
        {
                if (ptr)
                        ptr->addRef ();
        }
 
        inline IPtr ();
        inline ~IPtr ();
 
        inline I* operator= (I* ptr);
 
        inline IPtr& operator= (const IPtr& other);
 
        template <class T>
        inline IPtr& operator= (const IPtr<T>& other)
        {
                operator= (other.get ());
                return *this;
        }
 
        inline operator I* () const { return ptr; } // act as I*
        inline I* operator-> () const { return ptr; } // act as I*
 
        inline I* get () const { return ptr; }
 
#if SMTG_CPP11_STDLIBSUPPORT
        inline IPtr (IPtr<I>&& movePtr) SMTG_NOEXCEPT : ptr (movePtr.take ()) { }
        
        template <typename T>
        inline IPtr (IPtr<T>&& movePtr) SMTG_NOEXCEPT : ptr (movePtr.take ()) {  }
 
        inline IPtr& operator= (IPtr<I>&& movePtr) SMTG_NOEXCEPT
        {
                if (ptr)
                        ptr->release ();
 
                ptr = movePtr.take ();
                return *this;
        }
        
        template <typename T>
        inline IPtr& operator= (IPtr<T>&& movePtr) 
        {
                if (ptr)
                        ptr->release ();
                
                ptr = movePtr.take ();
                return *this;
        }
#endif
 
        inline void reset (I* obj = nullptr) 
        {
                if (ptr)
                        ptr->release();
                ptr = obj;
        }
 
        I* take () SMTG_NOEXCEPT 
        {
                I* out = ptr; 
                ptr = nullptr; 
                return out;
        }
 
        template <typename T>
        static IPtr<T> adopt (T* obj) SMTG_NOEXCEPT { return IPtr<T> (obj, false); }
 
//------------------------------------------------------------------------
protected:
        I* ptr;
};
 
//------------------------------------------------------------------------
template <class I>
inline IPtr<I>::IPtr (I* _ptr, bool addRef) : ptr (_ptr)
{
        if (ptr && addRef)
                ptr->addRef ();
}
 
//------------------------------------------------------------------------
template <class I>
inline IPtr<I>::IPtr (const IPtr<I>& other) : ptr (other.ptr)
{
        if (ptr)
                ptr->addRef ();
}
 
//------------------------------------------------------------------------
template <class I>
inline IPtr<I>::IPtr () : ptr (0)
{
}
 
//------------------------------------------------------------------------
template <class I>
inline IPtr<I>::~IPtr ()
{
        if (ptr) 
        {
                ptr->release ();
                ptr = nullptr;  //TODO_CORE: how much does this cost? is this something hiding for us?
        }
}
 
//------------------------------------------------------------------------
template <class I>
inline I* IPtr<I>::operator= (I* _ptr)
{
        if (_ptr != ptr)
        {
                if (ptr)
                        ptr->release ();
                ptr = _ptr;
                if (ptr)
                        ptr->addRef ();
        }
        return ptr;
}
 
//------------------------------------------------------------------------
template <class I>
inline IPtr<I>& IPtr<I>::operator= (const IPtr<I>& _ptr)
{
        operator= (_ptr.ptr);
        return *this;
}
 
//------------------------------------------------------------------------
template <class I>
class OPtr : public IPtr<I>
{
public:
//------------------------------------------------------------------------
        inline OPtr (I* p) : IPtr<I> (p, false) {}
        inline OPtr (const IPtr<I>& p) : IPtr<I> (p) {}
        inline OPtr (const OPtr<I>& p) : IPtr<I> (p) {}
        inline OPtr () {}
        inline I* operator= (I* _ptr)
        {
                if (_ptr != this->ptr)
                {
                        if (this->ptr)
                                this->ptr->release ();
                        this->ptr = _ptr;
                }
                return this->ptr;
        }
};
 
//------------------------------------------------------------------------
template <class I>
IPtr<I> owned (I* p)
{
        return IPtr<I> (p, false);
}

template <class I>
IPtr<I> shared (I* p)
{
        return IPtr<I> (p, true);
}
 
#if SMTG_CPP11_STDLIBSUPPORT
//------------------------------------------------------------------------
// Ownership functionality
//------------------------------------------------------------------------
namespace SKI {
namespace Detail {
struct Adopt;
} // Detail

template <typename T>
class Shared
{
        friend struct Detail::Adopt;
        T* obj = nullptr;
};

template <typename T>
class Owned
{
        friend struct Detail::Adopt;
        T* obj = nullptr;
};

template <typename T>
class Used
{
        friend struct Detail::Adopt;
        T* obj = nullptr;
};
        
namespace Detail {
 
struct Adopt 
{
        template <typename T>
        static IPtr<T> adopt (Shared<T>& ref) 
        { 
                using Steinberg::shared;
                return shared (ref.obj); 
        }
 
        template <typename T>
        static IPtr<T> adopt (Owned<T>& ref) 
        { 
                using Steinberg::owned;
                IPtr<T> out = owned (ref.obj);
                ref.obj = nullptr;
                return out;
        }
 
        template <typename T>
        static T* adopt (Used<T>& ref)
        {
                return ref.obj;
        }
 
        template <template <typename> class OwnerType, typename T>
        static OwnerType<T> toOwnerType (T* obj) 
        { 
                OwnerType<T> out;
                out.obj = obj;
                return out; 
        }
};
 
} // Detail

template <typename T>
IPtr<T> adopt (Shared<T>& ref) { return Detail::Adopt::adopt (ref); }
 
template <typename T>
IPtr<T> adopt (Shared<T>&& ref) { return Detail::Adopt::adopt (ref); }

template <typename T>
IPtr<T> adopt (Owned<T>& ref) { return Detail::Adopt::adopt (ref); }
 
template <typename T>
IPtr<T> adopt (Owned<T>&& ref) { return Detail::Adopt::adopt (ref); }

template <typename T>
T* adopt (Used<T>& ref) { return Detail::Adopt::adopt (ref); }
 
template <typename T>
T* adopt (Used<T>&& ref) { return Detail::Adopt::adopt (ref); }

template <typename T>
Owned<T> toOwned (T* obj) { return Detail::Adopt::toOwnerType<Owned> (obj); }

template <typename T>
Shared<T> toShared (T* obj) { return Detail::Adopt::toOwnerType<Shared> (obj); }

template <typename T>
Used<T> toUsed (T* obj) { return Detail::Adopt::toOwnerType<Used> (obj); }
 
//------------------------------------------------------------------------
} // SKI
#endif
} // Steinberg