DataConsistencyGroupHistorizedMatcher.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 "DataConsistencyGroupSimpleMatcher.h"
#include "TransferElementAbstractor.h"
 
namespace ChimeraTK {
 
  class ReadAnyGroup;
  class DataConsistencyGroup;
} // namespace ChimeraTK
 
namespace ChimeraTK::DataConsistencyGroupDetail {
 
  /********************************************************************************************************************/
 
  class HistorizedMatcher : public MatcherBase {
   public:
    HistorizedMatcher() = default;
    ~HistorizedMatcher() override;
 
    void add(TransferElementAbstractor& acc, unsigned histLen);
    [[nodiscard]] bool isConsistent();
 
    void updateCalled(const TransferElementID& transferElementID) { _updateCalled = transferElementID; }
 
    [[nodiscard]] const auto& getTargetElements() const { return _targetElements; }
 
    // functions needed by DataConsistencyDecorator:
    bool checkUpdate(const TransferElementID& transferElementID);
    void handleMissingPreReads(TransferElementID callerId);
    void handleMissingPostReads(TransferElementID callerId, bool updateBuffer);
 
    void updateHistory(TransferElementID transferElementID);
    void getMatchingInfo(TransferElementID id, VersionNumber& vs, DataValidity& dv);
    template<typename UserType>
    std::vector<std::vector<UserType>>& getMatchingBuffer(TransferElementID id);
    [[nodiscard]] TransferElementID lastUpdateCall() const { return _updateCalled; }
    [[nodiscard]] VersionNumber lastMatchingVersionNumber() const { return _lastMatchingVersionNumber; }
 
   protected:
    boost::shared_ptr<TransferElement> decorateAccessor(TransferElementAbstractor& acc);
 
    void setupHistory(const TransferElementAbstractor& element, unsigned histLen);
 
    bool findMatch(TransferElementID transferElementID);
 
    template<typename UserType>
    std::vector<std::vector<UserType>>& getUserBuffer(TransferElementID transferElementID);
 
    template<typename UserBufferType>
    std::vector<UserBufferType>* getBufferVector(TransferElementID id) {
      void* buf = _targetElements.at(id).histBuffer;
      return static_cast<std::vector<UserBufferType>*>(buf);
    }
 
    struct TargetElement {
      TransferElementAbstractor acc;
      unsigned histLen = 0;
      void* histBuffer = nullptr;
      const std::type_info& histBufferType;
      std::vector<VersionNumber> versionNumbers;
      std::vector<DataValidity> dataValidities;
      unsigned lastMatchingIndex = 0;
    };
 
    bool _decoratorsNeedPreRead = false;
    bool _handleMissingPreReadsCalled = false;
    bool _handleMissingPostReadsCalled = false;
 
    std::map<TransferElementID, TargetElement> _targetElements;
    VersionNumber _lastMatchingVersionNumber{nullptr};
    TransferElementID _updateCalled; // only for checking usage
  };
 
  /********************************************************************************************************************/
 
  template<typename UserType>
  std::vector<std::vector<UserType>>& HistorizedMatcher::getMatchingBuffer(TransferElementID id) {
    TargetElement& pe = _targetElements.at(id);
    using UserBufferType = std::vector<std::vector<UserType>>;
 
    if(pe.lastMatchingIndex > 0) {
      auto& bufferVector = *(getBufferVector<UserBufferType>(id));
      return bufferVector[pe.lastMatchingIndex - 1];
    }
    return getUserBuffer<UserType>(id);
  }
 
  /********************************************************************************************************************/
 
  template<typename UserType>
  std::vector<std::vector<UserType>>& HistorizedMatcher::getUserBuffer(TransferElementID transferElementID) {
    // note for improvement - we could use ChimeraTK::TemplateUserTypeMap, see e.g. ConfigReader.cc how to use it
    //  this should eliminiate casting and void* pointer
 
    const auto& impl = _targetElements.at(transferElementID).acc.getHighLevelImplElement();
    auto acc0 = boost::dynamic_pointer_cast<NDRegisterAccessor<UserType>>(impl);
    assert(acc0);
    return acc0->accessChannels();
  }
 
  /********************************************************************************************************************/
 
} // namespace ChimeraTK::DataConsistencyGroupDetail