Stream.h

Go to the documentation of this file.

#ifndef CPPUNIT_PORTABILITY_STREAM_H_INCLUDED
#define CPPUNIT_PORTABILITY_STREAM_H_INCLUDED

// This module define:
// Type CppUT::Stream (either std::stream or a custom type)
// Type CppUT::OStringStream (eitjer std::ostringstream, older alternate or a custom type)
// Functions stdCOut() & stdCErr() which returns a reference on cout & cerr stream (or our
// custom stream).

#include <cppunit/Portability.h>


#if defined( CPPUNIT_NO_STREAM )

#include <string>
#include <stdio.h>
#include <string.h>

CPPUNIT_NS_BEGIN

class StreamBuffer
{
public:
   virtual ~StreamBuffer() {}

   virtual void write( const char *text, unsigned int length ) = 0;

   virtual void flush() {}
};


class StringStreamBuffer : public StreamBuffer
{
public:
   std::string str() const
   {
      return str_;
   }

public: // overridden from StreamBuffer
   void write( const char *text, unsigned int length )
   {
      str_.append( text, length );
   }

private:
   std::string str_;
};


class FileStreamBuffer : public StreamBuffer
{
public:
   FileStreamBuffer( FILE *file )
      : file_( file )
   {
   }

   FILE *file() const
   {
      return file_;
   }

public: // overridden from StreamBuffer
   void write( const char *text, unsigned int length )
   {
      if ( file_ )
         fwrite( text, sizeof(char), length, file_ );
   }

   void flush() 
   {
      if ( file_ )
         fflush( file_ );
   }

private:
   FILE *file_;
};


class OStream
{
public:
   OStream()
      : buffer_( 0 )
   {
   }

   OStream( StreamBuffer *buffer )
      : buffer_( buffer )
   {
   }

   virtual ~OStream()
   {
     flush();
   }

   OStream &flush()
   {
           if ( buffer_ )
                    buffer_->flush();
           return *this;
   }

   void setBuffer( StreamBuffer *buffer )
   {
      buffer_ = buffer;
   }

   OStream &write( const char *text, unsigned int length )
   {
      if ( buffer_ )
         buffer_->write( text, length );
      return *this;
   }

   OStream &write( const char *text )
   {
      return write( text, strlen(text) );
   }

   OStream &operator <<( bool v )
   {
      const char *out = v ? "true" : "false";
      return write( out );
   }

   OStream &operator <<( short v )
   {
      char buffer[64];
      sprintf( buffer, "%hd", v );
      return write( buffer );
   }

   OStream &operator <<( unsigned short v )
   {
      char buffer[64];
      sprintf( buffer, "%hu", v );
      return write( buffer );
   }

   OStream &operator <<( int v )
   {
      char buffer[64];
      sprintf( buffer, "%d", v );
      return write( buffer );
   }

   OStream &operator <<( unsigned int v )
   {
      char buffer[64];
      sprintf( buffer, "%u", v );
      return write( buffer );
   }

   OStream &operator <<( long v )
   {
      char buffer[64];
      sprintf( buffer, "%ld", v );
      return write( buffer );
   }

   OStream &operator <<( unsigned long v )
   {
      char buffer[64];
      sprintf( buffer, "%lu", v );
      return write( buffer );
   }

   OStream &operator <<( float v )
   {
      char buffer[128];
      sprintf( buffer, "%.16g", double(v) );
      return write( buffer );
   }

   OStream &operator <<( double v )
   {
      char buffer[128];
      sprintf( buffer, "%.16g", v );
      return write( buffer );
   }

   OStream &operator <<( long double v )
   {
      char buffer[128];
      sprintf( buffer, "%.16g", double(v) );
      return write( buffer );
   }

   OStream &operator <<( const void *v )
   {
      char buffer[64];
      sprintf( buffer, "%p", v );
      return write( buffer );
   }

   OStream &operator <<( const char *v )
   {
      return write( v ? v : "NULL" );
   }

   OStream &operator <<( char c )
   {
      char buffer[16];
      sprintf( buffer, "%c", c );
      return write( buffer );
   }

   OStream &operator <<( const std::string &s )
   {
      return write( s.c_str(), s.length() );
   }

private:
   StreamBuffer *buffer_;
};


class OStringStream : public OStream
{
public:
        OStringStream()
                : OStream( &buffer_ )
        {
        }

        std::string str() const
        {
                return buffer_.str();
        }

private:
        StringStreamBuffer buffer_;
};


class OFileStream : public OStream
{
public:
   OFileStream( FILE *file )
      : OStream( &buffer_ )
      , buffer_( file )
      , ownFile_( false )
   {
   }

   OFileStream( const char *path )
      : OStream( &buffer_ )
      , buffer_( fopen( path, "wt" ) )
      , ownFile_( true )
   {
   }

   virtual ~OFileStream()
   {
      if ( ownFile_  &&  buffer_.file() )
         fclose( buffer_.file() );
   }

private:
   FileStreamBuffer buffer_;
   bool ownFile_;
};

inline OStream &stdCOut() 
{
   static OFileStream stream( stdout );
   return stream;
}

inline OStream &stdCErr() 
{
   static OFileStream stream( stderr );
   return stream;
}

CPPUNIT_NS_END

#elif CPPUNIT_HAVE_SSTREAM // #if defined( CPPUNIT_NO_STREAM )
# include <sstream>
# include <fstream>

    CPPUNIT_NS_BEGIN
    typedef std::ostringstream OStringStream;      // The standard C++ way
    typedef std::ofstream OFileStream;
    CPPUNIT_NS_END


#elif CPPUNIT_HAVE_CLASS_STRSTREAM
# include <string>
# if CPPUNIT_HAVE_STRSTREAM
#   include <strstream>
# else // CPPUNIT_HAVE_STRSTREAM
#  include <strstream.h>
# endif // CPPUNIT_HAVE_CLASS_STRSTREAM

    CPPUNIT_NS_BEGIN

    class OStringStream : public std::ostrstream 
    {
    public:
        std::string str()
        {
//            (*this) << '\0';
//            std::string msg(std::ostrstream::str());
//            std::ostrstream::freeze(false);
//            return msg;
// Alternative implementation that don't rely on freeze which is not
// available on some platforms:
            return std::string( std::ostrstream::str(), pcount() );
        }
    };

    CPPUNIT_NS_END
#else // CPPUNIT_HAVE_CLASS_STRSTREAM
#   error Cannot define CppUnit::OStringStream.
#endif // #if defined( CPPUNIT_NO_STREAM )



#if !defined( CPPUNIT_NO_STREAM )

#include <iostream>

    CPPUNIT_NS_BEGIN

    typedef std::ostream OStream;

    inline OStream &stdCOut() 
    {
        return std::cout;
    }

    inline OStream &stdCErr() 
    {
       return std::cerr;
    }

    CPPUNIT_NS_END
   
#endif // #if !defined( CPPUNIT_NO_STREAM )

#endif // CPPUNIT_PORTABILITY_STREAM_H_INCLUDED