LNMBackendRegisterInfo.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 "BackendRegisterInfoBase.h"
#include "ForwardDeclarations.h"
#include "RegisterInfo.h"
#include "TransferElement.h"
 
#include <boost/shared_ptr.hpp>
 
#include <mutex>
 
namespace ChimeraTK {
 
  namespace LNMBackend {
    class AccessorPluginBase;
  } // namespace LNMBackend
 
  class LNMBackendRegisterInfo : public BackendRegisterInfoBase {
   public:
    enum TargetType { INVALID, REGISTER, CHANNEL, BIT, CONSTANT, VARIABLE };
 
    LNMBackendRegisterInfo() = default;
    LNMBackendRegisterInfo(const LNMBackendRegisterInfo&) = default;
    LNMBackendRegisterInfo& operator=(const LNMBackendRegisterInfo& other) = default;
 
    [[nodiscard]] RegisterPath getRegisterName() const override { return name; }
 
    [[nodiscard]] unsigned int getNumberOfElements() const override { return length; }
 
    [[nodiscard]] unsigned int getNumberOfChannels() const override { return nChannels; }
 
    [[nodiscard]] const DataDescriptor& getDataDescriptor() const override { return _dataDescriptor; }
 
    [[nodiscard]] bool isReadable() const override { return readable; }
 
    [[nodiscard]] bool isWriteable() const override { return writeable; }
 
    [[nodiscard]] AccessModeFlags getSupportedAccessModes() const override { return supportedFlags; }
 
    RegisterPath name;
 
    TargetType targetType{TargetType::INVALID};
 
    std::string deviceName;
 
    std::string registerName;
 
    unsigned int firstIndex{};
 
    unsigned int length{};
 
    unsigned int channel{};
 
    unsigned int bit{};
 
    unsigned int nChannels{};
 
    DataType valueType;
 
    //    /** Hold values of CONSTANT or VARIABLE types in a type-dependent table. Only the entry matching the valueType
    //     *  is actually valid.
    //     *  Note: We cannot directly put the std::vector in a TemplateUserTypeMap, since it has more than one template
    //     *  arguments (with defaults). */
    //    template<typename T>
    //    struct ValueTable {
    //      std::vector<T> latestValue;
    //      DataValidity latestValidity;
    //      VersionNumber latestVersion;
    //      struct QueuedValue {
    //        std::vector<T> value;
    //        DataValidity validity;
    //        VersionNumber version;
    //      };
    //      std::map<TransferElementID, cppext::future_queue<QueuedValue>> subscriptions;
    //    };
    //    TemplateUserTypeMap<ValueTable> valueTable;
 
    //    /** Mutex one needs to hold while accessing valueTable. */
    //    std::mutex valueTable_mutex;
 
    bool readable{};
 
    bool writeable{};
 
    AccessModeFlags supportedFlags;
 
    std::vector<boost::shared_ptr<LNMBackend::AccessorPluginBase>> plugins;
 
    DataDescriptor _dataDescriptor;
 
    [[nodiscard]] std::unique_ptr<BackendRegisterInfoBase> clone() const override {
      return std::make_unique<LNMBackendRegisterInfo>(*this);
    }
  };
  /********************************************************************************************************************/
 
  /*class LNMRegisterCatalogue : public BackendRegisterCatalogue<LNMBackendRegisterInfo> {
    public:
      LNMRegisterCatalogue() = default;
      LNMRegisterCatalogue& operator=(const LNMRegisterCatalogue& other) = default;
      LNMRegisterCatalogue(const LNMRegisterCatalogue&) = default;
  };*/
 
  /********************************************************************************************************************/
} /* namespace ChimeraTK */