Classes
class	basic_any_ptr

class	basic_auto_ptr
	AutoPtr is a "smart" pointer for classes implementing reference counting based garbage collection. More...

struct	basic_default_clone

class	basic_clone_ptr

struct	basic_linked_ptr_node
	This class allows basic_linked_ptr<T> and basic_linked_ptr to share the same base nodes. More...

class	basic_linked_ptr
	This class implements a basic_linked_ptr template that it allows sharing of pointers between instances via reference counting. basic_linked_ptr objects can safely be copied. More...

class	basic_lock_ptr
	auto lock pointer. More...

class	node_ptr

class	basic_save_ptr

class	basic_scoped_ptr

class	basic_shared_ptr

struct	smart_pointer_traits

class	basic_unique_ptr
	A simple unique_ptr, for a single object. More...

class	basic_unique_ptr< T[], TAllocator, TDeleter >
	A simple unique_ptr, for a array object. More...

class	basic_value_ptr

class	basic_weak_ptr

Typedefs
using	any_ptr = basic_any_ptr< void >

template<typename T >
using	auto_ptr = basic_auto_ptr< T >

template<typename T , class TCloner = basic_default_clone<T>, class TDeleter = memory::default_delete<T>>
using	clone_ptr = basic_clone_ptr< T, TCloner, TDeleter >

template<typename T >
using	default_clone = basic_default_clone< T >

template<typename T >
using	linked_ptr = basic_linked_ptr< T >

template<typename T , class TLOCK = LockType_t>
using	lock_ptr = basic_lock_ptr< T, TLOCK >

template<typename T >
using	save_ptr = basic_save_ptr< T >

template<typename T >
using	scoped_ptr = basic_scoped_ptr< T >

template<typename T >
using	shared_ptr = basic_shared_ptr< T, size_t >

template<typename T >
using	shared_atomic_ptr = basic_shared_ptr< T, atomic_size_t >

template<typename T , class TAllocator = memory::default_allocator, class TDeleter = memory::default_delete<T, TAllocator>>
using	unique_ptr = basic_unique_ptr< T, TAllocator, TDeleter >

template<typename T , class TCloner = basic_default_clone<T>, class TDeleter = memory::default_delete<T>>
using	value_ptr = basic_value_ptr< T, TCloner, TDeleter >

template<typename T >
using	weak_ptr = basic_weak_ptr< T, size_t >

template<typename T >
using	weak_atomic_ptr = basic_weak_ptr< T, atomic_size_t >

Functions
template<typename T >
void	swap (basic_auto_ptr< T > &a, basic_auto_ptr< T > &b)

template<typename T , typename... Args>
auto_ptr< T >	make_auto (Args &&... args)
	Make a auto pointer. More...

template<typename T , class TCloner = basic_default_clone<T>, class TDeleter = memory::default_delete<T>>
void	swap (basic_clone_ptr< T, TCloner, TDeleter > &a, basic_clone_ptr< T, TCloner, TDeleter > &b)

template<typename T , typename... Args>
clone_ptr< T >	make_clone (Args &&... args)
	Make a clone pointer. More...

template<typename T >
basic_linked_ptr< T >	make_link (const basic_linked_ptr< T > &value)
	Make a linked pointer. More...

template<typename T , typename U >
basic_linked_ptr< T >	make_link (const basic_linked_ptr< U > &value)
	Make a linked pointer from a other linked pointer type. More...

template<typename T >
basic_linked_ptr< T >	make_link (T *value)
	Make a link pointer. More...

template<typename T >
T *	get (const basic_linked_ptr< T > &_pPtr)
	Get the pointer object. More...

template<typename T , typename U >
bool	operator== (const basic_linked_ptr< T > &a, const basic_linked_ptr< U > &b)
	Compares two basic_linked_ptr objects for equality. Equality is defined as being true when the pointer shared between two basic_linked_ptr objects is equal. More...

template<typename T , typename U >
bool	operator!= (const basic_linked_ptr< T > &a, const basic_linked_ptr< U > &b)
	Compares two basic_linked_ptr objects for inequality. More...

template<typename T , class TLOCK = LockType_t>
basic_lock_ptr< T, TLOCK >	make_lock_ref (volatile T &v, TLOCK &m)

template<typename T , class TLOCK = LockType_t>
basic_lock_ptr< T, TLOCK >	make_lock_ptr (volatile T *v, TLOCK &m)

template<typename T , typename... Args>
save_ptr< T >	make_save (Args &&... args)
	Make a save pointer. More...

template<typename T >
void	swap (save_ptr< T > &a, save_ptr< T > &b)
	swap a save pointer. More...

template<typename T , typename... Args>
basic_scoped_ptr< T >	make_scoped (Args &&... args)
	Make a scoped pointer. More...

template<typename T , typename TRefType >
void	swap (basic_shared_ptr< T, TRefType > &a, basic_shared_ptr< T, TRefType > &b)

template<typename T , typename... Args>
shared_ptr< T >	make_shared (Args &&... args)
	Make a shared pointer. More...

template<typename T , typename... Args>
shared_atomic_ptr< T >	make_atomic_shared (Args &&... args)
	Make a shared atomic pointer. More...

template<class TPR >
smart_pointer_traits< TPR >::pointer	get_pointer (const TPR &_pPtr)

template<class TPR >
bool	is_null (const TPR &_pPtr)

template<typename T , class TA , class TD >
void	swap (basic_unique_ptr< T, TA, TD > &a, basic_unique_ptr< T, TA, TD > &b)

template<typename T , class TA , class TD >
bool	operator== (basic_unique_ptr< T, TA, TD > &a, basic_unique_ptr< T, TA, TD > &b)

template<typename T , class TA , class TD >
bool	operator!= (basic_unique_ptr< T, TA, TD > &a, basic_unique_ptr< T, TA, TD > &b)

template<typename T , class TA , class TD >
bool	operator< (basic_unique_ptr< T, TA, TD > &a, basic_unique_ptr< T, TA, TD > &b)

template<typename T , class TA , class TD >
bool	operator> (basic_unique_ptr< T, TA, TD > &a, basic_unique_ptr< T, TA, TD > &b)

template<typename T , class TA , class TD >
bool	operator<= (basic_unique_ptr< T, TA, TD > &a, basic_unique_ptr< T, TA, TD > &b)

template<typename T , class TA , class TD >
bool	operator>= (basic_unique_ptr< T, TA, TD > &a, basic_unique_ptr< T, TA, TD > &b)

template<typename T , typename... TArgs>
basic_unique_ptr< T >	make_unique (TArgs &&... args)

template<typename T >
basic_unique_ptr< T[]>	make_unique (size_t siNums)

template<typename T , typename... TArgs>
basic_unique_ptr< T[]>	make_unique (TArgs &&...)=delete

template<class T >
basic_value_ptr< typename mn::decay< T >::type >	make_value (T &&v)

template<class T , class... Args>
basic_value_ptr< T >	make_value (Args &&... args)

template<class T , class U , class... Args>
basic_value_ptr< T >	make_value (mn::initializer_list< U > il, Args &&... args)

template<class T , class D , class C >
void	swap (basic_value_ptr< T, D, C > &a, basic_value_ptr< T, D, C > &b) noexcept

template<typename T , typename... Args>
weak_ptr< T >	make_weak (Args &&... args)
	Make a weak pointer. More...

template<typename T , typename... Args>
weak_atomic_ptr< T >	make_atomic_weak (Args &&... args)
	Make a weak atomic pointer. More...

Typedef Documentation

◆ any_ptr

using mn::pointer::any_ptr = typedef basic_any_ptr<void>

◆ auto_ptr

template<typename T >

using mn::pointer::auto_ptr = typedef basic_auto_ptr<T>

◆ clone_ptr

template<typename T , class TCloner = basic_default_clone<T>, class TDeleter = memory::default_delete<T>>

using mn::pointer::clone_ptr = typedef basic_clone_ptr<T, TCloner, TDeleter>

◆ default_clone

template<typename T >

using mn::pointer::default_clone = typedef basic_default_clone<T>

◆ linked_ptr

template<typename T >

using mn::pointer::linked_ptr = typedef basic_linked_ptr<T>

◆ lock_ptr

template<typename T , class TLOCK = LockType_t>

using mn::pointer::lock_ptr = typedef basic_lock_ptr<T, TLOCK>

◆ save_ptr

template<typename T >

using mn::pointer::save_ptr = typedef basic_save_ptr<T>

◆ scoped_ptr

template<typename T >

using mn::pointer::scoped_ptr = typedef basic_scoped_ptr<T>

◆ shared_atomic_ptr

template<typename T >

using mn::pointer::shared_atomic_ptr = typedef basic_shared_ptr<T, atomic_size_t>

◆ shared_ptr

template<typename T >

using mn::pointer::shared_ptr = typedef basic_shared_ptr<T, size_t>

◆ unique_ptr

template<typename T , class TAllocator = memory::default_allocator, class TDeleter = memory::default_delete<T, TAllocator>>

using mn::pointer::unique_ptr = typedef basic_unique_ptr<T, TAllocator, TDeleter>

◆ value_ptr

template<typename T , class TCloner = basic_default_clone<T>, class TDeleter = memory::default_delete<T>>

using mn::pointer::value_ptr = typedef basic_value_ptr<T, TCloner, TDeleter>

◆ weak_atomic_ptr

template<typename T >

using mn::pointer::weak_atomic_ptr = typedef basic_weak_ptr<T, atomic_size_t>

◆ weak_ptr

template<typename T >

using mn::pointer::weak_ptr = typedef basic_weak_ptr<T, size_t>

Function Documentation

◆ get()

template<typename T >

T* mn::pointer::get ( const basic_linked_ptr< T > & _pPtr )

inline

Get the pointer object.

Template Parameters

T	The type of the value

Parameters

_pPtr The input pointer to get the pointer

Returns: T* The pointer of the value from input

◆ get_pointer()

template<class TPR >

smart_pointer_traits<TPR>::pointer mn::pointer::get_pointer ( const TPR & _pPtr )

inline

◆ is_null()

template<class TPR >

bool mn::pointer::is_null ( const TPR & _pPtr )

inline

◆ make_atomic_shared()

template<typename T , typename... Args>

shared_atomic_ptr<T> mn::pointer::make_atomic_shared ( Args &&... args )

inline

Make a shared atomic pointer.

Template Parameters

T	Value type of the pointer.
Args	Argument for the object.

◆ make_atomic_weak()

template<typename T , typename... Args>

weak_atomic_ptr<T> mn::pointer::make_atomic_weak ( Args &&... args )

inline

Make a weak atomic pointer.

Template Parameters

T	Value type of the pointer.
Args	Argument for the object.

◆ make_auto()

template<typename T , typename... Args>

auto_ptr<T> mn::pointer::make_auto ( Args &&... args )

inline

Make a auto pointer.

Template Parameters

T	Value type of the pointer.
Args	Argument for the object.

◆ make_clone()

template<typename T , typename... Args>

clone_ptr<T> mn::pointer::make_clone ( Args &&... args )

inline

Make a clone pointer.

Template Parameters

T	Value type of the pointer.
Args	Argument for the object.

◆ make_link() [1/3]

template<typename T >

basic_linked_ptr<T> mn::pointer::make_link ( const basic_linked_ptr< T > & value )

inline

Make a linked pointer.

Template Parameters

T	Value type of the pointer.
Args	Argument for the object.

◆ make_link() [2/3]

template<typename T , typename U >

basic_linked_ptr<T> mn::pointer::make_link ( const basic_linked_ptr< U > & value )

inline

Make a linked pointer from a other linked pointer type.

Template Parameters

T	Value type of the pointer.
U	Value of the type of td

◆ make_link() [3/3]

template<typename T >

basic_linked_ptr<T> mn::pointer::make_link ( T * value )

inline

Make a link pointer.

Template Parameters

T	Value type of the pointer.
Args	Argument for the object.

◆ make_lock_ptr()

template<typename T , class TLOCK = LockType_t>

basic_lock_ptr<T, TLOCK> mn::pointer::make_lock_ptr	(	volatile T *	v,
		TLOCK &	m
	)

inline

◆ make_lock_ref()

template<typename T , class TLOCK = LockType_t>

basic_lock_ptr<T, TLOCK> mn::pointer::make_lock_ref	(	volatile T &	v,
		TLOCK &	m
	)

inline

◆ make_save()

template<typename T , typename... Args>

save_ptr<T> mn::pointer::make_save ( Args &&... args )

inline

Make a save pointer.

Template Parameters

T	Value type of the pointer.
Args	Argument for the object.

◆ make_scoped()

template<typename T , typename... Args>

basic_scoped_ptr<T> mn::pointer::make_scoped ( Args &&... args )

inline

Make a scoped pointer.

Template Parameters

T	Value type of the pointer.
Args	Argument for the object.

◆ make_shared()

template<typename T , typename... Args>

shared_ptr<T> mn::pointer::make_shared ( Args &&... args )

inline

Make a shared pointer.

Template Parameters

T	Value type of the pointer.
Args	Argument for the object.

◆ make_unique() [1/3]

template<typename T >

basic_unique_ptr<T[]> mn::pointer::make_unique ( size_t siNums )

inline

◆ make_unique() [2/3]

template<typename T , typename... TArgs>

basic_unique_ptr<T> mn::pointer::make_unique ( TArgs &&... args )

inline

◆ make_unique() [3/3]

template<typename T , typename... TArgs>

basic_unique_ptr<T[]> mn::pointer::make_unique ( TArgs && ... )

inlinedelete

◆ make_value() [1/3]

template<class T , class... Args>

basic_value_ptr<T> mn::pointer::make_value ( Args &&... args )

inline

◆ make_value() [2/3]

template<class T , class U , class... Args>

basic_value_ptr<T> mn::pointer::make_value	(	mn::initializer_list< U >	il,
		Args &&...	args
	)

inline

◆ make_value() [3/3]

template<class T >

basic_value_ptr< typename mn::decay<T>::type > mn::pointer::make_value ( T && v )

inline

◆ make_weak()

template<typename T , typename... Args>

weak_ptr<T> mn::pointer::make_weak ( Args &&... args )

inline

Make a weak pointer.

Template Parameters

T	Value type of the pointer.
Args	Argument for the object.

◆ operator!=() [1/2]

template<typename T , class TA , class TD >

bool mn::pointer::operator!=	(	basic_unique_ptr< T, TA, TD > &	a,
		basic_unique_ptr< T, TA, TD > &	b
	)

inline

◆ operator!=() [2/2]

template<typename T , typename U >

bool mn::pointer::operator!=	(	const basic_linked_ptr< T > &	a,
		const basic_linked_ptr< U > &	b
	)

inline

Compares two basic_linked_ptr objects for inequality.

◆ operator<()

template<typename T , class TA , class TD >

bool mn::pointer::operator<	(	basic_unique_ptr< T, TA, TD > &	a,
		basic_unique_ptr< T, TA, TD > &	b
	)

inline

◆ operator<=()

template<typename T , class TA , class TD >

bool mn::pointer::operator<=	(	basic_unique_ptr< T, TA, TD > &	a,
		basic_unique_ptr< T, TA, TD > &	b
	)

inline

◆ operator==() [1/2]

template<typename T , class TA , class TD >

bool mn::pointer::operator==	(	basic_unique_ptr< T, TA, TD > &	a,
		basic_unique_ptr< T, TA, TD > &	b
	)

inline

◆ operator==() [2/2]

template<typename T , typename U >

bool mn::pointer::operator==	(	const basic_linked_ptr< T > &	a,
		const basic_linked_ptr< U > &	b
	)

inline

Compares two basic_linked_ptr objects for equality. Equality is defined as being true when the pointer shared between two basic_linked_ptr objects is equal.

◆ operator>()

template<typename T , class TA , class TD >

bool mn::pointer::operator>	(	basic_unique_ptr< T, TA, TD > &	a,
		basic_unique_ptr< T, TA, TD > &	b
	)

inline

◆ operator>=()

template<typename T , class TA , class TD >

bool mn::pointer::operator>=	(	basic_unique_ptr< T, TA, TD > &	a,
		basic_unique_ptr< T, TA, TD > &	b
	)

inline

◆ swap() [1/6]

template<typename T >

void mn::pointer::swap	(	basic_auto_ptr< T > &	a,
		basic_auto_ptr< T > &	b
	)

inline

◆ swap() [2/6]

template<typename T , class TCloner = basic_default_clone<T>, class TDeleter = memory::default_delete<T>>

void mn::pointer::swap	(	basic_clone_ptr< T, TCloner, TDeleter > &	a,
		basic_clone_ptr< T, TCloner, TDeleter > &	b
	)

inline

◆ swap() [3/6]

template<typename T , typename TRefType >

void mn::pointer::swap	(	basic_shared_ptr< T, TRefType > &	a,
		basic_shared_ptr< T, TRefType > &	b
	)

◆ swap() [4/6]

template<typename T , class TA , class TD >

void mn::pointer::swap	(	basic_unique_ptr< T, TA, TD > &	a,
		basic_unique_ptr< T, TA, TD > &	b
	)

◆ swap() [5/6]

template<class T , class D , class C >

void mn::pointer::swap	(	basic_value_ptr< T, D, C > &	a,
		basic_value_ptr< T, D, C > &	b
	)

inlinenoexcept

◆ swap() [6/6]

template<typename T >

void mn::pointer::swap	(	save_ptr< T > &	a,
		save_ptr< T > &	b
	)

inline

swap a save pointer.

Classes

Typedefs

Functions

Typedef Documentation

◆ any_ptr

◆ auto_ptr

◆ clone_ptr

◆ default_clone

◆ linked_ptr

◆ lock_ptr

◆ save_ptr

◆ scoped_ptr

◆ shared_atomic_ptr

◆ shared_ptr

◆ unique_ptr

◆ value_ptr

◆ weak_atomic_ptr

◆ weak_ptr

Function Documentation

◆ get()

◆ get_pointer()

◆ is_null()

◆ make_atomic_shared()

◆ make_atomic_weak()

◆ make_auto()

◆ make_clone()

◆ make_link() [1/3]

◆ make_link() [2/3]

◆ make_link() [3/3]

◆ make_lock_ptr()

◆ make_lock_ref()

◆ make_save()

◆ make_scoped()

◆ make_shared()

◆ make_unique() [1/3]

◆ make_unique() [2/3]

◆ make_unique() [3/3]

◆ make_value() [1/3]

◆ make_value() [2/3]

◆ make_value() [3/3]

◆ make_weak()

◆ operator!=() [1/2]

◆ operator!=() [2/2]

◆ operator<()

◆ operator<=()

◆ operator==() [1/2]

◆ operator==() [2/2]

◆ operator>()

◆ operator>=()

◆ swap() [1/6]

◆ swap() [2/6]

◆ swap() [3/6]

◆ swap() [4/6]

◆ swap() [5/6]

◆ swap() [6/6]