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_ */