reservedvector.hh

Go to the documentation of this file.

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_COMMON_RESERVEDVECTOR_HH
#define DUNE_COMMON_RESERVEDVECTOR_HH
 
#include <algorithm>
#include <iostream>
#include <cstddef>
#include <dune/common/genericiterator.hh>
#include <initializer_list>
 
#include <dune/common/hash.hh>
 
#ifdef CHECK_RESERVEDVECTOR
#define CHECKSIZE(X) assert(X)
#else
#define CHECKSIZE(X) {}
#endif
 
namespace Dune
{
  template<class T, int n>
  class ReservedVector
  {
  public:
 
    typedef T value_type;
    typedef T* pointer;
    typedef T& reference;
    typedef const T& const_reference;
    typedef size_t size_type;
    typedef std::ptrdiff_t difference_type;
    typedef Dune::GenericIterator<ReservedVector, value_type> iterator;
    typedef Dune::GenericIterator<const ReservedVector, const value_type> const_iterator;
 
    ReservedVector() : sz(0) {}
 
    ReservedVector(std::initializer_list<T> const &l)
    {
      assert(l.size() <= n);// Actually, this is not needed any more!
      sz = l.size();
      std::copy_n(l.begin(), sz, data);
    }
 
    bool operator == (const ReservedVector & other) const
    {
      bool eq = (sz == other.sz);
      for (size_type i=0; i<sz && eq; ++i)
        eq = eq && (data[i] == other.data[i]);
      return eq;
    }
 
    void clear()
    {
      sz = 0;
    }
 
    void resize(size_t s)
    {
      CHECKSIZE(s<=n);
      sz = s;
    }
 
    void push_back(const T& t)
    {
      CHECKSIZE(sz<n);
      data[sz++] = t;
    }
 
    void pop_back()
    {
      if (! empty()) sz--;
    }
 
    iterator begin(){
      return iterator(*this, 0);
    }
 
    const_iterator begin() const {
      return const_iterator(*this, 0);
    }
 
    iterator end(){
      return iterator(*this, sz);
    }
 
    const_iterator end() const {
      return const_iterator(*this, sz);
    }
 
    reference operator[] (size_type i)
    {
      CHECKSIZE(sz>i);
      return data[i];
    }
 
    const_reference operator[] (size_type i) const
    {
      CHECKSIZE(sz>i);
      return data[i];
    }
 
    reference front()
    {
      CHECKSIZE(sz>0);
      return data[0];
    }
 
    const_reference front() const
    {
      CHECKSIZE(sz>0);
      return data[0];
    }
 
    reference back()
    {
      CHECKSIZE(sz>0);
      return data[sz-1];
    }
 
    const_reference back() const
    {
      CHECKSIZE(sz>0);
      return data[sz-1];
    }
 
    size_type size () const
    {
      return sz;
    }
 
    bool empty() const
    {
      return sz==0;
    }
 
    static constexpr size_type capacity()
    {
      return n;
    }
 
    static constexpr size_type max_size()
    {
      return n;
    }
 
    friend std::ostream& operator<< (std::ostream& s, const ReservedVector& v)
    {
      for (size_t i=0; i<v.size(); i++)
        s << v[i] << "  ";
      return s;
    }
 
    inline friend std::size_t hash_value(const ReservedVector& v) noexcept
    {
      return hash_range(v.data,v.data+v.sz);
    }
 
  private:
    T data[n];
    size_type sz;
  };
 
}
 
DUNE_DEFINE_HASH(DUNE_HASH_TEMPLATE_ARGS(typename T, int n),DUNE_HASH_TYPE(Dune::ReservedVector<T,n>))
 
#undef CHECKSIZE
 
#endif // DUNE_COMMON_RESERVEDVECTOR_HH