array/formatters.hpp

Go to the documentation of this file.

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

#ifndef ECL_CONTAINERS_ARRAY_FORMATTERS_HPP_
#define ECL_CONTAINERS_ARRAY_FORMATTERS_HPP_

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

#include <cmath>
#include <ecl/config/macros.hpp>
#include <ecl/formatters/common.hpp>
#include <ecl/formatters/number.hpp>
#include <ecl/formatters/floats.hpp>
#include "../common/formatters.hpp"
#include "../array.hpp"

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

namespace ecl
{
namespace formatters
{

/*****************************************************************************
 ** Using
 *****************************************************************************/

template<typename Type, size_t N>
class ECL_PUBLIC ArrayFormatter
{
public:
  virtual ~ArrayFormatter()
  {}
  ecl::Array<Type,N>& operator()(ecl::Array<Type,N> &array) {
    return array;
  }
};

/*****************************************************************************
 ** Interface [ByteArrayFormatter]
 *****************************************************************************/

template<typename Byte, size_t N>
class ECL_PUBLIC ByteArrayFormatter
{
public:
  ByteArrayFormatter() : ready_to_format(false)
  {};
  ByteArrayFormatter<Byte,N>& operator()(const Array<Byte,N> &array)
  {
    begin_iterator = array.begin();
    end_iterator = array.end();
    ready_to_format = true;
    return *this;
  }
  ByteArrayFormatter<Byte,N>& operator()(const Stencil< Array<Byte,N> > &stencil)
  {
    begin_iterator = stencil.begin();
    end_iterator = stencil.end();
    ready_to_format = true;
    return *this;
  }
  ByteArrayFormatter<Byte,N>& operator()(typename Array<Byte,N>::const_iterator begin_iter,
      typename Array<Byte,N>::const_iterator end_iter
  )
  {

    begin_iterator = begin_iter;
    end_iterator = end_iter;
    ready_to_format = true;
    return *this;
  }

  virtual ~ByteArrayFormatter()
  {}
  template <typename OutputStream, typename CharType, size_t M>
  friend OutputStream& operator << (OutputStream& ostream, const ByteArrayFormatter<CharType,M> &formatter);

private:
  typename Array<Byte,N>::const_iterator begin_iterator;
  typename Array<Byte,N>::const_iterator end_iterator;
  bool ready_to_format;
};

/*****************************************************************************
 ** Implementation [ByteArrayFormatter]
 *****************************************************************************/

template <typename OutputStream, typename CharType, size_t M>
OutputStream& operator <<(OutputStream& ostream, const ByteArrayFormatter<CharType, M> &formatter)
{
  ecl_assert_throw(formatter.ready_to_format, StandardException(LOC,UsageError,"The formatter cannot print any data - "
          "either there is no data available, or you have tried to use the "
          "formatter more than once in a single streaming operation. "
          "C++ produces unspecified results when functors are used multiply "
          "in the same stream sequence, so this is not permitted here.") );

  ecl::Format<CharType> format(-1, ecl::NoAlign, ecl::Hex);
  typename ecl::Array<CharType, M>::const_iterator iter;
ostream  << "[ ";
  for ( iter = formatter.begin_iterator; iter != formatter.end_iterator; ++iter )
  {
    ostream << format(*iter) << " ";
  }
  ostream << "]";
  ostream.flush();
  return ostream;
}

/*****************************************************************************
 ** Specialisations [ArrayFormatter][Char Types]
 *****************************************************************************/
template<size_t N>
class ECL_PUBLIC ArrayFormatter< signed char,N > : public ByteArrayFormatter<signed char, N>
{};

template<size_t N>
class ECL_PUBLIC ArrayFormatter< char,N > : public ByteArrayFormatter<char, N>
{};

template<size_t N>
class ECL_PUBLIC ArrayFormatter< unsigned char,N > : public ByteArrayFormatter<unsigned char, N>
{
};

template<size_t N>
class ECL_PUBLIC ArrayFormatter< float,N > : public FloatContainerFormatter< Array<float,N> >
{
public:
  ArrayFormatter(const int p=2, const int w=-1) : FloatContainerFormatter< Array<float,N> >(p,w)
  {};
  virtual ~ArrayFormatter()
  {}
};

template<size_t N>
class ECL_PUBLIC ArrayFormatter< double,N > : public FloatContainerFormatter< Array<double,N> >
{
public:
  ArrayFormatter(const int p=2, const int w=-1) : FloatContainerFormatter< Array<double,N> >(p,w)
  {};
  virtual ~ArrayFormatter()
  {}
};

} // namespace formatters
} // namespace ecl

#endif /* ECL_CONTAINERS_ARRAY_FORMATTERS_HPP_ */