Streambuf.h

Go to the documentation of this file.
00001 // -*- c++ -*-
00002 //------------------------------------------------------------------------------
00003 //                         Streambuf.h
00004 //------------------------------------------------------------------------------
00005 //  Copyright (c) 1999 by Vladislav Grinchenko
00006 //
00007 //  This library is free software; you can redistribute it and/or
00008 //  modify it under the terms of the GNU Library General Public
00009 //  License as published by the Free Software Foundation; either
00010 //  version 2 of the License, or (at your option) any later version.
00011 //------------------------------------------------------------------------------
00012 //  Created: 12/02/1999
00013 //------------------------------------------------------------------------------
00014 #ifndef STREAM_BUF_H
00015 #define STREAM_BUF_H
00016 
00017 #include <stdio.h>      // EOF
00018 #include "assa/Assure.h"        // trace() & Assert family
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;  // 64K
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; // set
00413     else
00414         m_flags &= ~ UNBUFFERED; // unset
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 /* c_ */)
00598 {
00599     trace_with_mask("Streambuf::overflow",STRMBUFTRACE);
00600 
00601     return (EOF);
00602 }
00603 
00604 } // end namespace ASSA
00605 
00606 #endif /* STREAM_BUF_H */  

Generated on Mon Dec 19 16:20:18 2005 for libassa by  doxygen 1.4.5