OneDRegisterAccessor.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 "NDRegisterAccessorAbstractor.h"
 
namespace ChimeraTK {
 
  /********************************************************************************************************************/
 
  template<user_type UserType>
  class OneDRegisterAccessor : public NDRegisterAccessorAbstractor<UserType> {
   public:
    // NOLINTNEXTLINE(google-explicit-constructor,hicpp-explicit-conversions)
    OneDRegisterAccessor(boost::shared_ptr<NDRegisterAccessor<UserType>> impl);
 
    OneDRegisterAccessor();
 
    UserType& operator[](unsigned int element) { return get()->accessData(0, element); }
 
    unsigned int getNElements() { return get()->getNumberOfSamples(); }
 
    /* Access data with std::vector-like iterators */
    using iterator = typename std::vector<UserType>::iterator;
    using const_iterator = typename std::vector<UserType>::const_iterator;
    using reverse_iterator = typename std::vector<UserType>::reverse_iterator;
    using const_reverse_iterator = typename std::vector<UserType>::const_reverse_iterator;
    iterator begin() { return get()->accessChannel(0).begin(); }
    const_iterator begin() const { return get()->accessChannel(0).cbegin(); }
    const_iterator cbegin() const { return get()->accessChannel(0).cbegin(); }
    iterator end() { return get()->accessChannel(0).end(); }
    const_iterator end() const { return get()->accessChannel(0).cend(); }
    const_iterator cend() const { return get()->accessChannel(0).cend(); }
    reverse_iterator rbegin() { return get()->accessChannel(0).rbegin(); }
    const_reverse_iterator rbegin() const { return get()->accessChannel(0).crbegin(); }
    const_reverse_iterator crbegin() const { return get()->accessChannel(0).crbegin(); }
    reverse_iterator rend() { return get()->accessChannel(0).rend(); }
    const_reverse_iterator rend() const { return get()->accessChannel(0).crend(); }
    const_reverse_iterator crend() const { return get()->accessChannel(0).crend(); }
 
    void swap(std::vector<UserType>& x) noexcept;
 
    OneDRegisterAccessor<UserType>& operator=(const std::vector<UserType>& x);
 
    // NOLINTNEXTLINE(google-explicit-constructor,hicpp-explicit-conversions)
    operator const std::vector<UserType>&() { return get()->accessChannel(0); }
 
    UserType* data() { return get()->accessChannel(0).data(); }
 
    template<typename COOKED_TYPE>
    COOKED_TYPE getAsCooked(unsigned int sample);
 
    template<typename COOKED_TYPE>
    void setAsCooked(unsigned int sample, COOKED_TYPE value);
 
    void writeIfDifferent(const std::vector<UserType>& newValue, VersionNumber versionNumber = VersionNumber{nullptr},
        DataValidity validity = DataValidity::ok);
 
    friend class TransferGroup;
 
    using NDRegisterAccessorAbstractor<UserType>::get;
  };
 
  /********************************************************************************************************************/
  /********************************************************************************************************************/
 
  template<user_type UserType>
  OneDRegisterAccessor<UserType>::OneDRegisterAccessor(boost::shared_ptr<NDRegisterAccessor<UserType>> impl)
  : NDRegisterAccessorAbstractor<UserType>(impl) {
    static_assert(!std::is_same<UserType, Void>::value,
        "You cannot create OneDRegisterAccessor<ChimeraTK::Void>! Use VoidRegisterAccessor instead.");
 
    if(get()->getNumberOfChannels() != 1) {
      throw ChimeraTK::logic_error(std::string("The OneDRegisterAccessor has a too low ") +
          "dimension to access the register " + impl->getName());
    }
  }
 
  /********************************************************************************************************************/
 
  template<user_type UserType>
  OneDRegisterAccessor<UserType>::OneDRegisterAccessor() {
    static_assert(!std::is_same<UserType, Void>::value,
        "You cannot create OneDRegisterAccessor<ChimeraTK::Void>! Use VoidRegisterAccessor instead.");
  }
 
  /********************************************************************************************************************/
 
  template<user_type UserType>
  void OneDRegisterAccessor<UserType>::swap(std::vector<UserType>& x) noexcept {
    if(x.size() != get()->accessChannel(0).size()) {
      // Do not throw in swap() and rather terminated. See CPP core guidlines C.85
      // https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c85-make-swap-noexcept
      std::cerr << "Swapping with a buffer of a different size is not allowed." << std::endl;
      std::exit(1);
    }
    get()->accessChannel(0).swap(x);
  }
 
  /********************************************************************************************************************/
 
  template<user_type UserType>
  OneDRegisterAccessor<UserType>& OneDRegisterAccessor<UserType>::operator=(const std::vector<UserType>& x) {
    if(x.size() != get()->accessChannel(0).size()) {
      throw ChimeraTK::logic_error("Copying in a buffer of a different size is not allowed.");
    }
    get()->accessChannel(0) = x;
    return *this;
  }
 
  /********************************************************************************************************************/
 
  template<user_type UserType>
  template<typename COOKED_TYPE>
  COOKED_TYPE OneDRegisterAccessor<UserType>::getAsCooked(unsigned int sample) {
    return get()->template getAsCooked<COOKED_TYPE>(0, sample);
  }
 
  /********************************************************************************************************************/
 
  template<user_type UserType>
  template<typename COOKED_TYPE>
  void OneDRegisterAccessor<UserType>::setAsCooked(unsigned int sample, COOKED_TYPE value) {
    return get()->template setAsCooked<COOKED_TYPE>(0, sample, value);
  }
 
  /********************************************************************************************************************/
 
  template<user_type UserType>
  void OneDRegisterAccessor<UserType>::writeIfDifferent(
      const std::vector<UserType>& newValue, VersionNumber versionNumber, DataValidity validity) {
    if(!std::equal(newValue.begin(), newValue.end(), get()->accessChannel(0).begin()) ||
        this->getVersionNumber() == VersionNumber(nullptr) || this->dataValidity() != validity) {
      operator=(newValue);
      if(versionNumber == VersionNumber{nullptr}) versionNumber = {};
      this->setDataValidity(validity);
      this->write(versionNumber);
    }
  }
 
  /********************************************************************************************************************/
 
  // Do not declare the template for all user types as extern here.
  // This could avoid optimisation of the inline code.
 
} // namespace ChimeraTK