TransferElementAbstractor.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 "TransferElement.h"
#include "TransferElementID.h"
#include "VersionNumber.h"
 
#include <boost/bind/bind.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/thread.hpp>
#include <boost/thread/future.hpp>
 
#include <functional>
#include <list>
#include <string>
#include <typeinfo>
#include <vector>
 
namespace ChimeraTK {
 
  class PersistentDataStorage;
 
  /********************************************************************************************************************/
 
  class TransferElementAbstractor {
   public:
    explicit TransferElementAbstractor(boost::shared_ptr<TransferElement> impl) : _impl(std::move(impl)) {}
 
    TransferElementAbstractor() = default;
 
    [[nodiscard]] const std::string& getName() const { return _impl->getName(); }
 
    [[nodiscard]] const std::string& getUnit() const { return _impl->getUnit(); }
 
    [[nodiscard]] const std::string& getDescription() const { return _impl->getDescription(); }
 
    [[nodiscard]] const std::type_info& getValueType() const { return _impl->getValueType(); }
 
    [[nodiscard]] AccessModeFlags getAccessModeFlags() const { return _impl->getAccessModeFlags(); }
 
    void read() { _impl->read(); }
 
    bool readNonBlocking() { return _impl->readNonBlocking(); }
 
    bool readLatest() { return _impl->readLatest(); }
 
    [[nodiscard]] ChimeraTK::VersionNumber getVersionNumber() const { return _impl->getVersionNumber(); }
 
    bool write(ChimeraTK::VersionNumber versionNumber = {}) { return _impl->write(versionNumber); }
 
    bool writeDestructively(ChimeraTK::VersionNumber versionNumber = {});
 
    [[nodiscard]] bool isReadOnly() const { return _impl->isReadOnly(); }
 
    [[nodiscard]] bool isReadable() const { return _impl->isReadable(); }
 
    [[nodiscard]] bool isWriteable() const { return _impl->isWriteable(); }
 
    std::vector<boost::shared_ptr<TransferElement>> getHardwareAccessingElements();
 
    std::list<boost::shared_ptr<TransferElement>> getInternalElements();
 
    const boost::shared_ptr<TransferElement>& getHighLevelImplElement() { return _impl; }
 
    [[nodiscard]] bool isInitialised() const { return _impl != nullptr; }
 
    void replace(const TransferElementAbstractor& newAccessor) { _impl = newAccessor._impl; }
 
    void replace(boost::shared_ptr<TransferElement> newImpl) { _impl = std::move(newImpl); }
 
    void replaceTransferElement(const boost::shared_ptr<TransferElement>& newElement);
 
    void setPersistentDataStorage(boost::shared_ptr<ChimeraTK::PersistentDataStorage> storage);
 
    [[nodiscard]] TransferElementID getId() const { return _impl->getId(); }
 
    void setDataValidity(DataValidity valid = DataValidity::ok) { _impl->setDataValidity(valid); }
 
    [[nodiscard]] DataValidity dataValidity() const { return _impl->dataValidity(); }
 
    void interrupt() { _impl->interrupt(); }
 
   protected:
    boost::shared_ptr<TransferElement> _impl;
  };
 
  /********************************************************************************************************************/
 
  inline bool TransferElementAbstractor::writeDestructively(ChimeraTK::VersionNumber versionNumber) {
    return _impl->writeDestructively(versionNumber);
  }
 
  /********************************************************************************************************************/
 
} /* namespace ChimeraTK */