DynExp's main namespace contains the implementation of DynExp including classes to manage resources (DynExp objects like hardware adapters, instruments, and modules) as well as their dependencies and parameters.
More...
|
class | ProjectParams |
| Defines a parameter class with parameters common to all DynExp projects. More...
|
|
class | DynExpCore |
| DynExp's core class acts as the interface between the user interface and DynExp's internal data like all DynExp::Object instances and their threads. There should only be one instance of this class. It owns all DynExp resources through the respective ResourceManagerBase instances. Logical const-ness: Non-const functions (like functions to run/stop/reset/save/... the project) cannot be called from DynExp::Object instances possessing a const handle to the DynExpCore instance. Instead, these functions should be called through the user interface (from the DynExpManager instance). More...
|
|
struct | DefaultLocaleSeparator |
| Default number separators used within DynExp. More...
|
|
class | HardwareAdapterParamsBase |
| Parameter class for HardwareAdapterBase . More...
|
|
class | HardwareAdapterConfiguratorBase |
| Configurator class for HardwareAdapterBase . More...
|
|
class | HardwareAdapterBase |
| Defines the base class for a hardware adapter object. Hardware adapters describe interfaces/connections to physical hardware. More...
|
|
class | SerialCommunicationException |
| Defines an exception caused by a serial communication operation of a hardware adapter. More...
|
|
class | SerialCommunicationHardwareAdapterParams |
| Parameter class for SerialCommunicationHardwareAdapter . More...
|
|
class | SerialCommunicationHardwareAdapterConfigurator |
| Configurator class for SerialCommunicationHardwareAdapter . More...
|
|
class | SerialCommunicationHardwareAdapter |
| Defines a hardware adapter for serial communication. Logical const-ness: see declaration of class DynExp::Object. More...
|
|
class | QSerialCommunicationHardwareAdapterParams |
| Parameter class for QSerialCommunicationHardwareAdapter . More...
|
|
class | QSerialCommunicationHardwareAdapterConfigurator |
| Configurator class for QSerialCommunicationHardwareAdapter . More...
|
|
class | QSerialCommunicationHardwareAdapterWorker |
| Qt worker which performs actual serial communication hardware operations in a separate thread in order not to interfer with processor time used to update the user interface. All functions are inherently thead-safe since they are only called by the worker thread the respective instance of this class lives in. More...
|
|
class | QSerialCommunicationHardwareAdapter |
| SerialCommunicationHardwareAdapter is based on a Qt communication object (wrapped by QSerialCommunicationHardwareAdapterWorker ) which cannot be shared between different threads. Instead, it lives in a DynExpCore's worker thread. QSerialCommunicationHardwareAdapter just pushes messages to it and allows the QSerialCommunicationHardwareAdapterWorker instance to communicate its state and data to the corresponding QSerialCommunicationHardwareAdapter instance. More...
|
|
class | NetworkException |
| Defines an exception caused by a hardware operation on an ethernet interface (e.g. reading/writing data to a TCP socket). More...
|
|
class | NetworkParamsExtension |
| Bundles several parameters to describe a network connection. Use in parameter classes. More...
|
|
class | HardwareAdapterTcpSocketParams |
| Parameter class for HardwareAdapterTcpSocket . More...
|
|
class | HardwareAdapterTcpSocketConfigurator |
| Configurator class for HardwareAdapterTcpSocket . More...
|
|
class | HardwareAdapterTcpSocketWorker |
| Qt worker for network communication in a separate thread. More...
|
|
class | HardwareAdapterTcpSocket |
| Implements a hardware adapter to communicate with text-based commands over TCP sockets. More...
|
|
class | SerialPortException |
| Defines an exception caused by a hardware operation on a COM port (e.g. reading/writing data to a COM port). More...
|
|
class | HardwareAdapterSerialPortParams |
| Parameter class for HardwareAdapterSerialPort . More...
|
|
class | HardwareAdapterSerialPortConfigurator |
| Configurator class for HardwareAdapterSerialPort . More...
|
|
class | HardwareAdapterSerialPortWorker |
| Qt worker for serial/COM port communication in a separate thread. More...
|
|
class | HardwareAdapterSerialPort |
| Implements a hardware adapter to communicate with text-based commands over COM ports. More...
|
|
class | ExceptionContainer |
| Wrapper holding a pointer to an exception and providing functionality for accessing it. Used to transfer exceptions between an instrument's task and the ModuleBase module enqueuing the task. Refer to TaskBase::CallbackType. More...
|
|
class | InstrumentDataBase |
| Data structure to contain data which is synchronized in between different threads. This is needed since the instrument thread, the threads of different modules, as well as the main thread might access the instrument at the same time. Every class (indirectly) derived from class InstrumentBase must be accompanied by a instrument data class derived from InstrumentDataBase . InstrumentDataBase and derived classes contain data shared by the respective instrument, module and main threads. Data only used by the instrument itself should be private members of the instrument class. More...
|
|
class | InstrumentParamsBase |
| Parameter class for InstrumentBase . More...
|
|
class | InstrumentConfiguratorBase |
| Configurator class for InstrumentBase . More...
|
|
class | InstrumentBase |
| Base class for instruments. Instruments comprise virtual devices (meta instruments) and physial devices (instruments). While meta instruments are used by modules (ModuleBase ) as an abstraction layer, physical instruments derive from meta instruments and make usually use of one hardware adapter (HardwareAdapterBase ) to communicate with the underlying hardware. More...
|
|
class | InstrumentInstance |
| Defines data for a thread belonging to a InstrumentBase instance. Refer to RunnableInstance . More...
|
|
class | TaskResultType |
| Defines the return type of task functions. More...
|
|
class | TaskBase |
| Base class for all tasks being processed by instruments. The class must not contain public virtual functions since TaskBase::CallbackFunc could call them in TaskBase's destructor. More...
|
|
class | DefaultTask |
| Default task which does not do anything. Though, calling it ensures that TaskBase::CallbackFunc gets called. This is required to avoid InstrumentBase::AsSyncTask() getting stuck in an infinite loop. All functions overridden from meta instruments, which are expected to enqueue a task, must at least enqueue a DefaultTask (by calling MakeAndEnqueueTask< DynExp::DefaultTask >(CallbackFunc) ;) More...
|
|
class | InitTaskBase |
| Defines a task for initializing an instrument within an instrument inheritance hierarchy. Each instrument (indirectly) derived from class InstrumentBase must be accompanied by an initialization task class derived from InitTaskBase . Even if the task does not do anything, at least it has to call InitTaskBase::InitFuncImpl() of the derived instrument's initialization task class. More...
|
|
class | ExitTaskBase |
| Defines a task for deinitializing an instrument within an instrument inheritance hierarchy. Each instrument (indirectly) derived from class InstrumentBase must be accompanied by a deinitialization task class derived from ExitTaskBase . Even if the task does not do anything, at least it has to call ExitTaskBase::ExitFuncImpl() of the derived instrument's deinitialization task class. More...
|
|
class | UpdateTaskBase |
| Defines a task for updating an instrument within an instrument inheritance hierarchy. Each instrument (indirectly) derived from class InstrumentBase must be accompanied by an update task class derived from UpdateTaskBase . Even if the task does not do anything, at least it has to call UpdateTaskBase::UpdateFuncImpl() of the derived instrument's update task class. More...
|
|
class | ArriveAtLatchTask |
| Defines a task which arrives at a std::latch when it is executed. This is useful to synchronize multiple instruments and make their execution block until a set of instruments has arrived at the latch. Refer to InstrumentBase::EnqueueArriveAtLatchTask() and to WaitForInstruments() . More...
|
|
class | LibraryObjectFactoryParamList |
| Type consisting of function pointer types instantiating DynExp objects. Refer to DynExp::LibraryObjectFactoryPtrType. More...
|
|
class | LibraryConfigFactoryParamList |
| Type consisting of function pointer types returning configurators for DynExp objects. Refer to DynExp::ConfiguratorBasePtrType. More...
|
|
class | LibraryStringParamList |
| Type consisting of function pointer types returning string literals. Refer to DynExp::LibraryStringParamPtrType. More...
|
|
struct | LibraryEntry |
| Represents an entry in the library. More...
|
|
class | LibraryBase |
| Represents the base class for a library containing library entries (DynExp::LibraryEntry). More...
|
|
class | LibraryBase< ObjectTypeBasePtr, LibraryObjectFactoryParamList< ObjectTypeBasePtr, ObjFactories... >, LibraryConfigFactoryParamList< ConfFactories... >, LibraryStringParamList< NameFuncs... >, LibraryStringParamList< CategoryFuncs... > > |
| Represents the specialized base class for a library containing library entries (DynExp::LibraryEntry). More...
|
|
class | HardwareAdapterLibrary |
| Represents a hardware adapter library to generate instances of classes derived from DynExp::HardwareAdapterBase. More...
|
|
class | InstrumentLibrary |
| Represents an instrument library to generate instances of classes derived from DynExp::InstrumentBase. More...
|
|
class | ModuleLibrary |
| Represents a module library to generate instances of classes derived from DynExp::ModuleBase. More...
|
|
struct | Resource |
| Defines a DynExp resource, which mainly owns a DynExp::Object instance wrapping a pointer to it. More...
|
|
class | CommonResourceManagerBase |
| Common base class for all derived ResourceManagerBase classes. Logical const-ness: Only const functions can be called from objects possessing a const handle to the DynExpCore instance. To protect the resource manager, some functions which should be non-const by that argument (ResourceManagerBase::Startup(), ResourceManagerBase::Shutdown(), ResourceManagerBase::ResetFailedResources()) are still const. These functions indirectly call Object::EnsureCallFromOwningThread() to ensure that they are only called by the main user interface thread (from the DynExpManager instance through its DynExpCore instance). Also refer to DynExpCore . More...
|
|
class | ResourceManagerBase |
| Typed resource manager base class deriving from class CommonResourceManagerBase . More...
|
|
class | HardwareAdapterManager |
| Resource manager for HardwareAdapterBase resources deriving from a specialized ResourceManagerBase class. More...
|
|
class | InstrumentManager |
| Resource manager for InstrumentBase resources deriving from a specialized ResourceManagerBase class. More...
|
|
class | ModuleManager |
| Resource manager for ModuleBase resources deriving from a specialized ResourceManagerBase class. More...
|
|
class | EventBase |
| Common base class for all events to store them in a FIFO queue to be invoked later. More...
|
|
class | DefaultEvent |
| Describes an event which consists of a receiver's member function and a set of arguments to call this function with. The first argument is expected to be of type ModuleInstance* . This argument is not included in ArgTupleType ). More...
|
|
class | ModuleDataBase |
| Data structure to contain data which is synchronized in between different threads. This is needed since the module thread as well as the main thread might access the module at the same time. Every class (indirectly) derived from class ModuleBase must be accompanied by a module data class derived from ModuleDataBase . ModuleDataBase and derived classes contain data shared by the respective module thread and the user interface (main) thread to e.g. visualize data. Data only used by the module thread should be private members of the module class. Data only used by the user interface should be private members of the module's widget class (derived from QModuleWidget ), respectively. More...
|
|
class | ModuleParamsBase |
| Parameter class for ModuleBase . More...
|
|
class | ModuleConfiguratorBase |
| Configurator class for ModuleBase . More...
|
|
class | ModuleBase |
| Base class for modules. Modules implement programs on their own (e.g. measurement protocols or servers for ethernet communication). They might have a user interface. Modules make use of meta instruments (InstrumentBase ) to implement e.g. measurement routines on a higher level, which renders the modules independent from physical devices from specific manufacturers. Derive from this class to implement modules without a user interface. More...
|
|
class | ModuleInstance |
| Defines data for a thread belonging to a ModuleBase instance. Refer to RunnableInstance . More...
|
|
class | EventListenersBase |
| Common base class for all managers of event listeners of type TypedEventListeners . ModuleBase instances are considered event listeners. More...
|
|
class | TypedEventListeners |
| Typed managers of event listeners class whose instances are owned by classes derived from InterModuleEvent . The class maps modules registering/subscribing to inter-module events to the respective event functions which are invoked when the related event occurs. More...
|
|
class | InterModuleEventBase |
| Common base class for all inter-module events. More...
|
|
class | InterModuleEvent |
| Typed base class for inter-module events to realize CRTP. More...
|
|
class | QModuleWidget |
| Window class for Qt-based user interfaces belonging to DynExp modules. User interface Qt window classes belonging to a module derived from ModuleBase have to derive from this class. More...
|
|
class | QModuleDockWidget |
| Provides a frame for QModuleWidget windows, which are undocked from the DynExpManager's QMdiArea. More...
|
|
class | QModuleDataBase |
| Data class for QModuleBase . More...
|
|
class | WindowStyleParamsExtension |
| Bundles several parameters to describe a UI window's style. Use in parameter classes. More...
|
|
class | QModuleParamsBase |
| Parameter class for QModuleBase . More...
|
|
class | QModuleConfiguratorBase |
| Configurator class for QModuleBase . More...
|
|
class | QModuleBase |
| Base class for modules with a Qt-based user interface. Derive from this class to implement modules with a user interface. More...
|
|
class | ObjectLink |
| Type to define object link parameters as ParamsBase::Param< ObjectLink< ObjectT > > or to define object link list parameters as ParamsBase::ListParam< ObjectLink< ObjectT > >. Such parameters own (one or multiple) ObjectLink instances and assign a resource to each instance. ObjectLink instances hold a std::weak_ptr to the resource and lock this weak_ptr if requested returning a respective LinkedObjectWrapper instance. A new resource can be assigned to an ObjectLink instance while LinkedObjectWrapper(s) exist since they hold an independent shared_ptr to the resource they have been created from. ObjectLink does not need to be thread-safe itself. All operations on it are performed through the respective ParamsBase::Param or ParamsBase::ListParam instance. To operate on those instances, the ParamsBase instance owning the respective parameter needs to be locked which renders ObjectLink implicitely thread-safe. More...
|
|
struct | ManagerTypeOfObjectType |
| Type trait relating a type ObjectType derived from either class HardwareAdapterBase or class InstrumentBase to the resource manager type (derived from DynExp::CommonResourceManagerBase) managing instances of the type ObjectType . More...
|
|
class | ObjectUserList |
| Helper class to enable keeping track of instances of class Object making use of the owner of the respective ObjectUserList's instance. Instances of class Object can register or deregister multiple times as an user which increments or decrements their respective registration count in ObjectUserList::UserList. More...
|
|
class | LinkBase |
| Abstract base class of link parameters (to be saved in project files) describing relations between multiple Object (e.g. a module making use of an instrument). More...
|
|
class | ParamsBase |
| Abstract base class for object parameter classes. Each class derived from class Object must be accompanied by a parameter class derived from ParamsBase . These parameter classes are intended to contain the object's parameters (sub-classes of ParamsBase::ParamBase ) which are stored in DynExp project files and which can be configured in the respective object instance's settings dialog or programmatically. Parameter classes are synchronized in between different threads (e.g. the main thread and an instrument/module thread). More...
|
|
class | ConfiguratorBase |
| The configurator classes have the task to generate parameter objects (refer to DynExp::ParamsBase) of the corresponding type for DynExp objects DynExp::Object. For each class derived from DynExp::Object, there must be a respective configurator derived from ConfiguratorBase. More...
|
|
class | Object |
| Base class for all DynExp Objects like hardware adapters (DynExp::HardwareAdapterBase), instruments (DynExp::InstrumentBase) and modules (DynExp::ModuleBase). Subclasses should also derive either form Util::INonCopyable or Util::ILockable since Object is not intended to be copied. Especially, it must not be moved to another thread (than the one creating it). Logical const-ness: const member functions can be called by other threads, non-const functions are visible only to main thread. More...
|
|
class | RunnableObjectParams |
| Parameter class for RunnableObject . More...
|
|
class | RunnableObjectConfigurator |
| Configurator class for RunnableObject . More...
|
|
class | RunnableObject |
| Defines an Object which possesses a thread it runs in. The RunnableObject can be started and stopped as well as paused and resumed. More...
|
|
class | LinkedObjectWrapperBase |
| Polymorphic base class to allow storing LinkedObjectWrapper of any type in a single list. More...
|
|
class | LinkedObjectWrapper |
| Holds a shared_ptr to a resource (instance of class Object ) and lets the resource keep track of its usage count by increasing a respective counter of the resource on construction and by decreasing the counter on destruction of the LinkedObjectWrapper instance again. Not copyable in order not to mess up the usage counter stored in LinkedObjectWrapper::DestinyResource. Only accessed via a thread's instance of class RunnableInstance in that thread. Also refer to RunnableInstance . More...
|
|
class | LinkedObjectWrapperPointer |
| This class describes a pointer to a LinkedObjectWrapper instance. It is a simple wrapper class which only adds specific behavior like always returning a const pointer to a LinkedObjectWrapper instance wrapping a const Object instance. More...
|
|
class | LinkedObjectWrapperContainerBase |
| Polymorphic base class to allow storing LinkedObjectWrapperContainer of any type in a single list. More...
|
|
class | LinkedObjectWrapperContainer |
| This class holds a pointer (LinkedObjectWrapperPointer ) to a LinkedObjectWrapper . Intances of this class should be owned by classes derived from class InstrumentDataBase or class ModuleDataBase . These instances provide access to objects referenced by object link parameters. LinkedObjectWrapperContainer does not own the referenced LinkedObjectWrapper . The LinkedObjectWrapper itself is owned by class RunnableInstance . The pointer hold here is also set and managed by class RunnableInstance . Also refer to class RunnableInstance . More...
|
|
class | LinkedObjectWrapperContainerList |
| This class defines a list of LinkedObjectWrapperContainer instances. The list owns the contained LinkedObjectWrapperContainer instances. Intances of this class should be owned by classes derived from class InstrumentDataBase or class ModuleDataBase . These instances provide access to objects referenced by object link list parameters (ListParam ). The list's entries are exclusively managed by the respective instance of class RunnableInstance . RunnableInstance stores references to list entries. Every list manipulation RunnableInstance is not aware of might cause dangling references! More...
|
|
class | ObjectLinkBase |
| Base class for object link parameter types to allow SFINAE in ParamsBase::Param for ObjectLink of any type. More...
|
|
class | RunnableInstance |
| Defines data for a thread belonging to a RunnableObject instance. This data is only accessed by the RunnableObject instance's thread. So, no synchronization mechanism is needed. Furthermore, this class is designed to exist only on the stack. RunnableInstance instances are to be passed as a parameter to the respective thread functions. This ensures that a RunnableInstance instances is deleted when its thread function returns. This class is responsible for locking an object link (list) parameter (ParamsBase::Param< ObjectLink< ObjectT > > or ParamsBase::ListParam< ObjectLink< ObjectT > >) hold by a class derived (indirectly) from class ParamsBase and for storing the locked resource in a LinkedObjectWrapper instance. In turn, the created LinkedObjectWrapper instance is stored in a LinkedObjectWrapperContainer instance hold by a class derived (indirectly) from InstrumentDataBase or from ModuleDataBase . Furthermore, this class is responsible for unlocking LinkedObjectWrapper instances it created. Unlocking is triggered either on request or on destruction of the RunnableInstance instance owning the LinkedObjectWrapper instance. More...
|
|
|
template<typename HardwareAdapterT > |
ConfiguratorBasePtrType | MakeHardwareAdapterConfig () |
| Factory function to generate a configurator for a specific hardware adapter type. More...
|
|
template<typename HardwareAdapterT > |
HardwareAdapterPtrType | MakeHardwareAdapter (const std::thread::id OwnerThreadID, ParamsBasePtrType &&Params) |
| Factory function to generate a hardware adapter of a specific type. More...
|
|
int | InstrumentThreadMain (InstrumentInstance Instance, InstrumentBase *const Instrument) |
| Instruments run in their own thread. This is the instrument thread's main function. More...
|
|
template<typename InstrumentT > |
ConfiguratorBasePtrType | MakeInstrumentConfig () |
| Factory function to generate a configurator for a specific instrument type. More...
|
|
template<typename InstrumentT > |
InstrumentPtrType | MakeInstrument (const std::thread::id OwnerThreadID, ParamsBasePtrType &&Params) |
| Factory function to generate an instrument of a specific type. More...
|
|
template<typename TaskT , typename... ArgTs> |
std::unique_ptr< TaskT > | MakeTask (ArgTs &&...Args) |
| Factory function to create a task to be enqueued in an instrument's task queue. More...
|
|
template<typename To , typename From , std::enable_if_t< std::is_same_v< InstrumentDataBase, std::remove_cv_t< From >>, int > = 0> |
auto | dynamic_InstrumentData_cast (Util::SynchronizedPointer< From > &&InstrumentDataPtr) |
| Casts the data base class From into a derived InstrumentBase's (To ) data class keeping the data locked by Util::SynchronizedPointer for thread-safe casting. More...
|
|
template<typename... InstrTs> |
void | WaitForInstruments (InstrTs &... Instruments) |
| Blocks until every instrument passed to the function as a reference parameter has arrived at a synchronization point. More...
|
|
template<typename LibraryVectorT > |
const LibraryVectorT::value_type & | FindInLibraryVector (const LibraryVectorT &LibraryVector, const std::string &Category, const std::string &Name) |
| Finds an entry in a library vector by category and name. More...
|
|
int | ModuleThreadMain (ModuleInstance Instance, ModuleBase *const Module) |
| Modules run in their own thread. This is the module thread's main function. More...
|
|
template<typename ModuleT > |
ConfiguratorBasePtrType | MakeModuleConfig () |
| Factory function to generate a configurator for a specific module type. More...
|
|
template<typename ModuleT > |
ModulePtrType | MakeModule (const std::thread::id OwnerThreadID, ParamsBasePtrType &&Params) |
| Factory function to generate a module of a specific type. More...
|
|
template<typename ReceiverType , typename... ArgsTs> |
auto | MakeEvent (ReceiverType *Receiver, typename DefaultEvent< ReceiverType, std::tuple< std::remove_reference_t< ArgsTs >... >>::EventFuncPtrType EventFuncPtr, ArgsTs &&...Args) |
| Creates an event of type DefaultEvent . More...
|
|
template<typename To , typename From , std::enable_if_t< std::is_same_v< ModuleDataBase, std::remove_cv_t< From >>, int > = 0> |
auto | dynamic_ModuleData_cast (Util::SynchronizedPointer< From > &&ModuleDataPtr) |
| Casts the data base class From into a derived ModuleBase's (To ) data class keeping the data locked by Util::SynchronizedPointer for thread-safe casting. More...
|
|
template<typename ParamType > |
auto | operator== (const ParamsBase::TypedParamBase< ParamType > &lhs, const ParamType &rhs) |
| Provides (in)equality comparison operators for two parameters. Since C++20, inequality operators (operator!=) are generated by compiler. More...
|
|
template<typename ParamType > |
auto | operator<=> (const ParamsBase::TypedParamBase< ParamType > &lhs, const ParamType &rhs) |
| Provides three-way comparison for two parameters. More...
|
|
template<typename ConfiguratorT > |
ParamsBasePtrType | MakeParams (ItemIDType ID, const DynExpCore &Core) |
| Factory function to generate an Object's parameters. More...
|
|
template<typename T > |
T::ParamsType * | dynamic_Params_cast (ParamsBasePtrType::element_type *Params) |
| Casts the parameter base class to a derived Object's parameter class. More...
|
|
template<typename To , typename From , std::enable_if_t< std::is_same_v< ParamsBase, std::remove_cv_t< From >>, int > = 0> |
auto | dynamic_Params_cast (Util::SynchronizedPointer< From > &&ParamsPtr) |
| Casts the parameter base class From to a derived Object's (To ) parameter class keeping the parameters locked by Util::SynchronizedPointer for thread-safe casting. More...
|
|
template<typename To , typename From , std::enable_if_t< std::is_base_of_v< Object, To > &&std::is_base_of_v< Object, From >, int > = 0> |
auto | dynamic_Object_cast (From *Obj) |
| Casts an Object to a derived type. More...
|
|
DynExp's main namespace contains the implementation of DynExp including classes to manage resources (DynExp objects like hardware adapters, instruments, and modules) as well as their dependencies and parameters.
DynExp's main namespace contains DynExp's core functionality.