Class Hierarchy
This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 1234]
  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::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::AbstractEventSourceFactory | This factory provides methods to handle events sources |
| fesa::AbstractField | Base class which defines virtual methods to manage all the FESA fields |
| fesa::AbstractMessage | A message that can be transmitted on a message queue |
| fesa::AbstractMsgQueue | An abstract message queue. The concrete implementation (the STL queue or the IPC queue) depends on the deployment mode (mixed or split) |
| 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::AbstractRTActionFactory | This class provides a method to create AbstractRTActions by their configuration and name |
| 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::AbstractUserDiagnostics | User side diagnostic infrastructure |
| fesa::AcqFieldHistory< FieldType, HistoryFieldType > | |
| fesa::AcqFieldHistory< AcqFieldFunction, GenericFieldFunction > | |
| fesa::AcqFieldHistory< AcqFieldFunctionList, GenericFieldFunctionList > | |
| fesa::AcqFieldHistory< AcqFieldScalar< T >, GenericFieldScalar< T > > | |
| fesa::AcqFieldHistory< AcqFieldScalarArray2D< T >, GenericFieldScalarArray2D< T > > | |
| fesa::AcqFieldHistory< AcqFieldScalarArray< T >, GenericFieldScalarArray< T > > | |
| fesa::AcqFieldHistory< AcqFieldString, GenericFieldString > | |
| fesa::AcqFieldHistory< AcqFieldStringArray, GenericFieldStringArray > | |
| fesa::AcqFieldHistory< AcqFieldStruct< T, MutableType >, GenericFieldStruct< T, MutableType > > | |
| fesa::AcqFieldHistory< AcqFieldStructArray2D< T >, GenericFieldStructArray2D< T > > | |
| fesa::AcqFieldHistory< AcqFieldStructArray< T >, GenericFieldStructArray< T > > | |
| fesa::AcquisitionFieldCommon | |
| fesa::Functors::AddPointee< T > | |
| fesa::Aligned< T > | |
| ds::AnyError | |
| fesa::Array2DRow< T, runtimeCheck > | |
| fesa::ServerData::Array2DSize | Representation of the size of a two-dimensional array |
| fesa::ServerData::ArraySize | Representation of the size of a one-dimensional array |
| fesa::AsyncGetCallback | |
| fesa::Atomic< T > | |
| fesa::Atomic< uint32_t > | |
| fesa::AttributeXML | This class represents an XML attribute containing name and value |
| fesa::ClassElement | Used to store all class-related Information from the Instantiation-File |
| fesa::Functors::CompareToReferenceOrder< T, InputIterator > | |
| ComplementExpression | This class extends the sorting expression in order to check if the context matches the negated expression |
| fesa::ConcurrentQueue< T > | |
| fesa::ConcurrentQueue< boost::shared_ptr< fesa::RTEvent > > | |
| 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::ContextData | |
| fesa::ControllerFactory | |
| fesa::Converter< T > | Conversion of values of arbitrary types to strings and vice versa |
| fesa::ConverterArray< T > | Class that contains conversion method to convert array data |
| fesa::ConverterArray2D< T > | Class that contains conversion method to convert array2D data |
| fesa::ConverterStringArray | Class that contains conversion method to convert string-array data |
| 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 lab package implements most of the methods |
| fesa::CycleSelector | This struct represents a cycle selector composed of timing domain, multiplexing criterion and the line |
| fesa::DataManager | |
| fesa::DataStore | Base class for field-storage classes in the framework: Device, GlobalDevice and DomainStore |
| fesa::DataStoreElement | Used to store all data-store-specific information which comes from the instance-file |
| fesa::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 |
| 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::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 |
| fesa::DeviceLogicalEventElement | Used to store all Device-LogicalEvent-specific Information which comes from the Instantiation-File |
| fesa::DiagnosticsDefs::DiagnosticMessage | A message collecting information needed for diagnostics |
| fesa::DiagnosticUtils::DiagnosticMessage | Diagnostic message |
| fesa::Diagnostics | Diagnostic infrastructure |
| fesa::DiagnosticsDefs::DiagnosticsEventPayload | Diagnostics setting information passed from the server part to the RT part needed to set up diagnostics |
| fesa::DiagnosticsDefs::DiagStateCounter | Diagnostic state counting information To be reviewd with FESA-2973 |
| fesa::ElementXML | This class represents an XML element containing name, value, a list of attributes and a list of child XML elements |
| EquipmentDevice | This class contains different information necessary to access from the Real time and the Server packages |
| fesa::EventConfigurationElement | Used to store all EventConfiguration-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::ExporterFactory | This class provides functionality for creation and storage of notification exporters |
| 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::FieldCallback | |
| fesa::FieldConfig | Configuration information needed for field construction |
| fesa::FieldElementImpl | Implementation of pure virtual class FieldElement |
| fesa::FieldSynchroManager | Class that manages the synchronization of persistent fields |
| fesa::FrameworkDiagnostics | Framework side diagnostic infrastructure |
| fesa::FunctionIterator< FunctionType, LocalFunctionType > | |
| fesa::FunctionIterator< const ImmutableFunction, ImmutableFunction > | |
| fesa::detail::FunctionStorage | |
| fesa::HasMetrics | |
| fesa::HomogeneousDevCol | This class contains a collection of devices and it lets do operations between other collections like add up, or rest |
| fesa::ImmutableArray< T, runtimeCheck, ArrayImpl > | |
| fesa::ImmutableArray2D< T, runtimeCheck > | |
| fesa::ImmutableArray< T, runtimeCheck > | |
| fesa::ImmutableFunction | |
| fesa::ImmutableFunctionList | |
| ds::InvalidDataValue | |
| ds::InvalidFilterValue | |
| fesa::Functors::LessOnPointees< T > | |
| fesa::SortingLexer::Lexeme | |
| 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. The mutex can also be unlocked explicitly, by calling the unlock() method |
| fesa::LogicalEvent | Abstract base-class for the LogicalEvent |
| fesa::LogicalEventElement | Used to handle and store all Logical-Event-specific Information which comes from the Instantiation-File |
| MannualNotificationMessage | A message type used for manual property notification |
| fesa::Metric | |
| fesa::MetricsManager | |
| fesa::ModifiedField | |
| fesa::MultiplexingContext | This class contains the information used for multiplexed fields |
| fesa::Mutex | |
| fesa::MuxSubscriptionMatcher | |
| ds::NoDataAvailable | |
| ds::NoDataAvailableForUser | |
| fesa::SortingParser::Node | |
| fesa::NotificationExporter::NotificationEvent | |
| 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::NotificationThreadFactory | |
| fesa::OnFaultNotificationConfig | Configuration information needed to set up the on-fault notification |
| fesa::PersistanceDataStoreElement | |
| fesa::PersistanceFieldSlot | |
| fesa::Pipe | |
| fesa::Point | |
| fesa::wrappers::PointerWrapper< T, CallbackType > | |
| fesa::PointIterator< PointType > | |
| fesa::PointIterator< const Point > | |
| fesa::ProcessConfigurer | Take care of configuring the FESA process from either configuration files or command line arguments |
| fesa::ProcessStackTrace | |
| fesa::Property | This class represents a property which computes through server actions the value of a requested attribute |
| fesa::PropertyBuilder | Used to build Properties. Can be extended in order to build lab-specific properties |
| fesa::PropertyConstructorParameters | |
| fesa::PropertyInfo | |
| fesa::FaultField< DataType >::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 |
| 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 instance of ProxyReplyHandler is passed as a reference to the Middleware when performing a subscription. The middleware then uses it as a callback |
| fesa::QueueLimits | Limit parameters of message queues |
| fesa::RangeChecker::Range< T > | Representation of a range of values |
| fesa::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 |
| fesa::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 |
| fesa::RTActionConfig | This structure stores all the necessary information to configure an action |
| 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::RTEventPayload | It is meant to carry the payload of an Event |
| fesa::RTLayerInfo | |
| RTSchedulingInfo | This structure contains the information from the design document necessary to create the schedulers |
| fesa::RTSchedulingUnitRef | |
| fesa::RWLock | |
| fesa::DeploymentThreadConfiguration::SchedulingConfig | A thread's scheduling configuration |
| fesa::ThreadConfigurer::SchedulingConfig | A thread's scheduling configuration, i.e. its priority and its affinity |
| fesa::SelectedDeviceCollection | |
| fesa::Semaphore | This class is a wrapper around POSIX semaphores |
| ServerActionDesignConfig | This structure contains the attributes to configure the action.These attributes come from the design document |
| fesa::ServerData | The framework's abstraction of a property's data or of a property's data filters. It provides access to the "raw" CMW data for get and set requests |
| fesa::SettingFieldsReadGuard | |
| fesa::SharedMemoryAllocator | |
| SingletonBase< T > | This class can be inherited by singletons to provide thread-safe instantiation and guaranteed destruction upon normal process exit |
| SingletonBase< MsgQueueFactory > | |
| SingletonBase< NotificationIDManager > | |
| 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::SortingLexer | |
| fesa::SortingParser | |
| fesa::StackTrace | |
| fesa::StoreManager | This class is responsible for storing and restoring devices of a class from a persistency mechanism |
| fesa::ServerData::StringArray2DSize | Representation of the size of a two-dimensional array of strings |
| fesa::ServerData::StringArraySize | Representation of the size of a one-dimensional array of strings |
| 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::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) |
| fesa::Watchdog | |
| fesa::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 |
 fesa::XMLParser | This class offers functions to extract information from an XML file. It uses the xPath functions of the library libXML |
