Device.cc

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
 
#include "Device.h"
 
#include "DeviceBackend.h"
 
#include <cmath>
#include <cstring>
 
namespace ChimeraTK {
 
  /********************************************************************************************************************/
 
  Device::Device(const std::string& aliasName) {
    BackendFactory& factoryInstance = BackendFactory::getInstance();
    _deviceBackendPointer = factoryInstance.createBackend(aliasName);
  }
  Device::Device(const std::string& aliasName) {…}
 
  /********************************************************************************************************************/
 
  RegisterCatalogue Device::getRegisterCatalogue() const {
    checkPointersAreNotNull();
    return _deviceBackendPointer->getRegisterCatalogue();
  }
  RegisterCatalogue Device::getRegisterCatalogue() const  {…}
 
  /********************************************************************************************************************/
 
  MetadataCatalogue Device::getMetadataCatalogue() const {
    checkPointersAreNotNull();
    return _deviceBackendPointer->getMetadataCatalogue();
  }
  MetadataCatalogue Device::getMetadataCatalogue() const  {…}
 
  /********************************************************************************************************************/
 
  std::string Device::readDeviceInfo() const {
    checkPointersAreNotNull();
    return _deviceBackendPointer->readDeviceInfo();
  }
  std::string Device::readDeviceInfo() const  {…}
 
  /********************************************************************************************************************/
 
  void Device::checkPointersAreNotNull() const {
    if(!static_cast<bool>(_deviceBackendPointer)) {
      throw ChimeraTK::logic_error("Device has not been opened correctly");
    }
  }
  void Device::checkPointersAreNotNull() const  {…}
 
  /********************************************************************************************************************/
 
  void Device::open() {
    checkPointersAreNotNull();
    _deviceBackendPointer->open();
  }
  void Device::open() {…}
 
  /********************************************************************************************************************/
 
  void Device::open(std::string const& aliasName) {
    BackendFactory& factoryInstance = BackendFactory::getInstance();
    _deviceBackendPointer = factoryInstance.createBackend(aliasName);
    _deviceBackendPointer->open();
  }
  void Device::open(std::string const& aliasName) {…}
 
  /********************************************************************************************************************/
 
  void Device::close() {
    checkPointersAreNotNull();
    _deviceBackendPointer->close();
  }
  void Device::close() {…}
 
  /********************************************************************************************************************/
 
  bool Device::isOpened() const {
    if(static_cast<bool>(_deviceBackendPointer)) {
      return _deviceBackendPointer->isOpen();
    }
    return false; // no backend is assigned: the device is not opened
  }
  bool Device::isOpened() const  {…}
 
  /********************************************************************************************************************/
 
  bool Device::isFunctional() const {
    if(static_cast<bool>(_deviceBackendPointer)) {
      return _deviceBackendPointer->isFunctional();
    }
    return false; // no backend is assigned: the device is not opened
  }
  bool Device::isFunctional() const  {…}
 
  /********************************************************************************************************************/
 
  void Device::activateAsyncRead() noexcept {
    _deviceBackendPointer->activateAsyncRead();
  }
  void Device::activateAsyncRead() noexcept {…}
 
  /********************************************************************************************************************/
 
  void Device::setException(const std::string& message) {
    _deviceBackendPointer->setException(message);
  }
  void Device::setException(const std::string& message) {…}
 
  /********************************************************************************************************************/
 
  VoidRegisterAccessor Device::getVoidRegisterAccessor(
      const RegisterPath& registerPathName, const AccessModeFlags& flags) const {
    checkPointersAreNotNull();
    return {_deviceBackendPointer->getRegisterAccessor<Void>(registerPathName, 0, 0, flags)};
  }
  VoidRegisterAccessor Device::getVoidRegisterAccessor( {…}
 
  /********************************************************************************************************************/
 
  boost::shared_ptr<DeviceBackend> Device::getBackend() {
    return _deviceBackendPointer;
  }
  boost::shared_ptr<DeviceBackend> Device::getBackend() {…}
 
  /********************************************************************************************************************/
 
  std::set<DeviceBackend::BackendID> Device::getInvolvedBackendIDs() {
    checkPointersAreNotNull();
    return _deviceBackendPointer->getInvolvedBackendIDs();
  }
  std::set<DeviceBackend::BackendID> Device::getInvolvedBackendIDs() {…}
 
  /*******************************************************************************************************************/
 
} // namespace ChimeraTK