--- name: "corelinux" section: "3" platform: "linux" package: "libcorelinux-dev" version: "0.4.32-5" release: "Debian 3.1 (Sarge)" platforms: ["linux"] url: "https://new.carta.tech/corelinux" --- # corelinux(3) Forward reference the various common classes. ## NAME corelinux - Forward reference the various common classes. ## SYNOPSIS ### Classes struct **\_CSAGroupHeader**\ *Describes a CSA semaphore group.* struct **\_CSAHeader**\ *Describes the tip control block for the Common* **Storage** *Area (CSA).* struct **\_CSASemaphoreHeader**\ *Describes a CSA semaphore entry.* 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.* 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 AbstractFactory.Each* **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***.* struct **AssertCt**\ class **Assertion**\ **Assertion** *is-a* **Exception** *created when an assertion fails.* 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.* class **Bridge**\ *When an abstraction can have one of several possible implementations, the usual way to accommodate them is to use inheritance.* class **Builder**\ **Builder** *seperates the construction of a complex object from its representation so that the same construction process can create different representations.* 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.* 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.* 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.* class **Decorator**\ *Decorators can attach additional responsibilities to an object dynamically which provide a more flexible alternative to subclassing for extending functionality.* class **Environment**\ **Environment** *is a class utility which encapsulates.* class **Event**\ **Event** *provides a type basis for event ontologies.* class **EventSemaphore**\ **EventSemaphore** *implements a way to queue its caller until a certain event takes place.* class **EventSemaphoreGroup**\ *A* **EventSemaphoreGroup** *is an extension to the* **SemaphoreGroup** *for creating only* **EventSemaphore** *types.* 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.* 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 **Limits**\ **Limits** *is to provide information regarding CoreLinux++ scalar types.* 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.* class **Prototype**\ *Specify the kinds of objects to create using a prototypical instance, and create new objects by copying (cloning) this prototype.* 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.* 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 **SemaphoreCommon**\ *The* **SemaphoreCommon** *manages the* **SemaphoreGroup** *common storage area.* class **SemaphoreException**\ **SemaphoreException** *is the base exception type for* **Semaphore***.* class **SemaphoreGroup**\ *A* **SemaphoreGroup** *is an extension to the Linux semaphore set.* struct **SemaphoreReference**\ 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 (e.g.* class **StorageException**\ **StorageException** *is the base exception type for* **Storage***.* class **Strategy**\ **Strategy** *is a base class for describing families of alogrithms.* class **String**\ 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 **Synchronized::Guard**\ **Guard** *is the automatic instance that insures a lock is not held beyond the scope where it was instantiated.* 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***.* class **TransientStorage**\ **TransientStorage** *type is an area of storage that will not be saved across system initializations.* 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.* ### Types Type defintions in the hopes to avoid portability problems and provide consistent standard naming style. Under Construction!!! typedef std::map\< SemaphoreReference, std::less\< Index \>, SemaphoreShares \> **Index**\ typedef Index \* **IndexPtr**\ typedef const Index \* **IndexCptr**\ typedef Index & **IndexRef**\ typedef const Index & **IndexCref**\ typedef char **Char**\ typedef char \* **CharPtr**\ typedef const Char \* **CharCptr**\ typedef Char & **CharRef**\ typedef const Char & **CharCref**\ typedef wchar\_t **Wchar**\ typedef wchar\_t \* **WcharPtr**\ typedef const Wchar \* **WcharCptr**\ typedef Wchar & **WcharRef**\ typedef const Wchar & **WcharCref**\ typedef short int **Short**\ typedef short int \* **ShortPtr**\ typedef const Short \* **ShortCptr**\ typedef Short & **ShortRef**\ typedef const Short & **ShortCref**\ typedef long int **Long**\ typedef long int \* **LongPtr**\ typedef const Long \* **LongCptr**\ typedef Long & **LongRef**\ typedef const Long & **LongCref**\ typedef int **Int**\ typedef int \* **IntPtr**\ typedef const Int \* **IntCptr**\ typedef Int & **IntRef**\ typedef const Int & **IntCref**\ typedef unsigned int **UnsignedInt**\ typedef unsigned int \* **UnsignedIntPtr**\ typedef const UnsignedInt \* **UnsignedIntCptr**\ typedef UnsignedInt & **UnsignedIntRef**\ typedef const UnsignedInt & **UnsignedIntCref**\ typedef unsigned char **Byte**\ typedef unsigned char \* **BytePtr**\ typedef const Byte \* **ByteCptr**\ typedef Byte & **ByteRef**\ typedef const Byte & **ByteCref**\ typedef unsigned short **Word**\ typedef unsigned short \* **WordPtr**\ typedef const Word \* **WordCptr**\ typedef Word & **WordRef**\ typedef const Word & **WordCref**\ typedef unsigned long **Dword**\ typedef unsigned long \* **DwordPtr**\ typedef const Dword \* **DwordCptr**\ typedef Dword & **DwordRef**\ typedef const Dword & **DwordCref**\ typedef double **Real**\ typedef double \* **RealPtr**\ typedef const Real \* **RealCptr**\ typedef Real & **RealRef**\ typedef const Real & **RealCref**\ typedef void \* **VoidPtr**\ typedef size\_t **Size**\ typedef size\_t \* **SizePtr**\ typedef const Size \* **SizeCptr**\ typedef Size & **SizeRef**\ typedef const Size & **SizeCref**\ typedef Long **Counter**\ typedef Long \* **CounterPtr**\ typedef const Counter \* **CounterCptr**\ typedef Counter & **CounterRef**\ typedef const Counter & **CounterCref**\ typedef Word **ResID**\ typedef Word \* **ResIDPtr**\ typedef const ResID \* **ResIDCptr**\ typedef ResID & **ResIDRef**\ typedef const ResID & **ResIDCref**\ typedef Dword **Count**\ typedef Dword \* **CountPtr**\ typedef const Count \* **CountCptr**\ typedef Count & **CountRef**\ typedef const Count & **CountCref**\ typedef VoidPtr **Handle**\ typedef VoidPtr \* **HandlePtr**\ typedef const Handle \* **HandleCptr**\ typedef Handle & **HandleRef**\ typedef const Handle & **HandleCref**\ typedef Dword **MessageID**\ typedef Dword \* **MessageIDPtr**\ typedef const MessageID \* **MessageIDCptr**\ typedef MessageID & **MessageIDRef**\ typedef const MessageID & **MessageIDCref**\ ### Typedefs typedef **AbstractCommand** \* **AbstractCommandPtr**\ typedef const **AbstractCommand** \* **AbstractCommandCptr**\ typedef **AbstractCommand** & **AbstractCommandRef**\ typedef const **AbstractCommand** & **AbstractCommandCref**\ typedef **AbstractFactoryException** \* **AbstractFactoryExceptionPtr**\ typedef const **AbstractFactoryException** \* **AbstractFactoryExceptionCptr**\ typedef **AbstractFactoryException** & **AbstractFactoryExceptionRef**\ typedef const **AbstractFactoryException** & **AbstractFactoryExceptionCref**\ typedef **SemaphoreGroup** \* **SemaphoreGroupPtr**\ typedef const **SemaphoreGroup** \* **SemaphoreGroupCptr**\ typedef **SemaphoreGroup** & **SemaphoreGroupRef**\ typedef const **SemaphoreGroup** & **SemaphoreGroupCref**\ typedef **AbstractSemaphore** \* **AbstractSemaphorePtr**\ typedef const **AbstractSemaphore** \* **AbstractSemaphoreCptr**\ typedef **AbstractSemaphore** & **AbstractSemaphoreRef**\ typedef const **AbstractSemaphore** & **AbstractSemaphoreCref**\ typedef **AbstractString** \* **AbstractStringPtr**\ typedef const **AbstractString** \* **AbstractStringCptr**\ typedef **AbstractString** & **AbstractStringRef**\ typedef const **AbstractString** & **AbstractStringCref**\ typedef **Adapter** \* **AdapterPtr**\ typedef const **Adapter** \* **AdapterCptr**\ typedef **Adapter** & **AdapterRef**\ typedef const **Adapter** & **AdapterCref**\ typedef **Allocator** \* **AllocatorPtr**\ typedef const **Allocator** \* **AllocatorCptr**\ typedef **Allocator** & **AllocatorRef**\ typedef const **Allocator** & **AllocatorCref**\ typedef **AllocatorAlreadyExistsException** \* **AllocatorAlreadyExistsExceptionPtr**\ typedef const **AllocatorAlreadyExistsException** \* **AllocatorAlreadyExistsExceptionCptr**\ typedef **AllocatorAlreadyExistsException** & **AllocatorAlreadyExistsExceptionRef**\ typedef const **AllocatorAlreadyExistsException** & **AllocatorAlreadyExistsExceptionCref**\ typedef **AllocatorNotFoundException** \* **AllocatorNotFoundExceptionPtr**\ typedef const **AllocatorNotFoundException** \* **AllocatorNotFoundExceptionCptr**\ typedef **AllocatorNotFoundException** & **AllocatorNotFoundExceptionRef**\ typedef const **AllocatorNotFoundException** & **AllocatorNotFoundExceptionCref**\ typedef **Assertion** \* **AssertionPtr**\ typedef const **Assertion** \* **AssertionCptr**\ typedef **Assertion** & **AssertionRef**\ typedef const **Assertion** & **AssertionCref**\ typedef **BoundsException** \* **BoundsExceptionPtr**\ typedef const **BoundsException** \* **BoundsExceptionCptr**\ typedef **BoundsException** & **BoundsExceptionRef**\ typedef const **BoundsException** & **BoundsExceptionCref**\ typedef **Mediator** \* **MediatorPtr**\ typedef const **Mediator** \* **MediatorCptr**\ typedef **Mediator** & **MediatorRef**\ typedef const **Mediator** & **MediatorCref**\ typedef **Colleague** \* **ColleaguePtr**\ typedef const **Colleague** \* **ColleagueCptr**\ typedef **Colleague** & **ColleagueRef**\ typedef const **Colleague** & **ColleagueCref**\ typedef **Command** \* **CommandPtr**\ typedef const **Command** \* **CommandCptr**\ typedef **Command** & **CommandRef**\ typedef const **Command** & **CommandCref**\ typedef **CommandFrame** \* **CommandFramePtr**\ typedef const **CommandFrame** \* **CommandFrameCptr**\ typedef **CommandFrame** & **CommandFrameRef**\ typedef const **CommandFrame** & **CommandFrameCref**\ typedef **CommandFrameException** \* **CommandFrameExceptionPtr**\ typedef const **CommandFrameException** \* **CommandFrameExceptionCptr**\ typedef **CommandFrameException** & **CommandFrameExceptionRef**\ typedef const **CommandFrameException** & **CommandFrameExceptionCref**\ typedef **CoreLinuxObject** \* **CoreLinuxObjectPtr**\ typedef const **CoreLinuxObject** \* **CoreLinuxObjectCptr**\ typedef **CoreLinuxObject** & **CoreLinuxObjectRef**\ typedef const **CoreLinuxObject** & **CoreLinuxObjectCref**\ typedef **StringUtf8** \* **StringUtf8Ptr**\ typedef const **StringUtf8** \* **StringUtf8Cptr**\ typedef **StringUtf8** & **StringUtf8Ref**\ typedef const **StringUtf8** & **StringUtf8Cref**\ typedef **Exception** \* **ExceptionPtr**\ typedef const **Exception** \* **ExceptionCptr**\ typedef **Exception** & **ExceptionRef**\ typedef const **Exception** & **ExceptionCref**\ typedef **NullPointerException** \* **NullPointerExceptionPtr**\ typedef const **NullPointerException** \* **NullPointerExceptionCptr**\ typedef **NullPointerException** & **NullPointerExceptionRef**\ typedef const **NullPointerException** & **NullPointerExceptionCref**\ typedef **Synchronized** \* **SynchronizedPtr**\ typedef const **Synchronized** \* **SynchronizedCptr**\ typedef **Synchronized** & **SynchronizedRef**\ typedef const **Synchronized** & **SynchronizedCref**\ typedef **Thread** \* **ThreadPtr**\ typedef const **Thread** \* **ThreadCptr**\ typedef **Thread** & **ThreadRef**\ typedef const **Thread** & **ThreadCref**\ typedef AbstractInteger \* **AbstractIntegerPtr**\ typedef const AbstractInteger \* **AbstractIntegerCptr**\ typedef AbstractInteger & **AbstractIntegerRef**\ typedef const AbstractInteger & **AbstractIntegerCref**\ typedef AbstractReal \* **AbstractRealPtr**\ typedef const AbstractReal \* **AbstractRealCptr**\ typedef AbstractReal & **AbstractRealRef**\ typedef const AbstractReal & **AbstractRealCref**\ typedef **Visitor** \* **VisitorPtr**\ typedef const **Visitor** \* **VisitorCptr**\ typedef **Visitor** & **VisitorRef**\ typedef const **Visitor** & **VisitorCref**\ typedef **Component** \* **ComponentPtr**\ typedef const **Component** \* **ComponentCptr**\ typedef **Component** & **ComponentRef**\ typedef const **Component** & **ComponentCref**\ typedef **CompositeException** \* **CompositeExceptionPtr**\ typedef const **CompositeException** \* **CompositeExceptionCptr**\ typedef **CompositeException** & **CompositeExceptionRef**\ typedef const **CompositeException** & **CompositeExceptionCref**\ typedef **State** \* **StatePtr**\ typedef const **State** \* **StateCptr**\ typedef **State** & **StateRef**\ typedef const **State** & **StateCref**\ typedef **Context** \* **ContextPtr**\ typedef const **Context** \* **ContextCptr**\ typedef **Context** & **ContextRef**\ typedef const **Context** & **ContextCref**\ typedef **CoreLinuxGuardGroup** \* **CoreLinuxGuardGroupPtr**\ typedef const **CoreLinuxGuardGroup** \* **CoreLinuxGuardGroupCptr**\ typedef **CoreLinuxGuardGroup** & **CoreLinuxGuardGroupRef**\ typedef const **CoreLinuxGuardGroup** & **CoreLinuxGuardGroupCref**\ typedef **AbstractSemaphorePtr** \* **AbstractSemaphorePtrPtr**\ typedef const **AbstractSemaphorePtr** \* **AbstractSemaphorePtrCptr**\ typedef **AbstractSemaphorePtr** & **AbstractSemaphorePtrRef**\ typedef const **AbstractSemaphorePtr** & **AbstractSemaphorePtrCref**\ typedef AbstractSemaphorePtr::iterator **AbstractSemaphorePtrIterator**\ typedef AbstractSemaphorePtr::iterator & **AbstractSemaphorePtrIteratorRef**\ typedef AbstractSemaphorePtr::iterator \* **AbstractSemaphorePtrIteratorPtr**\ typedef AbstractSemaphorePtr::const\_iterator **AbstractSemaphorePtrConstIterator**\ typedef AbstractSemaphorePtr::const\_iterator & **AbstractSemaphorePtrConstIteratorRef**\ typedef AbstractSemaphorePtr::const\_iterator \* **AbstractSemaphorePtrConstIteratorPtr**\ typedef AbstractSemaphorePtr::reverse\_iterator **AbstractSemaphorePtrRiterator**\ typedef AbstractSemaphorePtr::reverse\_iterator & **AbstractSemaphorePtrRiteratorRef**\ typedef AbstractSemaphorePtr::reverse\_iterator \* **AbstractSemaphorePtrRiteratorPtr**\ typedef **SynchronizedPtr** \* **SynchronizedPtrPtr**\ typedef const **SynchronizedPtr** \* **SynchronizedPtrCptr**\ typedef **SynchronizedPtr** & **SynchronizedPtrRef**\ typedef const **SynchronizedPtr** & **SynchronizedPtrCref**\ typedef SynchronizedPtr::iterator **SynchronizedPtrIterator**\ typedef SynchronizedPtr::iterator & **SynchronizedPtrIteratorRef**\ typedef SynchronizedPtr::iterator \* **SynchronizedPtrIteratorPtr**\ typedef SynchronizedPtr::const\_iterator **SynchronizedPtrConstIterator**\ typedef SynchronizedPtr::const\_iterator & **SynchronizedPtrConstIteratorRef**\ typedef SynchronizedPtr::const\_iterator \* **SynchronizedPtrConstIteratorPtr**\ typedef SynchronizedPtr::reverse\_iterator **SynchronizedPtrRiterator**\ typedef SynchronizedPtr::reverse\_iterator & **SynchronizedPtrRiteratorRef**\ typedef SynchronizedPtr::reverse\_iterator \* **SynchronizedPtrRiteratorPtr**\ typedef **CoreLinuxGuardPool** \* **CoreLinuxGuardPoolPtr**\ typedef const **CoreLinuxGuardPool** \* **CoreLinuxGuardPoolCptr**\ typedef **CoreLinuxGuardPool** & **CoreLinuxGuardPoolRef**\ typedef const **CoreLinuxGuardPool** & **CoreLinuxGuardPoolCref**\ typedef **Singleton**\< **CoreLinuxGuardPool** \> **GuardPool**\ typedef **Singleton**\< **CoreLinuxGuardPool** \> \* **GuardPoolPtr**\ typedef const **GuardPool** \* **GuardPoolCptr**\ typedef **GuardPool** & **GuardPoolRef**\ typedef const **GuardPool** & **GuardPoolCref**\ typedef **Environment** \* **EnvironmentPtr**\ typedef const **Environment** \* **EnvironmentCptr**\ typedef **Environment** & **EnvironmentRef**\ typedef const **Environment** & **EnvironmentCref**\ typedef **EventSemaphore** \* **EventSemaphorePtr**\ typedef const **EventSemaphore** \* **EventSemaphoreCptr**\ typedef **EventSemaphore** & **EventSemaphoreRef**\ typedef const **EventSemaphore** & **EventSemaphoreCref**\ typedef **EventSemaphoreGroup** \* **EventSemaphoreGroupPtr**\ typedef const **EventSemaphoreGroup** \* **EventSemaphoreGroupCptr**\ typedef **EventSemaphoreGroup** & **EventSemaphoreGroupRef**\ typedef const **EventSemaphoreGroup** & **EventSemaphoreGroupCref**\ typedef Dword **LineNum**\ typedef Dword \* **LineNumPtr**\ typedef const LineNum \* **LineNumCptr**\ typedef LineNum & **LineNumRef**\ typedef const LineNum & **LineNumCref**\ typedef **Facade** \* **FacadePtr**\ typedef const **Facade** \* **FacadeCptr**\ typedef **Facade** & **FacadeRef**\ typedef const **Facade** & **FacadeCref**\ typedef **Flyweight** \* **FlyweightPtr**\ typedef const **Flyweight** \* **FlyweightCptr**\ typedef **Flyweight** & **FlyweightRef**\ typedef const **Flyweight** & **FlyweightCref**\ typedef **GatewaySemaphore** \* **GatewaySemaphorePtr**\ typedef const **GatewaySemaphore** \* **GatewaySemaphoreCptr**\ typedef **GatewaySemaphore** & **GatewaySemaphoreRef**\ typedef const **GatewaySemaphore** & **GatewaySemaphoreCref**\ typedef std::map\< Count, std::less\< ThreadIdentifier \>, GatewayClient \> **ThreadIdentifier**\ typedef ThreadIdentifier \* **ThreadIdentifierPtr**\ typedef const ThreadIdentifier \* **ThreadIdentifierCptr**\ typedef ThreadIdentifier & **ThreadIdentifierRef**\ typedef const ThreadIdentifier & **ThreadIdentifierCref**\ typedef ThreadIdentifier::iterator **ThreadIdentifierIterator**\ typedef ThreadIdentifier::iterator & **ThreadIdentifierIteratorRef**\ typedef ThreadIdentifier::iterator \* **ThreadIdentifierIteratorPtr**\ typedef ThreadIdentifier::const\_iterator **ThreadIdentifierConstIterator**\ typedef ThreadIdentifier::const\_iterator & **ThreadIdentifierConstIteratorRef**\ typedef ThreadIdentifier::const\_iterator \* **ThreadIdentifierConstIteratorPtr**\ typedef ThreadIdentifier::reverse\_iterator **ThreadIdentifierRiterator**\ typedef ThreadIdentifier::reverse\_iterator & **ThreadIdentifierRiteratorRef**\ typedef ThreadIdentifier::reverse\_iterator \* **ThreadIdentifierRiteratorPtr**\ typedef **GatewaySemaphoreGroup** \* **GatewaySemaphoreGroupPtr**\ typedef const **GatewaySemaphoreGroup** \* **GatewaySemaphoreGroupCptr**\ typedef **GatewaySemaphoreGroup** & **GatewaySemaphoreGroupRef**\ typedef const **GatewaySemaphoreGroup** & **GatewaySemaphoreGroupCref**\ typedef **GuardSemaphore** \* **GuardSemaphorePtr**\ typedef const **GuardSemaphore** \* **GuardSemaphoreCptr**\ typedef **GuardSemaphore** & **GuardSemaphoreRef**\ typedef const **GuardSemaphore** & **GuardSemaphoreCref**\ typedef **Handler** \* **HandlerPtr**\ typedef const **Handler** \* **HandlerCptr**\ typedef **Handler** & **HandlerRef**\ typedef const **Handler** & **HandlerCref**\ typedef **Identifier** \* **IdentifierPtr**\ typedef const **Identifier** \* **IdentifierCptr**\ typedef **Identifier** & **IdentifierRef**\ typedef const **Identifier** & **IdentifierCref**\ typedef **InvalidCompositeException** \* **InvalidCompositeExceptionPtr**\ typedef const **InvalidCompositeException** \* **InvalidCompositeExceptionCptr**\ typedef **InvalidCompositeException** & **InvalidCompositeExceptionRef**\ typedef const **InvalidCompositeException** & **InvalidCompositeExceptionCref**\ typedef **InvalidIteratorException** \* **InvalidIteratorExceptionPtr**\ typedef const **InvalidIteratorException** \* **InvalidIteratorExceptionCptr**\ typedef **InvalidIteratorException** & **InvalidIteratorExceptionRef**\ typedef const **InvalidIteratorException** & **InvalidIteratorExceptionCref**\ typedef **InvalidThreadException** \* **InvalidThreadExceptionPtr**\ typedef const **InvalidThreadException** \* **InvalidThreadExceptionCptr**\ typedef **InvalidThreadException** & **InvalidThreadExceptionRef**\ typedef const **InvalidThreadException** & **InvalidThreadExceptionCref**\ typedef **IteratorBoundsException** \* **IteratorBoundsExceptionPtr**\ typedef const **IteratorBoundsException** \* **IteratorBoundsExceptionCptr**\ typedef **IteratorBoundsException** & **IteratorBoundsExceptionRef**\ typedef const **IteratorBoundsException** & **IteratorBoundsExceptionCref**\ typedef **IteratorException** \* **IteratorExceptionPtr**\ typedef const **IteratorException** \* **IteratorExceptionCptr**\ typedef **IteratorException** & **IteratorExceptionRef**\ typedef const **IteratorException** & **IteratorExceptionCref**\ typedef **Limits** \* **LimitsPtr**\ typedef const **Limits** \* **LimitsCptr**\ typedef **Limits** & **LimitsRef**\ typedef const **Limits** & **LimitsCref**\ typedef **Memento** \* **MementoPtr**\ typedef const **Memento** \* **MementoCptr**\ typedef **Memento** & **MementoRef**\ typedef const **Memento** & **MementoCref**\ typedef std::map\< CharCptr, std::less\< MemoryStoragePtr \>, MemoryMap \> **MemoryStoragePtr**\ typedef MemoryStoragePtr \* **MemoryStoragePtrPtr**\ typedef const MemoryStoragePtr \* **MemoryStoragePtrCptr**\ typedef MemoryStoragePtr & **MemoryStoragePtrRef**\ typedef const MemoryStoragePtr & **MemoryStoragePtrCref**\ typedef MemoryStoragePtr::iterator **MemoryStoragePtrIterator**\ typedef MemoryStoragePtr::iterator & **MemoryStoragePtrIteratorRef**\ typedef MemoryStoragePtr::iterator \* **MemoryStoragePtrIteratorPtr**\ typedef MemoryStoragePtr::const\_iterator **MemoryStoragePtrConstIterator**\ typedef MemoryStoragePtr::const\_iterator & **MemoryStoragePtrConstIteratorRef**\ typedef MemoryStoragePtr::const\_iterator \* **MemoryStoragePtrConstIteratorPtr**\ typedef MemoryStoragePtr::reverse\_iterator **MemoryStoragePtrRiterator**\ typedef MemoryStoragePtr::reverse\_iterator & **MemoryStoragePtrRiteratorRef**\ typedef MemoryStoragePtr::reverse\_iterator \* **MemoryStoragePtrRiteratorPtr**\ typedef **Memory** \* **MemoryPtr**\ typedef const **Memory** \* **MemoryCptr**\ typedef **Memory** & **MemoryRef**\ typedef const **Memory** & **MemoryCref**\ typedef **Singleton**\< **Memory** \> **MemoryManager**\ *Declare the memory manager as a singleton for* **Memory***.* typedef **Singleton**\< **Memory** \> \* **MemoryManagerPtr**\ typedef const **MemoryManager** \* **MemoryManagerCptr**\ typedef **MemoryManager** & **MemoryManagerRef**\ typedef const **MemoryManager** & **MemoryManagerCref**\ typedef const **MemoryStorage** \* **MemoryStorageCptr**\ typedef **MemoryStorage** & **MemoryStorageRef**\ typedef const **MemoryStorage** & **MemoryStorageCref**\ typedef **MutexSemaphore** \* **MutexSemaphorePtr**\ typedef const **MutexSemaphore** \* **MutexSemaphoreCptr**\ typedef **MutexSemaphore** & **MutexSemaphoreRef**\ typedef const **MutexSemaphore** & **MutexSemaphoreCref**\ typedef **MutexSemaphoreGroup** \* **MutexSemaphoreGroupPtr**\ typedef const **MutexSemaphoreGroup** \* **MutexSemaphoreGroupCptr**\ typedef **MutexSemaphoreGroup** & **MutexSemaphoreGroupRef**\ typedef const **MutexSemaphoreGroup** & **MutexSemaphoreGroupCref**\ typedef **Subject** \* **SubjectPtr**\ typedef const **Subject** \* **SubjectCptr**\ typedef **Subject** & **SubjectRef**\ typedef const **Subject** & **SubjectCref**\ typedef **Observer** \* **ObserverPtr**\ typedef const **Observer** \* **ObserverCptr**\ typedef **Observer** & **ObserverRef**\ typedef const **Observer** & **ObserverCref**\ typedef **Request** \* **RequestPtr**\ typedef const **Request** \* **RequestCptr**\ typedef **Request** & **RequestRef**\ typedef const **Request** & **RequestCref**\ typedef **Semaphore** \* **SemaphorePtr**\ typedef const **Semaphore** \* **SemaphoreCptr**\ typedef **Semaphore** & **SemaphoreRef**\ typedef const **Semaphore** & **SemaphoreCref**\ typedef **\_CSAHeader** **CSAHeader**\ typedef **\_CSAHeader** \* **CSAHeaderPtr**\ typedef const **CSAHeader** \* **CSAHeaderCptr**\ typedef **CSAHeader** & **CSAHeaderRef**\ typedef const **CSAHeader** & **CSAHeaderCref**\ typedef **\_CSAGroupHeader** **CSAGrpHeader**\ typedef **\_CSAGroupHeader** \* **CSAGrpHeaderPtr**\ typedef const **CSAGrpHeader** \* **CSAGrpHeaderCptr**\ typedef **CSAGrpHeader** & **CSAGrpHeaderRef**\ typedef const **CSAGrpHeader** & **CSAGrpHeaderCref**\ typedef **\_CSASemaphoreHeader** **CSASemHeader**\ typedef **\_CSASemaphoreHeader** \* **CSASemHeaderPtr**\ typedef const **CSASemHeader** \* **CSASemHeaderCptr**\ typedef **CSASemHeader** & **CSASemHeaderRef**\ typedef const **CSASemHeader** & **CSASemHeaderCref**\ typedef **SemaphoreCommon** \* **SemaphoreCommonPtr**\ typedef const **SemaphoreCommon** \* **SemaphoreCommonCptr**\ typedef **SemaphoreCommon** & **SemaphoreCommonRef**\ typedef const **SemaphoreCommon** & **SemaphoreCommonCref**\ typedef **SemaphoreException** \* **SemaphoreExceptionPtr**\ typedef const **SemaphoreException** \* **SemaphoreExceptionCptr**\ typedef **SemaphoreException** & **SemaphoreExceptionRef**\ typedef const **SemaphoreException** & **SemaphoreExceptionCref**\ typedef Index::iterator **IndexIterator**\ typedef Index::iterator & **IndexIteratorRef**\ typedef Index::iterator \* **IndexIteratorPtr**\ typedef Index::const\_iterator **IndexConstIterator**\ typedef Index::const\_iterator & **IndexConstIteratorRef**\ typedef Index::const\_iterator \* **IndexConstIteratorPtr**\ typedef Index::reverse\_iterator **IndexRiterator**\ typedef Index::reverse\_iterator & **IndexRiteratorRef**\ typedef Index::reverse\_iterator \* **IndexRiteratorPtr**\ typedef **Storage** \* **StoragePtr**\ typedef const **Storage** \* **StorageCptr**\ typedef **Storage** & **StorageRef**\ typedef const **Storage** & **StorageCref**\ typedef **StorageException** \* **StorageExceptionPtr**\ typedef const **StorageException** \* **StorageExceptionCptr**\ typedef **StorageException** & **StorageExceptionRef**\ typedef const **StorageException** & **StorageExceptionCref**\ typedef **Strategy** \* **StrategyPtr**\ typedef const **Strategy** \* **StrategyCptr**\ typedef **Strategy** & **StrategyRef**\ typedef const **Strategy** & **StrategyCref**\ typedef **ThreadContext** \* **ThreadContextPtr**\ typedef const **ThreadContext** \* **ThreadContextCptr**\ typedef **ThreadContext** & **ThreadContextRef**\ typedef const **ThreadContext** & **ThreadContextCref**\ typedef **Singleton**\< **Thread** \> **ThreadManager**\ typedef **Singleton**\< **Thread** \> \* **ThreadManagerPtr**\ typedef const **ThreadManager** \* **ThreadManagerCptr**\ typedef **ThreadManager** & **ThreadManagerRef**\ typedef const **ThreadManager** & **ThreadManagerCref**\ typedef int(\* **CallerFunctionPtr** )(**ThreadContextPtr**)\ *Callers function entry point.* typedef Int(\* **ThreadFrameFunctionPtr** )(**ThreadContextPtr**)\ **Thread** *frame entry point function handler.* typedef **ThreadContextPtr**(\* **ThreadContextCreatePtr** )(**ThreadContextRef**)\ *Managed* **ThreadContext** *creation function.* typedef void(\* **ThreadContextDestroyPtr** )(**ThreadContextPtr**)\ *Managed* **ThreadContext** *deallocate function.* typedef BytePtr(\* **ThreadStackCreatePtr** )(**ThreadContextPtr**)\ *Managed* **ThreadContext** *stack creation function.* typedef void(\* **ThreadStackDestroyPtr** )(BytePtr)\ *Managed* **ThreadContext** *stack deallocate function.* typedef **ThreadException** \* **ThreadExceptionPtr**\ typedef const **ThreadException** \* **ThreadExceptionCptr**\ typedef **ThreadException** & **ThreadExceptionRef**\ typedef const **ThreadException** & **ThreadExceptionCref**\ typedef **TransientStorage** \* **TransientStoragePtr**\ typedef const **TransientStorage** \* **TransientStorageCptr**\ typedef **TransientStorage** & **TransientStorageRef**\ typedef const **TransientStorage** & **TransientStorageCref**\ ### Enumerations enum **SemaphoreOperationStatus** { **KERNELERROR** = -1, **SUCCESS** = 0, **BALKED**, **TIMEDOUT**, **UNAVAILABLE** }\ *Semaphore method return enumeration.* enum **AccessRights** { **OWNER\_READ** = 0400, **OWNER\_MODIFY** = 0200, **OWNER\_ALL** = 0600, **GROUP\_READ** = 040, **GROUP\_MODIFY** = 020, **GROUP\_ALL** = 060, **PUBLIC\_READ** = 04, **PUBLIC\_MODIFY** = 02, **PUBLIC\_ALL** = 06 }\ *Access enumeration for various system level classes.* enum **CreateDisposition** { **CREATE\_OR\_REUSE** = 0, **FAIL\_IF\_EXISTS** = -1, **FAIL\_IF\_NOTEXISTS** = -2 }\ *Creation dispositions for various system utilities.* enum **AddressingConstraint** { **READ\_WRITE** = 0, **READ\_ONLY**, **EXECUTE** }\ *Addressings constraints.* enum **WorkState** { **BUILDING** = 0, **EXECUTING**, **COMPLETED**, **REVERSING**, **REVERSED**, **NEVERCOMPLETED** }\ *State of execution.* enum **ThreadState** { **THREAD\_WAITING\_TO\_START** = 0, **THREAD\_STARTING**, **THREAD\_RUNNING**, **THREAD\_NORMAL\_EXIT**, **THREAD\_START\_EXCEPTION**, **THREAD\_EXCEPTION**, **THREAD\_START\_FAILED** }\ *Thread state enumeration.* ### Functions Long **assertionFailed** (**AssertionCref** rAssertion)\ void **assertLoopDebugFunction** (void)\ AssertCt & **anAssertCt** (void)\ Long **asstDoEval** (Long &asstShortCut)\ const AssertCt & **operator!** (const AssertCt &a)\ Long **operator &&** (Long left, const AssertCt &)\ Long **operator\|\|** (int left, const AssertCt &)\ **CORELINUX\_VECTOR** (**IdentifierPtr**, EventIdentifiers)\ **CORELINUX\_VECTOR** (**AbstractCommandPtr**, Commands)\ **CORELINUX\_VECTOR** (**SemaphoreGroupPtr**, GroupVector)\ const Dword **NAMEBUFFERSIZE** (254)\ **DEFINE\_CLASS** (String)\ const Int **DEFAULT\_COUNT** (-1)\ *default maximum number of listeners is 'infinity'* const Count **DEFAULT\_COUNT** (2)\ const Size **DEFAULT\_STACKSIZE** (8192)\ ## Detailed Description Forward reference the various common classes. ## Typedef Documentation ### typedef int(\* corelinux::CallerFunctionPtr)(ThreadContextPtr) Callers function entry point. **Parameters:** *ThreadContext* object instance pointer **Returns:** int return code ### typedef ThreadContextPtr(\* corelinux::ThreadContextCreatePtr)( ThreadContextRef ) Managed **ThreadContext** creation function. This is declared so that callers may change the allocation routine (to map somewhere or instantiate a derived **ThreadContext** for example ). The default handler uses the global new operator. **Parameters:** *ThreadContext* reference to the callers inital **ThreadContext** **Returns:** **ThreadContext** pointer to managed **ThreadContext** ### typedef void(\* corelinux::ThreadContextDestroyPtr)( ThreadContextPtr ) Managed **ThreadContext** deallocate function. This is declared so that callers may change the deallocation of the managed **ThreadContext**. You would normally do this if you have substituted the ThreadContextCreatePtr as well. **Parameters:** *ThreadContext* pointer to managed **ThreadContext**. **Returns:** nothing ### typedef Int(\* corelinux::ThreadFrameFunctionPtr)( ThreadContextPtr ) **Thread** frame entry point function handler. **Parameters:** *ThreadContext* pointer to managed **ThreadContext** **Returns:** Int return code from caller thread ### typedef BytePtr(\* corelinux::ThreadStackCreatePtr)( ThreadContextPtr ) Managed **ThreadContext** stack creation function. This is declared so that callers may change the allocation for the threads stack. The default handler uses the global new operator. **Parameters:** *ThreadContext* pointer to managed **ThreadContext** **Returns:** Byte pointer to bottom of stack. ### typedef void(\* corelinux::ThreadStackDestroyPtr)( BytePtr ) Managed **ThreadContext** stack deallocate function. This is declared so that callers may change the deallocation of the threads stack. You would normally do this if you have substituted the ThreadStackCreatePtr as well. **Parameters:** *Byte* pointer as contained by **ThreadContext**. **Returns:** nothing ## Enumeration Type Documentation ### enum corelinux::AccessRights Access enumeration for various system level classes. **Enumeration values:** - *OWNER\_READ* *Owner has read access.* - *OWNER\_MODIFY* *Owner has write access.* - *OWNER\_ALL* *Owner has read/write access.* - *GROUP\_READ* *Group has read access.* - *GROUP\_MODIFY* *Group has write access.* - *GROUP\_ALL* *Group has read/write access.* - *PUBLIC\_READ* *Public has read access.* - *PUBLIC\_MODIFY* *Public has write access.* - *PUBLIC\_ALL* *Public has read/write access.* ### enum corelinux::AddressingConstraint *Addressings constraints.* **Enumeration values:** - *READ\_WRITE* *read write access (no constraints)* - *READ\_ONLY* *read only access* - *EXECUTE* *Execute access.* ### enum corelinux::CreateDisposition *Creation dispositions for various system utilities.* **Enumeration values:** - *CREATE\_OR\_REUSE* *Will create or open.* - *FAIL\_IF\_EXISTS* *Will throw exception if target exists.* - *FAIL\_IF\_NOTEXISTS* *Will throw exception if target does NOT exist.* ### enum corelinux::SemaphoreOperationStatus **Semaphore** *method return enumeration.* **Enumeration values:** - *KERNELERROR* *Kernel error, errno set.* - *SUCCESS* *Call success.* - *BALKED* **Semaphore** *balked request.* - *TIMEDOUT* **Semaphore** *request timed out.* - *UNAVAILABLE* **Semaphore** *unavailable for request.* ### enum corelinux::ThreadState **Thread** *state enumeration.* **Enumeration values:** - *THREAD\_WAITING\_TO\_START* *The thread is waiting to be started.* - *THREAD\_STARTING* *The thread is in the process of starting.* - *THREAD\_RUNNING* *The thread is running.* - *THREAD\_NORMAL\_EXIT* **Thread** *completed without exception.* - *THREAD\_START\_EXCEPTION* **Thread** *never started with exception.* - *THREAD\_EXCEPTION* **Thread** *has died with exception.* - *THREAD\_START\_FAILED* **Thread** *never started.* ### enum corelinux::WorkState **State** *of execution.* **Enumeration values:** - *BUILDING* *The state is in building, no work has been performed.* ## Author *Generated automatically by Doxygen for CoreLinux++ from the source code.*