iIstream.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 __iIstream_hpp__
#define __iIstream_hpp__
 
#include "IOstream.hpp"
#include "token.hpp"
#include "error.hpp"
#include "iOstream.hpp"
 
namespace pFlow
{
 
class iIstream
:
    public IOstream
{
 
    //- Private Data
 
        bool putBack_;
 
        token putBackToken_;
 
public:
 
 
        iIstream():
            IOstream(),
            putBack_(false) 
        {}
 
        iIstream(writeFormat wf):
            IOstream(wf),
            putBack_(false)
        {}
 
        iIstream(const iIstream&) = default;
 
        virtual ~iIstream() = default;
 
 
 
 
        void putBack(const token& tok);
 
        bool getBack(token& tok);
 
        bool peekBack(token& tok);
 
        void resetPutBack()
        {
            putBackToken_.reset();
            putBack_ = false;
        }
 
        virtual iIstream& read(token&) = 0;
 
        virtual iIstream& read(char&) = 0;
 
        virtual iIstream& read(word&) = 0;
 
        virtual iIstream& readString(word&) = 0;    
 
        virtual iIstream& read(int64&) = 0;
 
        virtual iIstream& read(int32&) = 0;
 
        virtual iIstream& read(int8&) = 0;
 
        virtual iIstream& read(uint64&) = 0;
 
        virtual iIstream& read(uint32&) = 0;
 
        virtual iIstream& read(uint8&) = 0;
 
        virtual iIstream& read(float&) = 0;
 
        virtual iIstream& read(double&) = 0;
 
        virtual iIstream& read(char* buffer, std::streamsize count) =0;
        
        virtual void rewind() = 0;
 
        virtual void seek(size_t pos) = 0;
 
        virtual size_t tell() = 0;
 
 
        virtual size_t findBinaryBlockStart();
 
        virtual bool findToken( const word & w );
 
        virtual bool findTokenResume(const word& w);
 
 
        virtual bool findTokenSilent( const word & w, int32 limitLine = 100 );
 
        virtual bool findTokenResumeSilent( const word & w, int32 limitLine = 100 );
 
        virtual bool findTokenAndNext( const word& w, word& nextW, bool checkEndStatement = true);
 
 
        virtual bool findTokenAndNextSilent( const word& w, word& nextW, int32 limitLine = 100);
 
        template<typename T>
        bool findKeywordAndVal(const word& keyword, T& val, bool checkEndStatement = true);
 
        template<typename T>
        T lookupData(const word& keyword);
 
        template<typename T>
        T lookupDataOrSet(const word& keyword, const T& setVal);
        
        template<typename T>
        bool nextData(const word& keyword, T& data);
 
 
        bool readBegin(const char* funcName);
 
        bool readEnd(const char* funcName);
 
        bool readBeginSquare(const char* funcName);
 
        bool readEndSquare(const char* funcName);
 
        char readBeginList(const char* funcName);
 
        char readEndList(const char* funcName);
 
        char readEndStatement(const char* funcName);
 
        
        iIstream& operator()() const;
 
};
 
 
typedef iIstream& (*iIstreamManip)(iIstream&);
 
inline iIstream& operator>>(iIstream& is, iIstreamManip f)
{
    return f(is);
}
 
inline iIstream& operator>>(iIstream& is, IOstreamManip f)
{
    f(is);
    return is;
}
 
 
// read operation for basic types it gets from the token stream
inline iIstream& operator>>( iIstream& is, word & w);
 
inline iIstream& operator>>( iIstream& is, int64& val);
 
inline iIstream& operator>>( iIstream& is, int32& val);
 
inline iIstream& operator>>( iIstream& is, int8& val);
 
inline iIstream& operator>>( iIstream& is, uint64& val);
 
inline iIstream& operator>>( iIstream& is, uint32& val);
 
inline iIstream& operator>>( iIstream& is, uint8& val);
 
inline iIstream& operator>>( iIstream& is, float& val);
 
inline iIstream& operator>>( iIstream& is, double& val);
 
inline iIstream& operator>>( iIstream& is, size_t& val);
 
 
 
} // pFlow
 
 
#include "iIstreamI.hpp"
 
 
#endif //__iIstream_hpp__