TabularStream.h

Go to the documentation of this file.

#ifndef _utl_TabularStream_h_
#define _utl_TabularStream_h_

#include <string>
#include <iostream>
#include <vector>
#include <deque>
#include <sstream>

#include <utl/ErrorLogger.h>


namespace utl {



  class TableCell {
  public:
    TableCell() { }
    TableCell(const TableCell& c) : fEntry(c.fEntry.str()) { }
    TableCell& operator=(const TableCell& c)
    { fEntry.str(c.fEntry.str()); return *this; }

  private:
    enum Justification {
      eFlushLeft,
      eFlushRight,
      eCenter,
      eCharAligned
    };

    template<typename T>
    TableCell& operator<<(const T& item) { fEntry << item; return *this; }

    std::string GetEntry(const int left = 0, const int right = 0) const
    { return std::string(left, ' ') + fEntry.str() + std::string(right, ' '); }

    std::string GetEntry(const Justification just, const int totalSize,
                         const int leftSize = 0, const char mid = '\0') const;

    int GetSize() const { return fEntry.str().size(); }

    std::pair<int, int> GetSize(const char mid) const;

    std::ostringstream fEntry;

    friend class TableColumn;
    friend class TabularStream;
  };


  // Holds one column of TableCells in the TabularStream class

  class TableColumn {
  public:
    TableColumn() : fWidth(-1) { }

  private:
    template<typename T>
    TableColumn& operator<<(const T& junk)
    { Front() << junk; return *this; }

    int GetLength() const { return fCells.size(); }

    void SetMargins(const std::string& prefix,
                    const std::string& postfix = std::string())
    { fPrefix = prefix; fPostfix = postfix; }

    void SetJustification(const TableCell::Justification just, const char mid = '\0')
    { fJustification = just; fMidChar = mid; }

    std::string Pop();

    void PopFront() { if (!fCells.empty()) fCells.pop_front(); }

    TableCell& Front() { return fCells.front(); }

    void Push() { fCells.push_front(TableCell()); }

    bool Empty() { return fCells.empty(); }

    void CalculateWidths();

    std::string fPrefix;
    std::string fPostfix;
    TableCell::Justification fJustification;
    char fMidChar;
    std::deque<TableCell> fCells;
    int fWidth;
    int fLeftWidth;

    friend class TabularStream;
  };



  class EndColumn {
  };

  const EndColumn endc = EndColumn();



  class EndRow {
  };

  const EndRow endr = EndRow();


  class DeleteRow {
  };

  const DeleteRow delr = DeleteRow();


  class HLine {
  public:
    HLine(const char sign) : fChar(sign) { }
    char GetChar() const { return fChar; }
  private:
    char fChar;
  };

  const HLine hline('-');


  class TabularStream {
  public:
    TabularStream(const std::string& format)
    { Clear(format); }

    void Clear() { fColumns.clear(); fMakeNewRow = true; }

    void Clear(const std::string& format)
    { Clear(); MakeFormat(format); }

    template<typename T>
    TabularStream&
    operator<<(const T& junk)
    {
      CheckFirst();
      *fCurrentColumn << junk;
      return *this;
    }

    TabularStream& operator<<(const EndColumn)
    { CheckFirst(); NextColumn(); return *this; }

    TabularStream& operator<<(const EndRow)
    { CheckFirst(); NextRow(); return *this; }

    TabularStream&
    operator<<(const HLine hl)
    {
      CheckFirst();
      if (fCurrentColumn != fColumns.begin())
        *this << "ERROR: hline can be used only at the begining of a new line";
      else {
        for (Columns::iterator cIt = fColumns.begin();
             cIt != fColumns.end(); ++cIt)
          *cIt << ((std::string("\r") + hl.GetChar()));
      }
      fMakeNewRow = true;
      return *this;
    }

    TabularStream&
    operator<<(const DeleteRow)
    {
      for (Columns::iterator cIt = fColumns.begin();
           cIt != fColumns.end(); ++cIt)
        cIt->PopFront();
      fMakeNewRow = true;
      return *this;
    }

    std::string Str();

  private:
    void MakeFormat(const std::string& format);

    void
    CheckFirst()
    {
      if (fMakeNewRow) {
        NextRow();
        fMakeNewRow = false;
      }
    }

    void
    NextColumn()
    {
      ++fCurrentColumn;
      if (fCurrentColumn == fColumns.end()) {
        ERROR("Running out of columns, will fill the last one!");
        --fCurrentColumn;
      }
    }

    void
    NextRow()
    {
      for (Columns::iterator cIt = fColumns.begin();
           cIt != fColumns.end(); ++cIt)
        cIt->Push();
      fCurrentColumn = fColumns.begin();
    }

    typedef std::vector<TableColumn> Columns;
    Columns::iterator fCurrentColumn;
    Columns fColumns;
    bool fMakeNewRow;

  };


  inline
  std::ostream&
  operator<<(std::ostream& os, TabularStream& ts)
  {
    return os << ts.Str();
  }

}

#endif