DoocsBackend.h

Go to the documentation of this file.

/*
 * DoocsBackend.h
 *
 *  Created on: Apr 26, 2016
 *      Author: Martin Hierholzer
 */
 
#pragma once
 
#include "RegisterInfo.h"
 
#include <ChimeraTK/async/DataConsistencyRealm.h>
#include <ChimeraTK/DeviceBackendImpl.h>
#include <ChimeraTK/VersionNumber.h>
 
#include <future>
#include <mutex>
 
namespace ChimeraTK {
 
  class DoocsBackendRegisterAccessorBase;
 
  class DoocsBackend : public DeviceBackendImpl {
   public:
    ~DoocsBackend() override;
 
    DoocsBackend(const std::string& serverAddress, const std::string& cacheFile, const std::string& updateCache,
        const std::string& dataConsistencyRealmName);
 
    RegisterCatalogue getRegisterCatalogue() const override;
 
    const DoocsBackendRegisterCatalogue& getBackendRegisterCatalogue() const;
 
    void open() override;
 
    void close() override;
 
    std::string readDeviceInfo() override { return std::string("DOOCS server address: ") + _serverAddress; }
 
    void setExceptionImpl() noexcept override;
 
    static boost::shared_ptr<DeviceBackend> createInstance(
        std::string address, std::map<std::string, std::string> parameters);
 
    template<typename UserType>
    boost::shared_ptr<NDRegisterAccessor<UserType>> getRegisterAccessor_impl(
        const RegisterPath& registerPathName, size_t numberOfWords, size_t wordOffsetInRegister, AccessModeFlags flags);
    DEFINE_VIRTUAL_FUNCTION_TEMPLATE_VTABLE_FILLER(DoocsBackend, getRegisterAccessor_impl, 4);
 
    std::string _serverAddress;
 
    class BackendRegisterer {
     public:
      BackendRegisterer();
    };
    static BackendRegisterer backendRegisterer;
 
    static bool checkZmqAvailability(const std::string& fullLocationPath, const std::string& propertyName);
 
    template<typename UserType>
    friend class DoocsBackendRegisterAccessor;
 
    void informRuntimeError(const std::string& address);
 
    void activateAsyncRead() noexcept override;
 
    std::atomic<bool> _asyncReadActivated{false};
 
    VersionNumber getStartVersion() {
      std::lock_guard<std::mutex> lk(_mxRecovery);
      return _startVersion;
    }
 
    static bool isCommunicationError(int doocs_error);
 
   private:
    std::string _cacheFile;
    std::promise<void> _cancelFlag{};
    mutable std::future<DoocsBackendRegisterCatalogue> _catalogueFuture;
    mutable DoocsBackendRegisterCatalogue catalogue;
    bool _catalogueFromCache{false}; // controls whether open() might re-trigger catalogue filling
 
    bool cacheFileExists();
    bool isCachingEnabled() const;
 
    mutable std::mutex _mxRecovery;
 
    VersionNumber _startVersion{nullptr};
 
    std::string lastFailedAddress;
 
    std::shared_ptr<async::DataConsistencyRealm> _dataConsistencyRealm;
  };
 
} // namespace ChimeraTK