RsaServer.h

Go to the documentation of this file.

#pragma once
#include <gii/gen/InformationServer.h>
#include <rsa/iface/RsaTypes.h>
#include <rsa/iface/global.h>
 
namespace sf
{
 
class RsaInterface;
class _RSA_CLASS RsaServer final
  : public InformationServer
  , public RsaTypes
{
  public:
    explicit RsaServer(int compatible, id_type deviceNumber, const std::string& serverName = {});
 
    ~RsaServer() override;
 
    [[nodiscard]] std::string getServerName() const;
 
    bool createImplementation(const std::string& name);
 
    [[nodiscard]] std::string getImplementationName() const;
 
    void destroyImplementation()
    {
      createImplementation(-1);
    }
 
    RsaInterface* getAcquisition()
    {
      return _acquisition;
    }
 
    [[nodiscard]] bool isLocked() const
    {
      return _lock;
    }
 
    void setLocked(bool);
 
  protected:
    bool createImplementation(int index);
 
    void createInterface();
 
    void destroyInterface();
 
    [[nodiscard]] Variable::PtrVector::size_type variableListFind(id_type id) const;
 
    bool createVariable(Variable*& var, RsaTypes::ParamInfo& info, const std::string& setup);
 
    void destroyVariable(Variable* var);
 
    std::string createSetupString(const RsaTypes::ParamInfo& info, long vid);
 
    void evaluateInterfaceParams();
 
    std::string getNameOffset(const RsaTypes::ParamInfo& info);
 
    std::string getDescription(const RsaTypes::ParamInfo& info);
 
    [[nodiscard]] ResultData::PtrVector::size_type resultListFind(id_type id) const;
 
    bool createResultData(ResultData*& res, RsaTypes::ResultInfo& info, const std::string& setup);
 
    void destroyResultData(ResultData* var);
 
    std::string createSetupString(const RsaTypes::ResultInfo& info, long vid);
 
    void evaluateInterfaceResults();
 
    std::string getNameOffset(const RsaTypes::ResultInfo& info);
 
    std::string getDescription(const RsaTypes::ResultInfo& info);
 
    struct ExtraInfo
    {
        unsigned _channel;
        IdType _id;
        std::string _setupString;
        int _flags;
    };
 
    ExtraInfo* castExtraInfo(const Variable* var);
 
    ExtraInfo* castExtraInfo(const ResultData* var);
 
    void onStateChange(EState prevState, EState nextState) override;
 
    void paramNotify(id_type id);
 
    void resultNotify(id_type id);
 
    void checkReadOnly();
 
    static void paramNotifyProc(void* data, id_type id);
 
    static void resultNotifyProc(void* data, id_type id);
 
    void clearValidations() override;
    RsaInterface* _acquisition;
    Variable _vImplementation;
    TVariableHandler<RsaServer> _serverVariableHandler;
    void serverVariableHandler(Variable::EEvent event, const Variable& caller, Variable& linker, bool sameInst);
    Variable::PtrVector _variableVector;
    TResultDataHandler<RsaServer> _serverResultDataHandler;
    void serverResultDataHandler(ResultData::EEvent event, const ResultData& caller, ResultData& link, const Range& rng, bool same_inst);
    ResultData::PtrVector _resultVector;
    IdType _deviceNumber;
    IdType _implementationId;
    int _compatible;
    std::string _serverName;
    bool _lock;
    IdType _handledParamId;
};
 
}// namespace sf