Memory Management classes and routines. More...

Classes

class Ageable
Base class for objects which change from time to time. More...
class AlzheimerCreator
A Creator object which forgets its data when memory is going low. More...
struct BaseChunk< T, Base, false >
Determine the base class for typed chunks of base classes that have another memory layout. More...
struct BaseChunk< T, Base, true >
Determine the base class for typed chunks of base classes that have the same memory layout. More...
struct BaseChunk< T, T, true >
Determine the base class for typed chunks of base classes. More...
class Cache
Main administrative Cache object container. More...
class Cacheable
A domain for objects which may be cached. More...
class CacheBase
Abstract base class for Cache objects. More...
class CacheMap
A list of cache queues for each cacheable type. More...
struct CacheMultiQueue
Cache queues of different purpose. More...
class CacheQueue
A root object that holds a tail of cacheable objects. More...
class Chunk
A class which handles a chunk of memory. More...
class ChunkBase
Base class for chunks of managed memory (any type possible). More...
struct ChunkDataAddress
struct ChunkDataAddress< bool >
struct CopyRef
Pointer to a refcountable object which automatically initializes the pointer with constructing an object, whereby copies of this pointer object also mean copying its value. More...
class Counter
Base class for thread-safe counting, comes with an exception-safe incrementing/decrementing counter class. More...
class Creator
A Creator is a forwarding of some data object to its creational object. More...
class CreatorBase
A Domain-related abstract base class for reference-counted objects which occupy some memory but are able to release it on demand. More...
class CreatorCacheMap
A list of cache maps for each creator type. More...
class Creature
An abstract base class for object creators. More...
struct DeferredInitializationTrait
Trait class that allows to execute some action on an object when it receives the first strong reference count in its life. More...
struct DeferredInitializationTrait< Cacheable >
struct DeferredInitializationTrait< Creature >
struct DeferredInitializationTrait< ReferenceBase< Object > >
struct domain_cast
class DynPtr
Encapsuled pointer class for pointers pointing to derived classes. More...
class DynPtr< ObjectBase, ObjectBase >
Base class for pointers to base classes. More...
struct Exception
Base class for exceptions. More...
struct FunctionStackProfiler
struct Functor
An abstract base class for scalar functions on double values. More...
class Intercube
A container that holds many Interfaces. More...
struct IntercubeIterator
Iterator object for an Intercube. More...
class Interface
Interface template. More...
class interface_cast
Interface cast: Given an Intercube, retrive the an interface object which is stored there. More...
class InterfaceBase
Base class for Interfaces. More...
class InterfaceIterationParameter
struct InterfacePtr
struct LastKnownSourceCodeLineEntry
class Lexicon
An incomplete development class for associating objects with strings, using lexical lookup and easy extraction of chapters. More...
class Loader
Abstract base class for object loaders, which are used by the LoaderRegistry. More...
class LoaderBase
Base class for Loaders. More...
struct LoaderMap
class LoaderParameters
Parameters for the loading process. More...
class LoaderProgress
A base class for callbacks during the load process. More...
class LoaderRegistry
Database for routines that may create objects of type X. More...
class LoaderRegistryBase
class LoaderRequest
Control structure that describes a network connection to a certain URL. More...
class lock
An exeption safe way for locking and unlocking an mutex. More...
struct MemoryException
struct MemVector
A convenience class that looks like a std::vector<>, but is actually referring to a reference-counted common chunk of data. More...
class mutex
Portable intra-process mutex class for locking threads. More...
class NotNullPtr
A type to specify non-null pointer requirements. More...
class NullPtr
A type indicating an invalid pointer, similar to the NULL pointer in C, but type-safe. More...
class OmegaPtr
The Omega pointer - forcibly makes an end to objects. More...
struct PreDestructionTrait
Trait class that allows to execute some action on an object when it is going to be deleted. More...
struct PreDestructionTrait< Cacheable >
struct Profiler
Profiling Support. More...
struct PtrMap_t
struct RangeException
Exception class for range violations. More...
struct Ref
Pointer to a refcountable object which automatically initializes the pointer with constructing an object. More...
class ReferenceBase
Base class for objects which do reference counting. More...
class ReferenceCount
Base class for thread-safe reference counting. More...
class Referer
Internal class for indirectly referencing objects, even dead ones. More...
class RefPtrTypeTrait
Default type trait for the RefPtr pointer -> operator. More...
class Result
class SaveInterfaceCreator
Abstract base class for objects that may equip a certain class object X with an interface to write this structure into a file. More...
class SaveInterfaceCreatorBase
class SaveParameters
class SaveRegistry
Database for routines saving a certain class to disk. More...
class SaveRegistryBase
struct SelfInitialize
Internal class used as an argument for a computational destructor. More...
class simplestring
struct SocketError
Exception class for socket failures. More...
struct SpeakPtr
struct StackTrace
struct StreamSaver
class StreamSaverInterface
struct StringList
A list of strings. More...
class StrongPtr
A reference counting pointer class which keeps objects alive as long as strong pointers to these objects exist. More...
class Timer
A class to hide system dependent methods to count seconds. More...
struct TypedChunk
Class of chunks of a specific type, recursively derived from chunks on base classes of the given type. More...
struct TypedChunkBase
The abstract base class for chunks that have a certain type. More...
class TypeInfo
Helper class for mapping C++ data types to objects. More...
class typemap
A class for mapping C++ types to some object. More...
class WeakPtr
A pointer class which behaves like native C++ pointers, but knows about the lifetime of the referenced objects. More...

Typedefs

typedef StrongPtr< Cacheable,
Cacheable > CacheablePtr
Strong pointer to a cacheable object.
typedef int idx_t
A type used for various indexing operations.
typedef unsigned long memsize_t
The type to describe memory in bytes.
typedef int socket_t
The identifier type for socked connection ID's, usually just an integer.
typedef int socketID_t
The identifier type for socked connection ID's, usually just an integer.
typedef std::vector< socket_t > sockets_t
Storage type for a set of socket connection descriptors.
typedef ::time_t time_t
typedef WeakPtr< Cacheable,
Cacheable > WCacheablePtr
Weak pointer to a cacheable object.
typedef WeakPtr< Cache, CacheBase > WCachePtr
typedef WeakPtr< LoaderBase,
LoaderBase > WeakPtrLoaderBase

Functions

void ________________________________________________getTime (double &sec, Timer &timer)
Reads the current time of a Timer into a variable.
void ________________________________________________printTime (const char *text, const double time)
Print a time value.
MEMCORE_API void CheckConstruction (void *, const std::type_info &RuntimeType, const std::type_info &CompiletimeType)
Debug function which registers a pointer with a type.
MEMCORE_API void CheckRefConstruction (void *)
void MEMCORE_API CheckRefExcludeObject (void *myObject)
Debug function which unregisters a pointer, see CheckConstruction();.
MEMCORE_API void CheckRefObjectInfo ()
socketID_t ConnectTo (const std::string &hostname, const std::string &service="6666") throw (SocketError)
Connect to a given host under service (portnumber).
string FileRead (const string &filename, const char *how="rb")
Read a file completely into memory as string.
MEMCORE_API double getEnvFloat (const char *n, const char *description)
Get a floating point value from an environment variable.
MEMCORE_API int getEnvInteger (const char *n, const char *description)
Get an integer from an environment variable.
const char * getLastKnownSourceCodeLine () throw ()
long getMemUsage ()
const type_info & getType (const string &s)
Get the intrinsic type information of a registered type (see setTypename() ) from its textual description.
bool InterfaceDemo ()
string NameOf (const type_info &t)
bool operator< (const Profiler::Info &A, const Profiler::Info &B)
string PathOpen (const std::list< string > &path, const string &filename)
Find a file out of a list of possible directories.
string PathOpen (const RefPtr< StringList > &SL, const string &filename)
string PathOpen (const string &path, const string &filename, char delimiter)
string PathOpen (const std::list< string > &path, const std::list< string > &filelist)
string PathOpen (const RefPtr< StringList > &SL, const RefPtr< StringList > &filenames)
string PathOpen (const string &path, char path_delimiter, const RefPtr< StringList > &filenames)
void SetLastKnownSourceCodeLine (const char *what) throw ()
void setTypename (const type_info &t, const string &s)
A typemap used for adding new type names.
string Typename (const type_info &t)
Given some type, return some human-readable platform independent unique short description.

Variables

class MEMCORE_API Cache
class MEMCORE_API Cacheable
class MEMCORE_API CacheQueue
MEMCORE_API int CheckRefcountedObjects = 0
The number of currently used reference counted objects.
class MEMCORE_API Creature
class MEMCORE_API Intercube
class MEMCORE_API LoaderBase
class MEMCORE_API LoaderRegistryBase
std::list< std::string > PathPrefixes
A list of possible path prefixes that will be indicated with "%0" etc.
MEMCORE_API int RefererObjects = 0
int ShowReferenceCheckInfoOnExit = getEnvInteger("MEMCORE_EXITINFO", "info on exit")

Detailed Description

Memory Management classes and routines.

The MemCore library provides

weak and strong pointers, i.e. allows reference counted garbage collection with manually controlled cycles
simplified downcasting of pointers
runtime-determined multiple inheritance via dynamic interfaces
cache management with prioritized queueing
transparent delayed on-demand procedural creation of objects The MemCore library is kept as simple as possible to provide only core services that might be central to a broad range of applications. It is a top-level library in that it does not require any other libraries.

"Weak" and "strong" pointers are a natural extension of the native C++ pointer concept. Their semantic is similar to native pointers, but they provide significant improvements:

A "weak pointer" is a pointer that has knowledge about the lifetime of the referenced objects. If the object is destructed, then the weak pointer becomes NULL (in contrast to a native pointer which is unchanged when the referred object is destructed).
A "strong pointer" keeps the referenced object alive as long as the pointer itself lives. This is commonly known as reference counting. Here, a strong pointer is also a weak pointer, i.e. if the object in charge is destroyed (e.g. the lifetime of an automatic object has expired or the object has been explicitely deleted), then the pointer becomes NULL. This allows mixing of pointers to dynamically and automatically/static allocated objects.
The C++ dynamic_cast<> operations allows to assign a base class to a pointer of a derived class. Its syntax requires the type name twice, which is an unneccesary inconvenience, because the type of the left-hand-side is already known in assignments or function paramaters. MemCore's weak and strong pointers allow dynamic_cast<> operations during construction and assignment from compatible class pointers. "compatible" means that they have the same base class, which is defined via class ReferenceBase<>. All objects that may be used via MemCore pointers must be derived from template class ReferenceBase<> instantiated over a common base type.

In contrast to simple reference counting as e.g. implemented via handles in OpenInventor, MemCore allows cyclic references and pointers to non-dynamically allocated (e.g. static or automatic) objects. It does that by utilizing intermediate object referers.

Function Documentation

void MemCore::________________________________________________getTime	(	double &	sec,
		Timer &	timer
	)		`[inline]`

Reads the current time of a Timer into a variable.

Timing functions tend to make the code hardly readable and also the debugging output. That's why this functions look so weird; to be visible, marking lines of time measures. Can be enabled by setting #define TIMEIT before including the header file Timer.hpp

void MemCore::________________________________________________printTime	(	const char *	text,
		const double	time
	)		`[inline]`

Print a time value.

Just to have a similar looking function as getTime for printing

MEMCORE_API string MemCore::FileRead	(	const string &	filename,
		const char *	how = `"rb"`
	)

Read a file completely into memory as string.

Parameters:

filename The file name, for instance as retrieved by PathOpen();

double MemCore::getEnvFloat	(	const char *	n,
		const char *	description
	)

Get a floating point value from an environment variable.

See also:: getEnvInteger

int MemCore::getEnvInteger	(	const char *	n,
		const char *	description
	)

Get an integer from an environment variable.

If the environment variable SHOW_ENVIRONMENT_CONTROL_VARIABLES is set, then a descriptive information is displayed for each environment variable upon its first possible use, even if it is not set.

MEMCORE_API string MemCore::PathOpen	(	const std::list< string > &	path,
		const string &	filename
	)

Find a file out of a list of possible directories.

Returns:: The full filename.

Variable Documentation

MEMCORE_API std::list< std::string > MemCore::PathPrefixes

A list of possible path prefixes that will be indicated with "%0" etc.

within a PathOpen() call.

%0 is supposed to relate to the program's start path.