← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/pbms/src/cslib/CSStream.h

  • Committer: Lee Bieber
  • Date: 2010-10-22 16:47:38 UTC
  • mfrom: (1841.1.7 drizzle_pbms)
  • Revision ID: kalebral@gmail.com-20101022164738-vv8w22b8towpb307
Merge Barry - fix bug 657830: PBMS build failure in GCC 4.5

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/pbms/src/cslib/CSStream.h
74
74
         */
75
75
        virtual void reset() = 0; 
76
76
 
 
77
        /* Return the name of the file, or whatever: */
 
78
        virtual const char *identify() = 0;
 
79
 
77
80
        /*
78
81
         * Read a line from the input stream. This function
79
82
         * handles all types of line endings. The function
109
112
        virtual void flush() = 0;
110
113
 
111
114
        /*
112
 
         *  Writes the specified byte to this output stream.
 
115
         * Writes the specified byte to this output stream.
113
116
         */
114
117
        virtual void write(char b) = 0; 
115
118
 
116
119
        /*
117
 
         *  Reset this output stream to the start inorder to restart the write.
 
120
         * Reset this output stream to the start inorder to restart the write.
118
121
         */
119
122
        virtual void reset() = 0; 
120
123
 
 
124
        virtual const char *identify() = 0;
 
125
 
121
126
        /*
122
127
         * Write a line. Terminator is specific to the
123
128
         * type of output stream and may depend on the
159
164
         */
160
165
        virtual void reset(); 
161
166
 
 
167
        virtual const char *identify();
 
168
 
162
169
        static CSFileInputStream *newStream(CSFile* f);
163
170
        static CSFileInputStream *newStream(CSFile* f, off64_t offset);
164
171
 
184
191
 
185
192
        virtual void reset(); 
186
193
 
 
194
        virtual const char *identify();
 
195
 
187
196
        static CSFileOutputStream *newStream(CSFile* f);
188
197
        static CSFileOutputStream *newStream(CSFile* f, off64_t offset);
189
198
 
209
218
 
210
219
        virtual void reset(); 
211
220
 
 
221
        virtual const char *identify();
 
222
 
212
223
        static CSSocketInputStream *newStream(CSSocket *s);
213
224
 
214
225
private:
232
243
 
233
244
        virtual void reset(); 
234
245
 
 
246
        virtual const char *identify();
 
247
 
235
248
        static CSSocketOutputStream *newStream(CSSocket *s);
236
249
 
237
250
private:
239
252
};
240
253
 
241
254
/* Buffered Stream: */
242
 
#ifdef DEBUG
243
 
#define CS_STREAM_BUFFER_SIZE                   11
244
 
//#define CS_STREAM_BUFFER_SIZE                 (64 * 1024)
 
255
#ifdef DEBUG_disabled
 
256
#define CS_STREAM_BUFFER_SIZE                   80
245
257
#else
246
 
#define CS_STREAM_BUFFER_SIZE                   (64 * 1024)
 
258
#define CS_STREAM_BUFFER_SIZE                   (32 * 1024)
247
259
#endif
248
260
 
249
261
class CSBufferedInputStream : public CSInputStream {
261
273
 
262
274
        virtual void reset(); 
263
275
 
 
276
        virtual const char *identify();
 
277
 
264
278
        static CSBufferedInputStream *newStream(CSInputStream* i);
265
279
 
266
280
private:
287
301
 
288
302
        virtual void reset(); 
289
303
 
 
304
        virtual const char *identify();
 
305
 
290
306
        static CSBufferedOutputStream *newStream(CSOutputStream* i);
291
307
 
292
308
private:
331
347
 
332
348
        virtual void reset() {iMemPos = 0;}
333
349
        
 
350
        virtual const char *identify() 
 
351
        {
 
352
                return "memory stream";
 
353
        }
 
354
 
334
355
        static CSMemoryInputStream *newStream(const u_char* buffer, uint32_t length);
335
356
 
336
357
private:
362
383
        
363
384
        virtual void reset();
364
385
        
 
386
        virtual const char *identify();
 
387
        
365
388
        static CSMemoryOutputStream *newStream(size_t init_length, size_t min_alloc);
366
389
 
367
390
private:
392
415
                iMemSpace = iMemSize;
393
416
        }
394
417
        
 
418
        virtual const char *identify() 
 
419
        {
 
420
                return "memory stream";
 
421
        }
 
422
        
395
423
        off64_t getSize() { return iMemPos - iMemory; }
396
424
 
397
425
private:
466
494
                doReset = false;
467
495
        }
468
496
 
 
497
        virtual const char *identify() 
 
498
        {
 
499
                return "callback stream";
 
500
        }
 
501
 
469
502
        static CSCallbackInputStream *newStream(CSStreamReadCallbackFunc callback, void *user_data);
470
503
 
471
504
private:
475
508
        bool havePeek;
476
509
        bool doReset;
477
510
};
 
511
 
478
512
#endif
479
513
 
480
514