source: trunk/contrib/cppunit-1.12.2/include/cppunit/portability/Stream.h @ 876

Last change on this file since 876 was 876, checked in by sam, 9 years ago

contrib: add a precompiled Win32 version of CppUnit and update build system
accordingly.

File size: 6.1 KB
Line 
1#ifndef CPPUNIT_PORTABILITY_STREAM_H_INCLUDED
2#define CPPUNIT_PORTABILITY_STREAM_H_INCLUDED
3
4// This module define:
5// Type CppUT::Stream (either std::stream or a custom type)
6// Type CppUT::OStringStream (eitjer std::ostringstream, older alternate or a custom type)
7// Functions stdCOut() & stdCErr() which returns a reference on cout & cerr stream (or our
8// custom stream).
9
10#include <cppunit/Portability.h>
11
12
13#if defined( CPPUNIT_NO_STREAM )
14
15#include <string>
16#include <stdio.h>
17#include <string.h>
18
19CPPUNIT_NS_BEGIN
20
21class StreamBuffer
22{
23public:
24   virtual ~StreamBuffer() {}
25
26   virtual void write( const char *text, unsigned int length ) = 0;
27
28   virtual void flush() {}
29};
30
31
32class StringStreamBuffer : public StreamBuffer
33{
34public:
35   std::string str() const
36   {
37      return str_;
38   }
39
40public: // overridden from StreamBuffer
41   void write( const char *text, unsigned int length )
42   {
43      str_.append( text, length );
44   }
45
46private:
47   std::string str_;
48};
49
50
51class FileStreamBuffer : public StreamBuffer
52{
53public:
54   FileStreamBuffer( FILE *file )
55      : file_( file )
56   {
57   }
58
59   FILE *file() const
60   {
61      return file_;
62   }
63
64public: // overridden from StreamBuffer
65   void write( const char *text, unsigned int length )
66   {
67      if ( file_ )
68         fwrite( text, sizeof(char), length, file_ );
69   }
70
71   void flush()
72   {
73      if ( file_ )
74         fflush( file_ );
75   }
76
77private:
78   FILE *file_;
79};
80
81
82class OStream
83{
84public:
85   OStream()
86      : buffer_( 0 )
87   {
88   }
89
90   OStream( StreamBuffer *buffer )
91      : buffer_( buffer )
92   {
93   }
94
95   virtual ~OStream()
96   {
97     flush();
98   }
99
100   OStream &flush()
101   {
102           if ( buffer_ )
103                    buffer_->flush();
104           return *this;
105   }
106
107   void setBuffer( StreamBuffer *buffer )
108   {
109      buffer_ = buffer;
110   }
111
112   OStream &write( const char *text, unsigned int length )
113   {
114      if ( buffer_ )
115         buffer_->write( text, length );
116      return *this;
117   }
118
119   OStream &write( const char *text )
120   {
121      return write( text, strlen(text) );
122   }
123
124   OStream &operator <<( bool v )
125   {
126      const char *out = v ? "true" : "false";
127      return write( out );
128   }
129
130   OStream &operator <<( short v )
131   {
132      char buffer[64];
133      sprintf( buffer, "%hd", v );
134      return write( buffer );
135   }
136
137   OStream &operator <<( unsigned short v )
138   {
139      char buffer[64];
140      sprintf( buffer, "%hu", v );
141      return write( buffer );
142   }
143
144   OStream &operator <<( int v )
145   {
146      char buffer[64];
147      sprintf( buffer, "%d", v );
148      return write( buffer );
149   }
150
151   OStream &operator <<( unsigned int v )
152   {
153      char buffer[64];
154      sprintf( buffer, "%u", v );
155      return write( buffer );
156   }
157
158   OStream &operator <<( long v )
159   {
160      char buffer[64];
161      sprintf( buffer, "%ld", v );
162      return write( buffer );
163   }
164
165   OStream &operator <<( unsigned long v )
166   {
167      char buffer[64];
168      sprintf( buffer, "%lu", v );
169      return write( buffer );
170   }
171
172   OStream &operator <<( float v )
173   {
174      char buffer[128];
175      sprintf( buffer, "%.16g", double(v) );
176      return write( buffer );
177   }
178
179   OStream &operator <<( double v )
180   {
181      char buffer[128];
182      sprintf( buffer, "%.16g", v );
183      return write( buffer );
184   }
185
186   OStream &operator <<( long double v )
187   {
188      char buffer[128];
189      sprintf( buffer, "%.16g", double(v) );
190      return write( buffer );
191   }
192
193   OStream &operator <<( const void *v )
194   {
195      char buffer[64];
196      sprintf( buffer, "%p", v );
197      return write( buffer );
198   }
199
200   OStream &operator <<( const char *v )
201   {
202      return write( v ? v : "NULL" );
203   }
204
205   OStream &operator <<( char c )
206   {
207      char buffer[16];
208      sprintf( buffer, "%c", c );
209      return write( buffer );
210   }
211
212   OStream &operator <<( const std::string &s )
213   {
214      return write( s.c_str(), s.length() );
215   }
216
217private:
218   StreamBuffer *buffer_;
219};
220
221
222class OStringStream : public OStream
223{
224public:
225        OStringStream()
226                : OStream( &buffer_ )
227        {
228        }
229
230        std::string str() const
231        {
232                return buffer_.str();
233        }
234
235private:
236        StringStreamBuffer buffer_;
237};
238
239
240class OFileStream : public OStream
241{
242public:
243   OFileStream( FILE *file )
244      : OStream( &buffer_ )
245      , buffer_( file )
246      , ownFile_( false )
247   {
248   }
249
250   OFileStream( const char *path )
251      : OStream( &buffer_ )
252      , buffer_( fopen( path, "wt" ) )
253      , ownFile_( true )
254   {
255   }
256
257   virtual ~OFileStream()
258   {
259      if ( ownFile_  &&  buffer_.file() )
260         fclose( buffer_.file() );
261   }
262
263private:
264   FileStreamBuffer buffer_;
265   bool ownFile_;
266};
267
268inline OStream &stdCOut()
269{
270   static OFileStream stream( stdout );
271   return stream;
272}
273
274inline OStream &stdCErr()
275{
276   static OFileStream stream( stderr );
277   return stream;
278}
279
280CPPUNIT_NS_END
281
282#elif CPPUNIT_HAVE_SSTREAM // #if defined( CPPUNIT_NO_STREAM )
283# include <sstream>
284# include <fstream>
285
286    CPPUNIT_NS_BEGIN
287    typedef std::ostringstream OStringStream;      // The standard C++ way
288    typedef std::ofstream OFileStream;
289    CPPUNIT_NS_END
290
291
292#elif CPPUNIT_HAVE_CLASS_STRSTREAM
293# include <string>
294# if CPPUNIT_HAVE_STRSTREAM
295#   include <strstream>
296# else // CPPUNIT_HAVE_STRSTREAM
297#  include <strstream.h>
298# endif // CPPUNIT_HAVE_CLASS_STRSTREAM
299
300    CPPUNIT_NS_BEGIN
301
302    class OStringStream : public std::ostrstream
303    {
304    public:
305        std::string str()
306        {
307//            (*this) << '\0';
308//            std::string msg(std::ostrstream::str());
309//            std::ostrstream::freeze(false);
310//            return msg;
311// Alternative implementation that don't rely on freeze which is not
312// available on some platforms:
313            return std::string( std::ostrstream::str(), pcount() );
314        }
315    };
316
317    CPPUNIT_NS_END
318#else // CPPUNIT_HAVE_CLASS_STRSTREAM
319#   error Cannot define CppUnit::OStringStream.
320#endif // #if defined( CPPUNIT_NO_STREAM )
321
322
323
324#if !defined( CPPUNIT_NO_STREAM )
325
326#include <iostream>
327
328    CPPUNIT_NS_BEGIN
329
330    typedef std::ostream OStream;
331
332    inline OStream &stdCOut()
333    {
334        return std::cout;
335    }
336
337    inline OStream &stdCErr()
338    {
339       return std::cerr;
340    }
341
342    CPPUNIT_NS_END
343   
344#endif // #if !defined( CPPUNIT_NO_STREAM )
345
346#endif // CPPUNIT_PORTABILITY_STREAM_H_INCLUDED
347
Note: See TracBrowser for help on using the repository browser.