TwoDRegisterAccessor.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"
 
#include <boost/smart_ptr.hpp>
 
namespace ChimeraTK {
 
  /********************************************************************************************************************/
 
  template<class UserType>
  class TwoDRegisterAccessor : public NDRegisterAccessorAbstractor<UserType> {
   public:
    // NOLINTNEXTLINE(google-explicit-constructor,hicpp-explicit-conversions)
    TwoDRegisterAccessor(boost::shared_ptr<NDRegisterAccessor<UserType>> _accessor);
 
    TwoDRegisterAccessor();
 
    std::vector<UserType>& operator[](size_t channel) { return get()->accessChannel(channel); }
 
    const std::vector<UserType>& operator[](size_t channel) const { return get()->accessChannel(channel); }
 
    TwoDRegisterAccessor<UserType>& operator=(const std::vector<std::vector<UserType>>& other);
 
    [[nodiscard]] size_t getNChannels() const { return get()->getNumberOfChannels(); }
 
    [[nodiscard]] size_t getNElementsPerChannel() const { return get()->getNumberOfSamples(); }
 
    template<typename COOKED_TYPE>
    COOKED_TYPE getAsCooked(unsigned int channel, unsigned int sample) const;
 
    template<typename COOKED_TYPE>
    void setAsCooked(unsigned int channel, unsigned int sample, COOKED_TYPE value);
 
    friend class TransferGroup;
 
    using NDRegisterAccessorAbstractor<UserType>::get;
  };
 
  /********************************************************************************************************************/
  /********************************************************************************************************************/
 
  template<class UserType>
  TwoDRegisterAccessor<UserType>::TwoDRegisterAccessor(boost::shared_ptr<NDRegisterAccessor<UserType>> _accessor)
  : NDRegisterAccessorAbstractor<UserType>(_accessor) {
    static_assert(!std::is_same<UserType, Void>::value,
        "You cannot create TwoDRegisterAccessor<ChimeraTK::Void>! Use VoidRegisterAccessor instead.");
  }
 
  /********************************************************************************************************************/
 
  template<class UserType>
  TwoDRegisterAccessor<UserType>::TwoDRegisterAccessor() {
    static_assert(!std::is_same<UserType, Void>::value,
        "You cannot create TwoDRegisterAccessor<ChimeraTK::Void>! Use VoidRegisterAccessor instead.");
  }
 
  /********************************************************************************************************************/
 
  template<class UserType>
  TwoDRegisterAccessor<UserType>& TwoDRegisterAccessor<UserType>::operator=(
      const std::vector<std::vector<UserType>>& other) {
    get()->accessChannels() = other;
    return *this;
  }
 
  /********************************************************************************************************************/
 
  template<class UserType>
  template<typename COOKED_TYPE>
  COOKED_TYPE TwoDRegisterAccessor<UserType>::getAsCooked(unsigned int channel, unsigned int sample) const {
    return get()->template getAsCooked<COOKED_TYPE>(channel, sample);
  }
 
  /********************************************************************************************************************/
 
  template<class UserType>
  template<typename COOKED_TYPE>
  void TwoDRegisterAccessor<UserType>::setAsCooked(unsigned int channel, unsigned int sample, COOKED_TYPE value) {
    return get()->template setAsCooked<COOKED_TYPE>(channel, sample, value);
  }
 
  /********************************************************************************************************************/
 
  // Do not declare the template for all user types as extern here.
  // This could avoid optimisation of the inline code.
 
} // namespace ChimeraTK