output.h

Go to the documentation of this file.

#ifndef OUTPUT_H
#define OUTPUT_H
#include "printable.h"
#include <boost/function.hpp>
#include <blitz/array.h>
#include <boost/shared_ptr.hpp>
#include <boost/bind.hpp>
#include <boost/lambda/lambda.hpp>
#include <boost/any.hpp>
#include <map>
#include <string>
#include <stdint.h>

namespace FullPhysics {
// Helper class to handle level padding.
// Don't have Doxygen document this class.
template<class T> class LevelPad {
public:
  LevelPad(const boost::function<blitz::Array<T, 1> ()>& F, T Fill, int Fullsize)
    : f(F), fill(Fill), fullsize(Fullsize) {}
  blitz::Array<T, 1> operator()() const
  {
    blitz::Array<T, 1> res(fullsize);
    res = fill;
    blitz::Array<T, 1> t = f();
    res(blitz::Range(0, t.rows() - 1)) = t;
    return res;
  }
private:
  boost::function<blitz::Array<T, 1> ()> f;
  T fill;
  int fullsize;
};

template<class T> class LevelPad2 {
public:
  LevelPad2(const boost::function<blitz::Array<T, 2> ()>& F, T Fill, int Fullsize)
    : f(F), fill(Fill), fullsize(Fullsize) {}
  blitz::Array<T, 2> operator()() const
  {
    blitz::Array<T, 2> res(fullsize);
    res = fill;
    blitz::Array<T, 2> t = f();
    res(blitz::Range(0, t.rows() - 1),
        blitz::Range(0, t.rows() - 1)) = t;
    return res;
  }
private:
  boost::function<blitz::Array<T, 2> ()> f;
  T fill;
  int fullsize;
};



/****************************************************************/
class Output : public Printable<Output> {
public:
  virtual ~Output() {};
  virtual void print(std::ostream& Os) const { Os << "Output";}

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

  template<class S, class T, int D> void
  register_data_source(const std::string& Dataset_name,
                       blitz::Array<T, D> (S::*Pmf)() const,
                       const boost::shared_ptr<S>& Src)
  {
    boost::function<blitz::Array<T, D> ()> f = boost::bind(Pmf, Src);
    register_data_source(Dataset_name, f);
  }

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

  template<class S, class T> void
  register_data_source_pad(const std::string& Dataset_name,
                           blitz::Array<T, 1> (S::*Pmf)() const,
                           const boost::shared_ptr<S>& Src,
                           int Full_size,
                           T Fill_value)
  {
    boost::function<blitz::Array<T, 1> ()> f = boost::bind(Pmf, Src);
    boost::function<blitz::Array<T, 1> ()> f2 =
      LevelPad<T>(f, Fill_value, Full_size);
    register_data_source(Dataset_name, f2);
  }
  
  template<class S, class T> void
  register_data_source_pad(const std::string& Dataset_name,
                           blitz::Array<T, 2> (S::*Pmf)() const,
                           const boost::shared_ptr<S>& Src,
                           int Full_size,
                           T Fill_value)
  {
    boost::function<blitz::Array<T, 2> ()> f = boost::bind(Pmf, Src);
    boost::function<blitz::Array<T, 2> ()> f2 =
      LevelPad2<T>(f, Fill_value, Full_size);
    register_data_source(Dataset_name, f2);
  }
  
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------

  template<class S, class T> void
  register_data_source(const std::string& Dataset_name,
                       T (S::*Pmf)() const,
                       const boost::shared_ptr<S>& Src)
  {
    boost::function<T ()> f = boost::bind(Pmf, Src);
    register_data_source(Dataset_name, f);
  }
  
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------

  template<class T, int D> void
  register_data_source(const std::string& Dataset_name,
                       const blitz::Array<T, D>& Val)
  {
    boost::function<blitz::Array<T, D> ()> f = 
      boost::lambda::constant(Val.copy());
    register_data_source(Dataset_name, f);
  }

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

  template<class T> void
  register_data_source(const std::string& Dataset_name,
                       const T& Val)
  {
    boost::function<T ()> f = boost::lambda::constant(Val);
    register_data_source(Dataset_name, f);
  }

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

  template<class T> 
  void register_data_source(const std::string& Dataset_name,
                            boost::function<T> f)
  { func[Dataset_name] = f;}
  void write();
  void write_best_attempt();
protected:

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

  virtual void start_write() {};

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

  virtual void end_write() {};

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

  virtual void end_because_of_error() {}

//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
  virtual void write_data(const std::string& Dataset_name, int Val) = 0;
  virtual void write_data(const std::string& Dataset_name, int64_t Val) = 0;
  virtual void write_data(const std::string& Dataset_name, double Val) = 0;
  virtual void write_data(const std::string& Dataset_name, 
                          const std::string& Val) = 0;
  virtual void write_data(const std::string& Dataset_name, 
                          const char* Val) = 0;
  virtual void write_data(const std::string& Dataset_name, 
                  const blitz::Array<int, 1>& Val) = 0;
  virtual void write_data(const std::string& Dataset_name, 
                  const blitz::Array<std::string, 1>& Val) = 0;
  virtual void write_data(const std::string& Dataset_name, 
                  const blitz::Array<const char*, 1>& Val) = 0;
  virtual void write_data(const std::string& Dataset_name, 
                  const blitz::Array<double, 1>& Val) = 0;
  virtual void write_data(const std::string& Dataset_name, 
                  const blitz::Array<int, 2>& Val) = 0;
  virtual void write_data(const std::string& Dataset_name, 
                  const blitz::Array<std::string, 2>& Val) = 0;
  virtual void write_data(const std::string& Dataset_name, 
                  const blitz::Array<const char*, 2>& Val) = 0;
  virtual void write_data(const std::string& Dataset_name, 
                  const blitz::Array<double, 2>& Val) = 0;
  virtual void write_data(const std::string& Dataset_name, 
                  const blitz::Array<int, 3>& Val) = 0;
  virtual void write_data(const std::string& Dataset_name, 
                  const blitz::Array<std::string, 3>& Val) = 0;
  virtual void write_data(const std::string& Dataset_name, 
                  const blitz::Array<const char*, 3>& Val) = 0;
  virtual void write_data(const std::string& Dataset_name, 
                  const blitz::Array<double, 3>& Val) = 0;
private:
  template<class T> 
  void pass_to_write_t(const std::string& Dataset_name, boost::any* D);
  void pass_to_write(const std::string& Dataset_name, boost::any* D);
  std::map<std::string, boost::any> func;
};

/****************************************************************/
template<class T> class OutputTemplate : public Output 
{
public:
  virtual ~OutputTemplate() {}
protected:
  virtual void write_data(const std::string& Dataset_name, int Val)
  { ((T*)this)->write_data_t(Dataset_name, Val); }
  virtual void write_data(const std::string& Dataset_name, int64_t Val)
  { ((T*)this)->write_data_t(Dataset_name, Val); }
  virtual void write_data(const std::string& Dataset_name, double Val)
  { ((T*)this)->write_data_t(Dataset_name, Val); }
  virtual void write_data(const std::string& Dataset_name, 
                          const std::string& Val)
  { ((T*)this)->write_data_t(Dataset_name, Val); }
  virtual void write_data(const std::string& Dataset_name, 
                          const char* Val)
  { ((T*)this)->write_data_t(Dataset_name, Val); }
  virtual void write_data(const std::string& Dataset_name, 
                  const blitz::Array<int, 1>& Val)
  { ((T*)this)->write_data_t(Dataset_name, Val); }
  virtual void write_data(const std::string& Dataset_name, 
                  const blitz::Array<std::string, 1>& Val)
  { ((T*)this)->write_data_t(Dataset_name, Val); }
  virtual void write_data(const std::string& Dataset_name, 
                  const blitz::Array<const char*, 1>& Val)
  { ((T*)this)->write_data_t(Dataset_name, Val); }
  virtual void write_data(const std::string& Dataset_name, 
                  const blitz::Array<double, 1>& Val)
  { ((T*)this)->write_data_t(Dataset_name, Val); }
  virtual void write_data(const std::string& Dataset_name, 
                  const blitz::Array<int, 2>& Val)
  { ((T*)this)->write_data_t(Dataset_name, Val); }
  virtual void write_data(const std::string& Dataset_name, 
                  const blitz::Array<std::string, 2>& Val)
  { ((T*)this)->write_data_t(Dataset_name, Val); }
  virtual void write_data(const std::string& Dataset_name, 
                  const blitz::Array<const char*, 2>& Val)
  { ((T*)this)->write_data_t(Dataset_name, Val); }
  virtual void write_data(const std::string& Dataset_name, 
                  const blitz::Array<double, 2>& Val)
  { ((T*)this)->write_data_t(Dataset_name, Val); }
  virtual void write_data(const std::string& Dataset_name, 
                  const blitz::Array<int, 3>& Val)
  { ((T*)this)->write_data_t(Dataset_name, Val); }
  virtual void write_data(const std::string& Dataset_name, 
                  const blitz::Array<std::string, 3>& Val)
  { ((T*)this)->write_data_t(Dataset_name, Val); }
  virtual void write_data(const std::string& Dataset_name, 
                  const blitz::Array<const char*, 3>& Val)
  { ((T*)this)->write_data_t(Dataset_name, Val); }
  virtual void write_data(const std::string& Dataset_name, 
                  const blitz::Array<double, 3>& Val)
  { ((T*)this)->write_data_t(Dataset_name, Val); }
};

class OutputDouble : public GenericObject {
public:
  OutputDouble() {}
  virtual ~OutputDouble() {}
  virtual double f() const = 0;
};

class OutputBlitz1d : public GenericObject {
public:
  OutputBlitz1d() {}
  virtual ~OutputBlitz1d() {}
  virtual blitz::Array<double,1> f() const = 0;
};

class OutputBlitz2d  : public GenericObject {
public:
  OutputBlitz2d() {}
  virtual ~OutputBlitz2d() {}
  virtual blitz::Array<double,2> f() const = 0;
};
}
  
#endif