namespace corelinux

Forward reference the various common classes.

typedef int (*CallerFunctionPtr)(ThreadContextPtr)

Callers function entry point

typedef ThreadContextPtr (*ThreadContextCreatePtr)( ThreadContextRef )

Managed ThreadContext creation function.

typedef void (*ThreadContextDestroyPtr)( ThreadContextPtr )

Managed ThreadContext deallocate function.

typedef Int (*ThreadFrameFunctionPtr)( ThreadContextPtr )

Thread frame entry point function handler

typedef BytePtr (*ThreadStackCreatePtr)( ThreadContextPtr )

Managed ThreadContext stack creation function.

typedef void (*ThreadStackDestroyPtr)( BytePtr )

Managed ThreadContext stack deallocate function.

defineCORELINUX_STACK(name, type)(stack<type>, name) (__VECTOR_HPP)(__COMMON_HPP)

STL stack template.

defineCORELINUX_QUEUE (name, type)(deque<type>, name)

STL queue template.

defineCORELINUX_LIST (name, type)(list<type>, name)

STL list template.

template< class TypeImpl > Singleton<TypeImpl> * Singleton<TypeImpl> ::theSingleton( NULLPTR )

Static definition for theSingleton

template< class TypeImpl > TypeImpl* Singleton<TypeImpl> ::theType( NULLPTR )

Static definition for theType

template< class TypeImpl > class AbstractAllocator

AbstractAllocator is a abstract template which provides for the extension of memory managment on a TypeImpl object by TypeImpl object basis.

class AbstractCommand

AbstractCommand captures the semantics of the capabilities of commands, which is basically to provide a execution context

template< class UniqueId > class AbstractFactory

AbstractFactory provides an interface for creating families of related or dependent objects without specifying their concrete classes.

class AbstractFactoryException

AbstractFactoryException is the base exception type for AbstractFactory.

class AbstractSemaphore

A AbstractSemaphore supports the protocol that processes and/or threads agree to follow for the purpose of controlled access to a resource.

class AbstractString

AbstractString is a temporary base abstraction.

class Adapter

An Adapter converts the interface of a class into another interface that clients expect.

class Allocator

Allocator is a Strategy class used by AbstractAllocator and AbstractFactoryEach Allocator instance tracks allocates and deallocates

class AllocatorAlreadyExistsException

AllocatorAlreadyExistsException is an exception that is usually thrown when a add of an Allocator collides in a AbstractFactory implementation

class AllocatorNotFoundException

AllocatorNotFoundException is an exception that is usually thrown when a AbstractFactory attempts to use a specific Allocator

template< class KeyType, class ElementType > class AssociativeIterator

The AssociativeIterator that extends Iterator to include the interface for describing an associative collection type without exposing its underlying representation.

class BoundsException

BoundsException is a type of StorageException, characterized when access to a storage object is invalid

template<class Implementation> class Bridge

When an abstraction can have one of several possible implementations, the usual way to accommodate them is to use inheritance.

template< class ProductImpl, class UniqueId > class Builder

Builder seperates the construction of a complex object from its representation so that the same construction process can create different representations.

define CORELINUX_MAP(name, key, value, comp)

STL map template.

typedef name::reverse_iterator* name RiteratorPtr define CORELINUX_MULTIMAP(name, key, value, comp)

STL multimap template.

typedef name::reverse_iterator* name RiteratorPtr define CORELINUX_MULTISET(name, key, comp)

STL multiset template.

define CORELINUX_PAIR(name, pair1, pair2)

STL pair template.

define CORELINUX_SET(name, key, comp)

STL set template.

class Colleague

Colleague knows its Mediator object, communicates with its mediator whenever it would have otherwise communicated with another Colleague.

class Command

Command captures the semantics of allowing commands to be added as a reverse command type.

class CommandFrame

CommandFrame builds a unit of work around one or more Commands.

class CommandFrameException

CommandFrameException is the base exception type for CommandFrame.

class Component

A Component declares the interface for the objects in a composition and implements default behavior.

class CompositeException

CompositeException is the base exception type for Composite.

class Context

Context defines the interface to clients and maintains an instance of a State subclass

template< class TraverseType, class KeyType, class ElementType > class CoreLinuxAssociativeIterator

The CoreLinuxAssociativeIterator provides a way to access the elements of any of the associative STL collections, by defining a CoreLinuxAssociativeIterator with a CORELINUX_COLLECTION nameAssociativeIterator definition, the KeyType and the Element Type

class CoreLinuxGuardGroup

A CoreLinuxGuardGroup is an extension to the SemaphoreGroup for creating semaphores for the CoreLinuxGuardPool.

class CoreLinuxGuardPool

The CoreLinuxGuardPool is a private SemaphoreGroup resource for class objects that require synchronization capability.

template< class TraverseType, class ElementType > class CoreLinuxIterator

The CoreLinuxIterator provides a way to access the elements of any of the non-associative STL collections.

class CoreLinuxObject

An CoreLinuxObject is a base class for the library.

DECLARE_CLASS( CoreLinuxObject )

DECLARE_TYPE( Singleton<Memory>, MemoryManager )

Declare the memory manager as a singleton for Memory

template<class Implementation> class Decorator

Decorators can attach additional responsibilities to an object dynamically which provide a more flexible alternative to subclassing for extending functionality

template< class IdentifierType = Identifier > class Event

Event provides a type basis for event ontologies

class Exception

Exception is the base exception class used in the CoreLinux++ libraries.

class Facade

Structuring a system into subsystems helps reduce complexity.

class Flyweight

Flyweight type is used to support large numbers of fine-grained objects

class GatewaySemaphore

GatewaySemphore enables a depth of resource indicator.

class GatewaySemaphoreGroup

A GatewaySemaphoreGroup is an extension to the SemaphoreGroup for creating only GatewaySemaphore types.

class GuardSemaphore

GuardSemaphore is a special case semaphore for use by the CoreLinuxGuardPool.

class Handler

Defines an interface for handling requests, accessing successors, and optionally implements the successor link.

class Identifier

An Identifier is a abstract representation of identity.

class InvalidCompositeException

InvalidCompositeException is an exception that is usually thrown when a composite operation is attempted on a leaf component

class InvalidIteratorException

InvalidIteratorException is an exception that indicates a Iterator could not be properly formed for some reason

class InvalidThreadException

InvalidThreadException describes an exception that is thrown when a operation is attempted on a non-managed thread context

template< class ElementType > class Iterator

The Iterator provides a way to access the elements of an collection type sequentially without exposing its underlying representation.

class IteratorBoundsException

IteratorBoundsException is thrown when a Iterator has position before the begining or past the end positions of its implementation

class IteratorException

IteratorException is the base exception type for Iterator.

class Mediator

Mediator declares an interface for communicating with Colleague objects

class Memento

Memento knows its Mediator object, communicates with its mediator whenever it would have otherwise communicated with another Memento.

class Memory

Memory is high speed transient storage managed by the operating system, for both itself and user processes, used to store data and programs.

class MemoryStorage

MemoryStorage is type of Storage characterized as transient and high speed.

class MutexSemaphore

MutexSemaphore implements a mutual exclusion control which can be used to insure that at most one (1) task has access at a time.

class MutexSemaphoreGroup

A MutexSemaphoreGroup is an extension to the SemaphoreGroup for creating only MutexSemaphore types.

class NullPointerException

NullPointerException is the base exception type for NullPointer.

class Observer

Observer observes Subjets and supports the event interface for recieving subject event notifications

struct PoolDescriptor

PoolDescriptor stores information about the ownership and usage of a semaphore in the pool

template< class TypeImpl > class Prototype

Specify the kinds of objects to create using a prototypical instance, and create new objects by copying (cloning) this prototype

template< class SubjectImpl > class Proxy

Provide a surrogate or placeholder for another object to control access to it

class Request

A Request is used for type identification to a handler object

template< class ScalarType > class ScalarIdentifier

ScalarIdentifier provides a templated interface for declaring CoreLinux Identifiers for simple scalar types

class Semaphore

A Semaphore supports the protocol that processes and/or threads agree to follow for the purpose of controlled access to a resource.

class SemaphoreException

SemaphoreException is the base exception type for Semaphore.

class SemaphoreGroup

A SemaphoreGroup is an extension to the Linux semaphore set.

enum SemaphoreOperationStatus

Semaphore method return enumeration

template< class TypeImpl > class Singleton

Ensure a class only has one instance, and provide a global point of access to it.

class State

Allow an object to alter its behavior when its internal state changes.

class Storage

Storage is the abstract type for anything that can be use to store and read (eg.

class StorageException

StorageException is the base exception type for Storage.

class Strategy

Strategy is a base class for describing families of alogrithms.

class StringUtf8

StringUtf8 is a temporary string implementation.

class Subject

Subject knows its Observer objects, communicates with its observers through event notification

class Synchronized

Synchronized is a mixin which allows class objects to enable monitor functionality

class Thread

Thread is a framework for the creation, management, and destruction of caller threads.

class ThreadContext

ThreadContext describes the context in which the thread operates.

class ThreadException

ThreadException is the base exception type for Thread.

enum ThreadState

Thread state enumeration

class TransientStorage

TransientStorage type is an area of storage that will not be saved across system initializations

template<class CompImpl> class TransparentComponent

A TransparentComponent is a templated Component whereas it declares the interface for the objects in a composition, implements default behavior and declares the interface for child operations

class Visitor

Represent an operation to be performed on the components of an object structure.

enum WorkState

State of execution

DECLARE_CLASS( CoreLinuxObject )

DECLARE_TYPE( Singleton<Memory>, MemoryManager )

Declare the memory manager as a singleton for Memory

template< class TypeImpl > Singleton<TypeImpl> * Singleton<TypeImpl> ::theSingleton( NULLPTR )

Static definition for theSingleton

template< class TypeImpl > TypeImpl* Singleton<TypeImpl> ::theType( NULLPTR )

Static definition for theType