DataConsistencyGroup.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 "TransferElementAbstractor.h"
#include "VersionNumber.h"
#include <unordered_set>
 
namespace ChimeraTK {
 
  /********************************************************************************************************************/
 
  class DataConsistencyGroup {
   public:
    DataConsistencyGroup();
 
    DataConsistencyGroup(std::initializer_list<TransferElementAbstractor> list);
    DataConsistencyGroup(std::initializer_list<boost::shared_ptr<TransferElement>> list);
 
    template<typename ITERATOR>
    DataConsistencyGroup(ITERATOR first, ITERATOR last);
 
    void add(const TransferElementAbstractor& element);
    void add(boost::shared_ptr<TransferElement> element);
 
    bool update(const TransferElementID& transferelementid);
 
    enum class MatchingMode {
      none, 
      exact 
    };
 
    void setMatchingMode(MatchingMode newMode) { mode = newMode; }
 
    MatchingMode getMatchingMode() const { return mode; };
 
    const std::map<TransferElementID, TransferElementAbstractor>& getElements() const { return push_elements; }
 
    bool isConsistent() const { return consistentElements.size() == push_elements.size(); }
 
   private:
    std::unordered_set<TransferElementID> consistentElements;
 
    std::unordered_set<TransferElementID> lasteSateOfConsistentElements;
 
    VersionNumber versionNumberToBeConsistentTo{nullptr};
 
    std::map<TransferElementID, TransferElementAbstractor> push_elements;
 
    MatchingMode mode{MatchingMode::exact};
  };
 
  /********************************************************************************************************************/
 
  template<typename ITERATOR>
  DataConsistencyGroup::DataConsistencyGroup(ITERATOR first, ITERATOR last) {
    for(auto it = first; it != last; ++it) add(*it);
  }
 
  /********************************************************************************************************************/
 
  inline bool DataConsistencyGroup::update(const TransferElementID& transferElementID) {
    // ignore transferElementID does not belong to DataConsistencyGroup
    if(push_elements.find(transferElementID) == push_elements.end()) {
      return false;
    }
    // if matching mode is none, always return true
    if(mode == MatchingMode::none) return true;
    assert(mode == MatchingMode::exact);
 
    auto getVNFromElement = push_elements[transferElementID].getVersionNumber();
    assert(getVNFromElement != VersionNumber{nullptr});
    if(getVNFromElement < versionNumberToBeConsistentTo) {
      return false;
    }
    if(versionNumberToBeConsistentTo != getVNFromElement) {
      versionNumberToBeConsistentTo = getVNFromElement;
      consistentElements.clear();
    }
    consistentElements.insert(transferElementID);
    if(consistentElements.size() == push_elements.size()) {
      lasteSateOfConsistentElements = consistentElements;
      return true;
    }
    return false;
  }
 
  /********************************************************************************************************************/
 
} // namespace ChimeraTK