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>
 
#include "bTypesFunctions.hpp"
 
using std::ios_base;
using std::istream;
using std::ostream;
 
using std::cin;
using std::cout;
using std::cerr;
 
 
 
namespace pFlow
{
 
class IOstream
{
 
public:
 
 
    enum streamAccess : char
    {
        CLOSED = 0,         
        OPENED              
    };
 
    enum writeFormat: char
    {
        ASCII = 0,          
        BINARY
    };
 
    static unsigned int precision_;
 
protected:
 
    static word staticName_;
 
    streamAccess openClosed_;
 
    writeFormat writeFormat_ = ASCII;
 
    ios_base::iostate ioState_;
 
  
    int32 lineNumber_;
 
 
    //- Protected Member Functions
   
        void setOpened()
        {
            openClosed_ = OPENED;
        }
 
        void setClosed()
        {
            openClosed_ = CLOSED;
        }
 
        void setState(ios_base::iostate state)
        {
            ioState_ = state;
        }
 
        void setWriteFormat(writeFormat wF)
        {
            writeFormat_ = wF;
        }
 
        void setGood()
        {
            ioState_ = ios_base::iostate(0);
        }
 
public:
 
 
        explicit IOstream():
            openClosed_(CLOSED),
            writeFormat_(ASCII),
            ioState_(ios_base::iostate(0)),
            lineNumber_(0)
        {
            setBad();
        }
 
        explicit IOstream(writeFormat wF):
            openClosed_(CLOSED),
            writeFormat_(wF),
            ioState_(ios_base::iostate(0)),
            lineNumber_(0)
        {
            setBad();
        }
 
        IOstream(const IOstream&) = default;
 
        virtual ~IOstream() = default;
          
        
 
        virtual const word& name() const;
 
        virtual word& name();
 
        virtual bool check(const char* operation) const;
 
        bool fatalCheck(const char* operation) const;
 
        bool opened() const
        {
            return openClosed_ == OPENED;
        }
 
        bool closed() const
        {
            return openClosed_ == CLOSED;
        }
 
        bool isBinary()const
        {
            return writeFormat_ == BINARY;
        }    
 
        bool good() const
        {
            return ioState_ == 0;
        }
 
        bool eof() const
        {
            return ioState_ & ios_base::eofbit;
        }
 
        bool fail() const
        {
            return ioState_ & (ios_base::badbit | ios_base::failbit);
        }
 
        bool bad() const
        {
            return ioState_ & ios_base::badbit;
        }
 
        explicit operator bool() const
        {
            return !fail();
        }
 
        bool operator!() const
        {
            return fail();
        }
 
       
        int32 lineNumber() const
        {
            return lineNumber_;
        }
 
        int32& lineNumber()
        {
            return lineNumber_;
        }
 
        int32 lineNumber(const int32 num)
        {
            const int32 old(lineNumber_);
            lineNumber_ = num;
            return old;
        }
 
        virtual ios_base::fmtflags flags() const = 0;
 
        static unsigned int defaultPrecision()
        {
            return precision_;
        }
 
        static unsigned int defaultPrecision(unsigned int prec)
        {
            unsigned int old(precision_);
            precision_ = prec;
            return old;
        }
 
        void setEof()
        {
            ioState_ |= ios_base::eofbit;
        }
 
        void setFail()
        {
            ioState_ |= ios_base::failbit;
        }
 
        void setBad()
        {
            ioState_ |= ios_base::badbit;
        }
 
        virtual ios_base::fmtflags flags(const ios_base::fmtflags f) = 0;
 
        ios_base::fmtflags setf(const ios_base::fmtflags f)
        {
            return flags(flags() | f);
        }
 
        ios_base::fmtflags setf
        (
            const ios_base::fmtflags f,
            const ios_base::fmtflags mask
        )
        {
            return flags((flags() & ~mask) | (f & mask));
        }
 
        void unsetf(const ios_base::fmtflags f)
        {
            flags(flags() & ~f);
        }
 
}; // end of IOstream
 
 
typedef IOstream& (*IOstreamManip)(IOstream&);
 
 
inline IOstream& dec(IOstream& io)
{
    io.setf(ios_base::dec, ios_base::dec|ios_base::hex|ios_base::oct);
    return io;
}
 
inline IOstream& hex(IOstream& io)
{
    io.setf(ios_base::hex, ios_base::dec|ios_base::hex|ios_base::oct);
    return io;
}
 
inline IOstream& oct(IOstream& io)
{
    io.setf(ios_base::oct, ios_base::dec|ios_base::hex|ios_base::oct);
    return io;
}
 
inline IOstream& fixed(IOstream& io)
{
    io.setf(ios_base::fixed, ios_base::floatfield);
    return io;
}
 
inline IOstream& scientific(IOstream& io)
{
    io.setf(ios_base::scientific, ios_base::floatfield);
    return io;
}
 
 
} // pFlow
 
#endif  //  __IOstream__hpp__