stencil.hpp

Go to the documentation of this file.

/*****************************************************************************
 ** Ifdefs
 *****************************************************************************/

#ifndef ECL_CONTAINERS_STENCIL_STENCIL_HPP_
#define ECL_CONTAINERS_STENCIL_STENCIL_HPP_

/*****************************************************************************
 ** Includes
 *****************************************************************************/

#include <cstddef>  // size_t
#include <ecl/config/macros.hpp>
#include <ecl/exceptions/standard_exception.hpp>
#include <ecl/concepts/containers.hpp>
#include <ecl/concepts/streams.hpp>
#include "../initialiser.hpp"
#include "formatters.hpp"

/*****************************************************************************
 ** Namespaces
 *****************************************************************************/

namespace ecl
{

/*****************************************************************************
 ** Interface
 *****************************************************************************/
template <typename Array>
class ECL_PUBLIC Stencil
{
public:
  /*********************
   ** Typedefs
   **********************/
  typedef typename Array::value_type value_type; 
  //   Looks like I'm now needing to rely on the underlying storage iterator definitions
  //   Naturally, this means I can't do stencils of c arrays, but hey, thats dangerous anyway and we want to avoid that.
  typedef typename Array::iterator iterator; 
  typedef typename Array::const_iterator const_iterator; 
  typedef typename Array::reference reference; 
  typedef typename Array::const_reference const_reference; 
  // typedef typename Array::value_type*          iterator;   /**< @brief Uses the array's iterator type. **/
  // typedef const typename Array::value_type*    const_iterator;  /**< @brief Uses the array's constant iterator type. **/
  // typedef typename Array::value_type&          reference;  /**< @brief Uses the array's element reference type. **/
  // typedef const typename Array::value_type&    const_reference; /**< @brief Uses the array's element const reference type. **/
  typedef std::size_t size_type; 
  typedef std::ptrdiff_t difference_type;
  typedef std::reverse_iterator<iterator> reverse_iterator; 
  typedef std::reverse_iterator<const_iterator> const_reverse_iterator; 
  typedef formatters::StencilFormatter<value_type,Array> Formatter;

  /*********************
   ** C&D's
   **********************/
  Stencil(Array& underlying_array, iterator begin_iter, iterator end_iter) ecl_assert_throw_decl(StandardException) :
  array(underlying_array),
  b_iter(begin_iter),
  e_iter(end_iter)
  {
    ecl_compile_time_concept_check(ContainerConcept<Array>);
    ecl_assert_throw((b_iter >= array.begin()) && (b_iter <= array.end()), StandardException(LOC, OutOfRangeError, "Begin iterator out of range."));
    ecl_assert_throw((e_iter >= array.begin()) && (e_iter <= array.end()), StandardException(LOC, OutOfRangeError, "End iterator out of range."));
  }

  Stencil(Array& underlying_array, const unsigned int& start_index = 0, const unsigned int &n = 0) ecl_assert_throw_decl(StandardException) :
  array(underlying_array),
  b_iter(array.begin()+start_index),
  e_iter(array.begin()+start_index+n)
  {
    ecl_compile_time_concept_check(ContainerConcept<Array>);
    ecl_assert_throw((b_iter >= array.begin()) && (b_iter <= array.end()), StandardException(LOC, OutOfRangeError, "Begin iterator out of range."));
    ecl_assert_throw((e_iter >= array.begin()) && (e_iter <= array.end()), StandardException(LOC, OutOfRangeError, "End iterator out of range."));
  }

  virtual ~Stencil()
  {};

  Stencil<Array> stencil(const unsigned int& start_index, const unsigned int& n) const ecl_assert_throw_decl(StandardException)
  {
    ecl_assert_throw( b_iter+start_index < array.end(), StandardException(LOC, OutOfRangeError, "Start index provided is larger than the underlying stencil size."));
    ecl_assert_throw( b_iter+start_index+n <= array.end(), StandardException(LOC, OutOfRangeError, "Finish index provided is larger than the underlying stencil size."));
    return Stencil<Array>(array,b_iter+start_index,b_iter+start_index+n);
  }

  void resettle(const unsigned int& start_index, const unsigned int& n) ecl_assert_throw_decl(StandardException)
  {

    b_iter = array.begin()+start_index;
    e_iter = array.begin()+start_index+n;
    ecl_assert_throw((b_iter >= array.begin()) && (b_iter <= array.end()), StandardException(LOC, OutOfRangeError, "Begin iterator out of range."));
    ecl_assert_throw((e_iter >= array.begin()) && (e_iter <= array.end()), StandardException(LOC, OutOfRangeError, "End iterator out of range."));
  }

  /*********************
   ** Assignment
   **********************/
  containers::BoundedListInitialiser<value_type,value_type*> operator<< (const value_type &value)
  {
    return containers::BoundedListInitialiser<value_type,iterator>(value, begin, size());
  }
  Stencil<Array>& operator=(const Stencil<Array> &s) ecl_assert_throw_decl(StandardException)
  {
    if ( &array == &(s.array) )
    { // resettle
      b_iter = s.b_iter;
      e_iter = s.e_iter;
    }
    else
    { // copy
      ecl_assert_throw( s.size() <= size(), StandardException(LOC, OutOfRangeError, "Stencil to be copied is larger than this stencil's size."));
      for ( unsigned int i = 0; i < s.size(); ++i )
      {
        *(b_iter+i) = *(s.b_iter+i);
      }
    }
    return *this;
  }

  /*********************
   ** Iterators
   **********************/
  iterator begin() ecl_assert_throw_decl(StandardException)
  {
    ecl_assert_throw( b_iter <= array.end(), StandardException(LOC,OutOfRangeError));
    return b_iter;
  }
  const_iterator begin() const ecl_assert_throw_decl(StandardException)
  {
    ecl_assert_throw( b_iter <= array.end(), StandardException(LOC,OutOfRangeError));
    return b_iter;
  }
  iterator end() ecl_assert_throw_decl(StandardException)
  {
    ecl_assert_throw( e_iter <= array.end(), StandardException(LOC,OutOfRangeError));
    return e_iter;
  }
  const_iterator end() const ecl_assert_throw_decl(StandardException)
  {
    ecl_assert_throw( e_iter <= array.end(), StandardException(LOC,OutOfRangeError));
    return e_iter;
  }
  reverse_iterator rbegin() ecl_assert_throw_decl(StandardException)
  {
    ecl_assert_throw( e_iter <= array.end(), StandardException(LOC,OutOfRangeError));
    return reverse_iterator(end());
  }
  const_reverse_iterator rbegin() const ecl_assert_throw_decl(StandardException)
  {
    ecl_assert_throw( e_iter <= array.end(), StandardException(LOC,OutOfRangeError));
    return const_reverse_iterator(end());
  }
  reverse_iterator rend() ecl_assert_throw_decl(StandardException)
  {
    ecl_assert_throw( b_iter <= array.end(), StandardException(LOC,OutOfRangeError));
    return reverse_iterator(begin());
  }
  const_reverse_iterator rend() const ecl_assert_throw_decl(StandardException)
  {
    ecl_assert_throw( b_iter <= array.end(), StandardException(LOC,OutOfRangeError));
    return const_reverse_iterator(begin());
  }

  /*********************
   ** Front/Back
   **********************/
  reference front() ecl_assert_throw_decl(StandardException)
  {
    ecl_assert_throw( b_iter <= array.end(), StandardException(LOC,OutOfRangeError));
    return *b_iter;
  }
  const_reference front() const ecl_assert_throw_decl(StandardException)
  {
    ecl_assert_throw( b_iter <= array.end(), StandardException(LOC,OutOfRangeError));
    return *b_iter;
  }
  reference back() ecl_assert_throw_decl(StandardException)
  {
    ecl_assert_throw( e_iter <= array.end(), StandardException(LOC,OutOfRangeError));
    return *(e_iter-1);
  }
  const_reference back() const ecl_assert_throw_decl(StandardException)
  {
    ecl_assert_throw( e_iter <= array.end(), StandardException(LOC,OutOfRangeError));
    return *(e_iter-1);
  }

  /*********************
   ** Accessors
   **********************/
  reference operator[](size_type i) ecl_assert_throw_decl(StandardException)
  {
    ecl_assert_throw( b_iter+i >= array.begin(), StandardException(LOC,OutOfRangeError));
    ecl_assert_throw( b_iter+i <= array.end(), StandardException(LOC,OutOfRangeError));
    return *(b_iter+i);
  }
  const_reference operator[](size_type i) const ecl_assert_throw_decl(StandardException)
  {
    ecl_assert_throw( b_iter+i >= array.begin(), StandardException(LOC,OutOfRangeError));
    ecl_assert_throw( b_iter+i <= array.end(), StandardException(LOC,OutOfRangeError));
    return *(b_iter+i);
  }
  reference at(size_type i) throw(StandardException)
  {
    if ( b_iter+i <= array.begin() )
    {
      throw StandardException(LOC,OutOfRangeError);
    }
    if ( b_iter+i >= array.end() )
    {
      throw StandardException(LOC,OutOfRangeError);
    }
    return *(b_iter+i);
  }
  const_reference at(size_type i) const throw(StandardException)
  {
    if ( b_iter+i <= array.begin() )
    {
      throw StandardException(LOC,OutOfRangeError);
    }
    if ( b_iter+i >= array.end() )
    {
      throw StandardException(LOC,OutOfRangeError);
    }
    return *(b_iter+i);
  }

  /*********************
   ** Utilities
   **********************/
  size_type size() const
  { return e_iter-b_iter;}

  /*********************
   ** Streaming
   **********************/
  template <typename OutputStream, typename ArrayType>
  friend OutputStream& operator<<(OutputStream &ostream , const Stencil<ArrayType> &stencil);

private:
  Array& array;
  iterator b_iter, e_iter;
};

/*****************************************************************************
 ** Implementation [Streaming]
 *****************************************************************************/

template<typename OutputStream, typename ArrayType>
  OutputStream& operator<<(OutputStream &ostream, const Stencil<ArrayType> &stencil)
  {

    ecl_compile_time_concept_check (StreamConcept<OutputStream> );

    ostream << "[ ";
    for (std::size_t i = 0; i < stencil.size(); ++i)
    {
      ostream << stencil[i] << " ";
    }
    ostream << "]";
    ostream.flush();

    return ostream;
  }

} // namespace ecl

#endif /* ECL_CONTAINERS_STENCIL_STENCIL_HPP_ */