MRUList.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2008 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 +
#pragma once
 
//----------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------
#include "MantidKernel/DllConfig.h"
#include <mutex>
 
#ifndef Q_MOC_RUN
#include <boost/multi_index/hashed_index.hpp>
#include <boost/multi_index/mem_fun.hpp>
#include <boost/multi_index/sequenced_index.hpp>
#include <boost/multi_index_container.hpp>
#endif
 
namespace Mantid {
namespace Kernel {
template <class T> class DLLExport MRUList {
private:
  using item_list = typename boost::multi_index::multi_index_container<
      std::shared_ptr<T>,
      boost::multi_index::indexed_by<boost::multi_index::sequenced<>,
                                     boost::multi_index::hashed_unique<::boost::multi_index::const_mem_fun<
                                         T, std::uintptr_t, &T::hashIndexFunction>>>>;
 
  using ordered_item_list = typename boost::multi_index::nth_index<item_list, 1>::type;
 
  mutable item_list il;
  const std::size_t max_num_items;
 
public:
  //---------------------------------------------------------------------------------------------
  MRUList(const std::size_t &max_num_items_) : max_num_items(max_num_items_) {}
 
  //---------------------------------------------------------------------------------------------
  MRUList() : max_num_items(100) {}
 
  //---------------------------------------------------------------------------------------------
  ~MRUList() { this->clear(); }
 
  //---------------------------------------------------------------------------------------------
  std::shared_ptr<T> insert(std::shared_ptr<T> item) {
    std::lock_guard<std::mutex> _lock(m_mutex);
    auto p = this->il.push_front(std::move(item));
 
    if (!p.second) {
      /* duplicate item */
      this->il.relocate(this->il.begin(), p.first); /* put in front */
      return nullptr;
    }
 
    bool exceeding_size;
    exceeding_size = this->il.size() > max_num_items;
 
    if (exceeding_size) {
      std::shared_ptr<T> toWrite;
      /* keep the length <= max_num_items */
      // This is dropping an item - you may need to write it to disk (if it's
      // changed) and delete
      // but this is left up to the calling class to do,
      // by returning the to-be-dropped item pointer.
      toWrite = std::move(this->il.back());
      this->il.pop_back();
      return toWrite;
    }
    return nullptr;
  }
 
  //---------------------------------------------------------------------------------------------
  void clear() {
    std::lock_guard<std::mutex> _lock(m_mutex);
    this->il.clear();
  }
 
  //---------------------------------------------------------------------------------------------
  void deleteIndex(const uintptr_t index) {
    std::lock_guard<std::mutex> _lock(m_mutex);
 
    auto it = il.template get<1>().find(index);
    if (it != il.template get<1>().end()) {
      il.template get<1>().erase(it);
    }
  }
 
  //---------------------------------------------------------------------------------------------
  size_t size() const { return il.size(); }
 
  //---------------------------------------------------------------------------------------------
  T *find(const uintptr_t index) const {
    std::lock_guard<std::mutex> _lock(m_mutex);
 
    auto it = il.template get<1>().find(index);
    if (it == il.template get<1>().end()) {
      return nullptr;
    } else {
      return it->get();
    }
  }
 
private:
  MRUList(MRUList &);
  MRUList &operator=(MRUList &);
 
  mutable std::mutex m_mutex;
};
 
} // namespace Kernel
} // namespace Mantid