JManip.hh

Go to the documentation of this file.

#ifndef __JLANG_JMANIP__
#define __JLANG_JMANIP__

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


/**
 * \file
 * I/O manipulators.
 * \author mdejong
 */
namespace JLANG {}
namespace JPP { using namespace JLANG; }

namespace JLANG {

  /**
   * 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 print option.
 *
 * \param  out       output stream
 * \return           print option
 */
inline int getPrintOption(std::ostream& out)
{
  return out.iword(JLANG::getIndex());
}


/**
 * Set print option.
 *
 * \param  out       output stream
 * \param  option    print option
 */
inline void setPrintOption(std::ostream& out, const int option)
{
  out.iword(JLANG::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) == JLANG::SHORT_PRINT;
}


/**
 * Set short print option.
 *
 * \param  out       output stream
 */
inline void setShortprint(std::ostream& out)
{
  return setPrintOption(out, JLANG::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) == JLANG::MEDIUM_PRINT;
}


/**
 * Set medium print option.
 *
 * \param  out       output stream
 */
inline void setMediumprint(std::ostream& out)
{
  return setPrintOption(out, JLANG::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) == JLANG::LONG_PRINT;
}


/**
 * Set long print option.
 *
 * \param  out       output stream
 */
inline void setLongprint(std::ostream& out)
{
  return setPrintOption(out, JLANG::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;

    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;
};


/**
 * Data structure for format specifications.
 */
struct JFormat_t {

  typedef std::ios_base::fmtflags  fmtflags;

  /**
   * Default constructor.
   */
  JFormat_t() :
    width    (0),
    precision(0),
    flags    (),
    fill     (' ') 
  {}


  /**
   * Constructor.
   *
   * \param  width        width
   * \param  precision    precision
   * \param  flags        flags
   * \param  fill         fill character
   */
  JFormat_t(const int      width,
            const int      precision  = 0,
            const fmtflags flags      = fmtflags(),
            const char     fill       = ' ') :
    width    (width),
    precision(precision),
    flags    (flags),
    fill     (fill)
  {}
  

  /**
   * Constructor.
   *
   * \param  out          output stream
   */
  JFormat_t(std::ostream& out)
  {
    get(out);
  }


  /**
   * Check validity of this manipulator.
   *
   * \return              true if valid; else false
   */
  inline bool is_valid() const
  {
    return (width > 0);
  }

  
  /**
   * Get format specificaton from given output stream.
   *
   * \param  out          output stream
   */
  void get(std::ostream& out)
  {
    this->width     = out.width();
    this->precision = out.precision();
    this->flags     = out.flags();
    this->fill      = out.fill();
  }


  /**
   * Put format specificaton to given output stream.
   *
   * \param  out          output stream
   */
  void put(std::ostream& out) const
  {
    out.width    (this->width);
    out.precision(this->precision);
    out.flags    (this->flags);
    out.fill     (this->fill);
  }


  /**
   * Format specifier.
   *
   * \param  out           output stream
   * \param  format        format
   * \return               output stream
   */
  friend inline std::ostream& operator<<(std::ostream& out, const JFormat_t& format)
  {
    format.put(out);
    
    return out;
  }
  
  int      width;
  int      precision;
  fmtflags flags;
  char     fill;
};


/**
 * Auxiliary class to temporarily define format specifications.
 *
 * The format specification of the output stream in use will be restored when this object is destroyed.
 */
struct JFormat :
  public JFormat_t
{
  /**
   * Constructor.
   *
   * \param  out       output stream
   */
  JFormat(std::ostream& out) :
    JFormat_t(),
    out      (out),
    format   (out)
  {}


  /**
   * Constructor.
   *
   * \param  out       output stream
   * \param  format    format
   */
  JFormat(std::ostream& out, const JFormat_t& format) :
    JFormat_t(format),
    out      (out),
    format   (out)
  {}


  /**
   * Destructor.
   */
  ~JFormat()
  {
    format.put(out);
  }

private:
  std::ostream&   out;
  const JFormat_t format;
};


/**
 * Get format for given type.
 *
 * \return           format
 */
template<class T>
inline JFormat_t& getFormat()
{
  static JFormat_t manip;

  return manip;
}


/**
 * Get format for given type.
 *
 * \param  format    default format
 * \return           actual  format
 */
template<class T>
inline JFormat_t getFormat(const JFormat_t& format)
{
  const JFormat_t& buffer = getFormat<T>();

  if (buffer.is_valid())
    return buffer;
  else
    return format;
}


/**
 * Set format for given type.
 *
 * \param  format    format
 */
template<class T>
inline void setFormat(const JFormat_t& format)
{
  getFormat<T>() = format;
}


/**
 * Auxiliary data structure to convert (lambda) function to printable object.
 *
 * The (lambda) function should conform with the type definition LAMBDA::function_type.\n
 * This data structure acts as a simple "wrapper" and should be used if the lambda has capture functionality.
 */
struct LAMBDA {
  /**
   * Type definition of print function.
   */
  typedef std::function<void(std::ostream&)>  function_type;


  /**
   * Constructor.
   *
   * \param  f1         (lambda) function
   */
  LAMBDA(const function_type& f1) :
    f1(f1)
  {}


  /**
   * Write printable object to output stream.
   *
   * \param  out        output stream
   * \param  object     printable object
   * \return            output stream
   */
  friend inline std::ostream& operator<<(std::ostream& out, const LAMBDA& object)
  {
    object.f1(out);

    return out;
  }

private:
  const function_type& f1;
};

#endif