vector_slice.h

// ---------------------------------------------------------------------
//
// Copyright (C) 2004 - 2018 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, redistribute
// it, and/or modify it under the terms of the GNU Lesser General
// Public License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE.md at
// the top level directory of deal.II.
//
// ---------------------------------------------------------------------

#ifndef dealii_vector_slice_h
#define dealii_vector_slice_h

#include <deal.II/base/config.h>

#include <deal.II/base/array_view.h>
#include <deal.II/base/exceptions.h>

DEAL_II_NAMESPACE_OPEN


template <typename VectorType>
class VectorSlice
{
public:
  VectorSlice(VectorType &v);
  VectorSlice(VectorType &v, unsigned int start, unsigned int length);

  operator ArrayView<typename VectorType::value_type *>();

  operator ArrayView<const typename VectorType::value_type *>() const;

  unsigned int
  size() const;

  typename VectorType::reference operator[](unsigned int i);

  typename VectorType::const_reference operator[](unsigned int i) const;

  typename VectorType::iterator
  begin();

  typename VectorType::const_iterator
  begin() const;

  typename VectorType::iterator
  end();

  typename VectorType::const_iterator
  end() const;

private:
  VectorType &v;
  const unsigned int start;
  const unsigned int length;
};


template <typename VectorType>
inline const VectorSlice<const VectorType>
make_slice(VectorType &v)
{
  const VectorSlice<const VectorType> r(v);
  return r;
}



template <typename VectorType>
inline const VectorSlice<const VectorType>
make_slice(VectorType &v, const unsigned int start, const unsigned int length)
{
  const VectorSlice<const VectorType> r(v, start, length);
  return r;
}



//---------------------------------------------------------------------------

template <typename VectorType>
inline VectorSlice<VectorType>::VectorSlice(VectorType &v)
  : v(v)
  , start(0)
  , length(v.size())
{}


template <typename VectorType>
inline VectorSlice<VectorType>::VectorSlice(VectorType & v,
                                            unsigned int start,
                                            unsigned int length)
  : v(v)
  , start(start)
  , length(length)
{
  Assert((start + length <= v.size()),
         ExcIndexRange(length, 0, v.size() - start + 1));
}


template <typename VectorType>
inline unsigned int
VectorSlice<VectorType>::size() const
{
  return length;
}


template <typename VectorType>
VectorSlice<VectorType>::operator ArrayView<typename VectorType::value_type *>()
{
  return ArrayView<typename VectorType::value_type *>(&v[start], length);
}


template <typename VectorType>
VectorSlice<VectorType>::
operator ArrayView<const typename VectorType::value_type *>() const
{
  return ArrayView<const typename VectorType::value_type *>(&v[start], length);
}


template <typename VectorType>
inline typename VectorType::reference VectorSlice<VectorType>::
                                      operator[](unsigned int i)
{
  Assert((i < length), ExcIndexRange(i, 0, length));

  return v[start + i];
}


template <typename VectorType>
inline typename VectorType::const_reference VectorSlice<VectorType>::
                                            operator[](unsigned int i) const
{
  Assert((i < length), ExcIndexRange(i, 0, length));

  return v[start + i];
}


template <typename VectorType>
inline typename VectorType::const_iterator
VectorSlice<VectorType>::begin() const
{
  return v.begin() + start;
}


template <typename VectorType>
inline typename VectorType::iterator
VectorSlice<VectorType>::begin()
{
  return v.begin() + start;
}


template <typename VectorType>
inline typename VectorType::const_iterator
VectorSlice<VectorType>::end() const
{
  return v.begin() + start + length;
}


template <typename VectorType>
inline typename VectorType::iterator
VectorSlice<VectorType>::end()
{
  return v.begin() + start + length;
}

DEAL_II_NAMESPACE_CLOSE

#endif