LogicalNameMappingBackend.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Deutsches Elektronen-Synchrotron DESY, MSK, ChimeraTK Project <chimeratk-support@desy.de>
// SPDX-License-Identifier: LGPL-3.0-or-later
#pragma once
 
#include "BackendRegisterCatalogue.h"
#include "DeviceBackendImpl.h"
#include "LNMBackendRegisterInfo.h"
#include "LNMVariable.h"
 
#include <mutex>
#include <unordered_set>
#include <utility>
 
namespace ChimeraTK {
 
  class LogicalNameMappingBackend : public DeviceBackendImpl {
   public:
    explicit LogicalNameMappingBackend(std::string lmapFileName = "");
 
    void open() override;
 
    void close() override;
 
    std::string readDeviceInfo() override { return std::string("Logical name mapping file: ") + _lmapFileName; }
 
    static boost::shared_ptr<DeviceBackend> createInstance(
        std::string address, std::map<std::string, std::string> parameters);
 
    RegisterCatalogue getRegisterCatalogue() const override;
 
    void setExceptionImpl() noexcept override;
 
    void activateAsyncRead() noexcept override;
 
    template<typename UserType>
    boost::shared_ptr<NDRegisterAccessor<UserType>> getRegisterAccessor_impl(const RegisterPath& registerPathName,
        size_t numberOfWords, size_t wordOffsetInRegister, AccessModeFlags flags, size_t omitPlugins = 0);
 
    template<typename UserType>
    boost::shared_ptr<NDRegisterAccessor<UserType>> getRegisterAccessor_internal(
        const RegisterPath& registerPathName, size_t numberOfWords, size_t wordOffsetInRegister, AccessModeFlags flags);
 
    std::set<DeviceBackend::BackendID> getInvolvedBackendIDs() override;
 
    void parse() const;
 
    mutable bool hasParsed;
 
    std::string _lmapFileName;
 
    mutable std::map<std::string, boost::shared_ptr<DeviceBackend>> _devices;
 
    std::map<std::string, std::string> _parameters;
 
    mutable BackendRegisterCatalogue<LNMBackendRegisterInfo> _catalogue_mutable;
    // mutable LNMRegisterCatalogue _catalogue_mutable;
    mutable bool catalogueCompleted{false};
 
    template<typename UserType>
    struct SharedAccessor {
      boost::weak_ptr<NDRegisterAccessor<UserType>> accessor;
      std::recursive_mutex mutex;
    };
 
    using AccessorKey = std::pair<DeviceBackend*, RegisterPath>;
    template<typename UserType>
    using SharedAccessorMap = std::map<AccessorKey, SharedAccessor<UserType>>;
    TemplateUserTypeMap<SharedAccessorMap> sharedAccessorMap;
    std::mutex sharedAccessorMap_mutex;
 
    mutable std::map<std::string /*name*/, LNMVariable> _variables;
 
    template<typename T>
    friend class LNMBackendRegisterAccessor;
 
    template<typename T>
    friend class LNMBackendChannelAccessor;
 
    template<typename T>
    friend class LNMBackendBitAccessor;
 
    template<typename T>
    friend class LNMBackendVariableAccessor;
 
    std::atomic<bool> _asyncReadActive{false};
 
    std::unordered_set<std::string> getTargetDevices() const;
 
   private:
    // A version number created when opening the backend. All variables will report this version number until they are
    // changed for the first time after opening the device.
    std::atomic<ChimeraTK::VersionNumber> _versionOnOpen{ChimeraTK::VersionNumber{nullptr}};
 
   public:
    ChimeraTK::VersionNumber getVersionOnOpen() const;
  };
 
} // namespace ChimeraTK