overflowarray.hh

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_FUNCTIONS_COMMON_OVERFLOWARRAY_HH
#define DUNE_FUNCTIONS_COMMON_OVERFLOWARRAY_HH
 
#include <algorithm>
#include <iostream>
#include <cstddef>
#include <array>
#include <initializer_list>
 
#include <dune/common/genericiterator.hh>
 
 
 
namespace Dune::Functions {
 
 
template<class BA, std::size_t maxSize = std::tuple_size_v<BA>>
class OverflowArray :
  public BA
{
  static constexpr std::size_t baseSize = std::tuple_size_v<BA>;
 
public:
  using BaseArray = BA;
 
  using value_type = typename BaseArray::value_type;
  using reference = value_type&;
  using const_reference = const value_type&;
  using pointer = value_type*;
  using difference_type = std::ptrdiff_t;
  using size_type = std::size_t;
  using iterator = Dune::GenericIterator<OverflowArray, value_type>;
  using const_iterator = Dune::GenericIterator<const OverflowArray, const value_type>;
 
private:
  using OverflowBuffer = std::array<value_type, maxSize-baseSize>;
 
public:
 
  OverflowArray() = default;
 
  OverflowArray(const std::initializer_list<value_type>& l) {
    assert(l.size() <= capacity());
    size_ = l.size();
    std::copy_n(l.begin(), size_, begin());
  }
 
  bool operator == (const OverflowArray& other) const {
    if (size() != other.size())
      return false;
    for (size_type i=0; i<size(); ++i)
      if ((*this)[i] != other[i])
        return false;
    return true;
  }
 
  void clear() {
    size_ = 0;
  }
 
  void resize(size_type n) {
    assert(n <= capacity());
    size_ = n;
  }
 
  void push_back(const value_type& t) {
    assert(size() < capacity());
    (*this)[size_++] = t;
  }
 
  void pop_back() {
    assert(size() > 0);
    if (! empty())
      size_--;
  }
 
  void push_front(const value_type& t) {
    assert(size() < capacity());
    for (size_type i=0; i<size(); i++)
      (*this)[i+1] = (*this)[i];
    (*this)[0] = t;
  }
 
  iterator begin() {
    return iterator(*this, 0);
  }
 
  const_iterator begin() const {
    return const_iterator(*this, 0);
  }
 
  iterator end() {
    return iterator(*this, size());
  }
 
  const_iterator end() const {
    return const_iterator(*this, size());
  }
 
  reference operator[] (size_type i) {
    assert(i < size());
    // If there's no padding between the base class and the overflow_ member,
    // the compiler should be able to optimize this to
    // return *(&BaseArray::operator[](0) + i);
    if (i<baseSize)
      return BaseArray::operator[](i);
    return overflow_[i-baseSize];
  }
 
  const_reference operator[] (size_type i) const {
    assert(i < size());
    // If there's no padding between the base class and the overflow_ member,
    // the compiler should be able to optimize this to
    // return *(&BaseArray::operator[](0) + i);
    if (i<baseSize)
      return BaseArray::operator[](i);
    return overflow_[i-baseSize];
  }
 
  reference front() {
    assert(size() > 0);
    return (*this)[0];
  }
 
  const_reference front() const {
    assert(size() > 0);
    return (*this)[0];
  }
 
  reference back() {
    assert(size() > 0);
    return (*this)[size()-1];
  }
 
  const_reference back() const {
    assert(size() > 0);
    return (*this)[size()-1];
  }
 
  size_type size () const {
    return size_;
  }
 
  bool empty() const {
    return size() == 0;
  }
 
  static constexpr size_type capacity() {
    return maxSize;
  }
 
  static constexpr size_type max_size() {
    return maxSize;
  }
 
  inline friend std::size_t hash_value(const OverflowArray& v) noexcept {
    return hash_range(v.begin(), v.end());
  }
 
  friend std::ostream& operator<< (std::ostream& s, const OverflowArray& c) {
    for (const auto& ci : c)
      s << ci << "  ";
    return s;
  }
 
private:
  OverflowBuffer overflow_;
  size_type size_ = 0;
};
 
 
 
} // namespace Dune::Functions
 
 
 
#endif // DUNE_FUNCTIONS_COMMON_OVERFLOWARRAY_HH