| fesa::AbstractAction | |
| fesa::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 |
| fesa::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) |
| fesa::AbstractDeviceClass | Each instance of this class represents a FESA-Class (XML-Design-Document) |
| fesa::AbstractDeviceFactory | This abstract class contains virtual methods to create the devices on the system |
| fesa::AbstractEquipment | This class is the head of each equipment. It is used to decouple the server and the RT package from the core package |
| fesa::AbstractEvent | Abstract Base class of the two concrete Events: RequestEvent and RTEvent This class cannot be instantiated and it contains only common services |
| fesa::AbstractEventSource | This class represents an event source on the system. Event sources are responsible for firing events and sending them to the right scheduler |
| fesa::AbstractEventSourceFactory | This factory provides methods to handle events sources |
| fesa::AbstractFaultField | |
| fesa::AbstractField | Base class which defines virtual methods to manage all the FESA fields |
| fesa::AbstractMessage | Message class that will be transmitted on the message queue |
| fesa::AbstractMsgQueue | This class provides an abstract Message Queue. Whether the message queue will be implemented as IPC-Queue or as standard message queue depends on the deployment mode of the application (split, or shared) |
| fesa::AbstractMultiplexingDataManager | The headclass of all DataManagers. It provides all kinds of methods, which are needed in order to work with different memory concepts |
| fesa::AbstractMultiplexingManager | This class is used to find the correct slot for a multiplexed field value using the virtual accelerator or the multiplexing context |
| fesa::AbstractMutex | This class provides the services that all the mutex have to implement This allows to define a interface so that you can use the mutex services without knowing the implementation (shared, or normal) |
| fesa::AbstractPropertyTypeDefinition | This class defines the attributes and abstract methods for all type definition properties |
| fesa::AbstractRealTimeLabObjectFactory | |
| fesa::AbstractRTAction | This class represents a real time action on the system. Real time actions are fired by an event source to carry out operations in the devices |
| fesa::AbstractRTActionFactory | This class provides a method to create AbstractRTActions by their configuration and name |
| fesa::AbstractRTDeviceClass | This class contains the real time data of the FESA class |
| fesa::AbstractRTEquipment | This class represents the real time part of the equipment. it contains all the AbstractRTDeviceClass and the AbstractRTController for the real time behavior |
| fesa::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 |
| fesa::AbstractServerActionFactory | This class is responsible to provide a method in order to create the server actions for the class |
| fesa::AbstractServerController | The AbstractServerController manages the proper startup and shutdown of all services, providet by the server side |
| fesa::AbstractServerDeviceClass | This class contains the properties of the class and lets access to them. Besides it creates the UserEventProducer |
| fesa::AbstractServerEquipment | This class contains all the AbstractServerDeviceClass for the equipment and validates the requests from external clients. It also lets retrieve the devices by its name |
| fesa::AbstractServiceLocator | |
| fesa::AbstractServiceLocatorFactory | |
| fesa::AbstractServiceLocatorImplementation | |
| fesa::AbstractSubscriptionFilter | |
| fesa::AbstractUserDiagnostics | User side diagnostic infrastructure |
| fesa::AcqFieldArray< T > | |
| fesa::AcqFieldArray2D< T > | |
| fesa::AcqFieldScalar< T > | 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 |
| fesa::AcqFieldScalarArray< T > | |
| fesa::AcqFieldScalarArray2D< T > | |
| fesa::AcqFieldString | |
| fesa::AcqFieldStringArray | |
| fesa::AcqFieldStruct< T > | 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 |
| fesa::AcqFieldStructArray< T > | |
| fesa::AcqFieldStructArray2D< T > | |
| fesa::ArrayUtilities< T > | Helper class that contains methods to fill arrays with elements of all types |
| fesa::AttributeXML | This class represents an XML attribute containing name and value |
| fesa::AutomaticNotificationMessage | Message type to automatically notify the server side via Notification ID |
| fesa::BasicFilter | |
| fesa::ClassElement | Used to store all class-related Information from the Instantiation-File |
| fesa::CommandMessage | This messageType can be used to send any type of command and up to 2 arguments as string |
| fesa::ComplementExpression | This class extends the sorting expression in order to check if the context matches the negated expression |
| fesa::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 |
| fesa::ConfigFieldArray< T > | |
| fesa::ConfigFieldArray2D< T > | |
| fesa::ConfigFieldScalar< T > | Wrapper class for scalar configuration fields The configuration field API offers methods to retrieve field values (get accessors), |
| fesa::ConfigFieldScalarArray< T > | |
| fesa::ConfigFieldScalarArray2D< T > | |
| fesa::ConfigFieldString | |
| fesa::ConfigFieldStringArray | |
| fesa::ConfigFieldStruct< T > | 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 |
| fesa::ConfigFieldStructArray< T > | |
| fesa::ConfigFieldStructArray2D< T > | |
| fesa::AbstractMsgQueue::Constants | Constants, which are filled at runtime |
| fesa::Converter< T > | Class that contains conversion method to convert numeric data types to string and strings to numeric data types |
| fesa::Converter< bool > | |
| fesa::Converter< DeviceRelation_DataType > | |
| fesa::Converter< FaultField_DataType > | |
| fesa::Converter< HostHardwareAddress_DataType > | |
| fesa::Converter< HostPortHardwareAddress_DataType > | |
| fesa::Converter< LogicalHardwareAddress_DataType > | |
| fesa::Converter< signed char > | |
| fesa::Converter< T * > | |
| fesa::CustomEventElement | Used to store all custom-event-element Information which comes from the Instantiation-File |
| fesa::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 lap package implements most of the methods |
| fesa::CycleSelector | |
| fesa::DataStore | Base class for field-storage classes in the framework: Device, GlobalDevice and DomainStore |
| fesa::DataStoreElement | Common base class for GlobalDeviceElement, DeviceElement and DomainStoreElement |
| fesa::DeviceElement | This class stores device information |
| fesa::DeviceElement2 | Used to store all device-specific Information which comes from the Instantiation-File |
| fesa::DeviceFactory< GlobalDeviceType, DomainStoreType, DevInstType > | 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 |
| fesa::DeviceFactoryImp< GlobalDeviceType, DomainStoreType, DevInstType > | 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 |
| fesa::DeviceLogicalEventElement | Used to store all Device-LogicalEvent-specific Information which comes from the Instantiation-File |
| fesa::DeviceRelation_DataType | |
| fesa::DiagnosticEventPayload | Diagnostic event pay load structure |
| fesa::DiagnosticUtils::DiagnosticMessage | Diagnostic message |
| fesa::Diagnostics | Diagnostic infrastructure |
| fesa::DiagnosticUtils::DiagStateCounter | Diagnostic state counting information |
| fesa::DomainStore | Groups common fields which are dependent on the timing domain |
| fesa::DomainStoreElement | This class stores domain store information |
| fesa::ElementXML | This class represents an XML element containing name, value, a list of attributes and a list of child XML elements |
| fesa::EquipmentData | |
| EquipmentDevice | This class contains different information necessary to access from the Real time and the Server packages |
| fesa::EventConfigurationElement | Used to store all DEventConfiguration-specific Information which comes from the Instantiation-File |
| fesa::EventElement | Used to handle and store all Event-specific Information which comes from the Instantiation-File. This class is Abstract |
| fesa::OnSubscriptionEventSource::EventInfo | Stores information about an event |
| fesa::EventsMappingLoader | This class provides access to the events specified in the instance document |
| fesa::ExtendedMultiplexingManager | This mutiplexing manager is needed in order to do Multi-Multiplexing. This means it needs to be able to handle extra criteria |
| fesa::FaultField< DataType > | Specialized field for fault fields. This type of field is meant to indicate a fault or problem in the system. It is a template as it can accept FaultField_DataTypes or derived classes of that type as template parameter |
| fesa::FaultField_DataType | |
| fesa::FesaBadConfigException | |
| fesa::FesaBadParameterException | |
| fesa::FesaDeviceServer | |
| fesa::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 .. |
| fesa::FesaFileException | |
| fesa::FesaInvalidResourceException | |
| fesa::FesaIOException | |
| fesa::AbstractSubscriptionFilter::FesaListener | |
| fesa::FesaLogger | |
| fesa::FesaLoggerBuffer | |
| FesaRDADeviceServer | The FesaRDADeviceServer is implemented as a singleton. It inherits from the rdaDeviceServerBase, and provides the framework with all necessary services from the RDA package (the middleware layer). The single instance of the server is kept by the parent class |
| fesa::FesaStream | |
| fesa::FesaTypeMismatchException | |
| fesa::Field< T > | Field template class for scalar fields |
| fesa::FieldArray< T > | FieldArray template class for arrays of various numeric types and structure types |
| fesa::FieldArray2D< T > | |
| fesa::FieldElement | This class stores field information in the form of field name, field value and multiplexing criterion |
| fesa::FieldExpression | This class extends the SortingExpression in order to know if the context matches a field |
| fesa::FieldString | |
| fesa::FieldStringArray | |
| fesa::FieldSynchroManager | Class that manages the synchronization of persistent fields |
| fesa::FieldValue< T > | Field value class for all field types |
| fesa::FieldValue< char *[]> | |
| fesa::FieldValue< char[]> | |
| fesa::FieldValue< T[]> | |
| fesa::FieldValue< T[][1]> | |
| fesa::FieldValueBase | Base class for all field values |
| fesa::FrameworkDiagnostics | Framework side diagnostic infrastructure |
| fesa::GenericFieldArray< T > | |
| fesa::GenericFieldArray2D< T > | |
| fesa::GenericFieldScalar< T > | 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 |
| fesa::GenericFieldScalarArray< T > | |
| fesa::GenericFieldScalarArray2D< T > | |
| fesa::GenericFieldString | |
| fesa::GenericFieldStringArray | |
| fesa::GenericFieldStruct< T > | 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 |
| fesa::GenericFieldStructArray< T > | |
| fesa::GenericFieldStructArray2D< T > | |
| fesa::GetDiagnosticSetting | Create one instance per equipment |
| fesa::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 |
| fesa::GlobalDeviceElement | This class stores global device information |
| fesa::HeapFactory< GlobalDeviceType, DomainStoreType, DevInstType > | This class is responsible for creating and initializing the data memory space on the heap:
- compute the required memory size and allocate the memory
- map each field into the data store
|
| fesa::HeapMultiplexingDataManager | This class extends the TimingDataManager class to deal with heap memory |
| fesa::HeapRollingMultiplexingDataManager | This class extends the RollingDataManager class to deal with heap memory |
| fesa::HomogeneousDevCol | This class contains a collection of devices and it lets do operations between other collections like add up, or rest |
| fesa::HostHardwareAddress_DataType | |
| fesa::HostPortHardwareAddress_DataType | |
| fesa::InitializeDataStoreManager | This class is responsible for retrieve the information from of the different devices linked to a class |
| fesa::IntersectExpression | This class extends the sorting expression in order to check if the context matches the intersection between the two sorting expressions |
| fesa::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 |
| fesa::LocalMsgQueue | If the RT task and the server are in the same process, the STL queue is used. The class provides the structure of the local message queue and its corresponding functions |
| fesa::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 |
| fesa::LogicalEventElement | Used to handle and store all Logical-Event-specific Information which comes from the Instantiation-File |
| fesa::LogicalHardwareAddress_DataType | |
| MannualNotificationMessage | Message type to allow the user to do a manual notification |
| fesa::ManualNotificationMessage | |
| fesa::Miscellaneous | Everything, that does not fit in any other class |
| fesa::MsgQueueFactory | This static class generates message queues on demand and stores the queues in a map |
| fesa::MultiplexingContext | This class contains the information used for multiplexed fields |
| fesa::MultiplexingDataManager | This class provides methods to retrieve/store information about the cycle stamp and slot linked to that cycle stamp |
| fesa::MultiplexingManager | This class extends the AbstractMultiplexingManager in order to provide a multiplexing manager in which every cycle has a fixed slot |
| fesa::Mutex | This class is c++ a wrapper in order to use POSIX mutex |
| fesa::NoneContext | This class extends the MultiplexingContext in order to provide a dedicate context for the user event source class |
| fesa::Notification | This class is used by the SubscriptionTreeManager to find the right subscribers, without any parsing of strings through the subscription tree. The NotificationID of each notification is unique and identifies the Notification on a RT Notify Event |
| fesa::NotificationConsumer | This class receives notification messages from the NotificationProducer and uses the SubscritionTreeManager class to nofity the clients |
| fesa::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 |
| NotificationIDGenerator | This class generates the notification id collection |
| fesa::NotificationIDManager | |
| fesa::NotificationProducer | This class is responsible for sending notification messages to the notification consumer, thus connecting the RT and server parts |
| fesa::NotificationThread::NotificationQueueElement | This class stores the triple context, request type, and subcycle |
| fesa::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 |
| fesa::NotificationThreadFactory | This class manages the Notification classes |
| fesa::OnDemandConsumer | This class provides services in order to receive messages from an OnDemandProducer |
| fesa::OnDemandConsumerImpl | |
| fesa::OnDemandEvent | This class extends the RTEvent class to incorporate acknowledge features necessary for user events |
| fesa::OnDemandEventElement | Used to handle and store all OnDemand-Event-specific Information which comes from the Instantiation-File |
| fesa::OnDemandEventSource | This class extends the AbstractEventSource class to provide a mechanism that allows clients to fire real time actions in a server/RT-action. The sending action puts a message in a message queue. The OnDemandEventSource class reads this message from the queue and fires a RTEvent |
| fesa::OnDemandMessage | Message type to allow the user to do an OnDemand event |
| fesa::OnDemandProducer | This class provides services in order to send on-demand messages to the OD-event-source |
| fesa::OnDemandProducerImpl | |
| fesa::AbstractAction::OnDemandProducerRef | |
| fesa::OnSubscriptionEventElement | Used to handle and store all OnSubscription-Event-specific Information which comes from the Instantiation-File |
| fesa::OnSubscriptionEventSource | OnSubscriptionEventSource is dedicated to establish subscriptions using the ProxyInterface and then trigger a rtEvent per notification received |
| fesa::OnSubscriptionRTEventPayload | |
| fesa::ParserElementFactory | |
| fesa::PersistencyManager | This class is responsible for managing the persistency mechanism of the classes |
| fesa::PersistencyUnit | |
| fesa::ProcessConfiguration | Take care of configuring the FESA process from either configuration files or command line arguments |
| fesa::ProcessConfigurationImpl | |
| fesa::Property | This class represents a property which computes through server actions the value of a requested attribute |
| fesa::PropertyInfo | This structure contains all the attributes that a user can specify in the design document |
| fesa::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 |
| fesa::ProxyReplyHandler | An object of ProxyReplyHandlerClass is passed as a reference to the Middleware when performing a subscription. Then Middleware use it as a callback |
| ProxyRTEventPayload | Payload carried by a RTEvent triggered by a proxy subscription |
| fesa::RealTimeLabObjectFactory | |
| fesa::RequestEvent | This class is used in order to encapsulate the cycle selector and the multiplexing context in a server action passing it as parameter |
| fesa::RollingMultiplexingDataManager | 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(virtual accelerators) 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 info data is available, since it was already overridden 6.) If the same cycle is played more than once, data will not be instantly overridden, like in the TimingDataManager |
| fesa::RollingMultiplexingElement | This class stores the information about the rolling multiplexing manager that the instantiation file contains |
| fesa::RollingMultiplexingManager | This class extends the AbstractMultiplexingManager in order to provide a rolling multiplexing manager (explanation of "rolling" see class RollingDataManager) |
| fesa::RTAction< DeviceType > | 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 |
| fesa::RTActionConfig | This structure stores all the necessary information to configure an action |
| fesa::RTActionInfo | |
| fesa::RTController | This class configures the real time process. It creates the event sources, actions, and schedulers and configures those elements so that the real time part is ready. The class is also responsible for starting the event sources and schedulers |
| fesa::RTDiagnosticSetting | This class is responsible for doing diagnostics in the framework. It turns on or off topics and diagnostic mode |
| fesa::RTEvent | This class defines an event created by an event source |
| fesa::RTEventPayload | It is meant to carry the payload of an Event |
| fesa::RTLayerInfo | This structure contains the information related to the layers in which the schedulers are running |
| fesa::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 |
| RTSchedulingInfo | This structure contains the information from the design document necessary to create the schedulers |
| fesa::RTSchedulingUnitInfo | |
| fesa::RTSchedulingUnitRef | |
| fesa::Semaphore | This class is a c++ wrapper for the sem_t class |
| fesa::ServerAction< DeviceType, DataType, FilterType > | |
| fesa::ServerActionConfig | |
| ServerActionDesignConfig | This structure contains the attributes to configure the action.These attributes come from the design document |
| fesa::ServiceLocator< GlobalDeviceType, DomainStoreType, DeviceType > | |
| fesa::ServiceLocatorRealtimeSplitImplementation | |
| fesa::ServiceLocatorServerSplitImplementation | |
| fesa::ServiceLocatorUnsplitImplementation | |
| fesa::SetDiagnosticSetting | |
| fesa::SettingFieldArray< T > | |
| fesa::SettingFieldArray2D< T > | |
| fesa::SettingFieldScalar< T > | Wrapper class for setting fields |
| fesa::SettingFieldScalarArray< T > | |
| fesa::SettingFieldScalarArray2D< T > | |
| fesa::SettingFieldString | |
| fesa::SettingFieldStringArray | |
| fesa::SettingFieldStruct< T > | Wrapper class for setting fields |
| fesa::SettingFieldStructArray< T > | |
| fesa::SettingFieldStructArray2D< T > | |
| fesa::SharedMutex | This class implements a mutex variable in shared memory |
| fesa::ShmFactory< GlobalDeviceType, DomainStoreType, DevInstType > | This class is responsible for create and initialize the data memory space into shared-memory space:
- compute the required mempry size and allocate the memory
- map each field into the datastore
|
| fesa::ShmHeader_t | |
| fesa::ShmMultiplexingDataManager | This class extends the CycleDataManager class to deal with shared memory |
| fesa::ShmRollingMultiplexingDataManager | This class extends the RollingMultiplexingDataManager class to deal with shared memory |
| fesa::SortingContext | |
| fesa::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 |
| fesa::SortingInterpreter | |
| fesa::StoreManager | This class is responsible for storing and restoring devices of a class from a persistency mechanism |
| fesa::StringUtilities | |
| fesa::AbstractEventSource::SubscribedScheduler | |
| fesa::SubscriptionCycle | |
| fesa::SubscriptionFilter | |
| fesa::SubscriptionParameter | The SubscriptionTreeManager is implemented as a singleton. It provides a functional interface to the subscription tree and manages the tree - mutex - policity |
| fesa::OnSubscriptionEventSource::SubscriptionThread | This class creates a thread that keeps the reconnection of pending subscriptions |
| fesa::SubscriptionTreeManager | The SubscriptionTreeManager is implemented as a singleton. It provides a functional interface to the subscription tree and manages the tree - mutex - policity |
| fesa::SynchronizationFactory | |
| fesa::SynchronizationLabObjectFactory | This class provides methods in order to create the different types of timing descriptors or in general the specific Lab synchronization objects |
| fesa::Thread | This class is a wrapper in order to manage threads according to the object oriented style |
| fesa::ThreadPriorityConfiguration | |
| fesa::ThreadPriorityConfigurationFromCCDB | |
| fesa::ThreadPriorityConfigurationFromFile | |
| fesa::TimerEventElement | Used to handle and store all Timer-Event-specific Information which comes from the Instantiation-File |
| fesa::TimerEventSource | |
| fesa::TimingContext | Specialized context for a RTEvent coming from the TimingEventSource. The implementation is lab specific |
| fesa::TimingEventElement | Used to handle and store all Timing-Event-specific Information which comes from the Instantiation-File |
| fesa::TsCounter | |
| fesa::UdpLogger | |
| fesa::UnionExpression | This class extends the sorting expression in order to check if the context matches a composition expression |
| fesa::XMLParser | This class offers functions to extract information from an XML file. It uses the xPath functions of the library libXML |
