HistoryView.cpp

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
//----------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------
#include "MantidAPI/HistoryView.h"
#include <algorithm>
#include <iterator>
 
namespace Mantid::API {
 
HistoryView::HistoryView(const WorkspaceHistory &wsHist) : m_wsHist(wsHist), m_historyItems() {
  // add all of the top level algorithms to the view by default
  const auto &algorithms = wsHist.getAlgorithmHistories();
  m_historyItems = std::vector<HistoryItem>(algorithms.begin(), algorithms.end());
}
 
void HistoryView::unroll(size_t index) {
  if (index >= m_historyItems.size()) {
    throw std::out_of_range("HistoryView::unroll() - Index out of range");
  }
 
  // advance to the item at the index
  auto it = m_historyItems.begin();
  std::advance(it, index);
  unroll(it);
}
 
void HistoryView::unroll(std::vector<HistoryItem>::iterator &it) {
  const auto history = it->getAlgorithmHistory();
  const auto childHistories = history->getChildHistories();
 
  if (!it->isUnrolled() && !childHistories.empty()) {
    // mark this record as being ignored by the script builder
    it->unrolled(true);
 
    // insert each of the records, in order, at this position
    std::vector<HistoryItem> tmpHistory(childHistories.cbegin(), childHistories.cend());
    // since we are using a std::vector, do all insertions at the same time.
    ++it; // move iterator forward to insertion position
    it = m_historyItems.insert(it, tmpHistory.begin(), tmpHistory.end());
  } else
    ++it;
}
 
void HistoryView::unrollAll() {
  auto it = m_historyItems.begin();
  while (it != m_historyItems.end()) {
    // iterator passed by reference to prevent iterator invalidation.
    // iterator incremented within function.
    unroll(it);
  }
}
 
void HistoryView::rollAll() {
  auto it = m_historyItems.begin();
  while (it != m_historyItems.end()) {
    // iterator incremented within function.
    roll(it);
  }
}
 
void HistoryView::roll(size_t index) {
  if (index >= m_historyItems.size()) {
    throw std::out_of_range("HistoryView::roll() - Index out of range");
  }
 
  // advance to the item at the index
  auto it = m_historyItems.begin();
  std::advance(it, index);
  roll(it);
}
 
void HistoryView::rollChildren(std::vector<HistoryItem>::iterator it) {
  const size_t numChildren = it->numberOfChildren();
  ++it;
  for (size_t i = 0; i < numChildren; ++i) {
    if (it->isUnrolled())
      roll(it);
    else {
      ++it;
    }
  }
}
 
void HistoryView::roll(std::vector<HistoryItem>::iterator &it) {
 
  // the number of records after this position
  const size_t numChildren = it->numberOfChildren();
  if (it->isUnrolled() && numChildren > 0) {
    // mark this record as not being ignored by the script builder
    it->unrolled(false);
    this->rollChildren(it);
    // Then just remove the children from the list
    ++it;
    it = m_historyItems.erase(it, it + numChildren);
  } else
    ++it;
}
 
void HistoryView::filterBetweenExecDate(Mantid::Types::Core::DateAndTime start, Mantid::Types::Core::DateAndTime end) {
  auto lastItem = std::remove_if(m_historyItems.begin(), m_historyItems.end(), [&start, &end](const HistoryItem &item) {
    Mantid::Types::Core::DateAndTime algExecutionDate = item.getAlgorithmHistory()->executionDate();
    return algExecutionDate < start || algExecutionDate > end;
  });
  m_historyItems.erase(lastItem, m_historyItems.end());
}
 
} // namespace Mantid::API