history.h

Go to the documentation of this file.

// ------------------------------------------------------------------------
//
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 2018 - 2023 by the deal.II authors
//
// This file is part of the deal.II library.
//
// Part of the source code is dual licensed under Apache-2.0 WITH
// LLVM-exception OR LGPL-2.1-or-later. Detailed license information
// governing the source code and code contributions can be found in
// LICENSE.md and CONTRIBUTING.md at the top level directory of deal.II.
//
// ------------------------------------------------------------------------
 
#ifndef dealii_storage_h
#define dealii_storage_h
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/exceptions.h>
 
#include <deque>
#include <memory>
#include <type_traits>
 
DEAL_II_NAMESPACE_OPEN
 
template <typename T>
class FiniteSizeHistory
{
public:
  static_assert(
    std::is_default_constructible_v<T>,
    "This class requires that the elements of type T are default constructible.");
 
  FiniteSizeHistory(const std::size_t max_elements = 0);
 
  void
  add(const T &element);
 
  void
  remove(const std::size_t index);
 
  T &
  operator[](const std::size_t index);
 
  const T &
  operator[](const std::size_t index) const;
 
  std::size_t
  size() const;
 
  std::size_t
  max_size() const;
 
  void
  clear();
 
private:
  std::size_t max_n_elements;
 
  std::deque<std::unique_ptr<T>> data;
 
  std::deque<std::unique_ptr<T>> cache;
};
 
 
 
// -------------------  inline and template functions ----------------
#ifndef DOXYGEN
 
 
 
template <typename T>
FiniteSizeHistory<T>::FiniteSizeHistory(const std::size_t max_elements)
  : max_n_elements(max_elements)
{}
 
 
 
template <typename T>
void
FiniteSizeHistory<T>::remove(const std::size_t ind)
{
  AssertIndexRange(ind, data.size());
  auto el = std::move(data[ind]);
  data.erase(data.begin() + ind);
 
  cache.push_back(std::move(el));
 
  // whatever we do, we shall not store more than the maximum number of
  // elements
  Assert(data.size() + cache.size() <= max_n_elements, ExcInternalError());
}
 
 
 
template <typename T>
void
FiniteSizeHistory<T>::add(const T &element)
{
  std::unique_ptr<T> new_el;
  if (data.size() < max_n_elements)
    // have not reached the maximum number of elements yet
    {
      if (cache.empty())
        // nothing is cached, just copy a given element
        {
          new_el = std::make_unique<T>(element);
        }
      else
        // something is cached, take one element and copy
        // the user provided one there.
        {
          new_el    = std::move(cache.back());
          (*new_el) = element;
 
          cache.pop_back(); // removes a pointer that is now a nullptr anyway
        }
    }
  else
    // we reached the maximum number of elements and
    // thus have to re-order/cycle elements currently stored
    {
      new_el    = std::move(data.back());
      (*new_el) = element;
 
      data.pop_back(); // removes a pointer that is now a nullptr anyway
    }
 
  // finally insert the new one where appropriate
  data.push_front(std::move(new_el));
 
  // whatever we do, we shall not store more than the maximum number of
  // elements
  Assert(data.size() + cache.size() <= max_n_elements, ExcInternalError());
}
 
 
 
template <typename T>
T &
FiniteSizeHistory<T>::operator[](const std::size_t ind)
{
  AssertIndexRange(ind, data.size());
  return *data[ind];
}
 
 
 
template <typename T>
const T &
FiniteSizeHistory<T>::operator[](const std::size_t ind) const
{
  AssertIndexRange(ind, data.size());
  return *data[ind];
}
 
 
 
template <typename T>
std::size_t
FiniteSizeHistory<T>::size() const
{
  return data.size();
}
 
 
 
template <typename T>
std::size_t
FiniteSizeHistory<T>::max_size() const
{
  return max_n_elements;
}
 
 
 
template <typename T>
void
FiniteSizeHistory<T>::clear()
{
  data.clear();
  cache.clear();
}
 
#endif // Doxygen
 
DEAL_II_NAMESPACE_CLOSE
 
#endif // dealii_storage_h