oTstream.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 __oTstream_hpp__
#define __oTstream_hpp__
 
#include "tokenList.hpp"
#include "iOstream.hpp"
 
 
namespace pFlow
{
 
 
//- Helper functions declearation
 
inline bool validTokenForStream(const token tok);
 
inline bool isBeginToken(const token& tok);
 
inline bool isEndToken(const token& tok);
 
class oTstream
:
    public iOstream
{
 
protected:
 
    word    name_;
 
    tokenList  tokenList_;
 
public:
    
 
        oTstream(const word& nm);
        
        oTstream(const oTstream& src);
 
        oTstream(oTstream&&) = default;
 
        virtual ~oTstream() = default;
 
    
    
        // Give const access 
        const tokenList& tokens()const;
 
        // Give access 
        tokenList& tokens();
    
 
 
        virtual bool write(const token& tok);
 
        virtual iOstream& write(const char c);
 
        virtual iOstream& write(const char* str);
 
        virtual iOstream& write(const word& str);
 
        
        virtual iOstream& writeQuoted(const std::string& str, const bool quoted=true );
 
        virtual iOstream& write(const int64 val) override;
 
        virtual iOstream& write(const int32 val) override;
 
        virtual iOstream& write(const int8 val) override;
 
        virtual iOstream& write(const uint64 val) override;
 
        virtual iOstream& write(const uint32 val) override;
 
        virtual iOstream& write(const uint8 val) override;
 
        virtual iOstream& write(const float val) override;
 
        virtual iOstream& write(const double val) override;
 
        virtual iOstream& write(const size_t val) override;
 
        void seek(size_t pos) override;
 
        iOstream& write(
            const char* binaryData, 
            std::streamsize count) override;
 
        virtual void append(const token& tok);
        
        virtual void append(const tokenList& tLisk);
        
    
 
 
        void reset();
 
        virtual void rewind();
 
        virtual void indent()
        {}
 
        virtual void startOfBinaryStreaming()
        {}
 
        virtual void endOfBinaryStreaming()
        {}
 
        virtual void flush()
        {}
 
        virtual void endl()
        {}
 
        virtual char fill() const
        {
            return 0;
        }
 
        virtual char fill(const char)
        {
            return 0;
        }
 
        virtual int width() const
        {
            return 0;
        }
 
        virtual int width(const int)
        {
             return 0;
        }
 
        virtual int precision() const
        {
             return 0;
        }
 
        virtual int precision(const int)
        {
             return 0;
        }
 
        virtual ios_base::fmtflags flags() const
        {
            return ios_base::fmtflags(0);
        }
 
        ios_base::fmtflags flags(const ios_base::fmtflags)
        {
            return ios_base::fmtflags(0);
        }
 
};
 
#include "helperTstream.hpp"
 
 
} // End namespace pFlow
 
 
#endif