basearray.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_BASEARRAY_HH
#define DUNE_BASEARRAY_HH
 
#include "assert.h"
#include <cmath>
#include <cstddef>
#include <memory>
#include <algorithm>
 
#include "istlexception.hh"
#include <dune/common/iteratorfacades.hh>
 
namespace Dune {
 
  template<class B, class A=std::allocator<B> >
  class base_array_unmanaged
  {
  public:
 
    //===== type definitions and constants
 
    typedef B member_type;
 
    typedef A allocator_type;
 
    typedef typename A::size_type size_type;
 
 
    //===== access to components
 
    B& operator[] (size_type i)
    {
#ifdef DUNE_ISTL_WITH_CHECKING
      if (i>=n) DUNE_THROW(ISTLError,"index out of range");
#endif
      return p[i];
    }
 
    const B& operator[] (size_type i) const
    {
#ifdef DUNE_ISTL_WITH_CHECKING
      if (i>=n) DUNE_THROW(ISTLError,"index out of range");
#endif
      return p[i];
    }
 
    template<class T>
    class RealIterator
      :  public RandomAccessIteratorFacade<RealIterator<T>, T>
    {
    public:
      typedef typename remove_const<T>::type ValueType;
 
      friend class RandomAccessIteratorFacade<RealIterator<const ValueType>, const ValueType>;
      friend class RandomAccessIteratorFacade<RealIterator<ValueType>, ValueType>;
      friend class RealIterator<const ValueType>;
      friend class RealIterator<ValueType>;
 
      RealIterator ()
        : p(0), i(0)
      {}
 
      RealIterator (const B* _p, B* _i) : p(_p), i(_i)
      {   }
 
      RealIterator(const RealIterator<ValueType>& it)
        : p(it.p), i(it.i)
      {}
 
      size_type index () const
      {
        return i-p;
      }
 
      bool equals (const RealIterator<ValueType>& other) const
      {
        assert(other.p==p);
        return i==other.i;
      }
 
      bool equals (const RealIterator<const ValueType>& other) const
      {
        assert(other.p==p);
        return i==other.i;
      }
 
      std::ptrdiff_t distanceTo(const RealIterator& o) const
      {
        return o.i-i;
      }
 
    private:
      void increment()
      {
        ++i;
      }
 
      void decrement()
      {
        --i;
      }
 
      B& dereference () const
      {
        return *i;
      }
 
      void advance(std::ptrdiff_t d)
      {
        i+=d;
      }
 
      const B* p;
      B* i;
    };
 
    typedef RealIterator<B> iterator;
 
 
    iterator begin ()
    {
      return iterator(p,p);
    }
 
    iterator end ()
    {
      return iterator(p,p+n);
    }
 
    iterator beforeEnd ()
    {
      return iterator(p,p+n-1);
    }
 
    iterator beforeBegin ()
    {
      return iterator(p,p-1);
    }
 
    iterator find (size_type i)
    {
      if (i<n)
        return iterator(p,p+i);
      else
        return iterator(p,p+n);
    }
 
    typedef RealIterator<const B> const_iterator;
 
    const_iterator begin () const
    {
      return const_iterator(p,p+0);
    }
 
    const_iterator end () const
    {
      return const_iterator(p,p+n);
    }
 
    const_iterator beforeEnd () const
    {
      return const_iterator(p,p+n-1);
    }
 
    const_iterator beforeBegin () const
    {
      return const_iterator(p,p-1);
    }
 
    const_iterator find (size_type i) const
    {
      if (i<n)
        return const_iterator(p,p+i);
      else
        return const_iterator(p,p+n);
    }
 
 
    //===== sizes
 
    size_type size () const
    {
      return n;
    }
 
  protected:
    base_array_unmanaged ()
      : n(0), p(0)
    {}
    base_array_unmanaged (size_type n_, B* p_)
      : n(n_), p(p_)
    {}
    size_type n;     // number of elements in array
    B *p;      // pointer to dynamically allocated built-in array
  };
 
 
 
  template<class B, class A=std::allocator<B> >
  class base_array_window : public base_array_unmanaged<B,A>
  {
  public:
 
    //===== type definitions and constants
 
    typedef B member_type;
 
    typedef A allocator_type;
 
    typedef typename base_array_unmanaged<B,A>::iterator iterator;
 
    typedef typename base_array_unmanaged<B,A>::const_iterator const_iterator;
 
    typedef typename base_array_unmanaged<B,A>::size_type size_type;
 
    typedef typename A::difference_type difference_type;
 
    //===== constructors and such
 
    base_array_window ()
      : base_array_unmanaged<B,A>()
    {   }
 
    base_array_window (B* _p, size_type _n)
      : base_array_unmanaged<B,A>(_n ,_p)
    {}
 
    //===== window manipulation methods
 
    void set (size_type _n, B* _p)
    {
      this->n = _n;
      this->p = _p;
    }
 
    void advance (difference_type newsize)
    {
      this->p += this->n;
      this->n = newsize;
    }
 
    void move (difference_type offset, size_type newsize)
    {
      this->p += offset;
      this->n = newsize;
    }
 
    void move (difference_type offset)
    {
      this->p += offset;
    }
 
    B* getptr ()
    {
      return this->p;
    }
  };
 
 
 
  template<class B, class A=std::allocator<B> >
  class base_array : public base_array_unmanaged<B,A>
  {
  public:
 
    //===== type definitions and constants
 
    typedef B member_type;
 
    typedef A allocator_type;
 
    typedef typename base_array_unmanaged<B,A>::iterator iterator;
 
    typedef typename base_array_unmanaged<B,A>::const_iterator const_iterator;
 
    typedef typename base_array_unmanaged<B,A>::size_type size_type;
 
    typedef typename A::difference_type difference_type;
 
    //===== constructors and such
 
    base_array ()
      : base_array_unmanaged<B,A>()
    {}
 
    base_array (size_type _n)
      : base_array_unmanaged<B,A>(_n, 0)
    {
      if (this->n>0) {
        this->p = allocator_.allocate(this->n);
        new (this->p)B[this->n];
      } else
      {
        this->n = 0;
        this->p = 0;
      }
    }
 
    base_array (const base_array& a)
    {
      // allocate memory with same size as a
      this->n = a.n;
 
      if (this->n>0) {
        this->p = allocator_.allocate(this->n);
        new (this->p)B[this->n];
      } else
      {
        this->n = 0;
        this->p = 0;
      }
 
      // and copy elements
      for (size_type i=0; i<this->n; i++) this->p[i]=a.p[i];
    }
 
    base_array (const base_array_unmanaged<B,A>& _a)
    {
      const base_array& a = static_cast<const base_array&>(_a);
 
      // allocate memory with same size as a
      this->n = a.n;
      if (this->n>0) {
        this->p = allocator_.allocate(this->n);
        new (this->p)B[this->n];
      } else
      {
        this->n = 0;
        this->p = 0;
      }
 
      // and copy elements
      for (size_type i=0; i<this->n; i++) this->p[i]=a.p[i];
    }
 
 
    ~base_array ()
    {
      if (this->n>0) {
        int i=this->n;
        while (i)
          this->p[--i].~B();
        allocator_.deallocate(this->p,this->n);
      }
    }
 
    void resize (size_type _n)
    {
      if (this->n==_n) return;
 
      if (this->n>0) {
        int i=this->n;
        while (i)
          this->p[--i].~B();
        allocator_.deallocate(this->p,this->n);
      }
      this->n = _n;
      if (this->n>0) {
        this->p = allocator_.allocate(this->n);
        new (this->p)B[this->n];
      } else
      {
        this->n = 0;
        this->p = 0;
      }
    }
 
    base_array& operator= (const base_array& a)
    {
      if (&a!=this)     // check if this and a are different objects
      {
        // adjust size of array
        if (this->n!=a.n)           // check if size is different
        {
          if (this->n>0) {
            int i=this->n;
            while (i)
              this->p[--i].~B();
            allocator_.deallocate(this->p,this->n);                     // delete old memory
          }
          this->n = a.n;
          if (this->n>0) {
            this->p = allocator_.allocate(this->n);
            new (this->p)B[this->n];
          } else
          {
            this->n = 0;
            this->p = 0;
          }
        }
        // copy data
        for (size_type i=0; i<this->n; i++) this->p[i]=a.p[i];
      }
      return *this;
    }
 
    base_array& operator= (const base_array_unmanaged<B,A>& a)
    {
      return this->operator=(static_cast<const base_array&>(a));
    }
 
  protected:
 
    A allocator_;
  };
 
 
 
 
  template<class B, class A=std::allocator<B> >
  class compressed_base_array_unmanaged
  {
  public:
 
    //===== type definitions and constants
 
    typedef B member_type;
 
    typedef A allocator_type;
 
    typedef typename A::size_type size_type;
 
    //===== access to components
 
    B& operator[] (size_type i)
    {
      size_type l=0, r=n-1;
      while (l<r)
      {
        size_type q = (l+r)/2;
        if (i <= j[q]) r=q;
        else l = q+1;
      }
      if (j[l]!=i) {
        DUNE_THROW(ISTLError,"index "<<i<<" not in compressed array");
      }
      return p[l];
    }
 
    const B& operator[] (size_type i) const
    {
      size_type l=0, r=n-1;
      while (l<r)
      {
        size_type q = (l+r)/2;
        if (i <= j[q]) r=q;
        else l = q+1;
      }
      if (j[l]!=i) {
        DUNE_THROW(ISTLError,"index "<<i<<" not in compressed array");
      }
      return p[l];
    }
 
    template<class T>
    class RealIterator
      : public BidirectionalIteratorFacade<RealIterator<T>, T>
    {
    public:
      typedef typename remove_const<T>::type ValueType;
 
      friend class BidirectionalIteratorFacade<RealIterator<const ValueType>, const ValueType>;
      friend class BidirectionalIteratorFacade<RealIterator<ValueType>, ValueType>;
      friend class RealIterator<const ValueType>;
      friend class RealIterator<ValueType>;
 
      RealIterator ()
        : p(0), j(0), i(0)
      {}
 
      RealIterator (B* _p, size_type* _j, size_type _i)
        : p(_p), j(_j), i(_i)
      {       }
 
      RealIterator(const RealIterator<ValueType>& it)
        : p(it.p), j(it.j), i(it.i)
      {}
 
 
      bool equals (const RealIterator<ValueType>& it) const
      {
        assert(p==it.p);
        return (i)==(it.i);
      }
 
      bool equals (const RealIterator<const ValueType>& it) const
      {
        assert(p==it.p);
        return (i)==(it.i);
      }
 
 
      size_type index () const
      {
        return j[i];
      }
 
      void setindex (size_type k)
      {
        return j[i] = k;
      }
 
      size_type offset () const
      {
        return i;
      }
 
    private:
      void increment()
      {
        ++i;
      }
 
      void decrement()
      {
        --i;
      }
 
      B& dereference () const
      {
        return p[i];
      }
 
      B* p;
      size_type* j;
      size_type i;
    };
 
    typedef RealIterator<B> iterator;
 
    iterator begin ()
    {
      return iterator(p,j,0);
    }
 
    iterator end ()
    {
      return iterator(p,j,n);
    }
 
    iterator beforeEnd ()
    {
      return iterator(p,j,n-1);
    }
 
    iterator beforeBegin ()
    {
      return iterator(p,j,-1);
    }
 
    iterator find (size_type i)
    {
      const size_type* lb = std::lower_bound(j, j+n, i);
      return (lb != j+n and *lb == i)
        ? iterator(p,j,lb-j)
        : end();
    }
 
    typedef RealIterator<const B> const_iterator;
 
    const_iterator begin () const
    {
      return const_iterator(p,j,0);
    }
 
    const_iterator end () const
    {
      return const_iterator(p,j,n);
    }
 
    const_iterator beforeEnd () const
    {
      return const_iterator(p,j,n-1);
    }
 
    const_iterator beforeBegin () const
    {
      return const_iterator(p,j,-1);
    }
 
    const_iterator find (size_type i) const
    {
      const size_type* lb = std::lower_bound(j, j+n, i);
      return (lb != j+n and *lb == i)
        ? const_iterator(p,j,lb-j)
        : end();
    }
 
    //===== sizes
 
    size_type size () const
    {
      return n;
    }
 
  protected:
    compressed_base_array_unmanaged ()
      : n(0), p(0), j(0)
    {}
 
    size_type n;      // number of elements in array
    B *p;       // pointer to dynamically allocated built-in array
    size_type* j;     // the index set
  };
 
} // end namespace
 
#endif