JPrint.hh

Go to the documentation of this file.

#ifndef __JEEP__JPRINT__
#define __JEEP__JPRINT__

#include <string>
#include <ostream>
#include <sstream>
#include <iomanip>

#include "Jeep/JStreamToolkit.hh"


/**
 * \file
 * I/O formatting auxiliaries.
 * \author mdejong
 */
namespace JEEP {}
namespace JPP { using namespace JEEP; }

namespace JEEP {

  /**
   * Get index for user I/O manipulation.
   *
   * \return           index
   */
  inline int getIndex() 
  {
    static const int index = std::ios_base::xalloc();

    return index;
  }

  
  /**
   * Print options.
   */
  enum JPrintOption_t {
    SHORT_PRINT  = 1,    //!< short  print
    MEDIUM_PRINT = 2,    //!< medium print
    LONG_PRINT   = 3     //!< long   print
  };


  /**
   * Get output stream for conversion to std::string.
   *
   * Note that the stream is emptied before use.
   * 
   * \return           output stream
   */
  inline std::ostream& getOstream()
  {
    static std::ostringstream buffer;

    buffer.str("");

    return buffer;
  }


  /**
   * Get output C-string.
   *
   * Note that this method is needed to guarentee livetime of underlying std::string.
   *
   * \param  input     input
   * \return           C-string
   */
  inline const char* getCString(const std::string& input)
  {
    static std::string buffer;

    buffer = input;

    return buffer.c_str();
  }
}


/**
 * Get print option.
 *
 * \param  out       output stream
 * \return           print option
 */
inline int getPrintOption(std::ostream& out)
{
  return out.iword(JEEP::getIndex());
}


/**
 * Set print option.
 *
 * \param  out       output stream
 * \param  option    print option
 */
inline void setPrintOption(std::ostream& out, const int option)
{
  out.iword(JEEP::getIndex()) = option;
}


/**
 * Get short print option.
 *
 * \param  out       output stream
 * \return           true if short print option is on; else false
 */
inline bool getShortprint(std::ostream& out)
{
  return getPrintOption(out) == JEEP::SHORT_PRINT;
}


/**
 * Set short print option.
 *
 * \param  out       output stream
 */
inline void setShortprint(std::ostream& out)
{
  return setPrintOption(out, JEEP::SHORT_PRINT);
}


/**
 * Get medium print option.
 *
 * \param  out       output stream
 * \return           true if medium print option is on; else false
 */
inline bool getMediumprint(std::ostream& out)
{
  return getPrintOption(out) == JEEP::MEDIUM_PRINT;
}


/**
 * Set medium print option.
 *
 * \param  out       output stream
 */
inline void setMediumprint(std::ostream& out)
{
  return setPrintOption(out, JEEP::MEDIUM_PRINT);
}


/**
 * Get long print option.
 *
 * \param  out       output stream
 * \return           true if long print option is on; else false
 */
inline bool getLongprint(std::ostream& out)
{
  return getPrintOption(out) == JEEP::LONG_PRINT;
}


/**
 * Set long print option.
 *
 * \param  out       output stream
 */
inline void setLongprint(std::ostream& out)
{
  return setPrintOption(out, JEEP::LONG_PRINT);
}


/**
 * Set short printing.
 *
 * \param  out       output stream
 * \return           output stream
 */
inline std::ostream& shortprint(std::ostream& out)
{
  setShortprint(out);

  return out;
}


/**
 * Set medium printing.
 *
 * \param  out       output stream
 * \return           output stream
 */
inline std::ostream& mediumprint(std::ostream& out)
{
  setMediumprint(out);

  return out;
}


/**
 * Set long printing.
 *
 * \param  out       output stream
 * \return           output stream
 */
inline std::ostream& longprint(std::ostream& out)
{
  setLongprint(out);

  return out;
}


/**
 * Print newline character.
 *
 * \param  out       output stream
 * \return           output stream
 */
inline std::ostream& newline(std::ostream& out)
{
  return out << '\n';
}


/**
 * Print white space character.
 *
 * \param  out       output stream
 * \return           output stream
 */
inline std::ostream& whitespace(std::ostream& out)
{
  return out << ' ';
}


/**
 * Print tab character.
 *
 * \param  out       output stream
 * \return           output stream
 */
inline std::ostream& tab(std::ostream& out)
{
  return out << '\t';
}


/**
 * Rewind character.
 *
 * \param  out       output stream
 * \return           output stream
 */
inline std::ostream& rewind(std::ostream& out)
{
  return (out << '\r').flush();
}


/**
 * Auxiliary data structure for alignment of data.
 */
struct WIDTH {
  /**
   * Constructor.
   *
   * \param  width         width
   */
  WIDTH(const int width)
  {
    this->width = width;
  }

  /**
   * Format specifier.
   *
   * \param  out           output stream
   * \param  format        format
   * \return               output stream
   */
  friend inline std::ostream& operator<<(std::ostream& out, const WIDTH& format)
  {
    using namespace std;
    
    return out << setw(format.width);
  }
  
  int  width;
};


/**
 * Auxiliary data structure for alignment of data.
 */
struct LEFT :
  public WIDTH
{
  /**
   * Constructor.
   *
   * \param  width         width
   */
  LEFT(const int width) :
    WIDTH(width)
  {}

  /**
   * Format specifier.
   *
   * \param  out           output stream
   * \param  format        format
   * \return               output stream
   */
  friend inline std::ostream& operator<<(std::ostream& out, const LEFT& format)
  {
    using namespace std;
    
    return out << setw(format.width) << left;
  }
};


/**
 * Auxiliary data structure for alignment of data.
 */
struct RIGHT :
  public WIDTH
{
  /**
   * Constructor.
   *
   * \param  width         width
   */
  RIGHT(const int width) :
    WIDTH(width)
  {}

  /**
   * Format specifier.
   *
   * \param  out           output stream
   * \param  format        format
   * \return               output stream
   */
  friend inline std::ostream& operator<<(std::ostream& out, const RIGHT& format)
  {
    using namespace std;
    
    return out << setw(format.width) << right;
  }
};


/**
 * Auxiliary data structure for sequence of same character.
 */
struct FILL :
  public WIDTH
{
  /**
   * Constructor.
   *
   * \param  width         width
   * \param  fill          fill character
   */
  FILL(const int  width = 0,
       const char fill  = ' ') :
    WIDTH(width)
  {
    this->fill = fill;
  }

  
  /**
   * Format specifier.
   *
   * \param  out           output stream
   * \param  format        format
   * \return               output stream
   */
  friend inline std::ostream& operator<<(std::ostream& out, const FILL& format)
  {
    using namespace std;

    //const char c = out.fill();
    
    return out << setfill(format.fill) << setw(format.width); 
  }

  char fill;
};


/**
 * Auxiliary data structure for alignment of data.
 */
struct CENTER :
  public WIDTH
{
protected:
  /**
   * Auxiliary class for format center.
   */
  struct JCenter :
    public WIDTH 
  {
    /**
     * Constructor.
     *
     * \param  out         output stream
     * \param  format      format center
     */
    JCenter(std::ostream& out, const WIDTH& format) :
      WIDTH(format),
      out   (out)
    {}


    /**
     * Write value to output stream.
     *
     * \param  value       value
     * \return             this JCenter
     */
    template<class T>
    std::ostream& operator<<(const T& value)
    {
      using namespace std;

      ostringstream os;

      os.copyfmt(out);

      os << value;

      const int  w = this->width - os.str().size();
      const char c = this->out.fill();

      if (w > 0)
        return this->out << FILL(w/2) << ' ' << os.str() << FILL((w+1)/2) << ' ' << setfill(c);
      else
        return this->out << os.str();
    }

  private:
    std::ostream& out; 
  };

public:
  /**
   * Constructor.
   *
   * \param  width         width
   */
  CENTER(const int width) :
    WIDTH(width)
  {}


  /**
   * Format specifier.
   *
   * \param  out           output stream
   * \param  format        format
   * \return               output stream
   */
  friend inline JCenter operator<<(std::ostream& out, const CENTER& format)
  {
    return JCenter(out, format);
  }
};


/**
 * Auxiliary data structure for floating point format specification.
 */
struct FIXED :
  public WIDTH
{
  /**
   * Constructor.
   *
   * \param  width         width
   * \param  precision     precision
   */
  FIXED(const int width,
        const int precision) :
    WIDTH(width)
  {
    this->precision = precision;
  }

  /**
   * Format specifier.
   *
   * \param  out           output stream
   * \param  format        format
   * \return               output stream
   */
  friend inline std::ostream& operator<<(std::ostream& out, const FIXED& format)
  {
    using namespace std;
    
    return out << fixed << right << setw(format.width) << setprecision(format.precision);
  }
  
  int precision;
};


/**
 * Auxiliary data structure for floating point format specification.
 */
struct SCIENTIFIC :
  public WIDTH
{
  /**
   * Constructor.
   *
   * \param  width         width
   * \param  precision     precision
   */
  SCIENTIFIC(const int width,
             const int precision) :
    WIDTH(width)
  {
    this->precision = precision;
  }

  /**
   * Format specifier.
   *
   * \param  out           output stream
   * \param  format        format
   * \return               output stream
   */
  friend inline std::ostream& operator<<(std::ostream& out, const SCIENTIFIC& format)
  {
    using namespace std;
    
    return out << scientific << right << setw(format.width) << setprecision(format.precision);
  }
  
  int precision;
};


/**
 * Auxiliary data structure for streaming of STL containers.
 *
 * This manipulator transfers the following stream operation to method JEEP::writeObject
 * so that all STL containers can directly be printed.
 */
struct JEEPZ
{
protected:
  /**
   * Auxiliary class for format STL containers.
   */
  struct JStream
  {
    /**
     * Constructor.
     *
     * \param  out         output stream
     */
    JStream(std::ostream& out) :
      out(out)
    {}


    /**
     * Write value to output stream.
     *
     * \param  value       value
     * \return             this JSTDStreamer
     */
    template<class T>
    std::ostream& operator<<(const T& value)
    {
      return JEEP::writeObject(out, value);
    }

  private:
    std::ostream& out;
  };

public:
  /**
   * Default constructor.
   */
  JEEPZ()
  {}


  /**
   * Format specifier.
   *
   * \param  out           output stream
   * \param  format        format
   * \return               output stream
   */
  friend inline JStream operator<<(std::ostream& out, const JEEPZ& format)
  {
    return JStream(out);
  }
};


/**
 * Auxiliary class to temporarily modify format specifications.
 */
struct JFlags {
  /**
   * Constructor.
   *
   * \param  out       output stream
   */
  JFlags(std::ostream& out) :
    __out(out)
  {
    __flags = out.flags();
  }


  /**
   * Constructor.
   *
   * \param  out       output stream
   * \param  flags     format flags 
   */
  JFlags(std::ostream& out, std::ios::fmtflags flags) :
    __out(out)
  {
    __flags = out.flags();

    out.setf(flags);
  }


  /**
   * Constructor.
   *
   * \param  out       output stream
   * \param  flags     format flags 
   * \param  mask      format mask
   */
  JFlags(std::ostream& out, std::ios::fmtflags flags, std::ios::fmtflags mask) :
    __out(out)
  {
    __flags = out.flags();

    out.setf(flags, mask);
  }


  /**
   * Destructor.
   *
   * This destructor restores the old format specifications.
   */
  ~JFlags()
  {
    __out.flags(__flags);
  }

protected:
  std::ostream&      __out;
  std::ios::fmtflags __flags;
  std::ios::fmtflags __mask;
};


/**
 * Make string for variadic macro.
 *
 * When called,
 *  - first argument should correspond to a dummy value;
 *  - second to the ##__VA_ARGS__ macro; and
 *  - third to the fall back value (e.g. "");
 *
 * \param  A           dummy value
 * \param  B           ##__VA_ARGS__ macro
 * \return             std::string
 */
#define VARGS_STRING(A, B, ...) MAKE_STRING(B)


/**
 * Make string.
 *
 * \param  A           std::ostream compatible construct
 * \return             std::string
 */
#define MAKE_STRING(A) (static_cast<std::ostringstream&>(JEEP::getOstream() << A)).str()


/**
 * Make C-string.
 *
 * \param  A           std::ostream compatible construct
 * \return             C-string
 */
#define MAKE_CSTRING(A) JEEP::getCString(MAKE_STRING(A))

#endif