array_view.h

// ---------------------------------------------------------------------
//
// Copyright (C) 2004 - 2016 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 at
// the top level of the deal.II distribution.
//
// ---------------------------------------------------------------------

#ifndef dealii__array_view_h
#define dealii__array_view_h

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

#include <boost/type_traits/remove_cv.hpp>

#include <vector>

DEAL_II_NAMESPACE_OPEN


template <typename ElementType>
class ArrayView
{
public:
  typedef ElementType value_type;

  ArrayView (value_type       *starting_element,
             const std::size_t n_elements);

  ArrayView (const ArrayView<typename boost::remove_cv<value_type>::type> &view);

  std::size_t size() const;

  value_type &operator[] (const std::size_t i) const;

private:
  value_type  *const starting_element;

  const std::size_t  n_elements;
};



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


template <typename ElementType>
inline
ArrayView<ElementType>::ArrayView(value_type        *starting_element,
                                  const std::size_t  n_elements)
  :
  starting_element (starting_element),
  n_elements(n_elements)
{}



template <typename ElementType>
inline
ArrayView<ElementType>::ArrayView(const ArrayView<typename boost::remove_cv<value_type>::type> &view)
  :
  starting_element (&view[0]),
  n_elements(view.size())
{}



template <typename ElementType>
inline
std::size_t
ArrayView<ElementType>::size() const
{
  return n_elements;
}


template <typename ElementType>
inline
typename ArrayView<ElementType>::value_type &
ArrayView<ElementType>::operator[](const std::size_t i) const
{
  Assert (i<n_elements, ExcIndexRange(i, 0, n_elements));

  return *(starting_element + i);
}


template <typename ElementType>
inline
ArrayView<ElementType>
make_array_view (std::vector<ElementType> &vector)
{
  return ArrayView<ElementType> (&vector[0], vector.size());
}



template <typename ElementType>
inline
ArrayView<const ElementType>
make_array_view (const std::vector<ElementType> &vector)
{
  return ArrayView<const ElementType> (&vector[0], vector.size());
}



template <typename ElementType>
inline
ArrayView<ElementType>
make_array_view (std::vector<ElementType> &vector,
                 const std::size_t         starting_index,
                 const std::size_t         size_of_view)
{
  Assert (starting_index + size_of_view <= vector.size(),
          ExcMessage ("The starting index and size of the view you want to "
                      "create would lead to a view that extends beyond the end "
                      "of the given vector."));
  return ArrayView<ElementType> (&vector[starting_index], size_of_view);
}



template <typename ElementType>
inline
ArrayView<const ElementType>
make_array_view (const std::vector<ElementType> &vector,
                 const std::size_t         starting_index,
                 const std::size_t         size_of_view)
{
  Assert (starting_index + size_of_view <= vector.size(),
          ExcMessage ("The starting index and size of the view you want to "
                      "create would lead to a view that extends beyond the end "
                      "of the given vector."));
  return ArrayView<const ElementType> (&vector[starting_index], size_of_view);
}



template <typename ElementType>
inline
ArrayView<ElementType>
make_array_view (Table<2,ElementType>                           &table,
                 const typename Table<2,ElementType>::size_type  row)
{
  AssertIndexRange (row, table.size()[0]);
  return ArrayView<ElementType> (&table[row][0], table.size()[1]);
}



template <typename ElementType>
inline
ArrayView<const ElementType>
make_array_view (const Table<2,ElementType>                     &table,
                 const typename Table<2,ElementType>::size_type  row)
{
  AssertIndexRange (row, table.size()[0]);
  return ArrayView<const ElementType> (&table[row][0], table.size()[1]);
}



template <typename ElementType>
inline
ArrayView<ElementType>
make_array_view (Table<2,ElementType>                           &table,
                 const typename Table<2,ElementType>::size_type  row,
                 const typename Table<2,ElementType>::size_type  starting_column,
                 const std::size_t                               size_of_view)
{
  AssertIndexRange (row, table.size()[0]);
  AssertIndexRange (starting_column, table.size()[1]);
  Assert (starting_column + size_of_view <= table.size()[1],
          ExcMessage ("The starting index and size of the view you want to "
                      "create would lead to a view that extends beyond the end "
                      "of a column of the given table."));
  return ArrayView<ElementType> (&table[row][starting_column], size_of_view);
}



template <typename ElementType>
inline
ArrayView<const ElementType>
make_array_view (const Table<2,ElementType>                     &table,
                 const typename Table<2,ElementType>::size_type  row,
                 const typename Table<2,ElementType>::size_type  starting_column,
                 const std::size_t                               size_of_view)
{
  AssertIndexRange (row, table.size()[0]);
  AssertIndexRange (starting_column, table.size()[1]);
  Assert (starting_column + size_of_view <= table.size()[1],
          ExcMessage ("The starting index and size of the view you want to "
                      "create would lead to a view that extends beyond the end "
                      "of a column of the given table."));
  return ArrayView<const ElementType> (&table[row][starting_column], size_of_view);
}



DEAL_II_NAMESPACE_CLOSE

#endif