TGo4Task.h

Go to the documentation of this file.

// $Id$
//-----------------------------------------------------------------------
//       The GSI Online Offline Object Oriented (Go4) Project
//         Experiment Data Processing at EE department, GSI
//-----------------------------------------------------------------------
// Copyright (C) 2000- GSI Helmholtzzentrum fuer Schwerionenforschung GmbH
//                     Planckstr. 1, 64291 Darmstadt, Germany
// Contact:            http://go4.gsi.de
//-----------------------------------------------------------------------
// This software can be used under the license agreements as stated
// in Go4License.txt file which is part of the distribution.
//-----------------------------------------------------------------------

#ifndef TGO4TASK_H
#define TGO4TASK_H

#include "TGo4ThreadManager.h"
#include "TGo4CommandReceiver.h"
#include "Go4EmergencyCommands.h"
#include "TString.h"

class TMutex;
class TGo4TaskOwner;
class TGo4Slave;
class TGo4Master;
class TGo4BufferQueue;
class TGo4ObjectQueue;
class TGo4TaskHandler;
class TGo4TaskHandlerCommandList;
class TGo4CommandProtoList;
class TGo4Command;
class TGo4Status;
class TGo4TaskStatus;

class TGo4Task : public TGo4ThreadManager, public TGo4CommandReceiver {

public:
    friend class TGo4LocalCommandRunnable; // access to command queue
    friend class TGo4Slave; // access to UpdateStatus
    friend class TGo4TaskOwner; // set workisstopped flag

    TGo4Task(const char *name, Bool_t blockingmode,
                               Bool_t autostart = kFALSE,
                               Bool_t autocreate = kTRUE,
                               Bool_t ismaster = kFALSE);

    virtual ~TGo4Task();

    virtual void Start();

    virtual void Stop();

    virtual void Quit();

    virtual void KillMain();

    virtual void RestartMain();

    void Terminate (Bool_t termapp=kTRUE) override;

    void TerminateFast() override;

    virtual void ExecuteString(const char *command);

    Bool_t IsMaster() const { return fbCommandMaster; }

    void SetOwner(TGo4TaskOwner* owner);

    virtual TGo4TaskHandler *GetTaskHandler() { return nullptr; }

    virtual TGo4BufferQueue *GetCommandQueue(const char *task = nullptr) { return nullptr; }

    virtual TGo4BufferQueue *GetStatusQueue(const char *task = nullptr) { return nullptr; }

    virtual TGo4BufferQueue *GetDataQueue(const char *task = nullptr) { return nullptr; }

    void AddUserCommand(TGo4Command *com);

    void AddUserCommandList(TGo4CommandProtoList *comlist);

    TGo4Status *NextStatus(Bool_t wait = kTRUE);

    TObject *NextObject(Bool_t wait = kTRUE);

    virtual TGo4Command *NextCommand();

    void SendObject(TObject *obj, const char *receiver = nullptr);

    virtual void SendStatus(TGo4Status *stat, const char *receiver = nullptr);

    virtual void SendStatusBuffer();

    TMutex *GetStatusBufferMutex(){return fxStatusMutex;}

    void SendStatusMessage(Int_t level, Bool_t printout, const char *text, ...)
    #if defined(__GNUC__) && !defined(__CINT__)
       __attribute__((format(printf, 4, 5)))
    #endif
    ;

    void UpdateStatusBuffer();

    Int_t Initialization() override;

    virtual TGo4TaskStatus *CreateStatus();

    Bool_t SubmitCommand(const char *name);

    Bool_t SubmitEmergencyCommand(Go4EmergencyCommand_t val);

    Bool_t SubmitEmergencyData(Go4EmergencyCommand_t val, const char *receiver = nullptr);


    Bool_t SubmitLocalCommand(TGo4Command *com);

    Bool_t SubmitCommand(TGo4Command *com);

    TGo4Command *MakeCommand(const char *name);

    void WakeCommandQueue(Int_t id = 0);

    virtual Int_t StartWorkThreads();

    virtual Int_t StopWorkThreads();

    Bool_t IsWorkStopped() const { return fbWorkIsStopped; }

    virtual void GetStatus();

    const char *GetCommanderName() const { return fxCommanderName.Data(); }

    TGo4Master* GetMaster() const { return fxMaster; }

    TGo4Slave* GetSlave() const { return fxSlave; }

    void SendStopBuffers(const char *taskname = nullptr);

    TBuffer *GetAbortBuffer(){return fxAbortBuffer;}

    static Int_t Get_fgiTERMID();

  protected:

    virtual TGo4TaskHandlerCommandList*  CreateCommandList();

    TGo4TaskHandlerCommandList * GetPrototype();

    virtual void UpdateStatus(TGo4TaskStatus *state);

    TGo4ObjectQueue* GetLocalCommandQueue() { return fxLocalCommandQueue; }

    void SetMaster(Bool_t on = kTRUE) { fbCommandMaster = on; }

    void SetWorkIsStopped(Bool_t on) { fbWorkIsStopped = on; }

    TMutex *fxStatusMutex{nullptr}; 

    TBuffer *fxStatusBuffer{nullptr}; 

  private:

    void SetMaster(TGo4Master* m);

    void SetSlave(TGo4Slave* s);

    TGo4TaskHandlerCommandList * fxCommandPrototype{nullptr}; 

    TGo4ObjectQueue* fxLocalCommandQueue{nullptr}; 

    Bool_t fbCommandMaster{kFALSE};

    TString fxCommanderName;

    TGo4Master *fxMaster{nullptr}; 

    TGo4Slave *fxSlave{nullptr}; 

    TGo4TaskOwner *fxOwner{nullptr};

    Bool_t fbWorkIsStopped{kFALSE};

    TBuffer *fxStopBuffer{nullptr}; 

    TBuffer *fxQuitBuffer{nullptr}; 

    TBuffer *fxAbortBuffer{nullptr}; 

    static const Int_t fgiTERMID;

  ClassDefOverride(TGo4Task,1)
};

#endif //TGO4TASK_H