specialisations.hpp

Go to the documentation of this file.

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

#ifndef ecl_containers_SPECIALISATIONS_HPP_
#define ecl_containers_SPECIALISATIONS_HPP_

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

#include "stencil.hpp"

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

namespace ecl {

/*****************************************************************************
 ** Interface
 *****************************************************************************/
template <>
class ECL_PUBLIC Stencil<unsigned char*>
{
public:
  /*********************
   ** Typedefs
   **********************/
  typedef unsigned char value_type; 
  typedef unsigned char* iterator; 
  typedef const unsigned char* const_iterator; 
  typedef unsigned char& reference; 
  typedef const unsigned char& const_reference; 
  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(iterator underlying_array, const unsigned int& length, iterator begin_iter, iterator end_iter) ecl_assert_throw_decl(StandardException) :
  array(underlying_array),
  length(length),
  b_iter(begin_iter),
  e_iter(end_iter)
  {
    ecl_assert_throw((b_iter <= array+length), StandardException(LOC, OutOfRangeError, "Begin iterator out of range."));
    ecl_assert_throw((e_iter <= array+length), StandardException(LOC, OutOfRangeError, "End iterator out of range."));
  }

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

  virtual ~Stencil()
  {};

  Stencil<unsigned char*> stencil(const unsigned int& start_index, const unsigned int& n) const ecl_assert_throw_decl(StandardException)
  {
    ecl_assert_throw( b_iter+start_index <= array+length, StandardException(LOC, OutOfRangeError, "Start index provided is larger than the underlying stencil size."));
    ecl_assert_throw( b_iter+start_index+n <= array+length, StandardException(LOC, OutOfRangeError, "Finish index provided is larger than the underlying stencil size."));
    // cant do out of range errors here (no idea how long the underlying array is!)
    return Stencil<unsigned char*>(array,length,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+start_index;
    e_iter = array+start_index+n;
    ecl_assert_throw((b_iter <= array + length), StandardException(LOC, OutOfRangeError, "Begin iterator out of range."));
    ecl_assert_throw((e_iter <= array + length), StandardException(LOC, OutOfRangeError, "End iterator out of range."));
  }

  /*********************
   ** Assignment
   **********************/
  containers::BoundedListInitialiser<value_type,iterator> operator<< (const value_type &value)
  {
    return containers::BoundedListInitialiser<value_type,iterator>(value, begin(), size());
  }
  Stencil<unsigned char*>& operator=(const Stencil<unsigned char*> &s) ecl_assert_throw_decl(StandardException)
  {
    array = s.array;
    length = s.length;
    b_iter = s.b_iter;
    e_iter = s.e_iter;
    return *this;
  }

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

  /*********************
   ** Front/Back
   **********************/
  reference front() ecl_assert_throw_decl(StandardException)
  {
    ecl_assert_throw( b_iter <= array+length, StandardException(LOC,OutOfRangeError));
    return *b_iter;
  }
  const_reference front() const ecl_assert_throw_decl(StandardException)
  {
    ecl_assert_throw( b_iter <= array+length, StandardException(LOC,OutOfRangeError));
    return *b_iter;
  }
  reference back() ecl_assert_throw_decl(StandardException)
  {
    ecl_assert_throw( e_iter <= array+length, StandardException(LOC,OutOfRangeError));
    return *(e_iter-1);
  }
  const_reference back() const ecl_assert_throw_decl(StandardException)
  {
    ecl_assert_throw( e_iter <= array+length, 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, StandardException(LOC,OutOfRangeError));
    ecl_assert_throw( b_iter+i <= array+length, 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, StandardException(LOC,OutOfRangeError));
    ecl_assert_throw( b_iter+i <= array+length, StandardException(LOC,OutOfRangeError));
    return *(b_iter+i);
  }
  reference at(size_type i) throw(StandardException)
  {
    if ( b_iter+i <= array )
    {
      throw StandardException(LOC,OutOfRangeError);
    }
    if ( b_iter+i >= array+length )
    {
      throw StandardException(LOC,OutOfRangeError);
    }
    return *(b_iter+i);
  }
  const_reference at(size_type i) const throw(StandardException)
  {
    if ( b_iter+i <= array )
    {
      throw StandardException(LOC,OutOfRangeError);
    }
    if ( b_iter+i >= array+length )
    {
      throw StandardException(LOC,OutOfRangeError);
    }
    return *(b_iter+i);
  }

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

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

private:
  iterator array;
  unsigned int length;
  iterator b_iter, e_iter;
};

/*****************************************************************************
 ** Const Specialisations
 *****************************************************************************/

template <>
class ECL_PUBLIC Stencil<const unsigned char*>
{
public:
  /*********************
   ** Typedefs
   **********************/
  typedef unsigned char value_type; 
  typedef const unsigned char* iterator; 
  typedef const unsigned char* const_iterator; 
  typedef const unsigned char& reference; 
  typedef const unsigned char& const_reference; 
  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(const_iterator underlying_array, const unsigned int& length, const_iterator begin_iter, const_iterator end_iter) ecl_assert_throw_decl(StandardException) :
  array(underlying_array),
  length(length),
  b_iter(begin_iter),
  e_iter(end_iter)
  {
    ecl_assert_throw((b_iter <= array+length), StandardException(LOC, OutOfRangeError, "Begin iterator out of range."));
    ecl_assert_throw((e_iter <= array+length), StandardException(LOC, OutOfRangeError, "End iterator out of range."));
  }

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

  virtual ~Stencil()
  {};

  Stencil<const unsigned char*> stencil(const unsigned int& start_index, const unsigned int& n) const ecl_assert_throw_decl(StandardException)
  {
    ecl_assert_throw( b_iter+start_index <= array+length, StandardException(LOC, OutOfRangeError, "Start index provided is larger than the underlying stencil size."));
    ecl_assert_throw( b_iter+start_index+n <= array+length, StandardException(LOC, OutOfRangeError, "Finish index provided is larger than the underlying stencil size."));
    // cant do out of range errors here (no idea how long the underlying array is!)
    return Stencil<const unsigned char*>(array,length,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+start_index;
    e_iter = array+start_index+n;
    ecl_assert_throw((b_iter <= array + length), StandardException(LOC, OutOfRangeError, "Begin iterator out of range."));
    ecl_assert_throw((e_iter <= array + length), StandardException(LOC, OutOfRangeError, "End iterator out of range."));
  }
  Stencil<const unsigned char*>& operator=(const Stencil<const unsigned char*> &s) ecl_assert_throw_decl(StandardException)
  {
    array = s.array;
    length = s.length;
    b_iter = s.b_iter;
    e_iter = s.e_iter;
    return *this;
  }

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

  /*********************
   ** Front/Back
   **********************/
  reference front() ecl_assert_throw_decl(StandardException)
  {
    ecl_assert_throw( b_iter <= array+length, StandardException(LOC,OutOfRangeError));
    return *b_iter;
  }
  const_reference front() const ecl_assert_throw_decl(StandardException)
  {
    ecl_assert_throw( b_iter <= array+length, StandardException(LOC,OutOfRangeError));
    return *b_iter;
  }
  reference back() ecl_assert_throw_decl(StandardException)
  {
    ecl_assert_throw( e_iter <= array+length, StandardException(LOC,OutOfRangeError));
    return *(e_iter-1);
  }
  const_reference back() const ecl_assert_throw_decl(StandardException)
  {
    ecl_assert_throw( e_iter <= array+length, 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, StandardException(LOC,OutOfRangeError));
    ecl_assert_throw( b_iter+i <= array+length, 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, StandardException(LOC,OutOfRangeError));
    ecl_assert_throw( b_iter+i <= array+length, StandardException(LOC,OutOfRangeError));
    return *(b_iter+i);
  }
  reference at(size_type i) throw(StandardException)
  {
    if ( b_iter+i <= array )
    {
      throw StandardException(LOC,OutOfRangeError);
    }
    if ( b_iter+i >= array+length )
    {
      throw StandardException(LOC,OutOfRangeError);
    }
    return *(b_iter+i);
  }
  const_reference at(size_type i) const throw(StandardException)
  {
    if ( b_iter+i <= array )
    {
      throw StandardException(LOC,OutOfRangeError);
    }
    if ( b_iter+i >= array+length )
    {
      throw StandardException(LOC,OutOfRangeError);
    }
    return *(b_iter+i);
  }

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

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

private:
  const_iterator array;
  unsigned int length;
  const_iterator b_iter, e_iter;
};

} // namespace ecl

#endif /* ecl_containers_SPECIALISATIONS_HPP_ */