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__
 
// based on OpenFOAM stream, with some modifications/simplifications
// to be tailored to our needs
 
 
#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";
 
 
 
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:
    
 
    // Constructors
 
        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 label val) = 0;
 
        virtual iOstream& write(const uint32 val) = 0;
 
        virtual iOstream& write(const uint16 val) = 0;
 
        virtual iOstream& write(const float val) = 0;
 
        virtual iOstream& write(const double val) = 0;
       
        virtual iOstream& write(const char* binaryData, std::streamsize count) = 0;
        
    
    // - Indent 
 
        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();
 
    //- Punctuations
    
        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();
        }
 
 
    //- Stream state functions
 
        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;
 
 
    //- Member Operators
 
        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 int16& val)
{
    return os.write(val);
}
 
inline iOstream& operator<<( iOstream& os, const int8& val)
{
    return os.write(val);
}
 
inline iOstream& operator<<( iOstream& os, const label& val)
{
    return os.write(val);
}
 
inline iOstream& operator<<( iOstream& os, const uint32& val)
{
    return os.write(val);
}
 
inline iOstream& operator<<( iOstream& os, const uint16& 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);
}
// Useful aliases for tab and newline characters
constexpr char tab = '\t';
constexpr char nl = '\n';
 
 
 
 
} //  pFlow
 
 
#endif
 
// ************************************************************************* //