Shared ownership smart pointer with strong references. More...

#include <refCntPtr.h>

Inheritance diagram for original::strongPtr< TYPE, DELETER >:

Collaboration diagram for original::strongPtr< TYPE, DELETER >:

Public Member Functions
	strongPtr (TYPE *p=std::nullptr_t{})
	Construct from raw pointer.

	strongPtr (const strongPtr &other)
	Copy constructor shares ownership.

strongPtr &	operator= (const strongPtr &other)
	Copy assignment shares ownership.

	strongPtr (strongPtr &&other) noexcept
	Move constructor transfers ownership.

void	reset () noexcept
	Resets the smart pointer and releases the managed object.

strongPtr &	operator= (strongPtr &&other) noexcept
	Move assignment transfers ownership.

std::string	className () const override
	Get class identifier.

	~strongPtr () override
	Destructor decreases strong references count.

Public Member Functions inherited from original::refCntPtr< TYPE, strongPtr< TYPE, DELETER >, DELETER >
bool	operator== (const refCntPtr< TYPE, O_DERIVED, DELETER > &other) const
	Equality comparison operator.

bool	operator!= (const refCntPtr< TYPE, O_DERIVED, DELETER > &other) const
	Inequality comparison operator.

std::string	toString (bool enter) const override
	Formatted string with reference info.

	~refCntPtr () override=default
	Default destructor of refCntPtr.

Public Member Functions inherited from original::autoPtr< TYPE, strongPtr< TYPE, DELETER >, DELETER >
u_integer	strongRefs () const
	Get strong reference count.

u_integer	weakRefs () const
	Get weak reference count.

bool	exist () const
	Check active ownership.

bool	expired () const
	Check resource validity.

	operator bool () const
	Boolean conversion operator.

const TYPE *	get () const
	Get managed pointer const version.

TYPE *	get ()
	Get managed pointer.

virtual const TYPE &	operator* () const
	Const dereference operator.

virtual TYPE &	operator* ()
	Mutable dereference operator.

virtual const TYPE *	operator-> () const
	Const member access operator.

virtual TYPE *	operator-> ()
	Mutable member access operator.

virtual const TYPE &	operator[] (u_integer index) const
	Const array access operator.

virtual TYPE &	operator[] (u_integer index)
	Mutable array access operator.

void	swap (autoPtr &other) noexcept
	Swaps the reference counters between two autoPtr instances.

integer	compareTo (const autoPtr &other) const override
	Compare reference counters.

	~autoPtr () override
	Destructor triggers reference cleanup.

Public Member Functions inherited from original::printable
	operator std::string () const
	Explicit conversion to std::string.

	operator const char * () const
	Explicit conversion to C-style string.

const char *	toCString (bool enter) const
	Direct C-string access with formatting control.

template<typename TYPE>
auto	formatString (const TYPE &t) -> std::string

template<typename TYPE>
auto	formatCString (const TYPE &t) -> const char *

template<typename TYPE>
auto	formatEnum (const TYPE &t) -> std::string

template<typename TYPE>
auto	formatString (TYPE *const &ptr) -> std::string

Public Member Functions inherited from original::comparable< autoPtr< TYPE, strongPtr< TYPE, DELETER >, DELETER > >
virtual integer	compareTo (const autoPtr< TYPE, strongPtr< TYPE, DELETER >, DELETER > &other) const=0
	Compares the current object with another of the same type.

bool	operator== (const autoPtr< TYPE, strongPtr< TYPE, DELETER >, DELETER > &other) const
	Checks if the current object is equal to another.

bool	operator!= (const autoPtr< TYPE, strongPtr< TYPE, DELETER >, DELETER > &other) const
	Checks if the current object is not equal to another.

bool	operator< (const autoPtr< TYPE, strongPtr< TYPE, DELETER >, DELETER > &other) const
	Checks if the current object is less than another.

bool	operator> (const autoPtr< TYPE, strongPtr< TYPE, DELETER >, DELETER > &other) const
	Checks if the current object is greater than another.

bool	operator<= (const autoPtr< TYPE, strongPtr< TYPE, DELETER >, DELETER > &other) const
	Checks if the current object is less than or equal to another.

bool	operator>= (const autoPtr< TYPE, strongPtr< TYPE, DELETER >, DELETER > &other) const
	Checks if the current object is greater than or equal to another.

virtual	~comparable ()=default
	Virtual destructor for proper cleanup of derived objects.

Friends
class	weakPtr< TYPE, DELETER >

template<typename T, typename DEL, typename... Args>
strongPtr< T, DEL >	makeStrongPtr (Args &&... args)
	Creates a new strongPtr managing a shared object.

template<typename T, typename DEL, typename... Args>
strongPtr< T, DEL >	makeStrongPtrArray (u_integer size, Args &&... args)
	Creates a new strongPtr managing a shared array.

Additional Inherited Members
Static Public Member Functions inherited from original::printable
template<typename TYPE>
static std::string	formatString (const TYPE &t)
	Universal value-to-string conversion.

template<typename TYPE>
static std::string	formatString (TYPE *const &ptr)
	Pointer-specific formatting.

template<typename TYPE>
static const char *	formatCString (const TYPE &t)
	C-string cache for temporary usage.

template<typename TYPE>
static std::string	formatEnum (const TYPE &t)
	Enum formatting utility.

template<>
auto	formatString (const char &t) -> std::string

template<>
auto	formatString (const bool &t) -> std::string

template<>
auto	formatString (const char *const &ptr) -> std::string

Protected Member Functions inherited from original::refCntPtr< TYPE, strongPtr< TYPE, DELETER >, DELETER >
	refCntPtr (TYPE *p=std::nullptr_t{})
	Construct from raw pointer.

Protected Member Functions inherited from original::autoPtr< TYPE, strongPtr< TYPE, DELETER >, DELETER >
	autoPtr (TYPE *p)
	Construct from raw pointer.

void	setPtr (TYPE *p)
	Replace managed pointer.

void	addStrongRef ()
	Increment strong reference count.

void	addWeakRef ()
	Increment weak reference count.

void	removeStrongRef ()
	Decrement strong reference count.

void	removeWeakRef ()
	Decrement weak reference count.

void	destroyRefCnt () noexcept
	Destroy reference counter.

void	clean () noexcept
	Cleanup resources when expired.

Static Protected Member Functions inherited from original::autoPtr< TYPE, strongPtr< TYPE, DELETER >, DELETER >
static refCount< TYPE, DELETER > *	newRefCount (TYPE *p=nullptr)
	Create new reference counter.

Protected Attributes inherited from original::autoPtr< TYPE, strongPtr< TYPE, DELETER >, DELETER >
refCount< TYPE, DELETER > *	ref_count
	Reference counter object.

Detailed Description

template<typename TYPE, typename DELETER>
class original::strongPtr< TYPE, DELETER >

Shared ownership smart pointer with strong references.

Template Parameters

TYPE	Managed object type
DELETER	Deletion policy type (default: deleter<TYPE>)

Maintains object lifetime through reference counting:

Increases strong count on copy
Decreases strong count on destruction
Destroys object when strong count reaches zero
Supports copy/move semantics for shared ownership

Constructor & Destructor Documentation

◆ strongPtr() [1/3]

template<typename TYPE, typename DELETER>

original::strongPtr< TYPE, DELETER >::strongPtr ( TYPE * p = std::nullptr_t{} )

explicit

Construct from raw pointer.

Parameters

p	Pointer to manage

Warning: Shares ownership of existing resource

◆ strongPtr() [2/3]

template<typename TYPE, typename DELETER>

original::strongPtr< TYPE, DELETER >::strongPtr ( const strongPtr< TYPE, DELETER > & other )

Copy constructor shares ownership.

Parameters

other Source strongPtr to copy from

◆ strongPtr() [3/3]

template<typename TYPE, typename DELETER>

original::strongPtr< TYPE, DELETER >::strongPtr ( strongPtr< TYPE, DELETER > && other )

noexcept

Move constructor transfers ownership.

Parameters

other Source strongPtr to move from

Postcondition: other becomes empty

Member Function Documentation

◆ className()

template<typename TYPE, typename DELETER>

std::string original::strongPtr< TYPE, DELETER >::className ( ) const

nodiscardoverridevirtual

Get class identifier.

Returns: Class name of strongPtr

Reimplemented from original::refCntPtr< TYPE, strongPtr< TYPE, DELETER >, DELETER >.

◆ operator=() [1/2]

template<typename TYPE, typename DELETER>

strongPtr< TYPE, DELETER > & original::strongPtr< TYPE, DELETER >::operator= ( const strongPtr< TYPE, DELETER > & other )

Copy assignment shares ownership.

Parameters

other Source strongPtr to copy from

Returns: Reference to this strongPtr

◆ operator=() [2/2]

template<typename TYPE, typename DELETER>

strongPtr< TYPE, DELETER > & original::strongPtr< TYPE, DELETER >::operator= ( strongPtr< TYPE, DELETER > && other )

noexcept

Move assignment transfers ownership.

Parameters

other Source strongPtr to move from

Returns: Reference to this strongPtr

Postcondition: other becomes empty

◆ reset()

template<typename TYPE, typename DELETER>

void original::strongPtr< TYPE, DELETER >::reset ( )

noexcept

Resets the smart pointer and releases the managed object.

Performs the following sequence of operations:

Decrements the current strong reference count
Cleans up the managed pointer and reference counter
Creates a new reference counter and initializes strong references
Postcondition
Equivalent to replacing the current strongPtr with a newly constructed empty pointer

Friends And Related Symbol Documentation

◆ makeStrongPtr

template<typename TYPE, typename DELETER>

template<typename T, typename DEL, typename... Args>

strongPtr< T, DEL > makeStrongPtr ( Args &&... args )

friend

Creates a new strongPtr managing a shared object.

Template Parameters

T	Type of object to create and manage
DEL	Deleter policy type (default: deleter<T>)
Args	Argument types for object construction

Parameters

args	Arguments to forward to T's constructor

Returns: strongPtr<T, DEL> sharing ownership of the new object

Note: Provides exception-safe object creation with shared ownership

The object will be destroyed when all strong references are released

// Create a strongPtr managing a new MyClass constructed with args

auto ptr = makeStrongPtr<MyClass>(arg1, arg2);

original::strongPtr::makeStrongPtr

friend strongPtr< T, DEL > makeStrongPtr(Args &&... args)

Creates a new strongPtr managing a shared object.

Definition refCntPtr.h:445

◆ makeStrongPtrArray

template<typename TYPE, typename DELETER>

template<typename T, typename DEL, typename... Args>

strongPtr< T, DEL > makeStrongPtrArray	(	u_integer	size,
		Args &&...	args )

friend

Creates a new strongPtr managing a shared array.

Template Parameters

T	Type of array elements to create
DEL	Deleter policy type (default: deleter<T[]>)
Args	Argument types for array element initialization

Parameters

size	Number of elements in the array
args	Arguments to forward to each element's constructor

Returns: strongPtr<T, DEL> sharing ownership of the new array

Note: Provides exception-safe array creation with shared ownership

The array will be destroyed when all strong references are released

// Create a strongPtr managing a new MyClass[10] array

auto arr = makeStrongPtrArray<MyClass>(10);

original::strongPtr::makeStrongPtrArray

friend strongPtr< T, DEL > makeStrongPtrArray(u_integer size, Args &&... args)

Creates a new strongPtr managing a shared array.

Definition refCntPtr.h:450

The documentation for this class was generated from the following file:

src/core/refCntPtr.h

Public Member Functions

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ strongPtr() [1/3]

◆ strongPtr() [2/3]

◆ strongPtr() [3/3]

Member Function Documentation

◆ className()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ reset()

Friends And Related Symbol Documentation

◆ makeStrongPtr

◆ makeStrongPtrArray