Skip to content

XP event5x XPListening, games, ratings, comments and chat earn five times the XP

leftLeaderboard

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.//-----------------------------------------------------------------------------#pragma once#include "pluginterfaces/base/fplatform.h"#if SMTG_CPP11_STDLIBSUPPORT#include <utility>#endif//------------------------------------------------------------------------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; }#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;}//------------------------------------------------------------------------/** 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);}#if 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#endif//------------------------------------------------------------------------} // namespace Steinberg