NDRegisterAccessor.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 "Exception.h"
#include "ForwardDeclarations.h"
#include "TransferElement.h"
#include "VirtualFunctionTemplate.h"
 
#include <boost/container/static_vector.hpp>
#include <boost/make_shared.hpp>
 
namespace ChimeraTK {
 
  template<user_type UserType>
  class NDRegisterAccessor : public TransferElement {
   public:
    NDRegisterAccessor(std::string const& name, AccessModeFlags accessModeFlags,
        std::string const& unit = std::string(TransferElement::unitNotSet),
        std::string const& description = std::string())
    : TransferElement(name, accessModeFlags, unit, description) {
      TransferElement::makeUniqueId();
      FILL_VIRTUAL_FUNCTION_TEMPLATE_VTABLE(getAsCooked_impl);
      FILL_VIRTUAL_FUNCTION_TEMPLATE_VTABLE(setAsCooked_impl);
    }
 
    UserType& accessData(size_t sample) { return buffer_2D[0][sample]; }
    const UserType& accessData(size_t sample) const { return buffer_2D[0][sample]; }
 
    UserType& accessData(unsigned int channel, unsigned int sample) { return buffer_2D[channel][sample]; }
    const UserType& accessData(unsigned int channel, unsigned int sample) const { return buffer_2D[channel][sample]; }
 
    std::vector<UserType>& accessChannel(unsigned int channel) { return buffer_2D[channel]; }
    const std::vector<UserType>& accessChannel(unsigned int channel) const { return buffer_2D[channel]; }
 
    std::vector<std::vector<UserType>>& accessChannels() { return buffer_2D; }
    const std::vector<std::vector<UserType>>& accessChannels() const { return buffer_2D; }
 
    unsigned int getNumberOfSamples() const { return buffer_2D[0].size(); }
 
    unsigned int getNumberOfChannels() const { return buffer_2D.size(); }
 
    const std::type_info& getValueType() const override { return typeid(UserType); }
 
    template<typename COOKED_TYPE>
    COOKED_TYPE getAsCooked(unsigned int channel, unsigned int sample) const;
    DEFINE_VIRTUAL_FUNCTION_TEMPLATE_VTABLE(getAsCooked_impl, T const(unsigned int, unsigned int));
    template<typename COOKED_TYPE>
    COOKED_TYPE getAsCooked_impl(unsigned int channel, unsigned int sample) const;
 
    template<typename COOKED_TYPE>
    void setAsCooked(unsigned int channel, unsigned int sample, COOKED_TYPE value);
    DEFINE_VIRTUAL_FUNCTION_TEMPLATE_VTABLE(setAsCooked_impl, void(unsigned int, unsigned int, T));
    template<typename COOKED_TYPE>
    void setAsCooked_impl(unsigned int channel, unsigned int sample, COOKED_TYPE value);
 
    boost::shared_ptr<TransferElement> makeCopyRegisterDecorator() override;
 
    [[nodiscard]] virtual boost::shared_ptr<NDRegisterAccessor<UserType>> decorateDeepInside(
        [[maybe_unused]] std::function<boost::shared_ptr<NDRegisterAccessor<UserType>>(
            const boost::shared_ptr<NDRegisterAccessor<UserType>>&)> factory) {
      return {};
    }
 
    struct Buffer {
      Buffer(size_t nChannels, size_t nElements) : value(nChannels) {
        for(auto& channel : value) channel.resize(nElements);
      }
 
      Buffer() = default;
 
      Buffer(Buffer&& other) noexcept
      : value(std::move(other.value)), versionNumber(other.versionNumber), dataValidity(other.dataValidity) {}
 
      Buffer& operator=(Buffer&& other) noexcept {
        value = std::move(other.value);
        versionNumber = other.versionNumber;
        dataValidity = other.dataValidity;
        return *this;
      }
 
      std::vector<std::vector<UserType>> value;
 
      ChimeraTK::VersionNumber versionNumber{nullptr};
 
      ChimeraTK::DataValidity dataValidity{ChimeraTK::DataValidity::ok};
    };
 
   protected:
    std::vector<std::vector<UserType>> buffer_2D;
    // boost::container::vector<boost::container::vector<UserType>> buffer_2D;
 
    friend class RegisterAccessor;
 
    DEFINE_VIRTUAL_FUNCTION_TEMPLATE_VTABLE_FILLER(NDRegisterAccessor<UserType>, getAsCooked_impl, 2);
    DEFINE_VIRTUAL_FUNCTION_TEMPLATE_VTABLE_FILLER(NDRegisterAccessor<UserType>, setAsCooked_impl, 3);
  };
 
  template<user_type UserType>
  template<typename COOKED_TYPE>
  COOKED_TYPE NDRegisterAccessor<UserType>::getAsCooked(unsigned int channel, unsigned int sample) const {
    return CALL_VIRTUAL_FUNCTION_TEMPLATE(getAsCooked_impl, COOKED_TYPE, channel, sample);
  }
 
  template<user_type UserType>
  template<typename COOKED_TYPE>
  COOKED_TYPE NDRegisterAccessor<UserType>::getAsCooked_impl(unsigned int /*channel*/, unsigned int /*sample*/) const {
    throw ChimeraTK::logic_error("Reading as cooked is not available for this accessor");
  }
 
  template<user_type UserType>
  template<typename COOKED_TYPE>
  void NDRegisterAccessor<UserType>::setAsCooked(unsigned int channel, unsigned int sample, COOKED_TYPE value) {
    CALL_VIRTUAL_FUNCTION_TEMPLATE(setAsCooked_impl, COOKED_TYPE, channel, sample, value);
  }
 
  template<user_type UserType>
  template<typename COOKED_TYPE>
  void NDRegisterAccessor<UserType>::setAsCooked_impl(
      unsigned int /*channel*/, unsigned int /*sample*/, COOKED_TYPE /*value*/) {
    throw ChimeraTK::logic_error("Setting as cooked is not available for this accessor");
  }
 
  DECLARE_TEMPLATE_FOR_CHIMERATK_USER_TYPES(NDRegisterAccessor);
 
} /* namespace ChimeraTK */