00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014 #ifndef STREAM_BUF_H
00015 #define STREAM_BUF_H
00016
00017 #include <stdio.h>
00018 #include "assa/Assure.h"
00019
00020 namespace ASSA {
00021
00030 class io_ptrs
00031 {
00032 public:
00033 char* m_read_base;
00034 char* m_read_ptr;
00035 char* m_read_end;
00036
00037 char* m_write_base;
00038 char* m_write_ptr;
00039 char* m_write_end;
00040
00041 char* m_buf_base;
00042 char* m_buf_end;
00043
00044 enum { USER_BUF = 1, UNBUFFERED = 2, EOF_SEEN = 4, ERR_SEEN = 8 };
00045
00046 int m_flags;
00047 char m_shortbuf[1];
00048
00049 io_ptrs () : m_read_base (0), m_read_ptr (0), m_read_end (0),
00050 m_write_base (0), m_write_ptr (0), m_write_end (0),
00051 m_buf_base (0), m_buf_end (0), m_flags (0)
00052 {
00053 m_shortbuf [0] = 0;
00054 }
00055
00056 void dump () const;
00057 };
00058
00090 class Streambuf : public io_ptrs
00091 {
00092 public:
00096 static const int Streambuf::MAXTCPFRAMESZ = 65536;
00097
00098 virtual ~Streambuf ();
00099
00103 Streambuf* pubsetbuf (char* s_, int n_);
00104
00109 int pubsync ();
00110
00116 int in_avail ();
00117
00128 int snextc ();
00129
00136 int sbumpc ();
00137
00143 int sgetc ();
00144
00152 int sgetn (char* b_, int len_);
00153
00160 int sputc (char c_);
00161
00169 int sputn (char* b_, int len_);
00170
00171
00176 void unbuffered (int i_);
00177
00180 int unbuffered ();
00181
00182 protected:
00187 Streambuf ();
00188
00189 Streambuf (const Streambuf&);
00190 Streambuf& operator= (const Streambuf&);
00191
00195 char* base () const;
00196
00203 char* gptr () const;
00204
00208 char* egptr () const;
00209
00212 void setg (char* gbeg_, char* gnext_, char* gend_);
00213
00219 char* pbase () const;
00220
00225 char* pptr () const;
00226
00232 char* epptr () const;
00233
00236 void setp (char* pbeg_, char* pend_);
00237
00240 void pbump (int n_);
00241
00252 void setb (char* b_, char* eb_, int del_);
00253
00254 void init ();
00255
00256 protected:
00265 virtual Streambuf* setbuf (char* p_, int len_);
00266
00278 virtual int sync ();
00279
00290 virtual int showmanyc ();
00291
00299 virtual int xsgetn (char* b_, int len_);
00300
00313 virtual int underflow ();
00314
00331 virtual int uflow ();
00332
00341 virtual int xsputn (const char* b_, int len_);
00342
00357 virtual int overflow (int c = EOF);
00358
00366 virtual int doallocate ();
00367 };
00368
00369 inline Streambuf*
00370 Streambuf::
00371 pubsetbuf (char* s_, int n_)
00372 {
00373 trace_with_mask("Streambuf::pubsetbuf",STRMBUFTRACE);
00374
00375 return setbuf (s_, n_);
00376 }
00377
00378 inline int
00379 Streambuf::
00380 pubsync ()
00381 {
00382 trace_with_mask("Streambuf::pubsync",STRMBUFTRACE);
00383
00384 return sync ();
00385 }
00386
00387 inline int
00388 Streambuf::
00389 in_avail ()
00390 {
00391 trace_with_mask("Streambuf::in_avail",STRMBUFTRACE);
00392
00393 return m_read_end - m_read_ptr;
00394 }
00395
00396 inline int
00397 Streambuf::
00398 unbuffered ()
00399 {
00400 trace_with_mask("Streambuf::unbuffered",STRMBUFTRACE);
00401
00402 return m_flags & UNBUFFERED ? 1 : 0;
00403 }
00404
00405 inline void
00406 Streambuf::
00407 unbuffered (int i_)
00408 {
00409 trace_with_mask("Streambuf::unbuffered",STRMBUFTRACE);
00410
00411 if (i_)
00412 m_flags |= UNBUFFERED;
00413 else
00414 m_flags &= ~ UNBUFFERED;
00415 }
00416
00417 inline
00418 Streambuf::
00419 Streambuf ()
00420 {
00421 trace_with_mask("Streambuf::Streambuf",STRMBUFTRACE);
00422
00423 init ();
00424 }
00425
00426 inline void
00427 Streambuf::
00428 init ()
00429 {
00430 trace_with_mask("Streambuf::init", STRMBUFTRACE);
00431
00432 m_read_base = m_read_ptr = m_read_end = 0;
00433 m_write_base = m_write_ptr = m_write_end = 0;
00434 m_buf_base = m_buf_end = 0;
00435 m_flags = 0;
00436
00437 m_shortbuf[0] = 0;
00438 }
00439
00440 inline
00441 Streambuf::
00442 ~Streambuf ()
00443 {
00444 trace_with_mask("Streambuf::~Streambuf",STRMBUFTRACE);
00445
00446 if (!(m_flags & USER_BUF)) {
00447 delete [] m_buf_base;
00448 m_buf_base = m_buf_end = 0;
00449 }
00450 }
00451
00452 inline char*
00453 Streambuf::
00454 base () const
00455 {
00456 trace_with_mask("Streambuf::base",STRMBUFTRACE);
00457
00458 return m_read_base;
00459 }
00460
00461 inline char*
00462 Streambuf::
00463 gptr () const
00464 {
00465 trace_with_mask("Streambuf::gptr",STRMBUFTRACE);
00466
00467 return m_read_ptr;
00468 }
00469
00470 inline char*
00471 Streambuf::
00472 egptr () const
00473 {
00474 trace_with_mask("Streambuf::egptr",STRMBUFTRACE);
00475
00476 return m_read_end;
00477 }
00478
00479 inline char*
00480 Streambuf::
00481 pbase () const
00482 {
00483 trace_with_mask("Streambuf::pbase",STRMBUFTRACE);
00484 return m_write_base;
00485 }
00486
00487 inline char*
00488 Streambuf::
00489 pptr () const
00490 {
00491 trace_with_mask("Streambuf::pptr",STRMBUFTRACE);
00492 return m_write_ptr;
00493 }
00494
00495 inline char*
00496 Streambuf::
00497 epptr () const
00498 {
00499 trace_with_mask("Streambuf::epptr",STRMBUFTRACE);
00500 return m_write_end;
00501 }
00502
00503 inline void
00504 Streambuf::
00505 pbump (int n_)
00506 {
00507 trace_with_mask("Streambuf::pbump",STRMBUFTRACE);
00508 m_write_ptr += n_;
00509 }
00510
00511 inline int
00512 Streambuf::
00513 sync ()
00514 {
00515 trace_with_mask("Streambuf::sync",STRMBUFTRACE);
00516 return 0;
00517 }
00518
00519 inline int
00520 Streambuf::
00521 showmanyc ()
00522 {
00523 trace_with_mask("Streambuf::showmanyc",STRMBUFTRACE);
00524 return -1;
00525 }
00526
00527 inline int
00528 Streambuf::
00529 sbumpc ()
00530 {
00531 trace_with_mask("Streambuf::sbumpc",STRMBUFTRACE);
00532
00533 return (m_read_ptr >= m_read_end ? uflow ()
00534 : *(unsigned char *) m_read_ptr++);
00535 }
00536
00537 inline int
00538 Streambuf::
00539 sgetc ()
00540 {
00541 trace_with_mask("Streambuf::sgetc",STRMBUFTRACE);
00542
00543 return (m_read_ptr >= m_read_end && underflow () == EOF
00544 ? EOF : *(unsigned char*) m_read_ptr);
00545 }
00546
00547 inline int
00548 Streambuf::
00549 sgetn (char* data_, int len_)
00550 {
00551 trace_with_mask("Streambuf::sgetn",STRMBUFTRACE);
00552
00553 return xsgetn (data_, len_);
00554 }
00555
00556 inline int
00557 Streambuf::
00558 sputc (char c_)
00559 {
00560 trace_with_mask("Streambuf::sputc",STRMBUFTRACE);
00561
00562 return (m_write_ptr >= m_write_end
00563 ? overflow (c_)
00564 : (unsigned char) (*m_write_ptr++ = c_));
00565 }
00566
00567 inline int
00568 Streambuf::
00569 sputn (char* b_, int len_)
00570 {
00571 trace_with_mask("Streambuf::sputn",STRMBUFTRACE);
00572
00573 return xsputn (b_, len_);
00574 }
00575
00576 inline void
00577 Streambuf::
00578 setp (char* pbeg_, char* pend_)
00579 {
00580 trace_with_mask("Streambuf::setp",STRMBUFTRACE);
00581
00582 m_write_base = m_write_ptr = pbeg_;
00583 m_write_end = pend_;
00584 }
00585
00586 inline int
00587 Streambuf::
00588 underflow ()
00589 {
00590 trace_with_mask("Streambuf::underflow",STRMBUFTRACE);
00591
00592 return (EOF);
00593 }
00594
00595 inline int
00596 Streambuf::
00597 overflow (int )
00598 {
00599 trace_with_mask("Streambuf::overflow",STRMBUFTRACE);
00600
00601 return (EOF);
00602 }
00603
00604 }
00605
00606 #endif