ScalarRegisterAccessor.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 <type_traits>
 
namespace ChimeraTK {
 
  /********************************************************************************************************************/
 
  template<user_type UserType, typename TAG = std::nullptr_t>
  class ScalarRegisterAccessor : public NDRegisterAccessorAbstractor<UserType> {
   public:
    // NOLINTNEXTLINE(google-explicit-constructor,hicpp-explicit-conversions)
    ScalarRegisterAccessor(boost::shared_ptr<NDRegisterAccessor<UserType>> impl);
 
    ScalarRegisterAccessor();
 
    // NOLINTNEXTLINE(google-explicit-constructor,hicpp-explicit-conversions)
    operator UserType&() { return get()->accessData(0, 0); }
 
    // NOLINTNEXTLINE(google-explicit-constructor,hicpp-explicit-conversions)
    operator const UserType&() const { return get()->accessData(0, 0); }
 
    template<typename OTHER_TAG>
    // NOLINTNEXTLINE(google-explicit-constructor,hicpp-explicit-conversions)
    operator ScalarRegisterAccessor<UserType, OTHER_TAG>&();
 
    template<typename OTHER_TAG>
    // NOLINTNEXTLINE(google-explicit-constructor,hicpp-explicit-conversions)
    operator const ScalarRegisterAccessor<UserType, OTHER_TAG>&() const {
      return *this;
    }
 
    ScalarRegisterAccessor& operator=(UserType rightHandSide);
 
    ScalarRegisterAccessor& operator++() { return operator=(get()->accessData(0, 0) + 1); }
 
    ScalarRegisterAccessor& operator--() { return operator=(get()->accessData(0, 0) - 1); }
 
    UserType operator++(int);
 
    UserType operator--(int);
 
    template<typename COOKED_TYPE>
    COOKED_TYPE getAsCooked();
 
    template<typename COOKED_TYPE>
    void setAsCooked(COOKED_TYPE value);
 
    void writeIfDifferent(UserType newValue, VersionNumber versionNumber = VersionNumber{nullptr},
        DataValidity validity = DataValidity::ok);
 
    void setAndWrite(UserType newValue, VersionNumber versionNumber = {});
 
    UserType readAndGet();
 
    friend class TransferGroup;
 
    using NDRegisterAccessorAbstractor<UserType>::get;
  };
 
  /********************************************************************************************************************/
 
  // Template specialisation for string. It does not have the ++ and -- operators
  template<>
  class ScalarRegisterAccessor<std::string> : public NDRegisterAccessorAbstractor<std::string> {
   public:
    // NOLINTNEXTLINE(google-explicit-constructor,hicpp-explicit-conversions)
    ScalarRegisterAccessor(boost::shared_ptr<NDRegisterAccessor<std::string>> impl);
 
    ScalarRegisterAccessor() = default;
 
    // NOLINTNEXTLINE(google-explicit-constructor,hicpp-explicit-conversions)
    operator std::string&();
 
    ScalarRegisterAccessor<std::string>& operator=(std::string rightHandSide);
 
    template<typename COOKED_TYPE>
    COOKED_TYPE getAsCooked();
 
    template<typename COOKED_TYPE>
    void setAsCooked(COOKED_TYPE value);
 
    void writeIfDifferent(const std::string& newValue, VersionNumber versionNumber = VersionNumber{nullptr},
        DataValidity dataValidity = DataValidity::ok);
 
    void setAndWrite(const std::string& newValue, VersionNumber versionNumber = {});
 
    std::string readAndGet();
 
    friend class TransferGroup;
  };
 
  /********************************************************************************************************************/
 
  template<>
  class ScalarRegisterAccessor<ChimeraTK::Boolean, std::nullptr_t>
  : public ScalarRegisterAccessor<ChimeraTK::Boolean, void> {
   public:
    using ScalarRegisterAccessor<ChimeraTK::Boolean, void>::ScalarRegisterAccessor;
    using ScalarRegisterAccessor<ChimeraTK::Boolean, void>::operator=;
 
    // NOLINTNEXTLINE(google-explicit-constructor,hicpp-explicit-conversions)
    operator const bool&() const { return get()->accessData(0, 0); }
 
    // NOLINTNEXTLINE(google-explicit-constructor,hicpp-explicit-conversions)
    operator bool&() { return get()->accessData(0, 0); }
  };
 
  /********************************************************************************************************************/
  /********************************************************************************************************************/
 
  template<user_type UserType, typename TAG>
  ScalarRegisterAccessor<UserType, TAG>::ScalarRegisterAccessor(boost::shared_ptr<NDRegisterAccessor<UserType>> impl)
  : NDRegisterAccessorAbstractor<UserType>(impl) {
    static_assert(!std::is_same<UserType, Void>::value,
        "You cannot create ScalarRegisterAccessor<ChimeraTK::Void>! Use VoidRegisterAccessor instead.");
  }
 
  /********************************************************************************************************************/
 
  template<user_type UserType, typename TAG>
  ScalarRegisterAccessor<UserType, TAG>::ScalarRegisterAccessor() {
    static_assert(!std::is_same<UserType, Void>::value,
        "You cannot create ScalarRegisterAccessor<ChimeraTK::Void>! Use VoidRegisterAccessor instead.");
  }
 
  /********************************************************************************************************************/
 
  template<user_type UserType, typename TAG>
  template<typename OTHER_TAG>
  // NOLINTNEXTLINE(google-explicit-constructor,hicpp-explicit-conversions)
  ScalarRegisterAccessor<UserType, TAG>::operator ScalarRegisterAccessor<UserType, OTHER_TAG>&() {
    return *this;
  }
 
  /********************************************************************************************************************/
 
  template<user_type UserType, typename TAG>
  ScalarRegisterAccessor<UserType, TAG>& ScalarRegisterAccessor<UserType, TAG>::operator=(UserType rightHandSide) {
    get()->accessData(0, 0) = rightHandSide;
    return *this;
  }
 
  /********************************************************************************************************************/
 
  template<user_type UserType, typename TAG>
  UserType ScalarRegisterAccessor<UserType, TAG>::operator++(int) {
    UserType v = get()->accessData(0, 0);
    operator=(v + 1);
    return v;
  }
 
  /********************************************************************************************************************/
 
  template<user_type UserType, typename TAG>
  UserType ScalarRegisterAccessor<UserType, TAG>::operator--(int) {
    UserType v = get()->accessData(0, 0);
    operator=(v - 1);
    return v;
  }
 
  /********************************************************************************************************************/
 
  template<user_type UserType, typename TAG>
  template<typename COOKED_TYPE>
  COOKED_TYPE ScalarRegisterAccessor<UserType, TAG>::getAsCooked() {
    return get()->template getAsCooked<COOKED_TYPE>(0, 0);
  }
 
  /********************************************************************************************************************/
 
  template<user_type UserType, typename TAG>
  template<typename COOKED_TYPE>
  void ScalarRegisterAccessor<UserType, TAG>::setAsCooked(COOKED_TYPE value) {
    return get()->template setAsCooked<COOKED_TYPE>(0, 0, value);
  }
 
  /********************************************************************************************************************/
 
  template<user_type UserType, typename TAG>
  void ScalarRegisterAccessor<UserType, TAG>::writeIfDifferent(
      UserType newValue, VersionNumber versionNumber, DataValidity validity) {
    if(get()->accessData(0, 0) != newValue || this->getVersionNumber() == VersionNumber(nullptr) ||
        this->dataValidity() != validity) {
      operator=(newValue);
      if(versionNumber == VersionNumber{nullptr}) {
        versionNumber = {};
      }
      this->setDataValidity(validity);
      this->write(versionNumber);
    }
  }
 
  /********************************************************************************************************************/
 
  template<user_type UserType, typename TAG>
  void ScalarRegisterAccessor<UserType, TAG>::setAndWrite(UserType newValue, VersionNumber versionNumber) {
    operator=(newValue);
    this->write(versionNumber);
  }
 
  /********************************************************************************************************************/
 
  template<user_type UserType, typename TAG>
  UserType ScalarRegisterAccessor<UserType, TAG>::readAndGet() {
    this->read();
    return get()->accessData(0, 0);
  }
 
  /********************************************************************************************************************/
  /********************************************************************************************************************/
 
  inline ScalarRegisterAccessor<std::string>::ScalarRegisterAccessor(
      boost::shared_ptr<NDRegisterAccessor<std::string>> impl)
  : NDRegisterAccessorAbstractor<std::string>(std::move(impl)) {}
 
  /********************************************************************************************************************/
 
  inline ScalarRegisterAccessor<std::string>::operator std::string&() {
    return boost::static_pointer_cast<NDRegisterAccessor<std::string>>(_impl)->accessData(0, 0);
  }
 
  /********************************************************************************************************************/
 
  inline ScalarRegisterAccessor<std::string>& ScalarRegisterAccessor<std::string>::operator=(
      std::string rightHandSide) {
    boost::static_pointer_cast<NDRegisterAccessor<std::string>>(_impl)->accessData(0, 0) = std::move(rightHandSide);
    return *this;
  }
 
  /********************************************************************************************************************/
 
  template<typename COOKED_TYPE>
  COOKED_TYPE ScalarRegisterAccessor<std::string>::getAsCooked() {
    return get()->template getAsCooked<COOKED_TYPE>(0, 0);
  }
 
  /********************************************************************************************************************/
 
  template<typename COOKED_TYPE>
  void ScalarRegisterAccessor<std::string>::setAsCooked(COOKED_TYPE value) {
    return get()->template setAsCooked<COOKED_TYPE>(0, 0, value);
  }
 
  /********************************************************************************************************************/
 
  inline void ScalarRegisterAccessor<std::string>::writeIfDifferent(
      const std::string& newValue, VersionNumber versionNumber, DataValidity validity) {
    if(get()->accessData(0, 0) != newValue || this->getVersionNumber() == VersionNumber(nullptr) ||
        this->dataValidity() != validity) {
      operator=(newValue);
      if(versionNumber == VersionNumber{nullptr}) versionNumber = {};
      this->setDataValidity(validity);
      this->write(versionNumber);
    }
  }
 
  /********************************************************************************************************************/
 
  inline void ScalarRegisterAccessor<std::string>::setAndWrite(
      const std::string& newValue, VersionNumber versionNumber) {
    operator=(newValue);
    this->write(versionNumber);
  }
 
  /********************************************************************************************************************/
 
  inline std::string ScalarRegisterAccessor<std::string>::readAndGet() {
    this->read();
    return get()->accessData(0, 0);
  }
 
  /********************************************************************************************************************/
  // Do not declare the template for all user types as extern here.
  // This could avoid optimisation of the inline code.
 
} // namespace ChimeraTK