table_stream.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ \.
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Vicente Mataix Ferrandiz
//  Inspired in bprinter, work of Dat Chu: https://github.com/dattanchu/bprinter
//  Removing all the dependencies of boost::karma and adding bold fonts and additional functionalities needed
//
 
#ifndef KRATOS_TABLE_STREAM_H_INCLUDED
#define KRATOS_TABLE_STREAM_H_INCLUDED
 
// System includes
#include <iostream>
#include <iomanip>
#include <vector>
#include <string>
#include <sstream>
 
// External includes
 
// Project includes
#include "includes/serializer.h"
#include "includes/exception.h"
 
namespace Kratos
{
 
 
 
 
 
 
class endl{};
 
class TableStream
{
public:
 
 
    KRATOS_CLASS_POINTER_DEFINITION(TableStream);
 
 
    TableStream(
        std::ostream * Output,
        const std::string& Separator = "|",
        const bool UseBoldFont = true
        ) : mOutStream(Output),
            mSeparator(Separator),
            mBoldFont(UseBoldFont)
    {
        // Initialize values
        mIndexRow    = 0;
        mIndexColumn = 0;
        mTableWidth  = 0;
        mFlushLeft = false;
    }
 
    virtual ~TableStream() = default;
 
 
    template<typename TClass>
    TableStream& operator<<(TClass Input)
    {
        if (typeid(TClass) == typeid(endl)) {
            while (mIndexColumn != 0) {
                *this << "";
            }
        } else {
            if (mIndexColumn == 0) {
                *mOutStream << "|";
            }
 
            if(mFlushLeft) {
                *mOutStream << std::left;
            } else {
                *mOutStream << std::right;
            }
 
            // Leave 3 extra space: One for negative sign, one for zero, one for decimal
            *mOutStream << std::setw(mColumnWidths.at(mIndexColumn)) << Input;
 
            if (mIndexColumn == GetNumColumns()-1) {
                *mOutStream << "|\n";
                mIndexRow = mIndexRow + 1;
                mIndexColumn = 0;
            } else {
                *mOutStream << mSeparator;
                mIndexColumn = mIndexColumn + 1;
            }
        }
 
        return *this;
    }
 
    TableStream& operator<<(float Input)
    {
        OutputDecimalNumber<float>(Input);
        return *this;
    }
 
    TableStream& operator<<(double Input)
    {
        OutputDecimalNumber<double>(Input);
        return *this;
    }
 
 
    unsigned int GetNumColumns() const
    {
        return mColumnHeaders.size();
    }
 
    unsigned int GetTableWidth() const
    {
        return mTableWidth;
    }
 
    void SetSeparator(const std::string& Separator)
    {
        mSeparator = Separator;
    }
 
    void SetBold(const bool& UseBoldFont)
    {
        mBoldFont = UseBoldFont;
    }
 
    void SetFlushLeft()
    {
        mFlushLeft = true;
    }
 
    void SetFlushRight()
    {
        mFlushLeft = false;
    }
 
    void AddColumn(
        const std::string& HeaderName,
        const int ColumnWidth
        )
    {
        KRATOS_ERROR_IF(ColumnWidth < 4) << "Column size has to be >= 4" << std::endl;
 
        mColumnHeaders.push_back(HeaderName);
        mColumnWidths.push_back(ColumnWidth);
        mTableWidth += ColumnWidth + mSeparator.size(); // for the separator
    }
 
    void PrintHeader()
    {
        PrintHorizontalLine();
 
        if (mBoldFont == true) {
        #if !defined(_WIN32)
            *mOutStream << "\x1B[1m";
        #endif
        }
 
        *mOutStream << "|";
 
        for (unsigned int i = 0; i < GetNumColumns(); ++i) {
            if(mFlushLeft) {
                *mOutStream << std::left;
            } else {
                *mOutStream << std::right;
            }
 
            *mOutStream << std::setw(mColumnWidths.at(i)) << mColumnHeaders.at(i).substr(0, mColumnWidths.at(i));
 
            if (i != GetNumColumns()-1) {
                *mOutStream << mSeparator;
            }
        }
 
        *mOutStream << "|";
 
        if (mBoldFont == true) {
        #if !defined(_WIN32)
            *mOutStream << "\x1B[0m";
        #endif
        }
 
        *mOutStream << "\n";
 
        PrintHorizontalLine();
    }
 
    void PrintFooter()
    {
        PrintHorizontalLine();
    }
 
 
 
 
 
 
 
 
protected:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
private:
 
 
 
    // Stream related variables
    std::ostream* mOutStream;                // The stream considered
    std::vector<std::string> mColumnHeaders; // This vector contains the header to print in each column
    std::vector<int> mColumnWidths;          // This vector contains the spaces of each column
    std::string mSeparator;                  // The separator considered in each column
 
    // The indexes currently used
    unsigned int mIndexRow;                  // Index of current row
    unsigned int mIndexColumn;               // Index of current column
 
    // Other variables related with the table output
    unsigned int mTableWidth;                // The table width
    bool mFlushLeft;                         // If the flush is aligned to the left or the right
    bool mBoldFont;                          // If the bold fonts are considered to use in the
 
 
 
 
 
    void PrintHorizontalLine()
    {
        *mOutStream << "+"; // the left bar
 
        for (unsigned int i = 0; i< mTableWidth-1; ++i) {
            *mOutStream << "-";
        }
 
        *mOutStream << "+"; // the right bar
        *mOutStream << "\n";
    }
 
    template<typename TClass>
    void OutputDecimalNumber(TClass Input)
    {
        // If we cannot handle this number, indicate so
        if (Input < 10*(mColumnWidths.at(mIndexColumn)-1) || Input > 10*mColumnWidths.at(mIndexColumn)) {
            std::stringstream string_out;
            string_out
            << std::setiosflags(std::ios::scientific)
            << std::setprecision(3)
            << std::uppercase
            << std::setw(mColumnWidths.at(mIndexColumn))
            << Input;
 
            std::string string_to_print = string_out.str();
 
            *mOutStream << string_to_print;
        } else {
            *mOutStream
            << std::setiosflags(std::ios::scientific)
            << std::setprecision(3)
            << std::uppercase
            << std::setw(mColumnWidths.at(mIndexColumn))
            << Input;
        }
 
        if (mIndexColumn == GetNumColumns()-1) {
            *mOutStream << "|\n";
            mIndexRow = mIndexRow + 1;
            mIndexColumn = 0;
        } else {
            *mOutStream << mSeparator;
            mIndexColumn = mIndexColumn + 1;
        }
    }
 
 
 
    friend class Serializer;
 
    void save(Serializer& rSerializer) const
    {
//         rSerializer.save("OutStream", mOutStream);
        rSerializer.save("ColumnHeaders", mColumnHeaders);
        rSerializer.save("ColumnWidths", mColumnWidths);
        rSerializer.save("Separator", mSeparator);
        rSerializer.save("IndexRow", mIndexRow);
        rSerializer.save("IndexColumn", mIndexColumn);
        rSerializer.save("TableWidth", mTableWidth);
        rSerializer.save("FlushLeft", mFlushLeft);
        rSerializer.save("BoldFont", mBoldFont);
    }
 
    void load(Serializer& rSerializer)
    {
//         rSerializer.load("OutStream", mOutStream);
        rSerializer.load("ColumnHeaders", mColumnHeaders);
        rSerializer.load("ColumnWidths", mColumnWidths);
        rSerializer.load("Separator", mSeparator);
        rSerializer.load("IndexRow", mIndexRow);
        rSerializer.load("IndexColumn", mIndexColumn);
        rSerializer.load("TableWidth", mTableWidth);
        rSerializer.load("FlushLeft", mFlushLeft);
        rSerializer.load("BoldFont", mBoldFont);
    }
 
 
 
}; // Class TableStream
 
} // namespace Kratos.
#endif