FEVInterfacesManager.h

#ifndef _ots_FEVInterfacesManager_h_
#define _ots_FEVInterfacesManager_h_
 
#include <map>
#include <memory>
#include <mutex>
#include <queue>
#include <string>
#include "otsdaq/Configurable/Configurable.h"
#include "otsdaq/FECore/FEVInterface.h"
#include "otsdaq/FiniteStateMachine/VStateMachine.h"
 
namespace ots
{
class FEVInterfacesManager : public Configurable, public VStateMachine
{
  public:
    FEVInterfacesManager(const ConfigurationTree& theXDAQContextConfigTree,
                         const std::string&       supervisorConfigurationPath);
    virtual ~FEVInterfacesManager(void);
 
    void init(void);
    void destroy(void);
    void createInterfaces(void);
 
    virtual void        configure(void) override;
    virtual void        halt(void) override;
    virtual void        pause(void) override;
    virtual void        resume(void) override;
    virtual void        start(std::string runNumber) override;
    virtual void        stop(void) override;
    virtual std::string getStatusProgressDetail(
        void) override;  
 
    void        universalRead(const std::string& interfaceID,
                              char*              address,
                              char*              returnValue);  
    void        universalWrite(const std::string& interfaceID,
                               char*              address,
                               char*              writeValue);                   
    std::string getFEListString(const std::string& supervisorLid);  
    std::string getFEMacrosString(
        const std::string& supervisorName,
        const std::string& supervisorLid);  
    void runFEMacro(
        const std::string&                         interfaceID,
        const FEVInterface::frontEndMacroStruct_t& feMacro,
        const std::string&                         inputArgs,
        std::string& outputArgs);  
    void runFEMacro(const std::string& interfaceID,
                    const std::string& feMacroName,
                    const std::string& inputArgs,
                    std::string&       outputArgs);  
    void runMacro(const std::string& interfaceID,
                  const std::string& macroObjectString,
                  const std::string& inputArgs,
                  std::string&       outputArgs);  
    void runFEMacroByFE(
        const std::string& callingInterfaceID,
        const std::string& interfaceID,
        const std::string& feMacroName,
        const std::string& inputArgs,
        std::string&       outputArgs);  
    void startFEMacroMultiDimensional(
        const std::string& requester,
        const std::string& interfaceID,
        const std::string& feMacroName,
        const bool         enableSavingOutput,
        const std::string& outputFilePath,
        const std::string& outputFileRadix,
        const std::string& inputArgs);  
    void startMacroMultiDimensional(
        const std::string& requester,
        const std::string& interfaceID,
        const std::string& macroName,
        const std::string& macroString,
        const bool         enableSavingOutput,
        const std::string& outputFilePath,
        const std::string& outputFileRadix,
        const std::string& inputArgs);  
    bool checkMacroMultiDimensional(
        const std::string& interfaceID,
        const std::string& macroName);  
 
    unsigned int getInterfaceUniversalAddressSize(
        const std::string& interfaceID);  
    unsigned int getInterfaceUniversalDataSize(
        const std::string& interfaceID);              
    bool                allFEWorkloopsAreDone(void);  
    const FEVInterface& getFEInterface(const std::string& interfaceID) const;
 
    const std::map<std::string /*name*/, std::unique_ptr<FEVInterface> >& getFEInterfaces(
        void) const
    {
        return theFEInterfaces_;
    }
    FEVInterface* getFEInterfaceP(const std::string& interfaceID);
 
    std::mutex frontEndCommunicationReceiveMutex_;
    std::map<std::string /*targetInterfaceID*/,  
             std::map<std::string /*requester*/, std::queue<std::string /*value*/> > >
        frontEndCommunicationReceiveBuffer_;
 
    std::mutex macroMultiDimensionalDoneMutex_;
    std::map<std::string /*targetInterfaceID*/,  
             std::string /*status := Active, Done, Error: <message> */>
        macroMultiDimensionalStatusMap_;
 
  private:
    std::map<std::string /*name*/, std::unique_ptr<FEVInterface> > theFEInterfaces_;
    std::vector<std::string /*name*/>                              theFENamesByPriority_;
 
    std::map<std::string /*name*/, bool /*isDone*/> stateMachinesIterationDone_;
    unsigned int                                    stateMachinesIterationWorkCount_;
    unsigned int                                    subIterationWorkStateMachineIndex_;
    void preStateMachineExecution(unsigned int i, const std::string& transitionName);
    bool postStateMachineExecution(unsigned int i);
    void preStateMachineExecutionLoop(void);
    void postStateMachineExecutionLoop(void);
};
 
}  // namespace ots
 
#endif