← Back to branch summary

~ubuntu-branches/ubuntu/utopic/psi/utopic

« back to all changes in this revision

Viewing changes to third-party/cppunit/cppunit/include/cppunit/portability/Stream.h

  • Committer: Bazaar Package Importer
  • Author(s): Jan Niehusmann
  • Date: 2009-09-25 17:49:51 UTC
  • mfrom: (6.1.3 sid)
  • Revision ID: james.westby@ubuntu.com-20090925174951-lvm7kdap82o8xhn3
Tags: 0.13-1
* Updated to upstream version 0.13
* Set Standards-Version to 3.8.3

Show diffs side-by-side

added added

removed removed

Lines of Context:
third-party/cppunit/cppunit/include/cppunit/portability/Stream.h
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
 
 
19
 
CPPUNIT_NS_BEGIN
20
 
 
21
 
class StreamBuffer
22
 
{
23
 
public:
24
 
   virtual ~StreamBuffer() {}
25
 
 
26
 
   virtual void write( const char *text, unsigned int length ) = 0;
27
 
 
28
 
   virtual void flush() {}
29
 
};
30
 
 
31
 
 
32
 
class StringStreamBuffer : public StreamBuffer
33
 
{
34
 
public:
35
 
   std::string str() const
36
 
   {
37
 
      return str_;
38
 
   }
39
 
 
40
 
public: // overridden from StreamBuffer
41
 
   void write( const char *text, unsigned int length )
42
 
   {
43
 
      str_.append( text, length );
44
 
   }
45
 
 
46
 
private:
47
 
   std::string str_;
48
 
};
49
 
 
50
 
 
51
 
class FileStreamBuffer : public StreamBuffer
52
 
{
53
 
public:
54
 
   FileStreamBuffer( FILE *file )
55
 
      : file_( file )
56
 
   {
57
 
   }
58
 
 
59
 
   FILE *file() const
60
 
   {
61
 
      return file_;
62
 
   }
63
 
 
64
 
public: // 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
 
 
77
 
private:
78
 
   FILE *file_;
79
 
};
80
 
 
81
 
 
82
 
class OStream
83
 
{
84
 
public:
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
 
 
217
 
private:
218
 
   StreamBuffer *buffer_;
219
 
};
220
 
 
221
 
 
222
 
class OStringStream : public OStream
223
 
{
224
 
public:
225
 
        OStringStream()
226
 
                : OStream( &buffer_ )
227
 
        {
228
 
        }
229
 
 
230
 
        std::string str() const
231
 
        {
232
 
                return buffer_.str();
233
 
        }
234
 
 
235
 
private:
236
 
        StringStreamBuffer buffer_;
237
 
};
238
 
 
239
 
 
240
 
class OFileStream : public OStream
241
 
{
242
 
public:
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
 
 
263
 
private:
264
 
   FileStreamBuffer buffer_;
265
 
   bool ownFile_;
266
 
};
267
 
 
268
 
inline OStream &stdCOut() 
269
 
{
270
 
   static OFileStream stream( stdout );
271
 
   return stream;
272
 
}
273
 
 
274
 
inline OStream &stdCErr() 
275
 
{
276
 
   static OFileStream stream( stderr );
277
 
   return stream;
278
 
}
279
 
 
280
 
CPPUNIT_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