streams.hh

#ifndef DUNE_FEM_STREAMS_HH
#define DUNE_FEM_STREAMS_HH
 
#include <string>
#include <fstream>
 
// we would use cstdint,
// if it would be available for all compilers, e.g. clang
//#include <stdint.h>
#include <cstdint>
 
#include <dune/common/exceptions.hh>
 
#include <dune/fem/misc/bartonnackmaninterface.hh>
#include <dune/fem/misc/mpimanager.hh>
 
namespace Dune
{
 
  namespace Fem
  {
 
    class StreamError : public Exception {};
 
 
    template< class TraitsImp >
    class OutStreamInterface
    : public BartonNackmanInterface< OutStreamInterface< TraitsImp >, typename TraitsImp::OutStreamType >
    {
      typedef OutStreamInterface< TraitsImp > ThisType;
      typedef BartonNackmanInterface< ThisType, typename TraitsImp::OutStreamType > BaseType;
 
    public:
      typedef TraitsImp Traits;
 
      typedef typename Traits::OutStreamType OutStreamType;
 
      typedef ThisType OutStreamInterfaceType;
 
    protected:
      using BaseType::asImp;
 
    public:
      void flush ()
      {
        CHECK_AND_CALL_INTERFACE_IMPLEMENTATION( asImp().flush() );
      }
 
      void writeDouble ( const double value )
      {
        CHECK_AND_CALL_INTERFACE_IMPLEMENTATION( asImp().writeDouble( value ) );
      }
 
      void writeFloat ( const float value )
      {
        CHECK_AND_CALL_INTERFACE_IMPLEMENTATION( asImp().writeFloat( value ) );
      }
 
      void writeInt ( const int value )
      {
        CHECK_AND_CALL_INTERFACE_IMPLEMENTATION( asImp().writeInt( value ) );
      }
 
      void writeSignedInt64 ( int64_t value )
      {
        CHECK_AND_CALL_INTERFACE_IMPLEMENTATION( asImp().writeSignedInt64( value ) );
      }
 
      void writeChar ( const char value )
      {
        CHECK_AND_CALL_INTERFACE_IMPLEMENTATION( asImp().writeChar( value ) );
      }
 
      void writeBool ( const bool value )
      {
        CHECK_AND_CALL_INTERFACE_IMPLEMENTATION( asImp().writeBool( value ) );
      }
 
      void writeString ( const std::string &s )
      {
        CHECK_AND_CALL_INTERFACE_IMPLEMENTATION( asImp().writeString( s ) );
      }
 
      void writeUnsignedInt ( unsigned int value )
      {
        CHECK_AND_CALL_INTERFACE_IMPLEMENTATION( asImp().writeUnsignedInt( value ) );
      }
 
      void writeUnsignedInt64 ( uint64_t value )
      {
        CHECK_AND_CALL_INTERFACE_IMPLEMENTATION( asImp().writeUnsignedInt64( value ) );
      }
 
    protected:
      void writeError () const
      {
        DUNE_THROW( StreamError, "Unable to write to stream." );
      }
    };
 
 
 
    template< class TraitsImp >
    class InStreamInterface
    : public BartonNackmanInterface< InStreamInterface< TraitsImp >, typename TraitsImp::InStreamType >
    {
      typedef InStreamInterface< TraitsImp > ThisType;
      typedef BartonNackmanInterface< ThisType, typename TraitsImp::InStreamType > BaseType;
 
    public:
      typedef TraitsImp Traits;
 
      typedef typename Traits::InStreamType InStreamType;
 
      typedef ThisType InStreamInterfaceType;
 
    protected:
      using BaseType::asImp;
 
    public:
      void readDouble ( double &value )
      {
        CHECK_AND_CALL_INTERFACE_IMPLEMENTATION( asImp().readDouble( value ) );
      }
 
      double readDouble ()
      {
        double value;
        readDouble( value );
        return value;
      }
 
      void readFloat ( float &value )
      {
        CHECK_AND_CALL_INTERFACE_IMPLEMENTATION( asImp().readFloat( value ) );
      }
 
      float readFloat ()
      {
        float value;
        readFloat( value );
        return value;
      }
 
      void readInt ( int &value )
      {
        CHECK_AND_CALL_INTERFACE_IMPLEMENTATION( asImp().readInt( value ) );
      }
 
      int readInt ()
      {
        int value;
        readInt( value );
        return value;
      }
 
      void readSignedInt64 ( int64_t &value )
      {
        CHECK_AND_CALL_INTERFACE_IMPLEMENTATION( asImp().readSignedInt64( value ) );
      }
 
      int64_t readSignedInt64 ()
      {
        int64_t value;
        readSignedInt64( value );
        return value;
      }
 
      void readChar ( char &value )
      {
        CHECK_AND_CALL_INTERFACE_IMPLEMENTATION( asImp().readChar( value ) );
      }
 
      int readChar ()
      {
        char value;
        readChar( value );
        return value;
      }
 
      void readBool ( bool &value )
      {
        CHECK_AND_CALL_INTERFACE_IMPLEMENTATION( asImp().readBool( value ) );
      }
 
      bool readBool ()
      {
        bool value;
        readBool( value );
        return value;
      }
 
      void readString ( std::string &s )
      {
        CHECK_AND_CALL_INTERFACE_IMPLEMENTATION( asImp().readString( s ) );
      }
 
      void readUnsignedInt ( unsigned int &value )
      {
        CHECK_AND_CALL_INTERFACE_IMPLEMENTATION( asImp().readUnsignedInt( value ) );
      }
 
      unsigned int readUnsignedInt ()
      {
        unsigned int value;
        readUnsignedInt( value );
        return value;
      }
 
      void readUnsignedInt64 ( uint64_t &value )
      {
        CHECK_AND_CALL_INTERFACE_IMPLEMENTATION( asImp().readUnsignedInt64( value ) );
      }
 
      uint64_t readUnsignedInt64 ()
      {
        uint64_t value;
        readUnsignedInt64( value );
        return value;
      }
 
    protected:
      void readError () const
      {
        DUNE_THROW( StreamError, "Unable to read from stream." );
      }
    };
 
    template <class StreamImpl>
    struct StreamFactory
    {
      typedef typename MPIHelper :: MPICommunicator MPICommunicatorType;
 
      static StreamImpl* create( const std::string& filename,
                                 const int rank = MPIManager::rank(),
                                 const MPICommunicatorType& mpiComm = MPIHelper :: getCommunicator() )
      {
        return new StreamImpl( filename );
      }
    };
 
  } // namespace Fem
 
} // end namespace Dune
 
#include "streams_inline.hh"
 
#endif // #ifndef DUNE_FEM_STREAMS_HH