create a status object with information on the current client state. this object may be sent to the server or may be used to restore current status by memento mechanism.
create a status object with information on the current client state. this object may be sent to the server or may be used to restore current status by memento mechanism
create a status object with information on the current (slave) task. this object may be sent to the master or may be used to restore current status by memento mechanism
create a status object with information on the current (slave) task. this object may be sent to the master or may be used to restore current status by memento mechanism
create a status object with information on the current taskhandler state. this object may be sent to the server or may be used to restore current status by memento mechanism
create a status object with information on the current client state. this object may be sent to the server or may be used to restore current status by memento mechanism.
True if the last specified client is removed from server. flag is set by connector thread who performs the DisconnectClient of TaskManager; is reset by WaitForClientRemoved method.
This flag indicates the main state of the task: either master (sends commands, receives data and status), or slave (receives commands and may send date and status)
On Termination, Notify will test fgiTERMWAITCYCLES times if Runnables are stopped, i.e. all TGo4Threads are in TCondition wait (safe cancelling point); afterwards, threads are deleted anyway
time in ms to wait for all Runnables being stopped before Termination; after this time, the AllWaiting() of TGo4ThreadHandler is tested again, until the max number of testing cycles (fgiTERMWAITCYCLES) is reached; then Termination is done anyway
mode number which can be used to create runnables with different actions in Workfunc; useful for testing without creating new subclasses of runnable...
Mutex to protect IsOperating flag, flag is set kTRUE to indicate that AppControl timer must not block, since thread launching or canceling operation is performed by thread handler.
link to external threadhandler which is used for the transport service threads (runnables); these runnables are instantiated from the task handler ctor and passed to the thread handler who takes over the responsibility for the runnables (threadhandler internal mode threads)
True if the analysis as controlled by slave process is running. if no slave task (analysis client) is available, always true (plain batch mode never stops) Test: read by reference than copy value, faster?
Get nameslist object from client. basename, password,host and portnumber may be specified at any time new if left out (default), the previously stored values are used
Get object by name from client. basename, password, host and portnumber may be specified at any time new if left out (default), the previously stored values are used
Checks duplicates in axis numbers, associated to different gaussian dimensions. leaveaixs (if specified) sets dimension number, which will be unchanged.
Replace default painter of this condition by external one. if different views of this condition shall exist for different TPads, the painter (i.e. view) can be exchanged before pad is updated.
Replace default painter of this condition by external one. if different views of this condition shall exist for different TPads, the painter (i.e. view) can be exchanged before pad is updated.
Replace default painter of this condition by external one. if different views of this condition shall exist for different TPads, the painter (i.e. view) can be exchanged before pad is updated.
Replace default painter of this condition by external one. if different views of this condition shall exist for different TPads, the painter (i.e. view) can be exchanged before pad is updated.
Set save flag for saving of object in slot, when slot stored to streamer: 0 - object will be saved if it owned, 1 - object always will be saved 2 - object never will be saved.
Set value from string expression to a certain memory address. expression will be converted according the memtype, and then copied to the location at address.
start the working threads of the task implementation; this method is used after the current connection has changed, to continue reading/writing the queues.
Start the working threads of the task owner implementation; this method is used after the current connection has changed, to continue reading/writing the queues.
stop the working threads of the task implementation; this method is used before the current connection is changed to prevent reading/writing and waiting for the wrong queues.
stop the working threads of the task owne implementation; this method is used before the current connection is changed to prevent reading/writing and waiting for the wrong queues.
This class controls a client application running in a task which is controlled by another server task via transport channels which are held by a task handler object.
This class controls a client application running in a task which is controlled by another server task via transport channels which are held by a task handler object.
Creates new object of class name on client side.Object will be kept in directory which matches to its base type, e.g in condition directory if it inherits from condition, in data index dir if inherits from TGo4EventDataIndex, etc.
Command to request basic status information on the client task; the reqest may be carried out by the command runnable that submits a system status object into the status queue; otherwise a concrete client runnable may submit any special status object into the queue on this command
Class that knows Command Object; When Client gets the Command it is passed to the Invoker who sets the CommandClient as receiver and calls its Execute method.
Runnable responsible for command exchange between transport (socket) and buffer (queue) In receiver mode, commands are received from transport, checked if sync or not, the command receiver of system (client) commands is set to the clienttask, sync commands are executed directly, async commands are passed to the queue in not receiver mode, runnables waits for the queue and sends all commands from the queue over the transport
Command calling the virtual method Start() of Client Task class; this method is overridden by user client, thus any start action of the application may be invoked by this (e.g. start of analysis main event loop)
Command calling the virtual method Stop() of Client Task class; this method is overridden by user client, thus any stop action of the application may be invoked by this (e.g. stop of analysis main event loop)
Exception Class responsible for runtime control actions: Exception mechanism is used as command pattern here; concrete exceptions act on single threads or the thread manager
Runnable responsible for data object exchange between transport (socket) and buffer (queue) In receiver mode, data objects are received from transport and passed to the queue in non receiver mode, runnables waits for the queue and sends all data objects from the queue over the transport
Example application class; this class may also run as standalone application without the threaded client-server mechanism (e.g. as later analysis class)
Example class for a client application; this may be the analysis client later on which keeps the analysis class itself as aggregate and provides threads to work on analysis
example class for a user control interface (might be a kind of GUI later on); methods of this class are used to request commands from the user and to display results which are sent by the client
Exception with default handler which removes TGo4Thread of given name from the threadhandlerlist of given TGo4Runnable (usually the exception throwing runnable) and deletes it; if no threadname is specified, the respective thread of the runnable is removed
Runnable responsible for status object exchange between transport (socket) and buffer (queue) In receiver mode, status objects are received from transport and passed to the queue in non receiver mode, runnables waits for the queue and sends all status objects from the queue over the transport
This class is responsible for the interconnection of two tasks: provided are three communication channels (data, command, status), one thread runnable is acting on each transport channel (e.g. socket); one queue (buffer) is assigned to each channel depending on client or server mode of the task handler, the threads get objects from transporl and put them into the queue, or vice versa.
Class containing all command prototypes of the TaskHandler system commands (and the basic test commands); may be derived by application or user command list class which can add own commands into the list using AddCommand Method of TGo4CommandProtoList Base Class
TGo4Thread constructor parameters: name: name of the thread runnable: external user runnable to be executed from TThread. internal: define if thread shall be owned by threadmanager, or if it belongs to other aggregation
Thread Handler holds array of Go4Thread Objects; each Go4Thread handles one TThread and Mutex, Condition... knows threadmanager instance that owns the handler (that owns the task connector which owns the thread handler, respectively) this threadmanager instance pointer is given to each thread and runnable on creation, thus each thread can acces its manager methods by threadmanager pointer
ctor parameters: blockingmode=true: gApplication is blocked by timer autostart=true: all thread runnables start their work on Initialization() autocreate=true: all threads added to handler in threadmanager ctor are created on Launch()
This method is used by the object connectortimer Notify to connect or disconnect a transportchannel (TSocket) on demand; the connection process itself is handled by the connector runnable
this method is used by the connectortimer Notify to connect or disconnect a transportchannel (TSocket) on demand; the connection process itself is handled by the connector runnable which uses services of the TaskManager class
TQRootGuiFactory As TRootGuiFactory from the ROOT library, this class uses the services of the general ABC TGuiFactory in order to get Qt Native GUI components instead of the ROOT ones.
Wakes up the control timer waiting for his condition; parameter mode specifies whether timer will block again at next turn (mode=0), timer will block when all threads are up (mode=1), or timer will not block again unless the next Block call, i.e. applicationrun flag is reset (mode=2)