Decaf's implementation of a Smart Pointer that is a template on a Type and is Thread Safe if the default Reference Counter is used. More...

#include <src/main/decaf/lang/Pointer.h>

Inheritance diagram for activemq::transport::failover::Pointer< T, REFCOUNTER >:

[legend]

Public Types
typedef T *	PointerType
typedef T &	ReferenceType
typedef REFCOUNTER	CounterType

Public Member Functions
	Pointer ()
	Default Constructor.
	Pointer (const PointerType value)
	Explicit Constructor, creates a Pointer that contains value with a single reference.
	Pointer (const Pointer &value)
	Copy constructor.
template<typename T1, typename R1>
	Pointer (const Pointer< T1, R1 > &value)
	Copy constructor.
template<typename T1, typename R1>
	Pointer (const Pointer< T1, R1 > &value, const STATIC_CAST_TOKEN &)
	Static Cast constructor.
template<typename T1, typename R1>
	Pointer (const Pointer< T1, R1 > &value, const DYNAMIC_CAST_TOKEN &)
	Dynamic Cast constructor.
virtual	~Pointer ()
void	reset (T *value=NULL)
	Resets the Pointer to hold the new value.
T *	release ()
	Releases the Pointer held and resets the internal pointer value to Null.
PointerType	get () const
	Gets the real pointer that is contained within this Pointer.
void	swap (Pointer &value)
	Exception Safe Swap Function.
Pointer &	operator= (const Pointer &right)
	Assigns the value of right to this Pointer and increments the reference Count.
template<typename T1, typename R1>
Pointer &	operator= (const Pointer< T1, R1 > &right)
ReferenceType	operator* ()
	Dereference Operator, returns a reference to the Contained value.
ReferenceType	operator* () const
PointerType	operator-> ()
	Indirection Operator, returns a pointer to the Contained value.
PointerType	operator-> () const
bool	operator! () const
template<typename T1, typename R1>
bool	operator== (const Pointer< T1, R1 > &right) const
template<typename T1, typename R1>
bool	operator!= (const Pointer< T1, R1 > &right) const
template<typename T1>
Pointer< T1, CounterType >	dynamicCast () const
template<typename T1>
Pointer< T1, CounterType >	staticCast () const
Public Member Functions inherited from decaf::util::concurrent::atomic::AtomicRefCounter
	AtomicRefCounter ()
	AtomicRefCounter (const AtomicRefCounter &other)
virtual	~AtomicRefCounter ()

Friends
bool	operator== (const Pointer &left, const T *right)
bool	operator== (const T *left, const Pointer &right)
bool	operator!= (const Pointer &left, const T *right)
bool	operator!= (const T *left, const Pointer &right)

Additional Inherited Members
Protected Member Functions inherited from decaf::util::concurrent::atomic::AtomicRefCounter
void	swap (AtomicRefCounter &other)
	Swaps this instance's reference counter with the one given, this allows for copy-and-swap semantics of this object.
bool	release ()
	Removes a reference to the counter Atomically and returns if the counter has reached zero, once the counter hits zero, the internal counter is destroyed and this instance is now considered to be unreferenced.

Detailed Description

template<typename T, typename REFCOUNTER = decaf::util::concurrent::atomic::AtomicRefCounter>
class activemq::transport::failover::Pointer< T, REFCOUNTER >

Decaf's implementation of a Smart Pointer that is a template on a Type and is Thread Safe if the default Reference Counter is used.

This Pointer type allows for the substitution of different Reference Counter implementations which provide a means of using invasive reference counting if desired using a custom implementation of ReferenceCounter.

The Decaf smart pointer provide comparison operators for comparing Pointer instances in the same manner as normal pointer, except that it does not provide an overload of operators ( <, <=, >, >= ). To allow use of a Pointer in a STL container that requires it, Pointer provides an implementation of std::less.

Since: 1.0

Member Typedef Documentation

◆ CounterType

template<typename T, typename REFCOUNTER = decaf::util::concurrent::atomic::AtomicRefCounter>

typedef REFCOUNTER decaf::lang::Pointer< T, REFCOUNTER >::CounterType

◆ PointerType

template<typename T, typename REFCOUNTER = decaf::util::concurrent::atomic::AtomicRefCounter>

typedef T* decaf::lang::Pointer< T, REFCOUNTER >::PointerType

◆ ReferenceType

template<typename T, typename REFCOUNTER = decaf::util::concurrent::atomic::AtomicRefCounter>

typedef T& decaf::lang::Pointer< T, REFCOUNTER >::ReferenceType

Constructor & Destructor Documentation

◆ Pointer() [1/6]

template<typename T, typename REFCOUNTER = decaf::util::concurrent::atomic::AtomicRefCounter>

decaf::lang::Pointer< T, REFCOUNTER >::Pointer ( )

inline

Default Constructor.

Initialized the contained pointer to NULL, using the -> operator results in an exception unless reset to contain a real value.

◆ Pointer() [2/6]

template<typename T, typename REFCOUNTER = decaf::util::concurrent::atomic::AtomicRefCounter>

decaf::lang::Pointer< T, REFCOUNTER >::Pointer ( const PointerType value )

inlineexplicit

Explicit Constructor, creates a Pointer that contains value with a single reference.

This object now has ownership until a call to release.

Parameters

value - The instance of the type we are containing here.

◆ Pointer() [3/6]

template<typename T, typename REFCOUNTER = decaf::util::concurrent::atomic::AtomicRefCounter>

decaf::lang::Pointer< T, REFCOUNTER >::Pointer ( const Pointer< T, REFCOUNTER > & value )

inline

Copy constructor.

Copies the value contained in the pointer to the new instance and increments the reference counter.

Parameters

value Another instance of a Pointer<T> that this Pointer will copy.

◆ Pointer() [4/6]

template<typename T, typename REFCOUNTER = decaf::util::concurrent::atomic::AtomicRefCounter>

template<typename T1, typename R1>

decaf::lang::Pointer< T, REFCOUNTER >::Pointer ( const Pointer< T1, R1 > & value )

inline

Copy constructor.

Copies the value contained in the pointer to the new instance and increments the reference counter.

Parameters

value A different but compatible Pointer instance that this Pointer will copy.

◆ Pointer() [5/6]

template<typename T, typename REFCOUNTER = decaf::util::concurrent::atomic::AtomicRefCounter>

template<typename T1, typename R1>

decaf::lang::Pointer< T, REFCOUNTER >::Pointer	(	const Pointer< T1, R1 > &	value,
		const STATIC_CAST_TOKEN &	)

inline

Static Cast constructor.

Copies the value contained in the pointer to the new instance and increments the reference counter performing a static cast on the value contained in the source Pointer object.

Parameters

value Pointer instance to cast to this type using a static_cast.

◆ Pointer() [6/6]

template<typename T, typename REFCOUNTER = decaf::util::concurrent::atomic::AtomicRefCounter>

template<typename T1, typename R1>

decaf::lang::Pointer< T, REFCOUNTER >::Pointer	(	const Pointer< T1, R1 > &	value,
		const DYNAMIC_CAST_TOKEN &	)

inline

Dynamic Cast constructor.

Copies the value contained in the pointer to the new instance and increments the reference counter performing a dynamic cast on the value contained in the source Pointer object. If the cast fails and return NULL then this method throws a ClassCastException.

Parameters

value Pointer instance to cast to this type using a dynamic_cast.

Exceptions

ClassCastException if the dynamic cast returns NULL

◆ ~Pointer()

template<typename T, typename REFCOUNTER = decaf::util::concurrent::atomic::AtomicRefCounter>

virtual decaf::lang::Pointer< T, REFCOUNTER >::~Pointer ( )

inlinevirtual

Member Function Documentation

◆ dynamicCast()

template<typename T, typename REFCOUNTER = decaf::util::concurrent::atomic::AtomicRefCounter>

template<typename T1>

Pointer< T1, CounterType > decaf::lang::Pointer< T, REFCOUNTER >::dynamicCast ( ) const

inline

◆ get()

template<typename T, typename REFCOUNTER = decaf::util::concurrent::atomic::AtomicRefCounter>

PointerType decaf::lang::Pointer< T, REFCOUNTER >::get ( ) const

inline

Gets the real pointer that is contained within this Pointer.

This is not really safe since the caller could delete or alter the pointer but it mimics the STL auto_ptr and gives access in cases where the caller absolutely needs the real Pointer. Use at your own risk.

Returns: the contained pointer.

◆ operator!()

template<typename T, typename REFCOUNTER = decaf::util::concurrent::atomic::AtomicRefCounter>

bool decaf::lang::Pointer< T, REFCOUNTER >::operator! ( ) const

inline

◆ operator!=()

template<typename T, typename REFCOUNTER = decaf::util::concurrent::atomic::AtomicRefCounter>

template<typename T1, typename R1>

bool decaf::lang::Pointer< T, REFCOUNTER >::operator!= ( const Pointer< T1, R1 > & right ) const

inline

◆ operator*() [1/2]

template<typename T, typename REFCOUNTER = decaf::util::concurrent::atomic::AtomicRefCounter>

ReferenceType decaf::lang::Pointer< T, REFCOUNTER >::operator* ( )

inline

Dereference Operator, returns a reference to the Contained value.

This method throws an NullPointerException if the contained value is NULL.

Returns: reference to the contained pointer.

Exceptions

NullPointerException if the contained value is Null

◆ operator*() [2/2]

template<typename T, typename REFCOUNTER = decaf::util::concurrent::atomic::AtomicRefCounter>

ReferenceType decaf::lang::Pointer< T, REFCOUNTER >::operator* ( ) const

inline

◆ operator->() [1/2]

template<typename T, typename REFCOUNTER = decaf::util::concurrent::atomic::AtomicRefCounter>

PointerType decaf::lang::Pointer< T, REFCOUNTER >::operator-> ( )

inline

Indirection Operator, returns a pointer to the Contained value.

This method throws an NullPointerException if the contained value is NULL.

Returns: reference to the contained pointer.

Exceptions

NullPointerException if the contained value is Null

◆ operator->() [2/2]

template<typename T, typename REFCOUNTER = decaf::util::concurrent::atomic::AtomicRefCounter>

PointerType decaf::lang::Pointer< T, REFCOUNTER >::operator-> ( ) const

inline

◆ operator=() [1/2]

template<typename T, typename REFCOUNTER = decaf::util::concurrent::atomic::AtomicRefCounter>

Pointer & decaf::lang::Pointer< T, REFCOUNTER >::operator= ( const Pointer< T, REFCOUNTER > & right )

inline

Assigns the value of right to this Pointer and increments the reference Count.

Parameters

right - Pointer on the right hand side of an operator= call to this.

◆ operator=() [2/2]

template<typename T, typename REFCOUNTER = decaf::util::concurrent::atomic::AtomicRefCounter>

template<typename T1, typename R1>

Pointer & decaf::lang::Pointer< T, REFCOUNTER >::operator= ( const Pointer< T1, R1 > & right )

inline

◆ operator==()

template<typename T, typename REFCOUNTER = decaf::util::concurrent::atomic::AtomicRefCounter>

template<typename T1, typename R1>

bool decaf::lang::Pointer< T, REFCOUNTER >::operator== ( const Pointer< T1, R1 > & right ) const

inline

◆ release()

template<typename T, typename REFCOUNTER = decaf::util::concurrent::atomic::AtomicRefCounter>

T * decaf::lang::Pointer< T, REFCOUNTER >::release ( )

inline

Releases the Pointer held and resets the internal pointer value to Null.

This method is not guaranteed to be safe if the Pointer is held by more than one object or this method is called from more than one thread.

Returns: The pointer instance that was held by this Pointer object, the pointer is no longer owned by this Pointer and won't be freed when this Pointer goes out of scope.

◆ reset()

template<typename T, typename REFCOUNTER = decaf::util::concurrent::atomic::AtomicRefCounter>

void decaf::lang::Pointer< T, REFCOUNTER >::reset ( T * value = NULL )

inline

Resets the Pointer to hold the new value.

Before the new value is stored reset checks if the old value should be destroyed and if so calls delete. Call reset with a value of NULL is supported and acts to set this Pointer to a NULL pointer.

Parameters

value The new value to contain or NULL to empty the pointer (default NULL if not set).

◆ staticCast()

template<typename T, typename REFCOUNTER = decaf::util::concurrent::atomic::AtomicRefCounter>

template<typename T1>

Pointer< T1, CounterType > decaf::lang::Pointer< T, REFCOUNTER >::staticCast ( ) const

inline

◆ swap()

template<typename T, typename REFCOUNTER = decaf::util::concurrent::atomic::AtomicRefCounter>

void decaf::lang::Pointer< T, REFCOUNTER >::swap ( Pointer< T, REFCOUNTER > & value )

inline

Exception Safe Swap Function.

Parameters

value The value to swap with this Pointer.

◆ operator!= [1/2]

template<typename T, typename REFCOUNTER = decaf::util::concurrent::atomic::AtomicRefCounter>

bool operator!=	(	const Pointer< T, REFCOUNTER > &	left,
		const T *	right )

friend

◆ operator!= [2/2]

template<typename T, typename REFCOUNTER = decaf::util::concurrent::atomic::AtomicRefCounter>

bool operator!=	(	const T *	left,
		const Pointer< T, REFCOUNTER > &	right )

friend

◆ operator== [1/2]

template<typename T, typename REFCOUNTER = decaf::util::concurrent::atomic::AtomicRefCounter>

bool operator==	(	const Pointer< T, REFCOUNTER > &	left,
		const T *	right )

friend

◆ operator== [2/2]

template<typename T, typename REFCOUNTER = decaf::util::concurrent::atomic::AtomicRefCounter>

bool operator==	(	const T *	left,
		const Pointer< T, REFCOUNTER > &	right )

friend

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

src/main/decaf/lang/Pointer.h

Public Types

Public Member Functions

Friends

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ CounterType

◆ PointerType

◆ ReferenceType

Constructor & Destructor Documentation

◆ Pointer() [1/6]

◆ Pointer() [2/6]

◆ Pointer() [3/6]

◆ Pointer() [4/6]

◆ Pointer() [5/6]

◆ Pointer() [6/6]

◆ ~Pointer()

Member Function Documentation

◆ dynamicCast()

◆ get()

◆ operator!()

◆ operator!=()

◆ operator*() [1/2]

◆ operator*() [2/2]

◆ operator->() [1/2]

◆ operator->() [2/2]

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ operator==()

◆ release()

◆ reset()

◆ staticCast()

◆ swap()

Friends And Related Symbol Documentation

◆ operator!= [1/2]

◆ operator!= [2/2]

◆ operator== [1/2]

◆ operator== [2/2]