CppUnit project page FAQ CppUnit home page

Main Page   Modules   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Namespace Members   Compound Members   File Members   Related Pages  

Stream.h

Go to the documentation of this file.
00001 #ifndef CPPUNIT_PORTABILITY_STREAM_H_INCLUDED
00002 #define CPPUNIT_PORTABILITY_STREAM_H_INCLUDED
00003 
00004 // This module define:
00005 // Type CppUT::Stream (either std::stream or a custom type)
00006 // Type CppUT::OStringStream (eitjer std::ostringstream, older alternate or a custom type)
00007 // Functions stdCOut() & stdCErr() which returns a reference on cout & cerr stream (or our
00008 // custom stream).
00009 
00010 #include <cppunit/Portability.h>
00011 
00012 
00013 #if defined( CPPUNIT_NO_STREAM )
00014 
00015 #include <string>
00016 #include <stdio.h>
00017 #include <string.h>
00018 
00019 CPPUNIT_NS_BEGIN
00020 
00021 class StreamBuffer
00022 {
00023 public:
00024    virtual ~StreamBuffer() {}
00025 
00026    virtual void write( const char *text, unsigned int length ) = 0;
00027 
00028    virtual void flush() {}
00029 };
00030 
00031 
00032 class StringStreamBuffer : public StreamBuffer
00033 {
00034 public:
00035    std::string str() const
00036    {
00037       return str_;
00038    }
00039 
00040 public: // overridden from StreamBuffer
00041    void write( const char *text, unsigned int length )
00042    {
00043       str_.append( text, length );
00044    }
00045 
00046 private:
00047    std::string str_;
00048 };
00049 
00050 
00051 class FileStreamBuffer : public StreamBuffer
00052 {
00053 public:
00054    FileStreamBuffer( FILE *file )
00055       : file_( file )
00056    {
00057    }
00058 
00059    FILE *file() const
00060    {
00061       return file_;
00062    }
00063 
00064 public: // overridden from StreamBuffer
00065    void write( const char *text, unsigned int length )
00066    {
00067       if ( file_ )
00068          fwrite( text, sizeof(char), length, file_ );
00069    }
00070 
00071    void flush() 
00072    {
00073       if ( file_ )
00074          fflush( file_ );
00075    }
00076 
00077 private:
00078    FILE *file_;
00079 };
00080 
00081 
00082 class OStream
00083 {
00084 public:
00085    OStream()
00086       : buffer_( 0 )
00087    {
00088    }
00089 
00090    OStream( StreamBuffer *buffer )
00091       : buffer_( buffer )
00092    {
00093    }
00094 
00095    virtual ~OStream()
00096    {
00097      flush();
00098    }
00099 
00100    OStream &flush()
00101    {
00102            if ( buffer_ )
00103                     buffer_->flush();
00104            return *this;
00105    }
00106 
00107    void setBuffer( StreamBuffer *buffer )
00108    {
00109       buffer_ = buffer;
00110    }
00111 
00112    OStream &write( const char *text, unsigned int length )
00113    {
00114       if ( buffer_ )
00115          buffer_->write( text, length );
00116       return *this;
00117    }
00118 
00119    OStream &write( const char *text )
00120    {
00121       return write( text, strlen(text) );
00122    }
00123 
00124    OStream &operator <<( bool v )
00125    {
00126       const char *out = v ? "true" : "false";
00127       return write( out );
00128    }
00129 
00130    OStream &operator <<( short v )
00131    {
00132       char buffer[64];
00133       sprintf( buffer, "%hd", v );
00134       return write( buffer );
00135    }
00136 
00137    OStream &operator <<( unsigned short v )
00138    {
00139       char buffer[64];
00140       sprintf( buffer, "%hu", v );
00141       return write( buffer );
00142    }
00143 
00144    OStream &operator <<( int v )
00145    {
00146       char buffer[64];
00147       sprintf( buffer, "%d", v );
00148       return write( buffer );
00149    }
00150 
00151    OStream &operator <<( unsigned int v )
00152    {
00153       char buffer[64];
00154       sprintf( buffer, "%u", v );
00155       return write( buffer );
00156    }
00157 
00158    OStream &operator <<( long v )
00159    {
00160       char buffer[64];
00161       sprintf( buffer, "%ld", v );
00162       return write( buffer );
00163    }
00164 
00165    OStream &operator <<( unsigned long v )
00166    {
00167       char buffer[64];
00168       sprintf( buffer, "%lu", v );
00169       return write( buffer );
00170    }
00171 
00172    OStream &operator <<( float v )
00173    {
00174       char buffer[128];
00175       sprintf( buffer, "%.16g", double(v) );
00176       return write( buffer );
00177    }
00178 
00179    OStream &operator <<( double v )
00180    {
00181       char buffer[128];
00182       sprintf( buffer, "%.16g", v );
00183       return write( buffer );
00184    }
00185 
00186    OStream &operator <<( long double v )
00187    {
00188       char buffer[128];
00189       sprintf( buffer, "%.16g", double(v) );
00190       return write( buffer );
00191    }
00192 
00193    OStream &operator <<( const void *v )
00194    {
00195       char buffer[64];
00196       sprintf( buffer, "%p", v );
00197       return write( buffer );
00198    }
00199 
00200    OStream &operator <<( const char *v )
00201    {
00202       return write( v ? v : "NULL" );
00203    }
00204 
00205    OStream &operator <<( char c )
00206    {
00207       char buffer[16];
00208       sprintf( buffer, "%c", c );
00209       return write( buffer );
00210    }
00211 
00212    OStream &operator <<( const std::string &s )
00213    {
00214       return write( s.c_str(), s.length() );
00215    }
00216 
00217 private:
00218    StreamBuffer *buffer_;
00219 };
00220 
00221 
00222 class OStringStream : public OStream
00223 {
00224 public:
00225         OStringStream()
00226                 : OStream( &buffer_ )
00227         {
00228         }
00229 
00230         std::string str() const
00231         {
00232                 return buffer_.str();
00233         }
00234 
00235 private:
00236         StringStreamBuffer buffer_;
00237 };
00238 
00239 
00240 class OFileStream : public OStream
00241 {
00242 public:
00243    OFileStream( FILE *file )
00244       : OStream( &buffer_ )
00245       , buffer_( file )
00246       , ownFile_( false )
00247    {
00248    }
00249 
00250    OFileStream( const char *path )
00251       : OStream( &buffer_ )
00252       , buffer_( fopen( path, "wt" ) )
00253       , ownFile_( true )
00254    {
00255    }
00256 
00257    virtual ~OFileStream()
00258    {
00259       if ( ownFile_  &&  buffer_.file() )
00260          fclose( buffer_.file() );
00261    }
00262 
00263 private:
00264    FileStreamBuffer buffer_;
00265    bool ownFile_;
00266 };
00267 
00268 inline OStream &stdCOut() 
00269 {
00270    static OFileStream stream( stdout );
00271    return stream;
00272 }
00273 
00274 inline OStream &stdCErr() 
00275 {
00276    static OFileStream stream( stderr );
00277    return stream;
00278 }
00279 
00280 CPPUNIT_NS_END
00281 
00282 #elif CPPUNIT_HAVE_SSTREAM // #if defined( CPPUNIT_NO_STREAM )
00283 # include <sstream>
00284 # include <fstream>
00285 
00286     CPPUNIT_NS_BEGIN
00287     typedef std::ostringstream OStringStream;      // The standard C++ way
00288     typedef std::ofstream OFileStream;
00289     CPPUNIT_NS_END
00290 
00291 
00292 #elif CPPUNIT_HAVE_CLASS_STRSTREAM
00293 # include <string>
00294 # if CPPUNIT_HAVE_STRSTREAM
00295 #   include <strstream>
00296 # else // CPPUNIT_HAVE_STRSTREAM
00297 #  include <strstream.h>
00298 # endif // CPPUNIT_HAVE_CLASS_STRSTREAM
00299 
00300     CPPUNIT_NS_BEGIN
00301 
00302     class OStringStream : public std::ostrstream 
00303     {
00304     public:
00305         std::string str()
00306         {
00307 //            (*this) << '\0';
00308 //            std::string msg(std::ostrstream::str());
00309 //            std::ostrstream::freeze(false);
00310 //            return msg;
00311 // Alternative implementation that don't rely on freeze which is not
00312 // available on some platforms:
00313             return std::string( std::ostrstream::str(), pcount() );
00314         }
00315     };
00316 
00317     CPPUNIT_NS_END
00318 #else // CPPUNIT_HAVE_CLASS_STRSTREAM
00319 #   error Cannot define CppUnit::OStringStream.
00320 #endif // #if defined( CPPUNIT_NO_STREAM )
00321 
00322 
00323 
00324 #if !defined( CPPUNIT_NO_STREAM )
00325 
00326 #include <iostream>
00327 
00328     CPPUNIT_NS_BEGIN
00329 
00330     typedef std::ostream OStream;
00331 
00332     inline OStream &stdCOut() 
00333     {
00334         return std::cout;
00335     }
00336 
00337     inline OStream &stdCErr() 
00338     {
00339        return std::cerr;
00340     }
00341 
00342     CPPUNIT_NS_END
00343    
00344 #endif // #if !defined( CPPUNIT_NO_STREAM )
00345 
00346 #endif // CPPUNIT_PORTABILITY_STREAM_H_INCLUDED
00347 

SourceForge Logo hosts this site. Send comments to:
CppUnit Developers