Public Types

typedef DynPtr< ObjectBase,
ObjectBase > DynPtr_t
Base class pointer.

Public Member Functions

const DynPtr & BasePtr () const throw ()
void deleteReferer ()
Explicitely delete the intermediate referer and invalidate the internal pointer.
DynPtr (ObjectBase *Obj, const SelfInitialize &)
Internal constructor.
DynPtr (ObjectBase *Obj, const NotNullPtr &)
Non=null constructor.
DynPtr (Referer< ObjectBase > *SomeReferer)
Construct from referer object.
DynPtr (const NullPtr &)
Construct from NullPtr.
DynPtr (const DynPtr &D)
Copy constructor.
void ExcludeFromRefChecking () const throw ()
void force_destroy () const throw ()
Delete the associated object unconditionally and mark this pointer as invalid.
const DynPtr & getDynPtr () const throw ()
const type_info & getType () const throw ()
Return type info of associated object,.
void operator= (const DynPtr &P) throw ()
Assignment operator, just copies the Referer pointer.
ObjectBase * rawptr () const
return pointer to referenced object, if valid pointer, otherwise NULL.
void ref () const
Increment the reference count.
void unref () const throw ()
Decrement the reference count.
bool valid () const throw ()
check whether the current pointer is valid
~DynPtr ()
Destructor of the dynamic pointer.

Validity Operators

operator void * () const throw ()
Check if the pointer is valid.
bool operator! () const throw ()
Check if the pointer is null.

Analyse functions for debugging

int strong_refs () const throw ()
Return the strong reference count, ie.
int weak_refs () const throw ()
Return the weak reference count, ie.

Pointer arithmetic

size_t hash_value () const throw ()
Return an integer value which is suitable for hashing.
const void * value () const throw ()
Return an void* value for debug output. Must not be used otherwise!
std::string addrstr () const throw ()
make a string containing hex numbers from the object's adress.
void speak (const char *s, const char *prefix="") const throw ()
Print some debug messages to the console via printf()
void Speak (const char *s, const char *prefix="") const
Print some debug messages to the console via printf(); this is a higher-level version of speak() which demangles the type names.
bool operator!= (const DynPtr &other) const throw ()
inequality operator
bool operator== (const DynPtr &other) const throw ()
Equality operator.
bool operator< (const DynPtr &other) const throw ()
lesser than operator
bool operator<= (const DynPtr &other) const throw ()
lesser equal than operator
bool operator> (const DynPtr &other) const throw ()
greater than operator
bool operator>= (const DynPtr &other) const throw ()
greater than operator

Static Public Member Functions

static const DynPtr & getNullPtr () throw ()

Protected Member Functions

void assignReferer (const DynPtr &P) throw ()
Assignment, copies the Referer pointer, used within derived classes.
void assignReferer (const NullPtr &) throw ()
void invalidateReferer () throw ()
void wref () const throw ()
increment the weak reference count
void wunref () throw ()
Decrement the weak reference count and remove the referer if it reaches zero.

Protected Attributes

Referer< ObjectBase > * myReferer
The intermediate referer object for indirect referencing.

Friends

class ReferenceBase< ObjectBase >

Detailed Description

Base class for pointers to base classes.

Implements basic operations on pointers.

Constructor & Destructor Documentation

MemCore::DynPtr< ObjectBase, ObjectBase >::~DynPtr ( ) [inline]

Destructor of the dynamic pointer.

It does neither touch the reference counting nor eventually delete the associated object, although it can detect a possible memory leak.

Note that even if the strong reference count is zero, the object is not destroyed.

		Data*Dptr = new Data(10);
		{
			WeakPtr<Data> d = Dptr;
		}
		delete Dptr;

Member Function Documentation

const type_info& MemCore::DynPtr< ObjectBase, ObjectBase >::getType ( ) const throw () [inline]

Return type info of associated object,.

typeid(void) is returned if the pointer is NULL

bool MemCore::DynPtr< ObjectBase, ObjectBase >::operator== ( const DynPtr< ObjectBase, ObjectBase > & other ) const throw () [inline]

Equality operator.

It compares the adresses of the intermediate reference object, not of the true data object. This enables comparisions with actually deleted objects when the WeakPtr already is invalid: Two invalid WeakPtr<>'s are ONLY equal if they both referred to the same deleted object, otherwise they are UNEQUAL, even if both are invalid and compare true to a NullPtr() !

void MemCore::DynPtr< ObjectBase, ObjectBase >::ref ( ) const [inline]

Increment the reference count.

Note that only semi-positive refcounts are increased. A negative refcount indicates a static or automatic object, i.e. one which does not require any refcounting at all.

Note:: The first referencing to a strong pointer will call deferred_initialize() . This function might possibly throw an exception.

int MemCore::DynPtr< ObjectBase, ObjectBase >::strong_refs ( ) const throw () [inline]

Return the strong reference count, ie.

how many pointers keep the object alive. Note that an negative value indicates a dead object. If the returned values is -2, then there is not even a referer object, ie. no more weak references exist. Actually, this cannot happen and indicates a bug, like intermediate usage of native pointers. Only somewhere in intermediate constuctor code such things are thinkable.

void MemCore::DynPtr< ObjectBase, ObjectBase >::unref ( ) const throw () [inline]

Decrement the reference count.

Once it reaches zero value, the object is inevitably destroyed and the reference count is set to -1 to indicate invalidity. There is no way to reset the reference count from a negative value to a positive one. Any further ref() calls will be ignored, the object is lost forever, but its referer object may still be alive as a zombie placeholder.

int MemCore::DynPtr< ObjectBase, ObjectBase >::weak_refs ( ) const throw () [inline]

Return the weak reference count, ie.

how many references exist to the object. Note that if only weak references exist to an object, it is likely to be a zombie.

void MemCore::DynPtr< ObjectBase, ObjectBase >::wunref ( ) throw () [inline, protected]

Decrement the weak reference count and remove the referer if it reaches zero.

The reference object is removed outside of a thread-critical section because it might involve a non-trivial destructor which e.g. waits for other threads. It were no good if just these threads are just waiting to enter the wunref() routine because this would lead to an infinite hangup.

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

memcore/DynPtr.hpp