Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
[detail level 123]
  fesa | |
 detail | |
  FunctionStorage | |
| DiagnosticsDefs | |
 DiagStateCounter | Diagnostic state counting information To be reviewd with FESA-2973 |
| DiagnosticMessage | A message collecting information needed for diagnostics |
| DiagnosticsEventPayload | Diagnostics setting information passed from the server part to the RT part needed to set up diagnostics |
| DiagnosticUtils | |
| DiagnosticMessage | Diagnostic message |
| Functors | |
| AddPointee | |
| LessOnPointees | |
| FwkPart | |
| ProcessType | |
| QueueMode | |
| RangeChecker | |
| Range | Representation of a range of values |
| RequestType | Access type, which is sent to the ReplyHandler of the client When a subscriber which is subscribed to a setting property receives an update, or when the manual update after a new subscription is triggered, the "get()" in the property has to be executed using the Request Type. In that case, this flag is added to the rdaData the subscriber will receive, in order to inform him about the purpose of the Notification. GET: update is due to a notification from a RealTimeAction (no additional tag is sent) SUBSCRIBE: first update after a subscription ... "1" is sent. SET: notification through a setting Property ... "2" is sent |
| UpdateType | |
| wrappers | |
| PointerWrapper | |
| AbstractComponentEquipment | This class is an abstraction of the components of an equipment. It contains common services shared by both the server and real time parts |
| AbstractDeviceClass | Each instance of this class represents a FESA-Class (XML-Design-Document) |
| AbstractEquipment | This class is the head of each equipment. It is used to decouple the server and the RT package from the core package |
| AbstractEvent | Abstract Base class of the two concrete Events: RequestEvent and RTEvent This class cannot be instantiated and it contains only common services |
| DeploymentThreadConfiguration | A class to retrieve a thread's scheduling configuration (its priority and affinity). A thread's scheduling configuration is retrieved either from the deployment unit's design (if it's specified there), or from the framework (the default configuration). If information about a thread's priority or affinity is available in the deployment unit's design, the member function corresponding to the thread has to be overriden in the generated derived class |
| SchedulingConfig | A thread's scheduling configuration |
| AbstractMsgQueue | An abstract message queue. The concrete implementation (the STL queue or the IPC queue) depends on the deployment mode (mixed or split) |
| IpcMsgQueue | If the RT and the server part are NOT in the same process, the POSIX message queue is used. The class provides the structure of the POSIX message queue and its corresponding functions |
| LocalMsgQueue | If the real-time and the server parts are in the same process, the STL queue is used. The class provides the structure of the local message queue and its corresponding functions |
| QueueLimits | Limit parameters of message queues |
| MsgQueueFactory | Creation of message queues |
| AbstractMessage | A message that can be transmitted on a message queue |
| AutomaticNotificationMessage | A message type to automatically notify the server side via Notification ID |
| CommandMessage | A message type that can be used to send any type of command of up to two arguments as a string |
| OnDemandMessage | A message type for on-demand events |
| NotificationID | This class provides an unique notification identifier. The ID is generated from the className, the devices specified by the selection criterion, and the properties that will be notified |
| NotificationProducer | This class is responsible for sending notification messages to the notification consumer, thus connecting the RT and server parts |
| ThreadConfigurer | A class to configure the framework's threads' scheduling parameters (their priorities and afffinities). The configuration is done based on the information given in the instantiation file, the deployment unit's design, and the framework itself (the default values) |
| SchedulingConfig | A thread's scheduling configuration, i.e. its priority and its affinity |
| AbstractDevice | This class represents an abstraction of the underlying device by defining the common fields of the FESA class devices (instance device and global one) |
| AbstractDeviceFactory | This abstract class contains virtual methods to create the devices on the system |
| AbstractField | Base class which defines virtual methods to manage all the FESA fields |
| AcqFieldScalar | Wrapper class for scalar acquisition fields. The acquisition field API offer methods to set fields, in contrast to configuration fields which cannot be set dynamically because they are constant |
| AcqFieldStruct | Wrapper class for acquisition fields. The acquisition field API offer methods to set fields, in contrast to configuration fields which cannot be set dynamically because they are constant |
| AcquisitionFieldCommon | |
| AcqFieldHistory | |
| AcqFieldHistoryScalarTemplate | |
| Array | A one-dimensional array wrapper class. An Array always has its own copy of the data. Consequently, the data passed to its constructor can be safely destroyed. An Array provides a subscript operator which allows modification of the data |
| Array2D | |
| ImmutableArray2D | |
| Array2DRow | |
| ImmutableArray | |
| ConfigFieldScalar | Wrapper class for scalar configuration fields The configuration field API offers methods to retrieve field values (get accessors), |
| ConfigFieldStruct | Wrapper class for struct configuration fields The configuration field API offers methods to retrieve field values (get accessors), Acquisition and setting field wrappers inherit from it |
| Converter | Conversion of values of arbitrary types to strings and vice versa |
| ConverterArray | Class that contains conversion method to convert array data |
| ConverterArray2D | Class that contains conversion method to convert array2D data |
| ConverterStringArray | Class that contains conversion method to convert string-array data |
| DataStore | Base class for field-storage classes in the framework: Device, GlobalDevice and DomainStore |
| DeviceFactory | This class is responsible for the instantiation of all the devices, global-device and domain-store. The DeviceFactory is designed as a bridge pattern to allow sub-classing of the class interface (this one) and the class implementation (DeviceFactoryImp) separately |
| DeviceFactoryImp | The DeviceFactory is designed as a bridge pattern to allow sub-classing of the class interface (DeviceFactory) and the class implementation (this one) separately. This DeviceFactoryImp is the abstract-class that declares the interface to the underlying device-factory implementation (Shm, Heap). It instantiates all devices, global-device, domain-store and initializes everything |
| DeviceInstantiationData | This class facades the class "DeviceElement" in order to provide a simple API for class-developers and to hide methods which were made for internal usage |
| DomainStore | Groups common fields which are dependent on the timing domain |
| FaultField | A specialized field for faults. This type of field is meant to indicate a fault or a problem in the system. It is a template class that can accept the FaultField_DataType type or its derived types as the template parameter |
| PropertyNotifier | Raising and lowering a fault field may automatically notify some lab-defined properties that display information about faults. Lowering a fault field should notify the properties whose get server actions were disabled by this field |
| Field | Field template class for scalar fields |
| FieldArray | FieldArray template class for arrays of various numeric types and structure types |
| FieldArray2D | Field template class for 2D arrays of various numeric types and structure types |
| FieldCallback | |
| FieldConfig | Configuration information needed for field construction |
| FieldString | Field template class for strings |
| FieldStringArray | Field template class for string arrays |
| FieldStruct | Field template class for struct fields |
| FieldSynchroManager | Class that manages the synchronization of persistent fields |
| FieldFunction | |
| FieldFunctionList | |
| Function | |
| FunctionList | Represents a FESA function list. A FunctionList has always its own copy of the data if not explicitly specified. Consequently, the data passed to its constructor can be safely destroyed |
| FunctionIterator | |
| ImmutableFunction | |
| ImmutableFunctionList | |
| Point | |
| PointIterator | |
| GenericFieldScalar | Wrapper class for scalar generic fields. The generic field API offer methods to set fields, in contrast to configuration fields which cannot be set dynamically because they are constant |
| GenericFieldStruct | Wrapper class for generic fields. The generic field API offer methods to set fields, in contrast to configuration fields which cannot be set dynamically because they are constant |
| GlobalDevice | This is the base class for the equipment-specialist's global-device class. It contains all the common global fields for any FESA class. Global field means all the fields accessible for all the devices for a given class in the same front-end. It is up to each FESA class to specify its specific global fields |
| HeapFactory | This class is responsible for creating and initializing the data memory space on the heap: |
| SharedMemoryAllocator | |
| MemoryMappedFileFactory | |
| OnFaultNotificationConfig | Configuration information needed to set up the on-fault notification |
| SettingFieldScalar | Wrapper class for setting fields |
| SettingFieldStruct | Wrapper class for setting fields |
| AbstractUserDiagnostics | User side diagnostic infrastructure |
| Diagnostics | Diagnostic infrastructure |
| FrameworkDiagnostics | Framework side diagnostic infrastructure |
| HasMetrics | |
| Metric | |
| MetricsManager | |
| FesaException | This class is the based class for all the exceptions in the FESA framework. It contains an error code in order to retrieve the message linked to the error. This error code has to be in the messages.cfg file The class also admits parameters to be replaced in the message in the format $1,$2 .. |
| ControllerFactory | |
| PeriodicalPersistencyTrigger | The producer of periodical persistency triggers. Its task is to periodically initiate the storing of the persistent data of all the FESA classes into the persistency file |
| PersistencyManager | Management of FESA classes' persistency |
| SettingsPersistencyTrigger | The producer of persistency triggers initiated by settings. Its task is (1) to initiate the storing of the persistent data of a FESA class into the persistency file after a setting, and (2) to protect against frequent writing into the persistency file when many settings are done one after the other (a burst). The producer gets triggerd by PersistencyManager::triggerWithDelay(), makes sure the burst is finished, and tells the consumer in PersistencyManager that it can store the data |
| StoreManager | This class is responsible for storing and restoring devices of a class from a persistency mechanism |
| AsyncGetCallback | |
| ProxyInterface | Interface to access device properties with set, get or subscription calls. This class is meant to be used as the implementation of an association relationship between classes. It could be also used to establish association relationships between devices of the same class. Therefore a class can access a device of the same class or different class deployed on the same or on a different frontend |
| ProxyReplyHandler | An instance of ProxyReplyHandler is passed as a reference to the Middleware when performing a subscription. The middleware then uses it as a callback |
| MuxSubscriptionMatcher | |
| RDAExporter | |
| AbstractEventSource | Representation of an event source in the system. Event sources are responsible for firing events and sending them to the right scheduler |
| AbstractEventSourceFactory | This factory provides methods to handle events sources |
| RTActionConfig | This structure stores all the necessary information to configure an action |
| AbstractRTAction | This class represents a real time action on the system |
| AbstractRTActionFactory | This class provides a method to create AbstractRTActions by their configuration and name |
| AbstractRTDeviceClass | This class contains the real time data of the FESA class |
| AbstractRTEquipment | This class represents the real time part of the equipment |
| RTSchedulingUnitRef | Contains information related to the layers in which the schedulers are running |
| RTLayerInfo | Contains information related to the layers in which the schedulers are running |
| LogicalEvent | Abstract base-class for the LogicalEvent |
| LogicalEventImpl | Implementation of the LogicalEvent |
| MultiThreadedEventSource | |
| MultiThreadedEventSourceProducer | |
| OnDemandEventSource | This class extends the AbstractEventSource class to provide a mechanism that allows clients to trigger real-time actions in a server or a RT action The sending action puts a message in the message queue. The OnDemandEventSource class reads this message from the queue and fires an RT event |
| OnSubscriptionEventSource | |
| OnSubscriptionEventSourceProducer | |
| OnSubscriptionRTEventPayload | Payload carried by a RTEvent triggered by a OnSubscriptionEventSource |
| RTAction | This class extends the AbstractRTAction and adds the deviceType parameter template. Specific real time actions will inherit from this class, replacing the template parameter for a specific device class |
| RTController | This class configures the real time process |
| RTDiagnosticSetting | Diagnostic logging. Switching on/off the diagnostic mode, enabling/disabling diagnostic topics, etc |
| RTEvent | This class defines an event created by an event source |
| RTEventPayload | It is meant to carry the payload of an Event |
| RTScheduler | The scheduler class contains the real time behavior of the class. It waits for events and then executes the real time action related to them |
| SettingFieldsReadGuard | |
| Watchdog | |
| AbstractServerAction | This is the based class for all the server actions in the system which will be executed when a property is requested. TODO discuss the DataType parameter |
| AbstractServerActionFactory | This class is responsible to provide a method in order to create the server actions for the class |
| AbstractServerController | The AbstractServerController manages the proper startup and shutdown of all services, providet by the server side |
| AbstractServerDeviceClass | This class contains the properties of the class and lets access to them. Besides it creates the UserEventProducer |
| AbstractServerEquipment | This class contains all the AbstractServerDeviceClass for the equipment and validates the requests from external clients |
| ExporterFactory | This class provides functionality for creation and storage of notification exporters |
| ContextData | |
| NotificationConsumer | This class receives notification messages from the notification producer and uses the subscrition tree manager class to nofity the clients |
| NotificationThread | This class is used to notify a subscriber with adjustable priority (always lower, than usual). Each property has a priority level. If that level is lower than the priority's of the server thread, notifications from that property are executed in a NotificationThread. The different NotificationThreads are kept in a Threadpool inside the NotificationThreadFactory. The Notifications of one NotificationThread are stored inside a queue. When the "startConsumption" conditional variable is triggered, the queue will be processed |
| NotificationThreadFactory | Creates threads used for notifications |
| PropertyConstructorParameters | Contains arguments of Property's constructor Used to make the code more readable and to avoid typos |
| PropertyInfo | |
| Property | This class represents a property which computes through server actions the value of a requested attribute |
| PropertyBuilder | Used to build Properties. Can be extended in order to build lab-specific properties |
| PropertyData | The framework's abstraction of a multiplexed property's data It provides access to the underlying CMW context |
| RequestEvent | This class is used in order to encapsulate the cycle selector and the multiplexing context in a server action passing it as parameter |
| ServerData | The framework's abstraction of a property's data or of a property's data filters |
| Array2DSize | Representation of the size of a two-dimensional array |
| ArraySize | Representation of the size of a one-dimensional array |
| StringArray2DSize | Representation of the size of a two-dimensional array of strings |
| StringArraySize | Representation of the size of a one-dimensional array of strings |
| FieldExpression | This class extends the SortingExpression in order to know if the context matches a field |
| HomogeneousDevCol | This class contains a collection of devices and it lets do operations between other collections like add up, or rest |
| IntersectExpression | This class extends the sorting expression in order to check if the context matches the intersection between the two sorting expressions |
| SortingContext | |
| SortingExpression | This is the base class which defines sorting expressions in the sorting package. It defines the match method in order to find out if the expression matches the context |
| SortingLexer | |
| Lexeme | |
| SortingParser | |
| BinaryOperation | |
| Node | |
| Value | |
| UnionExpression | This class extends the sorting expression in order to check if the context matches a composition expression |
| AbstractMultiplexingDataManager | The headclass of all DataManagers. It provides all kinds of methods, which are needed in order to work with different memory concepts |
| AbstractMultiplexingManager | This class is used to find the correct slot for a multiplexed field value using the virtual accelerator or the multiplexing context |
| BufferSynchronizer | |
| CycleDescriptor | This class provides an interface to retrieve the cycles ids and names depending on the timing domain. Since the timing Domain is lab specific, a child class inside the lab package implements most of the methods |
| DataManager | |
| ExtendedMultiplexingManager | This mutiplexing manager is needed in order to do Multi-Multiplexing. This means it needs to be able to handle extra criteria |
| ModifiedField | |
| FieldDataManager | |
| FieldTrackerDataManager | |
| HeapMultiplexingDataManager | This class extends the TimingDataManager class to deal with heap memory |
| HeapRollingBufferMuxDataManager | This class extends the RollingDataManager class to deal with heap memory |
| MultiplexingContext | This class contains the information used for multiplexed fields |
| MultiplexingDataManager | This class provides methods to retrieve/store information about the cycle stamp and slot linked to that cycle stamp |
| MultiplexingManager | This class extends the AbstractMultiplexingManager in order to provide a multiplexing manager in which every cycle has a fixed slot |
| NoneContext | This class extends the MultiplexingContext in order to provide a dedicate context for the user event source class |
| RollingBufferMuxDataManager | This class provides methods to retrieve information about the cycle IDs and names that a multiplexing manager uses regardless the implementation of the data. The prefix "rolling" means the following: 1.) The number of available slots can be defined per class-instance. 2.) Only acquisition data is handled by the rolling data manager. 3.) New values are written inside just one after another for all incoming cycles(cycleNames) 4.) If the last slot is reached, the rolling data manager will continue writing on the first slot. 5.) It is possible that for an "old" cycle no data is available, since it was already overridden |
| RollingBufferMuxManager | This class extends the AbstractMultiplexingManager in order to provide a rolling multiplexing manager (explanation of "rolling" see class RollingDataManager) |
| ShmMultiplexingDataManager | This class extends the CycleDataManager class to deal with shared memory |
| ShmRollingBufferMuxDataManager | This class extends the RollingBufferMuxDataManager class to deal with shared memory |
| SynchronizationLabObjectFactory | This class provides methods in order to create the different types of timing descriptors or in general the specific Lab synchronization objects |
| CycleSelector | This struct represents a cycle selector composed of timing domain, multiplexing criterion and the line |
| TimingContext | Specialized context for a RTEvent coming from the TimingEventSource. The implementation is lab specific |
| Aligned | |
| Atomic | |
| ConcurrentQueue | |
| ConditionalVariable | This class is a c++ wrapper in order to use conditional variables. Conditional variables help to synchronize threads when there's a logical condition for the synchronization |
| ClassElement | Used to store all class-related Information from the Instantiation-File |
| ClassElementImpl | Implementation of pure virtual class ClassElement |
| CustomEventElementImpl | Used to store all custom-event-element Information which comes from the Instantiation-File |
| DataStoreElement | Used to store all data-store-specific information which comes from the instance-file |
| DataStoreElementImpl | Implementation of abstract class DataStoreElement |
| DeviceElement | Used to store all device-specific Information which comes from the Instantiation-File |
| DeviceElementImpl | Implementation of pure virtual class DeviceElement |
| DeviceLogicalEventElement | Used to store all Device-LogicalEvent-specific Information which comes from the Instantiation-File |
| DeviceLogicalEventElementImpl | Implementation of pure virtual class DeviceLogicalEventElement |
| EventConfigurationElement | Used to store all EventConfiguration-specific Information which comes from the Instantiation-File |
| EventConfigurationElementImpl | Implementation of pure virtual class EventConfigurationElement |
| EventElement | Used to handle and store all Event-specific Information which comes from the Instantiation-File. This class is Abstract |
| EventElementImpl | Used to handle and store all Event-specific Information which comes from the Instantiation-File. This class is Abstract |
| FieldElementImpl | Implementation of pure virtual class FieldElement |
| LogicalEventElement | Used to handle and store all Logical-Event-specific Information which comes from the Instantiation-File |
| LogicalEventElementImpl | Implementation of pure virtual class LogicalEventElement |
| OnDemandEventElementImpl | Used to handle and store all OnDemand-Event-specific Information which comes from the Instantiation-File |
| OnSubscriptionEventElementImpl | Used to handle and store all OnSubscription-Event-specific Information which comes from the Instantiation-File |
| TimerEventElementImpl | Used to handle and store all Timer-Event-specific Information which comes from the Instantiation-File |
| TimingEventElementImpl | Used to handle and store all Timing-Event-specific Information which comes from the Instantiation-File |
| Lock | This class is used to automatically lock and unlock a mutex. The constructor calls lock() and the destructor calls unlock(). This makes it impossible to leave a block containing a Lock object without unlocking the mutex. The mutex can also be unlocked explicitly, by calling the unlock() method |
| Mutex | |
| PersistanceDataStoreElement | |
| Pipe | |
| ProcessConfigurer | Take care of configuring the FESA process from either configuration files or command line arguments |
| ProcessStackTrace | |
| ReadLock | This class is used to automatically lock and unlock a read-write lock for reading. The constructor acquires a read-lock. The destructor releases the lock if it has not been explicitly unlocked. This ensures the read-write lock is returned to its previous state when a ReadLock object leaves scope. The read-write lock can also be unlocked explicitly, by calling the unlock() method |
| RWLock | |
| Semaphore | This class is a wrapper around POSIX semaphores |
| SharedConditionalVariable | |
| SharedMutex | |
| SharedRWLock | |
| StackTrace | |
| Thread | This class is a wrapper in order to manage threads according to the object oriented style |
| WriteLock | This class is used to automatically lock and unlock a read-write lock for writing. The constructor acquires a read-lock. The destructor releases the lock if it has not been explicitly unlocked. This ensures the read-write lock is returned to its previous state when a WriteLock object leaves scope. The read-write lock can also be unlocked explicitly, by calling the unlock() method |
| AttributeXML | This class represents an XML attribute containing name and value |
| ElementXML | This class represents an XML element containing name, value, a list of attributes and a list of child XML elements |
| XMLParser | This class offers functions to extract information from an XML file. It uses the xPath functions of the library libXML |
| ComplementExpression | This class extends the sorting expression in order to check if the context matches the negated expression |
| EquipmentDevice | This class contains different information necessary to access from the Real time and the Server packages |
| MannualNotificationMessage | A message type used for manual property notification |
| NotificationIDGenerator | This class generates the notification id collection |
| RTSchedulingInfo | This structure contains the information from the design document necessary to create the schedulers |
| ServerActionDesignConfig | This structure contains the attributes to configure the action.These attributes come from the design document |
| SingletonBase | This class can be inherited by singletons to provide thread-safe instantiation and guaranteed destruction upon normal process exit |
