asciistreams.hh

#ifndef DUNE_FEM_ASCIISTREAMS_HH
#define DUNE_FEM_ASCIISTREAMS_HH
 
#include <iostream>
#include <fstream>
 
#include <dune/fem/io/streams/streams.hh>
 
namespace Dune
{
 
  namespace Fem
  {
 
    class ASCIIOutStream;
    class ASCIIInStream;
 
    struct ASCIIOutStreamTraits
    {
      typedef ASCIIOutStream OutStreamType;
    };
 
 
    class ASCIIOutStream
    : public OutStreamInterface< ASCIIOutStreamTraits >
    {
      typedef ASCIIOutStream ThisType;
      typedef OutStreamInterface< ASCIIOutStreamTraits > BaseType;
 
    public:
      typedef ASCIIOutStreamTraits Traits;
 
    protected:
      std::ostream &stream_;
      bool mustFreeStream_;
 
    protected:
      using BaseType::writeError;
 
    public:
      explicit ASCIIOutStream ( std::ostream &stream )
      : stream_( stream ),
        mustFreeStream_( false )
      {}
 
      explicit ASCIIOutStream ( const std::string &filename )
      : stream_( *(new std :: ofstream( filename.c_str() )) ),
        mustFreeStream_( true )
      {}
 
      ~ASCIIOutStream ()
      {
        if( mustFreeStream_ )
          delete &stream_;
      }
 
      void flush ()
      {
        stream_.flush();
      }
 
      void writeDouble ( const double value )
      {
        stream_.setf( std ::ios_base :: scientific, std :: ios_base :: floatfield );
        stream_ .precision( 16 );
        stream_ << value << std :: endl;
        if( !valid () )
          writeError();
      }
 
      void writeFloat ( const float value )
      {
        stream_.setf( std ::ios_base :: scientific, std :: ios_base :: floatfield );
        stream_ .precision( 7 );
        stream_ << value << std :: endl;
        if( !valid() )
          writeError();
      }
 
      void writeInt ( const int value )
      {
        stream_ << value << std :: endl;
        if( !valid () )
          writeError();
      }
 
      void writeSignedInt64 ( int64_t value )
      {
        stream_ << value << std::endl;
        if( !valid () )
          writeError();
      }
 
      void writeChar ( const char value )
      {
        // make sure char is written as number
        int val = (int) value;
        writeInt( val );
      }
 
      void writeBool ( const bool value )
      {
        std::string val( ( value == true ) ? "true" : "false" );
        writeString( val );
      }
 
      void writeString ( const std::string &s )
      {
        const unsigned int length = s.length();
        stream_ << length;
        for( unsigned int i = 0; i < length; ++i )
          stream_.put( s[ i ] );
        stream_ << std :: endl;
        if( !valid () )
          writeError();
      }
 
      void writeUnsignedInt ( unsigned int value )
      {
        stream_ << value << std::endl;
        if( !valid () )
          writeError();
      }
 
      void writeUnsignedInt64 ( uint64_t value )
      {
        stream_ << value << std::endl;
        if( !valid () )
          writeError();
      }
 
    protected:
      bool valid () const
      {
        return stream_.good() | stream_.eof();
      }
    };
 
 
 
    struct ASCIIInStreamTraits
    {
      typedef ASCIIInStream InStreamType;
    };
 
 
 
    class ASCIIInStream
    : public InStreamInterface< ASCIIInStreamTraits >
    {
      typedef ASCIIInStream ThisType;
      typedef InStreamInterface< ASCIIInStreamTraits > BaseType;
 
    public:
      typedef ASCIIInStreamTraits Traits;
 
    protected:
      std::istream &stream_;
      bool mustFreeStream_;
 
    protected:
      using BaseType::readError;
 
    public:
      explicit ASCIIInStream ( std::istream &stream )
      : stream_( stream ),
        mustFreeStream_( false )
      {}
 
      ASCIIInStream ( const std::string &filename )
      : stream_( *(new std :: ifstream( filename.c_str() )) ),
        mustFreeStream_( true )
      {}
 
      ~ASCIIInStream ()
      {
        if( mustFreeStream_ )
          delete &stream_;
      }
 
      void readDouble ( double &value )
      {
        stream_ >> value;
        if( !valid () )
          readError();
      }
 
      void readFloat ( float &value )
      {
        stream_ >> value;
        if( !valid () )
          readError();
      }
 
      void readInt ( int &value )
      {
        stream_ >> value;
        if( !valid () )
          readError();
      }
 
      void readSignedInt64 (int64_t &value )
      {
        stream_ >> value;
        if( !valid () )
          readError();
      }
 
      void readChar ( char &value )
      {
        int val;
        readInt( val );
        value = (char) val;
      }
 
      void readBool ( bool &value )
      {
        std::string val;
        readString( val );
 
        if( val == "true" )
          value = true;
        else if ( val == "false" )
          value = false;
        else
          readError();
      }
 
      void readString ( std::string &s )
      {
        unsigned int length;
        stream_ >> length;
        for( unsigned int i = 0; i < length; ++i )
          s += stream_.get();
        if( !valid () )
          readError();
      }
 
      void readUnsignedInt ( unsigned int &value )
      {
        stream_ >> value;
        if( !valid () )
          readError();
      }
 
      void readUnsignedInt64 (uint64_t &value )
      {
        stream_ >> value;
        if( !valid () )
          readError();
      }
 
    protected:
      bool valid () const
      {
        return stream_.good() | stream_.eof();
      }
    };
 
  } // namespace Fem
 
} // namespace Dune
 
#endif // #ifndef DUNE_FEM_ASCIISTREAMS_HH