iOstream.hpp

Go to the documentation of this file.

/*------------------------------- phasicFlow ---------------------------------
      O        C enter of
     O O       E ngineering and
    O   O      M ultiscale modeling of
   OOOOOOO     F luid flow       
------------------------------------------------------------------------------
  Copyright (C): www.cemf.ir
  email: hamid.r.norouzi AT gmail.com
------------------------------------------------------------------------------  
Licence:
  This file is part of phasicFlow code. It is a free software for simulating 
  granular and multiphase flows. You can redistribute it and/or modify it under
  the terms of GNU General Public License v3 or any other later versions. 
 
  phasicFlow is distributed to help others in their research in the field of 
  granular and multiphase flows, but WITHOUT ANY WARRANTY; without even the
  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
-----------------------------------------------------------------------------*/
#ifndef __iOstream_hpp__
#define __iOstream_hpp__
 
 
#include "IOstream.hpp"
 
const inline char* defaultColor = "\033[0m";
const inline char* blackColor   = "\033[30m";
const inline char* redColor     = "\033[31m";
const inline char* greenColor   = "\033[32m";
const inline char* yellowColor  = "\033[33m";
const inline char* blueColor    = "\033[34m";
const inline char* magentaColor = "\033[35m";
const inline char* cyanColor    = "\033[36m";
const inline char* whiteColor   = "\033[37m"; 
 
const inline char* boldChar     = "\033[1m";
 
#define Red_Text(text)      redColor<<text<<defaultColor
#define Yellow_Text(text)   yellowColor<<text<<defaultColor
#define Blue_Text(text)     blueColor<<text<<defaultColor
#define Green_Text(text)    greenColor<<text<<defaultColor
#define Magenta_Text(text)  magentaColor<<text<<defaultColor
#define Cyan_Text(text)         cyanColor<<text<<defaultColor
#define Bold_Text(text)         boldChar<<text<<defaultColor
 
namespace pFlow
{
 
// Forward Declarations
class token;
 
class iOstream
:
    public IOstream
{
protected:
 
    //- Protected Data
 
        static constexpr const unsigned short entryIndentation_ = 16;
 
        unsigned short indentSize_ = 4;
 
        unsigned short indentLevel_ = 0;
 
 
public:
    
 
 
        explicit iOstream()
        {}
 
        explicit iOstream(writeFormat wF):
            IOstream(wF)
        {}
 
        iOstream(const iOstream&) = default;
 
        virtual ~iOstream() = default;
 
 
 
        virtual bool write(const token& tok) = 0;
 
        virtual iOstream& write(const char c) = 0;
 
        virtual iOstream& write(const char* str) = 0;
 
        virtual iOstream& write(const word& str) = 0;
 
        virtual iOstream& writeQuoted
        (
            const word& str,
            const bool quoted=true
        ) = 0;
        
        virtual iOstream& write(const int64 val) = 0;
 
        virtual iOstream& write(const int32 val) = 0;
 
        virtual iOstream& write(const int8 val) = 0;
 
        virtual iOstream& write(const uint64 val) = 0;
 
        virtual iOstream& write(const uint32 val) = 0;
 
        virtual iOstream& write(const uint8 val) = 0;
 
        virtual iOstream& write(const float val) = 0;
 
        virtual iOstream& write(const double val) = 0;
       
        virtual iOstream& write(const size_t val) = 0;
         
        virtual iOstream& write(const char* binaryData, std::streamsize count) = 0;
 
        virtual iOstream& writeBinaryBlockFlag();
        
        virtual void seek(size_t pos) = 0;
 
        virtual void indent() = 0;
 
        unsigned short indentSize() const
        {
            return indentSize_;
        }
 
        unsigned short& indentSize()
        {
            return indentSize_;
        }
 
        unsigned short indentLevel() const
        {
            return indentLevel_;
        }
 
        unsigned short& indentLevel()
        {
            return indentLevel_;
        }
 
        void incrIndent()
        {
            ++indentLevel_;
        }
 
        void decrIndent();
 
    
        virtual iOstream& beginBlock(const word& kw);
 
        virtual iOstream& beginBlock();
 
        virtual iOstream& endBlock();
 
        virtual iOstream& beginList();
 
        virtual iOstream& beginList(const word& kw);
 
        virtual iOstream& endList();
 
        virtual iOstream& beginSquare();
 
        virtual iOstream& beginSquare(const word& kw);
 
        virtual iOstream& endSquare();
 
        virtual iOstream& endEntry();
 
        virtual iOstream& newLine();
 
        virtual iOstream& space(int32 n=1);
 
        virtual iOstream& writeWordKeyword(const word& kw);
 
        template<class T>
        iOstream& writeWordEntry(const word& key, const T& value)
        {
            writeWordKeyword(key) << value;
            return endEntry();
        }
 
 
 
        virtual void startOfBinaryStreaming() =0;
 
        virtual void endOfBinaryStreaming() = 0 ;
 
        virtual void flush() = 0;
 
        virtual void endl() = 0;
 
        virtual char fill() const = 0;
 
        virtual char fill(const char fillch) = 0;
 
        virtual int width() const = 0;
 
        virtual int width(const int w) = 0;
 
        virtual int precision() const = 0;
 
        virtual int precision(const int p) = 0;
 
 
 
        iOstream& operator()() const
        {
            return const_cast<iOstream&>(*this);
        }
};
 
 
 
typedef iOstream& (*iOstreamManip)(iOstream&);
 
 
inline iOstream& operator<<(iOstream& os, iOstreamManip f)
{
    return f(os);
}
 
inline iOstream& operator<<(iOstream& os, IOstreamManip f)
{
    f(os);
    return os;
}
 
 
inline iOstream& indent(iOstream& os)
{
    os.indent();
    return os;
}
 
inline iOstream& incrIndent(iOstream& os)
{
    os.incrIndent();
    return os;
}
 
inline iOstream& decrIndent(iOstream& os)
{
    os.decrIndent();
    return os;
}
 
 
inline iOstream& flush(iOstream& os)
{
    os.flush();
    return os;
}
 
 
inline iOstream& endl(iOstream& os)
{
    os.endl();
    return os;
}
 
 
//  Increments indentation, adds newline.
inline iOstream& beginBlock(iOstream& os)
{
    os.beginBlock();
    return os;
}
 
 
//  Decrements indentation, adds newline.
inline iOstream& endBlock(iOstream& os)
{
    os.endBlock();
    return os;
}
 
 
inline iOstream& endEntry(iOstream& os)
{
    os.endEntry();
    return os;
}
 
 
// overloading for basic types
inline iOstream& operator<<( iOstream& os, const char c)
{
    return os.write(c);
}
 
inline iOstream& operator<<( iOstream& os, const char * buf)
{
    return os.write(buf);
}
 
inline iOstream& operator<<( iOstream& os, const word& w)
{
    return os.write(w);
}
 
 
inline iOstream& operator<<( iOstream& os, const int64& val)
{
    return os.write(val);
}
 
inline iOstream& operator<<( iOstream& os, const int32& val)
{
    return os.write(val);
}
 
 
inline iOstream& operator<<( iOstream& os, const int8& val)
{
    return os.write(val);
}
 
inline iOstream& operator<<( iOstream& os, const uint64& val)
{
    return os.write(val);
}
 
inline iOstream& operator<<( iOstream& os, const uint32& val)
{
    return os.write(val);
}
 
inline iOstream& operator<<( iOstream& os, const uint8& val)
{
    return os.write(val);
}
 
inline iOstream& operator<<( iOstream& os, const float& val)
{
    return os.write(val);
}
 
 
inline iOstream& operator<<( iOstream& os, const double& val)
{
    return os.write(val);
}
 
inline iOstream& operator<<( iOstream& os, const size_t& val)
{
    return os.write(val);
}
 
// Useful aliases for tab and newline characters
constexpr char tab = '\t';
constexpr char nl = '\n';
 
 
} //  pFlow
 
 
#endif