juicewrld-desktopsrc-taurihostvst3sdkpluginterfacesbasesmartpointer.h
1.4.2Released Nov 21, 2026
smartpointer.h
386 lines9.7 KBC++//-----------------------------------------------------------------------------// 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.//----------------------------------------------------------------------------- once "pluginterfaces/base/fplatform.h" SMTG_CPP11_STDLIBSUPPORT <utility>//------------------------------------------------------------------------namespace Steinberg {//------------------------------------------------------------------------// IPtr//------------------------------------------------------------------------/** IPtr - Smart pointer template class. \ingroup pluginBase - can be used as an I* pointer - handles refCount of the interface - Usage example: \codeIPtr<IPath> path (sharedPath);if (path) path->ascend (); \endcode */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; } 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; } 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;}//------------------------------------------------------------------------/** OPtr - "owning" smart pointer used for newly created FObjects. \ingroup pluginBase FUnknown implementations are supposed to have a refCount of 1 right after creation. So using an IPtr on newly created objects would lead to a leak. Instead the OPtr can be used in this case. \n Example: \code OPtr<IPath> path = FHostCreate (IPath, hostClasses); // no release is needed... \endcode The assignment operator takes ownership of a new object and releases the old. So its safe to write: \code OPtr<IPath> path = FHostCreate (IPath, hostClasses); path = FHostCreate (IPath, hostClasses); path = 0; \endcode This is the difference to using an IPtr with addRef=false. \code // DONT DO THIS: IPtr<IPath> path (FHostCreate (IPath, hostClasses), false); path = FHostCreate (IPath, hostClasses); path = 0; \endcode This will lead to a leak! */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; }};//------------------------------------------------------------------------/** Assigning newly created object to an IPtr. Example: \code IPtr<IPath> path = owned (FHostCreate (IPath, hostClasses)); \endcode which is a slightly shorter form of writing: \code IPtr<IPath> path = OPtr<IPath> (FHostCreate (IPath, hostClasses)); \endcode */template <class I>IPtr<I> owned (I* p){ return IPtr<I> (p, false);}/** Assigning shared object to an IPtr. Example: \code IPtr<IPath> path = shared (iface.getXY ()); \endcode */template <class I>IPtr<I> shared (I* p){ return IPtr<I> (p, true);} SMTG_CPP11_STDLIBSUPPORT//------------------------------------------------------------------------// Ownership functionality//------------------------------------------------------------------------namespace SKI {namespace Detail {struct Adopt;} // Detail/** Strong typedef for shared reference counted objects. * Use SKI::adopt to unwrap the provided object. * @tparam T Referenced counted type. */template <typename T>class Shared{ friend struct Detail::Adopt; T* obj = nullptr;};/** Strong typedef for transferring the ownership of reference counted objects. * Use SKI::adopt to unwrap the provided object. * After calling adopt the reference in this object is null. * @tparam T Referenced counted type. */template <typename T>class Owned{ friend struct Detail::Adopt; T* obj = nullptr;};/** Strong typedef for using reference counted objects. * Use SKI::adopt to unwrap the provided object. * After calling adopt the reference in this object is null. * @tparam T Referenced counted type. */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/** Common function to adopt referenced counted object. * @tparam T Referenced counted type. * @param ref The reference to be adopted in a smart pointer. */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); }/** Common function to adopt referenced counted object. * @tparam T Referenced counted type. * @param ref The reference to be adopted in a smart pointer. */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); }/** Common function to adopt referenced counted object. * @tparam T Referenced counted type. * @param ref The reference to be adopted in a smart pointer. */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); }/** Common function to wrap owned instances. */template <typename T>Owned<T> toOwned (T* obj) { return Detail::Adopt::toOwnerType<Owned> (obj); }/** Common function to wrap shared instances. */template <typename T>Shared<T> toShared (T* obj) { return Detail::Adopt::toOwnerType<Shared> (obj); }/** Common function to wrap used instances. */template <typename T>Used<T> toUsed (T* obj) { return Detail::Adopt::toOwnerType<Used> (obj); }//------------------------------------------------------------------------} // SKI//------------------------------------------------------------------------} // namespace Steinberg