CoreLinux++
|
Goals
|
|
Developer's Corner
|
|
Contacts
|
|
|
Semaphore Class Report
Semaphore Class Report
Generated at: Sat, Mar 11, 2000
12:06:39
TABLE OF CONTENTS
- REPORT BODY
- Class report
- Data package
- Component View package
- libcorelinux package
- corelinux package
- SemaphoreGroup class
- Semaphore class
- SemaphoreGroupFactory class
- Identifier class
- One-to-One class
- One-to-Many class
- Many-to-One class
- SemaphoreIdentifier class
- Participants package
- Implementor class
- Developer class
- Solution Domain package
- libcorelinux package
- Semaphore class
- AccessRights class
- SemaphoreOperationStatus class
- SemaphoreException class
- MutexSemaphore class
- Time class
- GatewaySemaphore class
- EventSemaphore class
- SemaphoreIdentifier class
- SemaphoreGroup class
- SemaphoreGroupIdentifier class
- AbstractSemaphore class
- SemaphoreGroupRegister class
- CreateDisposition class
- CoreLinuxGuardPool class
- MutexSemaphoreGroup class
- Synchronized class
- PoolDescriptor class
- ThreadIdentifier class
- GuardSemaphore class
- CoreLinuxGuardGroup class
- GatewaySemaphoreGroup class
- Model dictionary
- SUMMARY
REPORT BODY
Class report
- package Data
- package Data::Component View
- package Data::Component View::libcorelinux
- package Data::corelinux
- Stereotype:
<<system>>
- Documentation:
CoreLinux++ class library.
- class SemaphoreGroup
- Documentation:
A SemaphoreGroup is an extension to the Linux semaphore set. This provides a way to logically group semaphores. A SemaphoreGroup acts as a Semaphore factory, creating and destroying Semaphores for the user.
- Operations:
- public Semaphore create ( )
- Documentation:
Creates a semaphore from the group.
- public destroy ( aSemaphore : Semaphore )
-
- aSemaphore : Semaphore
- Documentation:
The semaphore to destroy
- class Semaphore
- Documentation:
A Semaphore is a protocol by which processes and/or threads agree to follow for the purpose of controlled access to a resource. The resource can be anything that the developer considers to need access controls on, such as memory, hardware, methods, computer instructions, and so on. The Semaphore is pinned to the Linux kernel which enforces blocking (being made to wait) the caller until a resource is available.
- Operations:
- public lock ( )
- Documentation:
Locks the semaphore
- public release ( )
- Documentation:
Releases the semaphore lock
- class SemaphoreGroupFactory
- Documentation:
SemaphoreGroupFactory creates and destroys SemaphoreGroups.
- Operations:
- public SemaphoreGroup create ( )
- Stereotype:
<<constructor>>
- Documentation:
Create a SemaphoreGroup
- public destroy ( aGroup : SemaphoreGroup )
- public SemaphoreGroup get ( )
- Documentation:
Gets a specific semaphore group
- public return ( aGroup : SemaphoreGroup )
-
- aGroup : SemaphoreGroup
- Documentation:
The group to be returned
- abstract class Identifier
- class One-to-One
- Superclasses:
- Data::corelinux::Semaphore
- Documentation:
When used to prevent concurrent access to a resource, the caller must first obtain control of the associated Semaphore. When a caller has control of the Semaphore, the resource(s) that are associated with the Semaphore are considered locked and accessible by the caller. When the caller has completed access of the resource it relinquishes control and the resource is now considered unlocked.
Attempts may be made to access the resource by other threads of execution or from seperate processes. These callers are queued and the requestor is put into a blocked state. In this state the caller waits until the resource is unlocked. If multiple requests are blocking for the same control, the determination of which caller gains access next is, from a applications perspective, arbitrary.
When balking mode is enabled callers will be turned away as long as the Semaphore is locked.
- class One-to-Many
- Superclasses:
- Data::corelinux::Semaphore
- Documentation:
When used in this fashion, a Semaphore can be used as an access count controller. The Semaphore is created, as determined by the solution domain, with the maximum number of concurrent active callers allowed. As long as the caller count does not reach the maximum, the arrival will be granted immediate access. When the maximum has been reached, arriving callers are blocked.
When balking mode is enabled callers will be turned away until the count reduces to less than maximum.
- class Many-to-One
- Superclasses:
- Data::corelinux::Semaphore
- Documentation:
When used in this fashion, a single Semaphore is used to let callers block until some event occurs. Unlike the serialzed access, where one caller at a time is released to gain access to a resource, when the designated event occurs all blocked callers are released at once.
The creator of this type of Semaphore can designate the maximum number of listeners that can wait on a single Semaphore event. When used in this manner, balking mode is automatically enabled.
When balking mode is enabled callers will be turned away until the number of listeners on the event drops below maximum.
- class SemaphoreIdentifier
- Superclasses:
- Data::corelinux::Identifier
- Stereotype:
<<type>>
- package Data::Participants
- Documentation:
Roles defined by the requirement.
- class Implementor
- Superclasses:
- Data::Participants::Developer
- Stereotype:
<<actor>>
- Documentation:
Implementor is a developer that uses either the corelinux or extension types into solution space applications.
- Operations:
- public doWork ( )
- class Developer
- Stereotype:
<<actor>>
- Documentation:
Developer extends classes for use in a solution space
- package Data::Solution Domain
- Stereotype:
<<topLevelPackage>>
- Documentation:
The Solution Domain represents the implementors application, library, or process domain. It does not effect corelinux but uses the classes and/or abstractions provided.
- package Data::libcorelinux
- Documentation:
Design namespace
- abstract class Semaphore
- Superclasses:
- Data::libcorelinux::AbstractSemaphore
- Documentation:
Semaphore implements the storage of attributes common to all semaphore types.
- Attributes:
- private theBalkMode : bool = false
-
- Documentation:
Indication on whether the semaphore was created with Balk capability. If true, balk mode is enabled.
- private theGroupIdentifier SemaphoreGroupIdentifier
-
- Documentation:
Identifies the SemaphoreGroup that this Semaphore belongs to.
- private theRecursiveMode : bool = true
-
- Documentation:
Indicates whether a process and/or thread that has the lock already can continue to issue locks without dead-locking.
- private theIdentifier SemaphoreIdentifier
-
- Documentation:
The Semaphore identifier in the SemaphoreGroup context.
- private theOwningThread ThreadIdentifier
-
- Documentation:
The identifier for the thread, set by implementation semantics.
- private theRecursionQueueLength : unsigned short = 0
-
- Documentation:
The length of the recursion as implementation defined.
- Operations:
- public Semaphore ( [Unnamed] : SemaphoreGroup, [Unnamed] : SemaphoreIdentifier, aRecursiveMode : bool=true, aBalkMode : bool=false )
-
-
-
-
- [Unnamed] : SemaphoreGroup
- Documentation:
A pointer to the semaphore group that created it.
[Unnamed] : SemaphoreIdentifier
- Documentation:
Identifies the Semaphore.
aRecursiveMode : bool=true
- Documentation:
Indicates whether recursive mode is enabled.
aBalkMode : bool=false
- Documentation:
Indicates whether the semaphore balks or not based on type.
- Stereotype:
<<constructor>>
- Documentation:
Default constructor
- public ~Semaphore ( [Unnamed] : void )
- Stereotype:
<<destructor>>
- Documentation:
Virtual Destructor
- public SemaphoreIdentifier getIdentifier ( [Unnamed] : void )
- Stereotype:
<<getter>>
- Constraints: {query}
- Documentation:
Returns the semaphore identifier
- public bool operator== ( aSemaphore : Semaphore )
- Stereotype:
<<operator>>
- Constraints: {query}
- Documentation:
Returns true if instance identifiers are the same.
- public SemaphoreGroupIdentifier getGroupIdentifier ( [Unnamed] : void )
- Stereotype:
<<getter>>
- Constraints: {query}
- Documentation:
Returns the identifier of the group that this semaphore is a member of.
- protected Semaphore ( [Unnamed] : void )
- Stereotype:
<<constructor>>
- Documentation:
Void constructor not allowed, throws assertion
- protected Semaphore ( aSemaphore : Semaphore )
- Stereotype:
<<constructor>>
- Documentation:
Copy constructor throws Assertion
- protected Semaphore operator== ( aSemaphore : Semaphore )
- Stereotype:
<<operator>>
- Documentation:
Assignment operator throws assertion
- public ThreadIdentifier getOwningThreadIdentifier ( [Unnamed] : void )
- Stereotype:
<<getter>>
- Constraints: {query}
- Documentation:
Returns the thread that owns the AbstractSemaphore, the semantics of which are implementation defined.
- public unsigned short getRecursionQueueLength ( [Unnamed] : void )
- Stereotype:
<<getter>>
- Constraints: {query}
- Documentation:
Returns the recursion depth that the owning thread has called for this semaphore, or 0 if recursion is not enabled.
- class AccessRights
- Stereotype:
<<type>>
- Documentation:
Enumerates the possible access rights given to an object.
- Attributes:
- public OWNER_READ
-
- Documentation:
Owner has read access.
- public OWNER_MODIFY
-
- Documentation:
Owner has write access.
- public GROUP_READ
-
- Documentation:
Group has read access.
- public GROUP_MODIFY
-
- Documentation:
Group has write access.
- public PUBLIC_READ
-
- Documentation:
Public read access.
- public PUBLIC_MODIFY
-
- Documentation:
Public has write access.
- public OWNER_ALL
-
- Documentation:
Owner has all access rights.
- public GROUP_ALL
-
- Documentation:
Group has all access rights.
- public PUBLIC_ALL
-
- Documentation:
Public has all access rights.
- class SemaphoreOperationStatus
- Stereotype:
<<type>>
- Documentation:
Enumeration of status for various mutators.
- Attributes:
- public SUCCESS
-
- Documentation:
Indicates a success for the call semantics.
- public BALKED
-
- Documentation:
Indicates that the call failed because the semaphore has balked at the request.
- public TIMEDOUT
-
- Documentation:
Indicates that the call failed because the request timed out waiting for a state change in the semaphore.
- public UNAVAILABLE
-
- Documentation:
Indicates that the lock was unavailable.
- class SemaphoreException
- Documentation:
A SemaphoreException base class.
- class MutexSemaphore
- Superclasses:
- Data::libcorelinux::Semaphore
- Documentation:
The MutexSemaphore controls mutual exclusion to a resource. This semaphore recognizes a lock state and unlocked state.
- Operations:
- public bool isLocked ( [Unnamed] : void )
- Stereotype:
<<getter>>
- Constraints: {query}
- Documentation:
Returns true if semaphore is currently in a locked state.
- public SemaphoreOperationStatus lockWithWait ( [Unnamed] : void )
- Stereotype:
<<setter>>
- Documentation:
Requests a lock. The caller will wait until the semaphore can grant this request.
- public SemaphoreOperationStatus lockWithNoWait ( [Unnamed] : void )
- Stereotype:
<<setter>>
- Documentation:
Requests a lock. The caller will not wait until the semaphore can grant this request but would rather have a return indicating the lock was unavailable at that moment.
- public SemaphoreOperationStatus lockWithTimeOut ( aTimeOut : Time )
-
- aTimeOut : Time
- Documentation:
The timeout value to wait before giving up a lock attempt.
- Stereotype:
<<setter>>
- Documentation:
Requests a lock. The caller will wait until the semaphore can grant this request or until the time specified elapses.
- public SemaphoreOperationStatus release ( [Unnamed] : void )
- Stereotype:
<<setter>>
- Documentation:
Interface for release semantics. For this type it means changing the GuardLockState of the semaphore to UNLOCKED.
- public MutexSemaphore ( aIdentifier : SemaphoreIdentifier, aAutoLock : bool=false, aRecursive : bool=true, aBalkMode : bool=false )
-
-
-
-
- aIdentifier : SemaphoreIdentifier
- Documentation:
Identifies the Semaphore.
aAutoLock : bool=false
- Documentation:
Specify true to have Semaphore automatically lock for the creator.
aRecursive : bool=true
- Documentation:
Indicates whether recursive mode is enabled.
aBalkMode : bool=false
- Documentation:
Indicates whether the semaphore balks or not based on type.
- Stereotype:
<<constructor>>
- Documentation:
Default constructor. In addition to the AbstractSemaphore defaults, we have an indication that can set the semaphore to be automatically locked upon creation.
- public ~MutexSemaphore ( [Unnamed] : void )
- Stereotype:
<<destructor>>
- Documentation:
Virtual Destructor
- class Time
- Stereotype:
<<type>>
- Documentation:
Time type
- class GatewaySemaphore
- Superclasses:
- Data::libcorelinux::Semaphore
- Documentation:
GatewaySemphore enables a depth of resource indicator. Unlike the tradition boolean semaphore (locked,unlocked), this type assumes a finite number of threads/processes can be granted access up to theResourceMaximum.
- Attributes:
- private theResourceMaximum : Count
-
- Documentation:
Maximum resource count.
- Operations:
- public GatewaySemaphore ( aIdentifier : SemaphoreIdentifier, aResourceCount : Count, aAutoLock : bool=false, aRecursive : bool=true, aBalkMode : bool=false )
-
-
-
-
-
- aIdentifier : SemaphoreIdentifier
- Documentation:
Identifies the Semaphore.
aResourceCount : Count
- Documentation:
Specifies the number of resources this semaphore provides access for.
aAutoLock : bool=false
- Documentation:
Indicates that all resources multiplex through this semaphore are to be initialized to locked.
aRecursive : bool=true
- Documentation:
Indicates whether recursive mode is enabled.
aBalkMode : bool=false
- Documentation:
Indicates whether the semaphore balks or not based on type.
- Stereotype:
<<constructor>>
- Documentation:
Default constructor requires a count specifier.
- public bool isLocked ( [Unnamed] : void )
- Stereotype:
<<getter>>
- Constraints: {query}
- Documentation:
Returns true if semaphore has no more resources available for access.
- public SemaphoreOperationStatus lockWithWait ( [Unnamed] : void )
- Stereotype:
<<setter>>
- Documentation:
Requests a lock. The caller will wait until the number of resources controlled by this semaphore are greater than zero.
- public SemaphoreOperationStatus lockWithNoWait ( [Unnamed] : void )
- Stereotype:
<<setter>>
- Documentation:
Requests a lock. The caller will not wait until the semaphore can grant this request but would rather have a returned indicating one of the resources controlled by this semaphore was unavailable at that moment.
- public SemaphoreOperationStatus lockWithTimeOut ( aTimeOut : Time )
- Stereotype:
<<setter>>
- Documentation:
Requests a lock. The caller will wait until the semaphore can grant this request or until the time specified elapses.
- public SemaphoreOperationStatus release ( [Unnamed] : void )
- Stereotype:
<<setter>>
- Documentation:
Release one of the resources controlled by this semaphore.
- public Iterator<Identifier> createActiveIterator ( [Unnamed] : void )
- Stereotype:
<<constructor>>
- Constraints: {query}
- Documentation:
Returns a iterator over a snapshot of the current active resource process/thread identifiers.
- public void destroyActiveIterator ( aIterator : Iteratator<Identifier> )
-
- aIterator : Iteratator<Identifier>
- Documentation:
The iterator.
- Stereotype:
<<destructor>>
- Constraints: {query}
- Documentation:
Destroys the iterator of active resource users.
- public ~Gateway ( [Unnamed] : void )
- Stereotype:
<<destructor>>
- Documentation:
Virtual Destructor
- class EventSemaphore
- Superclasses:
- Data::libcorelinux::Semaphore
- Documentation:
The EventSemaphore provides a way to queue and release interested parties when a certain condition is met. Unlike the Mutex or Gateway, EventSemaphore has the ability to release all queued callers.
- Operations:
- public SemaphoreOperationStatus release ( [Unnamed] : void )
- Stereotype:
<<setter>>
- Documentation:
Interface for release semantics.
- public SemaphoreOperationStatus lockWithTimeOut ( aTimeOut : Time )
- Stereotype:
<<setter>>
- Documentation:
Requests to be notified when a event occurs, but only wants to wait so long in the queue.
- public SemaphoreOperationStatus lockWithNoWait ( [Unnamed] : void )
- Stereotype:
<<setter>>
- Documentation:
Requests a notification indication without waiting in the queue. This is where the caller would like to identify that a event has occured but has not been reset.
- public SemaphoreOperationStatus lockWithWait ( [Unnamed] : void )
- Stereotype:
<<setter>>
- Documentation:
Requests to be notified when a EventSemaphore is released. The notification is identified when control is returned to the caller with a SemaphoreOperationStatus of SUCCESS.
- public bool isLocked ( [Unnamed] : void )
- Stereotype:
<<getter>>
- Constraints: {query}
- Documentation:
Returns true if semaphore is locked in regards to type semantics.
- public ~EventSemaphore ( [Unnamed] : void )
- Stereotype:
<<destructor>>
- Documentation:
Virtual Destructor
- public EventSemaphore ( aIdentifier : Identifier, aRecursiveMode : bool=true, aBalkMode : bool=false )
-
-
-
- aIdentifier : Identifier
- Documentation:
Identifies the Semaphore.
aRecursiveMode : bool=true
- Documentation:
Indicates whether recursive mode is enabled.
aBalkMode : bool=false
- Documentation:
Indicates whether the semaphore balks or not based on type.
- Stereotype:
<<constructor>>
- class SemaphoreIdentifier
- Stereotype:
<<type>>
- class SemaphoreGroup
- Superclasses:
- Data::libcorelinux::Synchronized
- Documentation:
A SemaphoreGroup is an extension to the Linux semaphore set. This provides a way to logically group semaphores. A SemaphoreGroup acts as a Semaphore factory, creating and destroying Semaphores for the user.
- Operations:
- public SemaphoreGroup ( aCount : short )
-
- aCount : short
- Documentation:
Number of Semaphores this group manages.
- Stereotype:
<<constructor>>
- Documentation:
Default constructor creates a private SemaphoreGroup with OWNER_ALL access and with aCount number of semaphores being created.
- public SemaphoreGroup ( aCount : short, aIdentifier : SemaphoreGroupIdentifier, rights : int, disp : CreateDisposition=FAIL_IF_EXISTS )
-
-
-
-
- aCount : short
- Documentation:
Number of Semaphores this group manages.
aIdentifier : SemaphoreGroupIdentifier
- Documentation:
The identifier to use on create or find on open
rights : int
- Documentation:
The AccessRights this group has set upon construction.
disp : CreateDisposition=FAIL_IF_EXISTS
- Documentation:
Default is to fail if the requested object exists.
- Stereotype:
<<constructor>>
- Documentation:
Constructor which takes a SemaphoreGroupIdentifier.
- public SemaphoreGroup ( aCount : short, aName : std::string, rights : int, disp : CreateDisposition=FAIL_IF_EXISTS )
-
-
-
-
- aCount : short
- Documentation:
Count of Semaphores this group manages
aName : std::string
- Documentation:
The name to convert to an identifier for creation.
rights : int
- Documentation:
The AccessRights for this groups semaphores and control
disp : CreateDisposition=FAIL_IF_EXISTS
- Documentation:
Default is to fail if the object being created exists.
- Stereotype:
<<constructor>>
- Documentation:
Constructor which takes a string for identity
- public ~SemaphoreGroup ( [Unnamed] : void )
- Stereotype:
<<destructor>>
- Documentation:
Virtual Destructor
- public bool operator== ( aGroup : SemaphoreGroup )
- Stereotype:
<<operator>>
- Constraints: {query}
- Documentation:
Returns true if theIdentifiers match.
- public SemaphoreGroup ( aCount : short, rights : int )
-
-
- aCount : short
- Documentation:
The number of semaphore groups
rights : int
- Documentation:
The access rights for the private group.
- Stereotype:
<<constructor>>
- Documentation:
Default constructor which allows control over access rights on group.
- public short getSemaphoreCount ( [Unnamed] : void )
- Stereotype:
<<getter>>
- Constraints: {query}
- Documentation:
Returns the number of semaphores in this group
- public abstract AbstractSemaphore createSemaphore ( [Unnamed] : void )
- Stereotype:
<<constructor>>
- Documentation:
Creates a default semaphore for this group
- public abstract AbstractSemaphore createSemaphore ( [Unnamed] : SemaphoreIdentifier, [Unnamed] : CreateDisposition=CREATE_OR_REUSE, [Unnamed] : bool=true, [Unnamed] : bool=false )
-
-
-
-
- [Unnamed] : SemaphoreIdentifier
- Documentation:
The identifier for the semaphore
[Unnamed] : CreateDisposition=CREATE_OR_REUSE
- Documentation:
Disposition if semaphore already exists, or does not exists.
[Unnamed] : bool=true
- Documentation:
Defines recursive setting for created semaphore, ignored on open.
[Unnamed] : bool=false
- Documentation:
Defines if the semaphore is allowed to balk requests.
- Stereotype:
<<constructor>>
- Documentation:
Creates or retrieves a semaphore identified in the argument.
- public abstract AbstractSemaphore createSemaphore ( [Unnamed] : std::string, [Unnamed] : CreateDisposition=CREATE_OR_REUSE, [Unnamed] : bool=true, [Unnamed] : bool=false )
-
-
-
-
- [Unnamed] : std::string
- Documentation:
Identifies the semaphore by name
[Unnamed] : CreateDisposition=CREATE_OR_REUSE
- Documentation:
Defines behavior if semaphore exists or not.
[Unnamed] : bool=true
- Documentation:
Defines whether semaphore is recursive for threads
[Unnamed] : bool=false
- Documentation:
Defines whether semaphores can balk requests.
- Stereotype:
<<constructor>>
- Documentation:
Creates or opens a semaphore identified in the argument.
- public abstract void destroySemaphore ( aSemaphore : AbstractSemaphore )
- Stereotype:
<<destructor>>
- Documentation:
Destroys the semaphore instance.
- protected SemaphoreGroup ( [Unnamed] : void )
- Stereotype:
<<constructor>>
- Documentation:
Asserts for lack of required information.
- public SemaphoreGroupIdentifier getIdentifier ( [Unnamed] : void )
- Stereotype:
<<getter>>
- Constraints: {query}
- Documentation:
Gets the identifier for the SemaphoreGroup
- protected SemaphoreGroup ( aSemaphoreGroup : SemaphoreGroup )
- Stereotype:
<<constructor>>
- Documentation:
Copy constructor
- protected SemaphoreGroup operator= ( aSemaphoreGroup : SemaphoreGroup )
- Stereotype:
<<setter>>
- Documentation:
Assignment operator
- class SemaphoreGroupIdentifier
- Stereotype:
<<type>>
- abstract class AbstractSemaphore
- Superclasses:
- Data::libcorelinux::Synchronized
- Documentation:
AbstractSemaphore provides a base abstraction for the fundemental interface of CoreLinux++ semaphore types.
- Operations:
- public abstract bool isBalkingEnabled ( [Unnamed] : void )
- Stereotype:
<<getter>>
- Constraints: {query}
- Documentation:
Returns true if semaphore has balking mode enabled.
- public abstract bool isRecursionEnabled ( [Unnamed] : void )
- Stereotype:
<<getter>>
- Constraints: {query}
- Documentation:
Returns true if recursion is allowed.
- public abstract SemaphoreOperationStatus lockWithWait ( [Unnamed] : void )
- Stereotype:
<<setter>>
- Documentation:
Requests a lock. The caller will wait until the semaphore can grant this request.
- public abstract SemaphoreOperationStatus lockWithNoWait ( [Unnamed] : void )
- Stereotype:
<<setter>>
- Documentation:
Requests a lock. The caller will not wait until the semaphore can grant this request but would rather have a returned indicating the lock was unavailable at that moment.
- public abstract SemaphoreOperationStatus lockWithTimeOut ( aTimeOut : Time )
- Stereotype:
<<setter>>
- Documentation:
Requests a lock. The caller will wait until the semaphore can grant this request or until the time specified elapses. The semantics of which are type defined.
- public abstract SemaphoreOperationStatus release ( [Unnamed] : void )
- Stereotype:
<<setter>>
- Documentation:
Interface for release semantics.
- public abstract bool isLocked ( [Unnamed] : void )
- Stereotype:
<<getter>>
- Documentation:
Returns true if semaphore is locked in regards to type semantics.
- public abstract SemaphoreIdentifier getIdentifier ( [Unnamed] : void )
- Stereotype:
<<getter>>
- Constraints: {query}
- Documentation:
Returns the semaphore identifier
- public abstract SemaphoreGroupIdentifier getGroupIdentifier ( [Unnamed] : void )
- Stereotype:
<<getter>>
- Constraints: {query}
- Documentation:
Returns the identifier of the group that this semaphore is a member of.
- public int getValue ( [Unnamed] : void )
- Stereotype:
<<getter>>
- Documentation:
Returns the semaphores current value.
- protected SemaphoreOperationStatus setLock ( aFlag : int )
-
- aFlag : int
- Documentation:
A flag for specifying IPC_NOWAIT and/or IPC_UNDO
- Stereotype:
<<setter>>
- Documentation:
Sets the lock by calling the kernel.
- protected SemaphoreOperationStatus setUnlock ( aFlag : int )
-
- aFlag : int
- Documentation:
A flag for specifying IPC_NOWAIT and/or IPC_UNDO
- Stereotype:
<<setter>>
- Documentation:
Sets the unlock by calling the kernel.
- protected SemaphoreOperationStatus setValue ( aValue : int )
-
- aValue : int
- Documentation:
The value to set the semaphore to.
- Stereotype:
<<setter>>
- Documentation:
Sets the semaphore to a specific value.
- protected abstract SemaphoreGroupIdentifier getGroupId ( [Unnamed] : void )
- Stereotype:
<<getter>>
- Documentation:
Returns non-const for low level operations.
- protected abstract SemaphoreIdentifier getId ( [Unnamed] : void )
- Stereotype:
<<getter>>
- Documentation:
Gets identifier for low level operations.
- public abstract ThreadIdentifier getOwningThreadIdentifier ( [Unnamed] : void )
- Stereotype:
<<getter>>
- Constraints: {query}
- Documentation:
Returns the thread that owns the AbstractSemaphore, the semantics of which are implementation defined.
- public abstract unsigned short getRecursionQueueLength ( [Unnamed] : void )
- Stereotype:
<<getter>>
- Constraints: {query}
- Documentation:
Returns the recursion depth that the owning thread has called for this semaphore, or 0 if recursion is not enabled.
- protected abstract ThreadIdentifier getOwnerId ( [Unnamed] : void )
- Stereotype:
<<getter>>
- Documentation:
Returns the owner thread identifier, the semantics of which are implementation defined.
- class SemaphoreGroupRegister
- Stereotype:
<<implementationClass>>
- Documentation:
The SemaphoreGroupRegister manages the IPC between threads and non-private semaphore groups.
- class CreateDisposition
- Stereotype:
<<type>>
- Documentation:
Designations for behavior on create and open activity.
- Attributes:
- public CREATE_OR_REUSE
-
- Documentation:
Indication that the operation should create the object if it does not exist, or reuse the object if it exists.
- public FAIL_IF_EXISTS
-
- Documentation:
Indicates that if the object being created exists already, then the operation should fail.
- public FAIL_IF_NOTEXISTS
-
- Documentation:
Indicates that the object being requested must exist to be used by the caller, or fail if it does not exist.
- class CoreLinuxGuardPool
- Stereotype:
<<implementationClass>>
- Documentation:
The GuardPool is a specialialization of the SemaphoreGroup which allows supports class use of Guard objects. By definition, the GuardPool is a collection of MutexSemaphores associated to unique instance objects.
- Attributes:
- private theExtentSize : short = 0
-
- Documentation:
The extent size, defaults to 0
- private theInitalSize : short = 0
-
- Documentation:
The initialized pool size.
- private theCallers : Map<Synchronized,AbstractSemaphore>
-
- Documentation:
Maps a specific Synchronized instance to the semaphore its using.
- private theSemaphores : Map<AbstractSemaphore,PoolDescriptor>
-
- Documentation:
Association of Semaphore in use to its descriptor.
- Operations:
- public GuardPool ( aInitialCount : short=8, aExtentCount : short=0 )
-
-
- aInitialCount : short=8
- Documentation:
Indicates the number of semaphores in the base pool.
aExtentCount : short=0
- Documentation:
Indicates the number of semaphores that should be added when an extent is needed. If zero (0-the default) is specified, the GuardPool will block the caller on a live guard that has the shortest mean time between usage.
- Stereotype:
<<constructor>>
- Documentation:
Default constructor requires a initial count and optional extent count of semobjects.
- public void lock ( aInstance : Synchronized )
- Stereotype:
<<setter>>
- Documentation:
Locks the Synchorized object.
- public void release ( aInstance : Synchronized )
- Stereotype:
<<setter>>
- Documentation:
Releases the Synchronized object.
- public short getInitialPoolSize ( [Unnamed] : void )
- Stereotype:
<<getter>>
- Documentation:
Returns the initial pool size.
- public short getExtentSize ( [Unnamed] : void )
- Stereotype:
<<getter>>
- Documentation:
Returns the extent size
- public int getTotalPoolSize ( [Unnamed] : void )
- Documentation:
Gets the current size of the pool, this is guarenteed to be >= theInitialSize.
- public bool isLocked ( aInstance : Synchronized )
- Documentation:
Determines if there is a lock on the synchronized object.
- class MutexSemaphoreGroup
- Superclasses:
- Data::libcorelinux::SemaphoreGroup
- Documentation:
MutexSemaphoreGroup is a SemaphoreGroup specialization which emits MutexSemaphores.
- Operations:
- public AbstractSemaphore createSemaphore ( [Unnamed] : void )
- Stereotype:
<<constructor>>
- Documentation:
Creates a default MutexSemaphore
- public AbstractSemaphore createSemaphore ( [Unnamed] : SemaphoreIdentifier, [Unnamed] : CreateDisposition=CREATE_OR_REUSE, [Unnamed] : bool=true, [Unnamed] : bool=false )
-
-
-
-
- [Unnamed] : SemaphoreIdentifier
- Documentation:
The identifier for the semaphore
[Unnamed] : CreateDisposition=CREATE_OR_REUSE
- Documentation:
Disposition if semaphore already exists, or does not exists.
[Unnamed] : bool=true
- Documentation:
Defines recursive setting for created semaphore, ignored on open.
[Unnamed] : bool=false
- Documentation:
Defines if the semaphore is allowed to balk requests.
- Stereotype:
<<constructor>>
- Documentation:
Creates or retrieves a MutexSemaphore identified in the argument.
- public AbstractSemaphore createSemaphore ( [Unnamed] : std::string, [Unnamed] : CreateDisposition=CREATE_OR_REUSE, [Unnamed] : bool=true, [Unnamed] : bool=false )
-
-
-
-
- [Unnamed] : std::string
- Documentation:
Identifies the semaphore by name
[Unnamed] : CreateDisposition=CREATE_OR_REUSE
- Documentation:
Defines behavior if semaphore exists or not.
[Unnamed] : bool=true
- Documentation:
Defines whether semaphore is recursive for threads
[Unnamed] : bool=false
- Documentation:
Defines whether semaphores can balk requests.
- Stereotype:
<<constructor>>
- Documentation:
Creates or opens a MutexSemaphore identified in the argument.
- public void destroySemaphore ( aSemaphore : AbstractSemaphore )
- Stereotype:
<<destructor>>
- Documentation:
Destroys the MutexSemaphore instance.
- public AbstractSemaphore createLockedSemaphore ( [Unnamed] : void )
- Stereotype:
<<constructor>>
- Documentation:
Creates a MutexSemaphore that is locked on creation.
- public AbstractSemaphore createLockedSemaphore ( [Unnamed] : SemaphoreIdentifier, [Unnamed] : CreateDisposition=CREATE_OR_REUSE, [Unnamed] : bool=true, [Unnamed] : bool=false )
-
-
- [Unnamed] : bool=true
- Documentation:
Recursion flag
[Unnamed] : bool=false
- Documentation:
Balking flag.
- Stereotype:
<<constructor>>
- Documentation:
Creates or opens a specific Semphore from the group, will autolock it or wait for availability.
- class Synchronized
- Stereotype:
<<utility>>
- Documentation:
Class derived from Synchronized are enabled for Guard locking within scope.
- Operations:
- protected Guard access ( [Unnamed] : void )
- Stereotype:
<<constructor>>
- Documentation:
Creates a Guard instance and locks everything below scope until destroyed. Once the Guard goes out of scope, it will destruct and release the guard.
- class PoolDescriptor
- Stereotype:
<<type>>
- Documentation:
Maintains information from a semaphore to the pool it originated from.
- Attributes:
- public theGroupIndex : unsigned long = 0
-
- Documentation:
Identifies the index of the group in theGroups collection.
- public theQueueLength : short = 0
-
- Documentation:
Queue length of concurrent requests for the same semaphore.
- class ThreadIdentifier
- Stereotype:
<<type>>
- Documentation:
ThreadIdentifier is a unique value for each thread in the process, and in the system.
- class GuardSemaphore
- Superclasses:
- Data::libcorelinux::Semaphore
- Documentation:
A GuardSemaphore is a special purpose Semaphore used by the CoreLinuxGuardPool for enabling Synchronized object monitor control. It is NOT recursive and does not support BALKING.
- class CoreLinuxGuardGroup
- Superclasses:
- Data::libcorelinux::SemaphoreGroup
- Documentation:
CoreLinuxGuardGroup is a SemaphoreGroup specialization which emits GuardSemaphores for use by the CoreLinuxGuardPool.
- class GatewaySemaphoreGroup
- Superclasses:
- Data::libcorelinux::SemaphoreGroup
- Documentation:
GatewaySemaphoreGroup is a SemaphoreGroup specialization which emits GatewaySemaphores. Like MutexSemaphoreGroup, GatewaySemaphoreGroup adds interface for creating a non-default GatewaySemaphore.
- Operations:
- public AbstractSemaphore createCountSemaphore ( aCount : unsigned short )
- Stereotype:
<<constructor>>
- Documentation:
There are two methods that create a GatewaySemaphore that is initialized to a value > 1. The first, this one, is the default which only allows you to specify the count to initialize the Gateway to.
- public createCountSemaphore ( aIdentifier : SemaphoreIdentifier, aCount : unsigned short )
- Documentation:
There are two methods that create a GatewaySemaphore that is initialized to a value > 1. The second allows the caller to specify the value for a specific GatewaySemaphore in the group.
Model dictionary
A B C D E F G I L M O P R S T U ~
A
- AbstractSemaphore class from package libcorelinux
- AbstractSemaphore provides a base abstraction for the fundemental interface of CoreLinux++ semaphore types.
- access operation from class libcorelinux.Synchronized
- Creates a Guard instance and locks everything below scope until destroyed. Once the Guard goes out of scope, it will destruct and release the guard.
- AccessRights class from package libcorelinux
- Enumerates the possible access rights given to an object.
B
- BALKED attribute from class libcorelinux.SemaphoreOperationStatus
- Indicates that the call failed because the semaphore has balked at the request.
C
- Component View package
- corelinux package
- CoreLinux++ class library.
- CoreLinuxGuardGroup class from package libcorelinux
- CoreLinuxGuardGroup is a SemaphoreGroup specialization which emits GuardSemaphores for use by the CoreLinuxGuardPool.
- CoreLinuxGuardPool class from package libcorelinux
- The GuardPool is a specialialization of the SemaphoreGroup which allows supports class use of Guard objects. By definition, the GuardPool is a collection of MutexSemaphores associated to unique instance objects.
- create operation from class corelinux.SemaphoreGroupFactory
- Create a SemaphoreGroup
- create operation from class corelinux.SemaphoreGroup
- Creates a semaphore from the group.
- createActiveIterator operation from class libcorelinux.GatewaySemaphore
- Returns a iterator over a snapshot of the current active resource process/thread identifiers.
- createCountSemaphore operation from class libcorelinux.GatewaySemaphoreGroup
- There are two methods that create a GatewaySemaphore that is initialized to a value > 1. The first, this one, is the default which only allows you to specify the count to initialize the Gateway to.
- createCountSemaphore operation from class libcorelinux.GatewaySemaphoreGroup
- There are two methods that create a GatewaySemaphore that is initialized to a value > 1. The second allows the caller to specify the value for a specific GatewaySemaphore in the group.
- CreateDisposition class from package libcorelinux
- Designations for behavior on create and open activity.
- createLockedSemaphore operation from class libcorelinux.MutexSemaphoreGroup
- Creates a MutexSemaphore that is locked on creation.
- createLockedSemaphore operation from class libcorelinux.MutexSemaphoreGroup
- Creates or opens a specific Semphore from the group, will autolock it or wait for availability.
- createSemaphore operation from class libcorelinux.SemaphoreGroup
- Creates a default semaphore for this group
- createSemaphore operation from class libcorelinux.SemaphoreGroup
- Creates or retrieves a semaphore identified in the argument.
- createSemaphore operation from class libcorelinux.SemaphoreGroup
- Creates or opens a semaphore identified in the argument.
- createSemaphore operation from class libcorelinux.MutexSemaphoreGroup
- Creates a default MutexSemaphore
- createSemaphore operation from class libcorelinux.MutexSemaphoreGroup
- Creates or retrieves a MutexSemaphore identified in the argument.
- createSemaphore operation from class libcorelinux.MutexSemaphoreGroup
- Creates or opens a MutexSemaphore identified in the argument.
- CREATE_OR_REUSE attribute from class libcorelinux.CreateDisposition
- Indication that the operation should create the object if it does not exist, or reuse the object if it exists.
D
- Data package
- destroy operation from class corelinux.SemaphoreGroup
- destroy operation from class corelinux.SemaphoreGroupFactory
- destroyActiveIterator operation from class libcorelinux.GatewaySemaphore
- Destroys the iterator of active resource users.
- destroySemaphore operation from class libcorelinux.SemaphoreGroup
- Destroys the semaphore instance.
- destroySemaphore operation from class libcorelinux.MutexSemaphoreGroup
- Destroys the MutexSemaphore instance.
- Developer class from package Participants
- Developer extends classes for use in a solution space
- doWork operation from class Participants.Implementor
E
- EventSemaphore class from package libcorelinux
- The EventSemaphore provides a way to queue and release interested parties when a certain condition is met. Unlike the Mutex or Gateway, EventSemaphore has the ability to release all queued callers.
- EventSemaphore operation from class libcorelinux.EventSemaphore
F
- FAIL_IF_EXISTS attribute from class libcorelinux.CreateDisposition
- Indicates that if the object being created exists already, then the operation should fail.
- FAIL_IF_NOTEXISTS attribute from class libcorelinux.CreateDisposition
- Indicates that the object being requested must exist to be used by the caller, or fail if it does not exist.
G
- GatewaySemaphore class from package libcorelinux
- GatewaySemphore enables a depth of resource indicator. Unlike the tradition boolean semaphore (locked,unlocked), this type assumes a finite number of threads/processes can be granted access up to theResourceMaximum.
- GatewaySemaphore operation from class libcorelinux.GatewaySemaphore
- Default constructor requires a count specifier.
- GatewaySemaphoreGroup class from package libcorelinux
- GatewaySemaphoreGroup is a SemaphoreGroup specialization which emits GatewaySemaphores. Like MutexSemaphoreGroup, GatewaySemaphoreGroup adds interface for creating a non-default GatewaySemaphore.
- get operation from class corelinux.SemaphoreGroupFactory
- Gets a specific semaphore group
- getExtentSize operation from class libcorelinux.CoreLinuxGuardPool
- Returns the extent size
- getGroupId operation from class libcorelinux.AbstractSemaphore
- Returns non-const for low level operations.
- getGroupIdentifier operation from class libcorelinux.AbstractSemaphore
- Returns the identifier of the group that this semaphore is a member of.
- getGroupIdentifier operation from class libcorelinux.Semaphore
- Returns the identifier of the group that this semaphore is a member of.
- getId operation from class libcorelinux.AbstractSemaphore
- Gets identifier for low level operations.
- getIdentifier operation from class libcorelinux.Semaphore
- Returns the semaphore identifier
- getIdentifier operation from class libcorelinux.SemaphoreGroup
- Gets the identifier for the SemaphoreGroup
- getIdentifier operation from class libcorelinux.AbstractSemaphore
- Returns the semaphore identifier
- getInitialPoolSize operation from class libcorelinux.CoreLinuxGuardPool
- Returns the initial pool size.
- getOwnerId operation from class libcorelinux.AbstractSemaphore
- Returns the owner thread identifier, the semantics of which are implementation defined.
- getOwningThreadIdentifier operation from class libcorelinux.Semaphore
- Returns the thread that owns the AbstractSemaphore, the semantics of which are implementation defined.
- getOwningThreadIdentifier operation from class libcorelinux.AbstractSemaphore
- Returns the thread that owns the AbstractSemaphore, the semantics of which are implementation defined.
- getRecursionQueueLength operation from class libcorelinux.AbstractSemaphore
- Returns the recursion depth that the owning thread has called for this semaphore, or 0 if recursion is not enabled.
- getRecursionQueueLength operation from class libcorelinux.Semaphore
- Returns the recursion depth that the owning thread has called for this semaphore, or 0 if recursion is not enabled.
- getSemaphoreCount operation from class libcorelinux.SemaphoreGroup
- Returns the number of semaphores in this group
- getTotalPoolSize operation from class libcorelinux.CoreLinuxGuardPool
- Gets the current size of the pool, this is guarenteed to be >= theInitialSize.
- getValue operation from class libcorelinux.AbstractSemaphore
- Returns the semaphores current value.
- GROUP_ALL attribute from class libcorelinux.AccessRights
- Group has all access rights.
- GROUP_MODIFY attribute from class libcorelinux.AccessRights
- Group has write access.
- GROUP_READ attribute from class libcorelinux.AccessRights
- Group has read access.
- GuardPool operation from class libcorelinux.CoreLinuxGuardPool
- Default constructor requires a initial count and optional extent count of semobjects.
- GuardSemaphore class from package libcorelinux
- A GuardSemaphore is a special purpose Semaphore used by the CoreLinuxGuardPool for enabling Synchronized object monitor control. It is NOT recursive and does not support BALKING.
I
- Identifier class from package corelinux
- Implementor class from package Participants
- Implementor is a developer that uses either the corelinux or extension types into solution space applications.
- isBalkingEnabled operation from class libcorelinux.AbstractSemaphore
- Returns true if semaphore has balking mode enabled.
- isLocked operation from class libcorelinux.GatewaySemaphore
- Returns true if semaphore has no more resources available for access.
- isLocked operation from class libcorelinux.EventSemaphore
- Returns true if semaphore is locked in regards to type semantics.
- isLocked operation from class libcorelinux.AbstractSemaphore
- Returns true if semaphore is locked in regards to type semantics.
- isLocked operation from class libcorelinux.CoreLinuxGuardPool
- Determines if there is a lock on the synchronized object.
- isLocked operation from class libcorelinux.MutexSemaphore
- Returns true if semaphore is currently in a locked state.
- isRecursionEnabled operation from class libcorelinux.AbstractSemaphore
- Returns true if recursion is allowed.
L
- libcorelinux package from package Component View
- libcorelinux package
- Design namespace
- lock operation from class libcorelinux.CoreLinuxGuardPool
- Locks the Synchorized object.
- lock operation from class corelinux.Semaphore
- Locks the semaphore
- lockWithNoWait operation from class libcorelinux.EventSemaphore
- Requests a notification indication without waiting in the queue. This is where the caller would like to identify that a event has occured but has not been reset.
- lockWithNoWait operation from class libcorelinux.AbstractSemaphore
- Requests a lock. The caller will not wait until the semaphore can grant this request but would rather have a returned indicating the lock was unavailable at that moment.
- lockWithNoWait operation from class libcorelinux.MutexSemaphore
- Requests a lock. The caller will not wait until the semaphore can grant this request but would rather have a return indicating the lock was unavailable at that moment.
- lockWithNoWait operation from class libcorelinux.GatewaySemaphore
- Requests a lock. The caller will not wait until the semaphore can grant this request but would rather have a returned indicating one of the resources controlled by this semaphore was unavailable at that moment.
- lockWithTimeOut operation from class libcorelinux.EventSemaphore
- Requests to be notified when a event occurs, but only wants to wait so long in the queue.
- lockWithTimeOut operation from class libcorelinux.GatewaySemaphore
- Requests a lock. The caller will wait until the semaphore can grant this request or until the time specified elapses.
- lockWithTimeOut operation from class libcorelinux.MutexSemaphore
- Requests a lock. The caller will wait until the semaphore can grant this request or until the time specified elapses.
- lockWithTimeOut operation from class libcorelinux.AbstractSemaphore
- Requests a lock. The caller will wait until the semaphore can grant this request or until the time specified elapses. The semantics of which are type defined.
- lockWithWait operation from class libcorelinux.EventSemaphore
- Requests to be notified when a EventSemaphore is released. The notification is identified when control is returned to the caller with a SemaphoreOperationStatus of SUCCESS.
- lockWithWait operation from class libcorelinux.AbstractSemaphore
- Requests a lock. The caller will wait until the semaphore can grant this request.
- lockWithWait operation from class libcorelinux.GatewaySemaphore
- Requests a lock. The caller will wait until the number of resources controlled by this semaphore are greater than zero.
- lockWithWait operation from class libcorelinux.MutexSemaphore
- Requests a lock. The caller will wait until the semaphore can grant this request.
M
- Many-to-One class from package corelinux
- When used in this fashion, a single Semaphore is used to let callers block until some event occurs. Unlike the serialzed access, where one caller at a time is released to gain access to a resource, when the designated event occurs all blocked callers are released at once.
- The creator of this type of Semaphore can designate the maximum number of listeners that can wait on a single Semaphore event. When used in this manner, balking mode is automatically enabled.
- When balking mode is enabled callers will be turned away until the number of listeners on the event drops below maximum.
- MutexSemaphore class from package libcorelinux
- The MutexSemaphore controls mutual exclusion to a resource. This semaphore recognizes a lock state and unlocked state.
- MutexSemaphore operation from class libcorelinux.MutexSemaphore
- Default constructor. In addition to the AbstractSemaphore defaults, we have an indication that can set the semaphore to be automatically locked upon creation.
- MutexSemaphoreGroup class from package libcorelinux
- MutexSemaphoreGroup is a SemaphoreGroup specialization which emits MutexSemaphores.
O
- One-to-Many class from package corelinux
- When used in this fashion, a Semaphore can be used as an access count controller. The Semaphore is created, as determined by the solution domain, with the maximum number of concurrent active callers allowed. As long as the caller count does not reach the maximum, the arrival will be granted immediate access. When the maximum has been reached, arriving callers are blocked.
- When balking mode is enabled callers will be turned away until the count reduces to less than maximum.
- One-to-One class from package corelinux
- When used to prevent concurrent access to a resource, the caller must first obtain control of the associated Semaphore. When a caller has control of the Semaphore, the resource(s) that are associated with the Semaphore are considered locked and accessible by the caller. When the caller has completed access of the resource it relinquishes control and the resource is now considered unlocked.
- Attempts may be made to access the resource by other threads of execution or from seperate processes. These callers are queued and the requestor is put into a blocked state. In this state the caller waits until the resource is unlocked. If multiple requests are blocking for the same control, the determination of which caller gains access next is, from a applications perspective, arbitrary.
- When balking mode is enabled callers will be turned away as long as the Semaphore is locked.
- operator= operation from class libcorelinux.SemaphoreGroup
- Assignment operator
- operator== operation from class libcorelinux.SemaphoreGroup
- Returns true if theIdentifiers match.
- operator== operation from class libcorelinux.Semaphore
- Assignment operator throws assertion
- operator== operation from class libcorelinux.Semaphore
- Returns true if instance identifiers are the same.
- OWNER_ALL attribute from class libcorelinux.AccessRights
- Owner has all access rights.
- OWNER_MODIFY attribute from class libcorelinux.AccessRights
- Owner has write access.
- OWNER_READ attribute from class libcorelinux.AccessRights
- Owner has read access.
P
- Participants package
- Roles defined by the requirement.
- PoolDescriptor class from package libcorelinux
- Maintains information from a semaphore to the pool it originated from.
- PUBLIC_ALL attribute from class libcorelinux.AccessRights
- Public has all access rights.
- PUBLIC_MODIFY attribute from class libcorelinux.AccessRights
- Public has write access.
- PUBLIC_READ attribute from class libcorelinux.AccessRights
- Public read access.
R
- release operation from class libcorelinux.EventSemaphore
- Interface for release semantics.
- release operation from class libcorelinux.GatewaySemaphore
- Release one of the resources controlled by this semaphore.
- release operation from class libcorelinux.AbstractSemaphore
- Interface for release semantics.
- release operation from class corelinux.Semaphore
- Releases the semaphore lock
- release operation from class libcorelinux.CoreLinuxGuardPool
- Releases the Synchronized object.
- release operation from class libcorelinux.MutexSemaphore
- Interface for release semantics. For this type it means changing the GuardLockState of the semaphore to UNLOCKED.
- return operation from class corelinux.SemaphoreGroupFactory
S
- Semaphore operation from class libcorelinux.Semaphore
- Void constructor not allowed, throws assertion
- Semaphore operation from class libcorelinux.Semaphore
- Default constructor
- Semaphore class from package corelinux
- A Semaphore is a protocol by which processes and/or threads agree to follow for the purpose of controlled access to a resource. The resource can be anything that the developer considers to need access controls on, such as memory, hardware, methods, computer instructions, and so on. The Semaphore is pinned to the Linux kernel which enforces blocking (being made to wait) the caller until a resource is available.
- Semaphore operation from class libcorelinux.Semaphore
- Copy constructor throws Assertion
- Semaphore class from package libcorelinux
- Semaphore implements the storage of attributes common to all semaphore types.
- SemaphoreException class from package libcorelinux
- A SemaphoreException base class.
- SemaphoreGroup operation from class libcorelinux.SemaphoreGroup
- Default constructor which allows control over access rights on group.
- SemaphoreGroup operation from class libcorelinux.SemaphoreGroup
- Constructor which takes a string for identity
- SemaphoreGroup class from package libcorelinux
- A SemaphoreGroup is an extension to the Linux semaphore set. This provides a way to logically group semaphores. A SemaphoreGroup acts as a Semaphore factory, creating and destroying Semaphores for the user.
- SemaphoreGroup operation from class libcorelinux.SemaphoreGroup
- Copy constructor
- SemaphoreGroup operation from class libcorelinux.SemaphoreGroup
- Default constructor creates a private SemaphoreGroup with OWNER_ALL access and with aCount number of semaphores being created.
- SemaphoreGroup class from package corelinux
- A SemaphoreGroup is an extension to the Linux semaphore set. This provides a way to logically group semaphores. A SemaphoreGroup acts as a Semaphore factory, creating and destroying Semaphores for the user.
- SemaphoreGroup operation from class libcorelinux.SemaphoreGroup
- Asserts for lack of required information.
- SemaphoreGroup operation from class libcorelinux.SemaphoreGroup
- Constructor which takes a SemaphoreGroupIdentifier.
- SemaphoreGroupFactory class from package corelinux
- SemaphoreGroupFactory creates and destroys SemaphoreGroups.
- SemaphoreGroupIdentifier class from package libcorelinux
- SemaphoreGroupRegister class from package libcorelinux
- The SemaphoreGroupRegister manages the IPC between threads and non-private semaphore groups.
- SemaphoreIdentifier class from package libcorelinux
- SemaphoreIdentifier class from package corelinux
- SemaphoreOperationStatus class from package libcorelinux
- Enumeration of status for various mutators.
- setLock operation from class libcorelinux.AbstractSemaphore
- Sets the lock by calling the kernel.
- setUnlock operation from class libcorelinux.AbstractSemaphore
- Sets the unlock by calling the kernel.
- setValue operation from class libcorelinux.AbstractSemaphore
- Sets the semaphore to a specific value.
- Solution Domain package
- The Solution Domain represents the implementors application, library, or process domain. It does not effect corelinux but uses the classes and/or abstractions provided.
- SUCCESS attribute from class libcorelinux.SemaphoreOperationStatus
- Indicates a success for the call semantics.
- Synchronized class from package libcorelinux
- Class derived from Synchronized are enabled for Guard locking within scope.
T
- theBalkMode attribute from class libcorelinux.Semaphore
- Indication on whether the semaphore was created with Balk capability. If true, balk mode is enabled.
- theCallers attribute from class libcorelinux.CoreLinuxGuardPool
- Maps a specific Synchronized instance to the semaphore its using.
- theExtentSize attribute from class libcorelinux.CoreLinuxGuardPool
- The extent size, defaults to 0
- theGroupIdentifier attribute from class libcorelinux.Semaphore
- Identifies the SemaphoreGroup that this Semaphore belongs to.
- theGroupIndex attribute from class libcorelinux.PoolDescriptor
- Identifies the index of the group in theGroups collection.
- theIdentifier attribute from class libcorelinux.Semaphore
- The Semaphore identifier in the SemaphoreGroup context.
- theInitalSize attribute from class libcorelinux.CoreLinuxGuardPool
- The initialized pool size.
- theOwningThread attribute from class libcorelinux.Semaphore
- The identifier for the thread, set by implementation semantics.
- theQueueLength attribute from class libcorelinux.PoolDescriptor
- Queue length of concurrent requests for the same semaphore.
- theRecursionQueueLength attribute from class libcorelinux.Semaphore
- The length of the recursion as implementation defined.
- theRecursiveMode attribute from class libcorelinux.Semaphore
- Indicates whether a process and/or thread that has the lock already can continue to issue locks without dead-locking.
- theResourceMaximum attribute from class libcorelinux.GatewaySemaphore
- Maximum resource count.
- theSemaphores attribute from class libcorelinux.CoreLinuxGuardPool
- Association of Semaphore in use to its descriptor.
- ThreadIdentifier class from package libcorelinux
- ThreadIdentifier is a unique value for each thread in the process, and in the system.
- Time class from package libcorelinux
- Time type
- TIMEDOUT attribute from class libcorelinux.SemaphoreOperationStatus
- Indicates that the call failed because the request timed out waiting for a state change in the semaphore.
U
- UNAVAILABLE attribute from class libcorelinux.SemaphoreOperationStatus
- Indicates that the lock was unavailable.
~
- ~EventSemaphore operation from class libcorelinux.EventSemaphore
- Virtual Destructor
- ~Gateway operation from class libcorelinux.GatewaySemaphore
- Virtual Destructor
- ~MutexSemaphore operation from class libcorelinux.MutexSemaphore
- Virtual Destructor
- ~Semaphore operation from class libcorelinux.Semaphore
- Virtual Destructor
- ~SemaphoreGroup operation from class libcorelinux.SemaphoreGroup
- Virtual Destructor
SUMMARY
- Total packages reported: 7
- Total classes reported: 32
- Total attributes reported: 29
- Total operations reported: 91
Copyright © 1999, 2000 by CoreLinux Consortium
This material may be distributed only subject to the terms and conditions set forth in the
Open Publication License
|
|
|
