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::AbstractRTEquipment	This class represents the real time part of the equipment
fesa::AbstractServerEquipment	This class contains all the AbstractServerDeviceClass for the equipment and validates the requests from external clients
fesa::AbstractDeviceClass	Each instance of this class represents a FESA-Class (XML-Design-Document)
fesa::AbstractRTDeviceClass	This class contains the real time data of the FESA class
fesa::AbstractServerDeviceClass	This class contains the properties of the class and lets access to them. Besides it creates the UserEventProducer
fesa::AbstractDeviceFactory	This abstract class contains virtual methods to create the devices on the system
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::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::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::RTEvent	This class defines an event created by an event source
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::Field< T >	Field template class for scalar fields
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::ConfigFieldScalar< T >	Wrapper class for scalar configuration fields The configuration field API offers methods to retrieve field values (get accessors),
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::SettingFieldScalar< T >	Wrapper class for setting fields
fesa::FieldArray< T >	FieldArray template class for arrays of various numeric types and structure types
fesa::FieldArray2D< T >	Field template class for 2D arrays of various numeric types and structure types
fesa::FieldString	Field template class for strings
fesa::FieldStringArray	Field template class for string arrays
fesa::FieldStruct< T >	Field template class for struct fields
fesa::AcqFieldStruct< T, MutableType >	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::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::GenericFieldStruct< T, MutableType >	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::SettingFieldStruct< T, MutableType >	Wrapper class for setting fields
fesa::Field< bool >
fesa::GenericFieldScalar< bool >
fesa::Field< int32_t >
fesa::GenericFieldScalar< int32_t >
fesa::FieldArray< detail::FunctionStorage >
fesa::FieldFunctionList
fesa::FieldArray< Point >
fesa::FieldFunction
fesa::FieldStruct< DataType >
fesa::GenericFieldStruct< DataType >
fesa::FaultField< DataType >	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
fesa::AbstractMessage	A message that can be transmitted on a message queue
fesa::AutomaticNotificationMessage	A message type to automatically notify the server side via Notification ID
fesa::CommandMessage	A message type that can be used to send any type of command of up to two arguments as a string
fesa::OnDemandMessage	A message type for on-demand events
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::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 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
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::MultiplexingDataManager	This class provides methods to retrieve/store information about the cycle stamp and slot linked to that cycle stamp
fesa::HeapMultiplexingDataManager	This class extends the TimingDataManager class to deal with heap memory
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::HeapRollingBufferMuxDataManager	This class extends the RollingDataManager class to deal with heap memory
fesa::ShmRollingBufferMuxDataManager	This class extends the RollingBufferMuxDataManager class to deal with shared memory
fesa::ShmMultiplexingDataManager	This class extends the CycleDataManager class to deal with shared memory
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::ExtendedMultiplexingManager	This mutiplexing manager is needed in order to do Multi-Multiplexing. This means it needs to be able to handle extra criteria
fesa::MultiplexingManager	This class extends the AbstractMultiplexingManager in order to provide a multiplexing manager in which every cycle has a fixed slot
fesa::RollingBufferMuxManager	This class extends the AbstractMultiplexingManager in order to provide a rolling multiplexing manager (explanation of "rolling" see class RollingDataManager)
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::AcqFieldHistoryScalarTemplate< FieldType, HistoryFieldType, ParamType >
fesa::AcqFieldHistory< AcqFieldFunction, GenericFieldFunction >
fesa::AcqFieldHistory< AcqFieldFunctionList, GenericFieldFunctionList >
fesa::AcqFieldHistory< AcqFieldScalar< T >, GenericFieldScalar< T > >
fesa::AcqFieldHistoryScalarTemplate< AcqFieldScalar< T >, GenericFieldScalar< T >, 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::AcqFieldHistoryScalarTemplate< AcqFieldStruct< T, MutableType >, GenericFieldStruct< T, MutableType >, const T * >
fesa::AcqFieldHistory< AcqFieldStructArray2D< T >, GenericFieldStructArray2D< T > >
fesa::AcqFieldHistory< AcqFieldStructArray< T >, GenericFieldStructArray< T > >
fesa::AcquisitionFieldCommon
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::AcqFieldStruct< T, MutableType >	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::Functors::AddPointee< T >
fesa::Aligned< T >
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::ClassElementImpl	Implementation of pure virtual class ClassElement
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::ConcurrentQueue< std::string >
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::SharedConditionalVariable
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::FieldDataManager
fesa::FieldTrackerDataManager
fesa::DataStore	Base class for field-storage classes in the framework: Device, GlobalDevice and DomainStore
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::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::DomainStore	Groups common fields which are dependent on the timing domain
fesa::DataStoreElement	Used to store all data-store-specific information which comes from the instance-file
fesa::DataStoreElementImpl	Implementation of abstract class DataStoreElement
fesa::DeviceElement	Used to store all device-specific Information which comes from the Instantiation-File
fesa::DeviceElementImpl	Implementation of pure virtual class DeviceElement
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::HeapFactory< GlobalDeviceType, DomainStoreType, DevInstType >	This class is responsible for creating and initializing the data memory space on the heap:
fesa::MemoryMappedFileFactory< GlobalDeviceType, DomainStoreType, DevInstType >
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::DeviceLogicalEventElementImpl	Implementation of pure virtual class DeviceLogicalEventElement
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::EventConfigurationElementImpl	Implementation of pure virtual class EventConfigurationElement
fesa::EventElement	Used to handle and store all Event-specific Information which comes from the Instantiation-File. This class is Abstract
fesa::EventElementImpl	Used to handle and store all Event-specific Information which comes from the Instantiation-File. This class is Abstract
fesa::CustomEventElementImpl	Used to store all custom-event-element Information which comes from the Instantiation-File
fesa::OnDemandEventElementImpl	Used to handle and store all OnDemand-Event-specific Information which comes from the Instantiation-File
fesa::OnSubscriptionEventElementImpl	Used to handle and store all OnSubscription-Event-specific Information which comes from the Instantiation-File
fesa::TimerEventElementImpl	Used to handle and store all Timer-Event-specific Information which comes from the Instantiation-File
fesa::TimingEventElementImpl	Used to handle and store all Timing-Event-specific Information which comes from the Instantiation-File
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::AbstractEventSource	Representation of an event source in the system. Event sources are responsible for firing events and sending them to the right scheduler
fesa::MultiThreadedEventSource
fesa::OnSubscriptionEventSource
fesa::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
fesa::AbstractRTAction	This class represents a real time action on the system
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::RTDiagnosticSetting	Diagnostic logging. Switching on/off the diagnostic mode, enabling/disabling diagnostic topics, etc
fesa::LogicalEventImpl	Implementation of the LogicalEvent
fesa::NotificationConsumer	This class receives notification messages from the notification producer and uses the subscrition tree manager class to nofity the clients
fesa::NotificationProducer	This class is responsible for sending notification messages to the notification consumer, thus connecting the RT and server parts
fesa::RDAExporter
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
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::Array2D< T, runtimeCheck >
fesa::ImmutableArray< T, runtimeCheck >
fesa::Array< T, runtimeCheck >	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
fesa::ImmutableFunction
fesa::Function
fesa::ImmutableFunctionList
fesa::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
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::LogicalEventImpl	Implementation of the LogicalEvent
fesa::LogicalEventElement	Used to handle and store all Logical-Event-specific Information which comes from the Instantiation-File
fesa::LogicalEventElementImpl	Implementation of pure virtual class LogicalEventElement
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::NoneContext	This class extends the MultiplexingContext in order to provide a dedicate context for the user event source class
fesa::TimingContext	Specialized context for a RTEvent coming from the TimingEventSource. The implementation is lab specific
fesa::Mutex
fesa::SharedMutex
fesa::MuxSubscriptionMatcher
fesa::SortingParser::Node
fesa::SortingParser::BinaryOperation
fesa::SortingParser::Value
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	Creates threads used for notifications
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	Contains arguments of Property's constructor Used to make the code more readable and to avoid typos
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::RTActionConfig	This structure stores all the necessary information to configure an action
fesa::RTController	This class configures the real time process
fesa::RTEventPayload	It is meant to carry the payload of an Event
fesa::OnSubscriptionRTEventPayload	Payload carried by a RTEvent triggered by a OnSubscriptionEventSource
fesa::RTLayerInfo	Contains information related to the layers in which the schedulers are running
RTSchedulingInfo	This structure contains the information from the design document necessary to create the schedulers
fesa::RTSchedulingUnitRef	Contains information related to the layers in which the schedulers are running
fesa::RWLock
fesa::SharedRWLock
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
fesa::PropertyData	The framework's abstraction of a multiplexed property's data It provides access to the underlying CMW context
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
fesa::MsgQueueFactory	Creation of message queues
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::FieldExpression	This class extends the SortingExpression in order to know if the context matches a field
fesa::IntersectExpression	This class extends the sorting expression in order to check if the context matches the intersection between the two sorting expressions
fesa::UnionExpression	This class extends the sorting expression in order to check if the context matches a composition expression
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::AbstractEventSource	Representation of an event source in the system. Event sources are responsible for firing events and sending them to the right scheduler
fesa::BufferSynchronizer
fesa::MultiThreadedEventSourceProducer
fesa::OnSubscriptionEventSourceProducer
fesa::NotificationConsumer	This class receives notification messages from the notification producer and uses the subscrition tree manager class to nofity the clients
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::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
fesa::PersistencyManager	Management of FESA classes' persistency
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
fesa::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
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