ASSA::Streambuf

ASSA::Streambuf Class Reference

Streambuf class. More...

#include <Streambuf.h>

Inheritance diagram for ASSA::Streambuf:

Inheritance graph
[legend]
Collaboration diagram for ASSA::Streambuf:

Collaboration graph
[legend]
List of all members.

Public Member Functions

virtual ~Streambuf ()
Streambuf * pubsetbuf (char *s_, int n_)
 Set buffer.
int pubsync ()
int in_avail ()
 This function returns the number of characters immediately available in the get area.
int snextc ()
 This function moves the get pointer forward one position, then returns the character after the get pointer's new position.
int sbumpc ()
 This function should probably have been called ``sgetc''.
int sgetc ()
 This function returns the character after the get pointer, or EOF if the get pointer is at the end of the sequence.
int sgetn (char *b_, int len_)
 This function gets the next len_ characters following the get pointer, copying them to the char array pointed to by b_; it advances the get pointer past the last character fetched.
int sputc (char c_)
 This function stores c just after the put pointer, and advances the pointer one position, possibly extending the sequence.
int sputn (char *b_, int len_)
 From the location pointed to by ptr, stores exactly len characters after the put pointer, advancing the put pointer just past the last character.
void unbuffered (int i_)
 If i_ is non-zero, then all IO operations are buffered.
int unbuffered ()

Static Public Attributes

static const int MAXTCPFRAMESZ = 65536
 Size of the internal input/output buffer.

Protected Member Functions

 Streambuf ()
 The default constructor is protected for class Streambuf to asssure that only objects for classes derived from this class may be constructed.
 Streambuf (const Streambuf &)
Streambuf & operator= (const Streambuf &)
char * base () const
 Returns the lowest possible value for gptr() - the beginning of the get area.
char * gptr () const
 Returns a pointer to the beginning of the get area, and thus to the next character to be fetched (if there are any).
char * egptr () const
 Returns a pointer just past the end of the get area, the maximum possible value for gptr().
void setg (char *gbeg_, char *gnext_, char *gend_)
 Set get area pointers.
char * pbase () const
 Returns a pointer to the beginning fo the space available for the put area, the lowest possible value for pptr().
char * pptr () const
 Returns a pointer to the beginning of the put area, and thus to the location of the next character that is stored (if possible).
char * epptr () const
 Returns a pointer just past the end of the put area, the maximum possible value for pptr().
void setp (char *pbeg_, char *pend_)
 Set put area pointers.
void pbump (int n_)
 Advances the next pointer for the output sequence by n_.
void setb (char *b_, char *eb_, int del_)
 Establish the reserve area (buffer).
void init ()
virtual Streambuf * setbuf (char *p_, int len_)
 Performs an operation that is defined separately for each class derived from Streambuf.
virtual int sync ()
 This function synchronizes the streambuf with its actual stream of characters.
virtual int showmanyc ()
 The morphemes of showmanyc are "es-how-many-see", not "show-man-ic".
virtual int xsgetn (char *b_, int len_)
 Assigns up to len_ characters to successive elements of the array whose first element is designated by b_.
virtual int underflow ()
 This function is called to supply characters for input (from some source) when the get area is empty, although it may be called at other times.
virtual int uflow ()
 Reads the characters from the input sequence, if possible, and moves the stream position past it, as follows:.
virtual int xsputn (const char *b_, int len_)
 Writes up to len_ characters to the output sequence as if by repeated calls to sputc (c).
virtual int overflow (int c=EOF)
 This function is called to consume characters (flush them to output), typically when the put area is full and an attempt is made to store another character.
virtual int doallocate ()
 This function is called by allocate when unbuffered() is zero and base() is zero.

Detailed Description

Streambuf class.

Streambuf class is based on Standard C++ iostream streambuf class.

Extending std::streambuf is always pain due to the obscurity and complexity of its interface, and in general, lack of the source code needed to efficiently understand its implementation.

I wrote my own Streambuf that implements a subset of std::streambuf functions - a bare minimum to get by for Socket buffering.

The buffer of a Streambuf may be considered to have three parts: the get area, the put area, and the reserve area (which is the same as the buffer area).

The get area contains the characters immediately available for input.

The put area holds characters stored for output but not yet consumed by (flushed to) their ultimate destination. The get and put areas may be disjoint or may overlap (in my implementation they are two disjoined buffers). The reserve area is the entire buffer, overlapped by the get and put areas (in my implementation, reserve area covers get area only). The get and put areas may expand into the remainder of the reserve area. In the course of input and output operations, the sizes of the get and put areas expand and shrink, always bounded by the total buffer size.

Definition at line 90 of file Streambuf.h.

Constructor & Destructor Documentation

ASSA::Streambuf::~Streambuf (   )  [inline, virtual]
 

Definition at line 452 of file Streambuf.h.

References ASSA::io_ptrs::m_buf_base, ASSA::io_ptrs::m_buf_end, ASSA::io_ptrs::m_flags, ASSA::STRMBUFTRACE, trace_with_mask, and ASSA::io_ptrs::USER_BUF.

00453 {
00454     trace_with_mask("Streambuf::~Streambuf",STRMBUFTRACE);
00455 
00456     if (!(m_flags & USER_BUF)) {
00457         delete [] m_buf_base;
00458         m_buf_base = m_buf_end = 0;
00459     }
00460 }

ASSA::Streambuf::Streambuf (   )  [inline, protected]
 

The default constructor is protected for class Streambuf to asssure that only objects for classes derived from this class may be constructed.

Definition at line 429 of file Streambuf.h.

References init(), ASSA::STRMBUFTRACE, and trace_with_mask.

00430 { 
00431     trace_with_mask("Streambuf::Streambuf",STRMBUFTRACE);
00432 
00433     init (); 
00434 }

ASSA::Streambuf::Streambuf (  const Streambuf &   )  [protected]
 

Member Function Documentation

char * ASSA::Streambuf::base (   )  const [inline, protected]
 

Returns the lowest possible value for gptr() - the beginning of the get area.

Definition at line 464 of file Streambuf.h.

References ASSA::io_ptrs::m_read_base, ASSA::STRMBUFTRACE, and trace_with_mask.

Referenced by ASSA::Socketbuf::underflow().

00465 { 
00466     trace_with_mask("Streambuf::base",STRMBUFTRACE);
00467 
00468     return m_read_base; 
00469 }

int Streambuf::doallocate (   )  [protected, virtual]
 

This function is called by allocate when unbuffered() is zero and base() is zero.

It attempts to make a buffer of suitable size available. On success it must call setb to establish the reserve area, then return a value greater than zero. On failure it returns EOF. The default behavior is to allocate a buffer using new.

Reimplemented in ASSA::Socketbuf.

Definition at line 234 of file Streambuf.cpp.

References setb(), ASSA::STRMBUFTRACE, and trace_with_mask.

00235 {
00236     trace_with_mask("Streambuf::doallocate",STRMBUFTRACE);
00237 
00238     char* buf;
00239     buf = new char [1024];
00240     if (buf == NULL) {
00241         return EOF;
00242     }
00243     setb (buf, buf+1024, 1);
00244 
00245     return 1;
00246 }

char * ASSA::Streambuf::egptr (   )  const [inline, protected]
 

Returns a pointer just past the end of the get area, the maximum possible value for gptr().

Definition at line 482 of file Streambuf.h.

References ASSA::io_ptrs::m_read_end, ASSA::STRMBUFTRACE, and trace_with_mask.

Referenced by ASSA::Socketbuf::underflow().

00483 { 
00484     trace_with_mask("Streambuf::egptr",STRMBUFTRACE);
00485 
00486     return m_read_end; 
00487 }

char * ASSA::Streambuf::epptr (   )  const [inline, protected]
 

Returns a pointer just past the end of the put area, the maximum possible value for pptr().

The space from pptr() through epptr() is immediately available for storing characters without a flush operation.

Definition at line 507 of file Streambuf.h.

References ASSA::io_ptrs::m_write_end, ASSA::STRMBUFTRACE, and trace_with_mask.

Referenced by ASSA::Socketbuf::flush_output(), and ASSA::Socketbuf::overflow().

00508 { 
00509     trace_with_mask("Streambuf::epptr",STRMBUFTRACE);
00510     return m_write_end; 
00511 }

char * ASSA::Streambuf::gptr (   )  const [inline, protected]
 

Returns a pointer to the beginning of the get area, and thus to the next character to be fetched (if there are any).

The characters immediately available are from gptr() through egptr()-1. If egptr()<=gptr(), no char- acters are available.

Definition at line 473 of file Streambuf.h.

References ASSA::io_ptrs::m_read_ptr, ASSA::STRMBUFTRACE, and trace_with_mask.

Referenced by ASSA::Socketbuf::underflow().

00474 { 
00475     trace_with_mask("Streambuf::gptr",STRMBUFTRACE);
00476 
00477     return m_read_ptr; 
00478 }

int ASSA::Streambuf::in_avail (   )  [inline]
 

This function returns the number of characters immediately available in the get area.

It is certain that i characters may be fetched without error, and without accessing any external device.

Definition at line 399 of file Streambuf.h.

References ASSA::io_ptrs::m_read_end, ASSA::io_ptrs::m_read_ptr, ASSA::STRMBUFTRACE, and trace_with_mask.

Referenced by ASSA::IPv4Socket::clone(), ASSA::IPv4Socket::close(), ASSA::Socket::getBytesAvail(), and ASSA::IPv4Socket::in_avail().

00400 { 
00401     trace_with_mask("Streambuf::in_avail",STRMBUFTRACE);
00402 
00403     return m_read_end - m_read_ptr; 
00404 }

void ASSA::Streambuf::init (   )  [inline, protected]
 

Definition at line 438 of file Streambuf.h.

References ASSA::io_ptrs::m_buf_base, ASSA::io_ptrs::m_buf_end, ASSA::io_ptrs::m_flags, ASSA::io_ptrs::m_read_base, ASSA::io_ptrs::m_read_end, ASSA::io_ptrs::m_read_ptr, ASSA::io_ptrs::m_shortbuf, ASSA::io_ptrs::m_write_base, ASSA::io_ptrs::m_write_end, ASSA::io_ptrs::m_write_ptr, ASSA::STRMBUFTRACE, and trace_with_mask.

Referenced by Streambuf().

00439 {
00440     trace_with_mask("Streambuf::init", STRMBUFTRACE);
00441 
00442     m_read_base = m_read_ptr = m_read_end = 0;
00443     m_write_base = m_write_ptr = m_write_end = 0;
00444     m_buf_base = m_buf_end = 0;
00445     m_flags = 0;
00446 
00447     m_shortbuf[0] = 0;
00448 }

Streambuf& ASSA::Streambuf::operator= (  const Streambuf &   )  [protected]
 

int ASSA::Streambuf::overflow (  int  c = EOF  )  [inline, protected, virtual]
 

This function is called to consume characters (flush them to output), typically when the put area is full and an attempt is made to store another character.

If c is not EOF, overflow must either store or consume the character, following those already in the put area. It returns EOF on error, any other value on success. The default behavior of the base class version is undefined, so each derived class must define its own overflow. The normal action for a derived class version is to consume the characters in the put area (those between pbase() and pptr()), call setp() to set up a new put area, then store c (using sputc()) if it is not EOF.

Reimplemented in ASSA::Socketbuf.

Definition at line 607 of file Streambuf.h.

References ASSA::STRMBUFTRACE, and trace_with_mask.

Referenced by sputc().

00608 {
00609     trace_with_mask("Streambuf::overflow",STRMBUFTRACE);
00610 
00611     return (EOF);
00612 }

char * ASSA::Streambuf::pbase (   )  const [inline, protected]
 

Returns a pointer to the beginning fo the space available for the put area, the lowest possible value for pptr().

The area from pbase() through pptr()-1 represents characters which have been stored int the buffer but not yet consumed.

Definition at line 491 of file Streambuf.h.

References ASSA::io_ptrs::m_write_base, ASSA::STRMBUFTRACE, and trace_with_mask.

Referenced by ASSA::Socketbuf::flush_output(), and ASSA::Socketbuf::overflow().

00492 { 
00493     trace_with_mask("Streambuf::pbase",STRMBUFTRACE);
00494     return m_write_base; 
00495 }

void ASSA::Streambuf::pbump (  int  n_  )  [inline, protected]
 

Advances the next pointer for the output sequence by n_.

Definition at line 515 of file Streambuf.h.

References ASSA::io_ptrs::m_write_ptr, ASSA::STRMBUFTRACE, and trace_with_mask.

Referenced by ASSA::Socketbuf::flush_output(), and ASSA::Socketbuf::xput_char().

00516 { 
00517     trace_with_mask("Streambuf::pbump",STRMBUFTRACE);
00518     m_write_ptr += n_; 
00519 }

char * ASSA::Streambuf::pptr (   )  const [inline, protected]
 

Returns a pointer to the beginning of the put area, and thus to the location of the next character that is stored (if possible).

Definition at line 499 of file Streambuf.h.

References ASSA::io_ptrs::m_write_ptr, ASSA::STRMBUFTRACE, and trace_with_mask.

Referenced by ASSA::Socketbuf::flush_output(), ASSA::Socketbuf::overflow(), and ASSA::Socketbuf::xput_char().

00500 { 
00501     trace_with_mask("Streambuf::pptr",STRMBUFTRACE);
00502     return m_write_ptr; 
00503 }

Streambuf * ASSA::Streambuf::pubsetbuf (  char *  s_,
int  n_
)  [inline]
 

Set buffer.

Returns:
setbuf(s_, n_)

Definition at line 381 of file Streambuf.h.

References setbuf(), ASSA::STRMBUFTRACE, and trace_with_mask.

00382 { 
00383     trace_with_mask("Streambuf::pubsetbuf",STRMBUFTRACE);
00384     
00385     return setbuf (s_, n_); 
00386 }

int ASSA::Streambuf::pubsync (   )  [inline]
 

See also:
sync
Returns:
sync()

Definition at line 390 of file Streambuf.h.

References ASSA::STRMBUFTRACE, sync(), and trace_with_mask.

00391 { 
00392     trace_with_mask("Streambuf::pubsync",STRMBUFTRACE);
00393 
00394     return sync (); 
00395 }

int ASSA::Streambuf::sbumpc (   )  [inline]
 

This function should probably have been called ``sgetc''.

It moves the get pointer forward one posi- tion and returns the character it moved past. If the get pointer is currently at the end of the sequence, this function returns EOF.

Definition at line 539 of file Streambuf.h.

References ASSA::io_ptrs::m_read_end, ASSA::io_ptrs::m_read_ptr, ASSA::STRMBUFTRACE, trace_with_mask, and uflow().

Referenced by ASSA::IPv4Socket::close(), and ASSA::IPv4Socket::read().

00540 {
00541     trace_with_mask("Streambuf::sbumpc",STRMBUFTRACE);
00542 
00543     return (m_read_ptr >= m_read_end ? uflow ()
00544             : *(unsigned char *) m_read_ptr++);
00545 }

void Streambuf::setb (  char *  b_,
char *  eb_,
int  del_
)  [protected]
 

Establish the reserve area (buffer).

Set base() to b_, ebuf() to eb_. If del_ is non-zero, the buffer will be deleted whenever base() is changed by another call to setb(), or when Streambuf destructor is invoked. If del_ is zero, the buffer will not be deleted automatically.

Parameters:
b_ pointer to the buffer's first byte
eb_ pointer to the byte one past the buffer's last byte
del_ 0 - external memory management, 1 - delete on swap/destruction

Definition at line 80 of file Streambuf.cpp.

References ASSA::io_ptrs::dump(), ASSA::io_ptrs::m_buf_base, ASSA::io_ptrs::m_buf_end, ASSA::io_ptrs::m_flags, ASSA::STRMBUFTRACE, trace_with_mask, and ASSA::io_ptrs::USER_BUF.

Referenced by doallocate(), ASSA::Socketbuf::doallocate(), and setbuf().

00081 {
00082     trace_with_mask("Streambuf::setb",STRMBUFTRACE);
00083 
00084     if (m_buf_base && !(m_flags & USER_BUF))
00085         delete m_buf_base;
00086 
00087     m_buf_base = b_;
00088     m_buf_end = eb_;
00089     
00090     if (del_)
00091         m_flags &= ~ USER_BUF; // clear bit
00092     else
00093         m_flags |= USER_BUF; // set bit
00094 
00095     dump ();
00096 }

Streambuf * Streambuf::setbuf (  char *  p_,
int  len_
)  [protected, virtual]
 

Performs an operation that is defined separately for each class derived from Streambuf.

Default behavior is to set internal buffer to p_. If p_ is NULL or len_ is 0, then unbuffered I/O (one byte at a time) is assumed.

Parameters:
p_ buffer to use
len_ length of the buffer

Definition at line 100 of file Streambuf.cpp.

References DL, setb(), setg(), setp(), ASSA::STRMBUF, ASSA::STRMBUFTRACE, sync(), trace_with_mask, and unbuffered().

Referenced by pubsetbuf().

00101 {
00102     trace_with_mask("Streambuf::setb",STRMBUFTRACE);
00103 
00104     if (sync () == EOF) // Flush out all pending bytes before
00105         return NULL;    // resetting buffer. Also, first time around,
00106     // calling sync() suppose to set put area
00107     // pointers.
00108 
00109     if (p_ == NULL || len_ == 0) {
00110         DL((STRMBUF,"Unbuffered IO set.\n"));
00111         unbuffered (1);
00112         // We do it from doalloc instead - vlg
00113         // setb (m_shortbuf, m_shortbuf+1, 0);
00114     }
00115     else {
00116         DL((STRMBUF,"Buffered IO set.\n"));
00117         unbuffered (0);
00118         setb (p_, p_ + len_, 0);
00119     }
00120     setp (0, 0);
00121     setg (0, 0, 0);
00122 
00123     return this;
00124 }

void Streambuf::setg (  char *  gbeg_,
char *  gnext_,
char *  gend_
)  [protected]
 

Set get area pointers.

Definition at line 69 of file Streambuf.cpp.

References ASSA::io_ptrs::m_read_base, ASSA::io_ptrs::m_read_end, ASSA::io_ptrs::m_read_ptr, ASSA::STRMBUFTRACE, and trace_with_mask.

Referenced by ASSA::Socketbuf::doallocate(), setbuf(), and ASSA::Socketbuf::underflow().

00070 {
00071     trace_with_mask("Streambuf::setg",STRMBUFTRACE);
00072 
00073     m_read_base = gbeg_;
00074     m_read_ptr  = gnext_;
00075     m_read_end  = gend_;
00076 }

void ASSA::Streambuf::setp (  char *  pbeg_,
char *  pend_
)  [inline, protected]
 

Set put area pointers.

Definition at line 588 of file Streambuf.h.

References ASSA::io_ptrs::m_write_base, ASSA::io_ptrs::m_write_end, ASSA::io_ptrs::m_write_ptr, ASSA::STRMBUFTRACE, and trace_with_mask.

Referenced by ASSA::Socketbuf::doallocate(), ASSA::Socketbuf::flush_output(), and setbuf().

00589 {
00590     trace_with_mask("Streambuf::setp",STRMBUFTRACE);
00591 
00592     m_write_base = m_write_ptr = pbeg_;
00593     m_write_end  = pend_;
00594 }

int ASSA::Streambuf::sgetc (   )  [inline]
 

This function returns the character after the get pointer, or EOF if the get pointer is at the end of the sequence.

Despite its name, this function does NOT move the get pointer.

Definition at line 549 of file Streambuf.h.

References ASSA::io_ptrs::m_read_end, ASSA::io_ptrs::m_read_ptr, ASSA::STRMBUFTRACE, trace_with_mask, and underflow().

Referenced by snextc().

00550 {
00551     trace_with_mask("Streambuf::sgetc",STRMBUFTRACE);
00552 
00553     return (m_read_ptr >= m_read_end && underflow () == EOF 
00554             ? EOF : *(unsigned char*) m_read_ptr);
00555 }

int ASSA::Streambuf::sgetn (  char *  b_,
int  len_
)  [inline]
 

This function gets the next len_ characters following the get pointer, copying them to the char array pointed to by b_; it advances the get pointer past the last character fetched.

If fewer than len characters are left, it gets as many as are available.

Returns:
the number of characters fetched.

Definition at line 559 of file Streambuf.h.

References ASSA::STRMBUFTRACE, trace_with_mask, and xsgetn().

00560 {
00561     trace_with_mask("Streambuf::sgetn",STRMBUFTRACE);
00562 
00563     return xsgetn (data_, len_);
00564 }

int ASSA::Streambuf::showmanyc (   )  [inline, protected, virtual]
 

The morphemes of showmanyc are "es-how-many-see", not "show-man-ic".

Return an estimate of the number of characters available in the sequence, or -1. If it returns a positive value, then successive calls to underflow() will not return EOF until at least that number of characters have been supplied. If showmanyc() returns -1, then calls to underflow() or uflow() will fail. The intention is not only that these calls will not return EOF, but that they will return ``immediately.''

Reimplemented in ASSA::Socketbuf.

Definition at line 531 of file Streambuf.h.

References ASSA::STRMBUFTRACE, and trace_with_mask.

00532 { 
00533     trace_with_mask("Streambuf::showmanyc",STRMBUFTRACE);
00534     return -1; 
00535 }

int Streambuf::snextc (   ) 
 

This function moves the get pointer forward one position, then returns the character after the get pointer's new position.

If the get pointer is at the end of the sequence before or after the call to this function (no character is available), this function returns EOF. Example: Suppose the input buffer looks like this: abc|def where `|' marks the position of the get pointer. This function will advance the get pointer and return `e'.

Definition at line 57 of file Streambuf.cpp.

References ASSA::io_ptrs::m_read_end, ASSA::io_ptrs::m_read_ptr, sgetc(), ASSA::STRMBUFTRACE, trace_with_mask, and underflow().

00058 {   
00059     trace_with_mask("Streambuf::snextc",STRMBUFTRACE);
00060 
00061     if (m_read_ptr >= m_read_end && underflow () == EOF) {
00062         return EOF;
00063     }
00064     return m_read_ptr++, sgetc (); 
00065 }

int ASSA::Streambuf::sputc (  char  c_  )  [inline]
 

This function stores c just after the put pointer, and advances the pointer one position, possibly extending the sequence.

It returns c, or EOF on error. What constitutes an error depends on the actual derived buffer class.

Definition at line 568 of file Streambuf.h.

References ASSA::io_ptrs::m_write_end, ASSA::io_ptrs::m_write_ptr, overflow(), ASSA::STRMBUFTRACE, and trace_with_mask.

Referenced by ASSA::IPv4Socket::write().

00569 {
00570     trace_with_mask("Streambuf::sputc",STRMBUFTRACE);
00571 
00572     return (m_write_ptr >= m_write_end
00573             ? overflow (c_)
00574             : (unsigned char) (*m_write_ptr++ = c_));
00575 }

int ASSA::Streambuf::sputn (  char *  b_,
int  len_
)  [inline]
 

From the location pointed to by ptr, stores exactly len characters after the put pointer, advancing the put pointer just past the last character.

It returns the number of characters stored, which ought to be len. Fewer than len characters stored indicates some sort of error.

Definition at line 579 of file Streambuf.h.

References ASSA::STRMBUFTRACE, trace_with_mask, and xsputn().

00580 {
00581     trace_with_mask("Streambuf::sputn",STRMBUFTRACE);
00582 
00583     return xsputn (b_, len_);
00584 }

int ASSA::Streambuf::sync (   )  [inline, protected, virtual]
 

This function synchronizes the streambuf with its actual stream of characters.

The derived class version should flush any characters in the put area to their final destination, and if possible give back any characters in the input buffer to their source. It should return EOF on any error, zero on success. The default behavior of the base class version is to return zero if there are no pending input or output characters (in_avail() and out_waiting() are both zero), and return EOF otherwise.

Reimplemented in ASSA::Socketbuf.

Definition at line 523 of file Streambuf.h.

References ASSA::STRMBUFTRACE, and trace_with_mask.

Referenced by pubsync(), and setbuf().

00524 { 
00525     trace_with_mask("Streambuf::sync",STRMBUFTRACE);
00526     return 0; 
00527 }

int Streambuf::uflow (   )  [protected, virtual]
 

Reads the characters from the input sequence, if possible, and moves the stream position past it, as follows:.

1) If the input sequence has a read position available the function signals success by returning (unsigned char)*gnext++.

2) Otherwise, if the function can read the character x directly from the associated input sequence, it signals succes by returning (unsigned char) x. If the function makes a read position available, it also assigns x to *gnext.

The default behavior is to call underflow () and, if that function returns EOF or fails to make a read position available, return EOF. Otherwise, the function signals success by returning (unsigned char)*gnext++.

Definition at line 172 of file Streambuf.cpp.

References ASSA::io_ptrs::dump(), ASSA::io_ptrs::m_read_ptr, ASSA::STRMBUFTRACE, trace_with_mask, and underflow().

Referenced by sbumpc().

00173 {
00174     trace_with_mask("Streambuf::uflow",STRMBUFTRACE);
00175 
00176     if (underflow () == EOF)
00177         return EOF;
00178     dump ();
00179     return *(unsigned char *) m_read_ptr++;
00180 }

int ASSA::Streambuf::unbuffered (   )  [inline]
 

Returns:
true if unbuffered, false otherwise

Definition at line 408 of file Streambuf.h.

References ASSA::io_ptrs::m_flags, ASSA::STRMBUFTRACE, trace_with_mask, and ASSA::io_ptrs::UNBUFFERED.

Referenced by ASSA::Socketbuf::flush_output(), ASSA::Socketbuf::overflow(), setbuf(), ASSA::Socketbuf::Socketbuf(), and ASSA::Socketbuf::underflow().

00409 { 
00410     trace_with_mask("Streambuf::unbuffered",STRMBUFTRACE);
00411     
00412     return m_flags & UNBUFFERED ? 1 : 0; 
00413 }

void ASSA::Streambuf::unbuffered (  int  i_  )  [inline]
 

If i_ is non-zero, then all IO operations are buffered.

If i_ is zero, then unbuffered IO is performed (one character at a time.

Definition at line 417 of file Streambuf.h.

References ASSA::io_ptrs::m_flags, ASSA::STRMBUFTRACE, trace_with_mask, and ASSA::io_ptrs::UNBUFFERED.

Referenced by ASSA::IPv4Socket::read(), and ASSA::IPv4Socket::write().

00418 {
00419     trace_with_mask("Streambuf::unbuffered",STRMBUFTRACE);
00420 
00421     if (i_) 
00422         m_flags |= UNBUFFERED; // set
00423     else
00424         m_flags &= ~ UNBUFFERED; // unset
00425 }

int ASSA::Streambuf::underflow (   )  [inline, protected, virtual]
 

This function is called to supply characters for input (from some source) when the get area is empty, although it may be called at other times.

If the get area is not empty, it should just return the first character (without advancing the get pointer). If the get area is empty, it should establish a new get area, aquire new input, and return the first character, if any. If no input characters are available, it should leave an empty get area and return EOF. The default behavior of the base class version is undefined, so each derived class must define its own underflow.

Reimplemented in ASSA::Socketbuf.

Definition at line 598 of file Streambuf.h.

References ASSA::STRMBUFTRACE, and trace_with_mask.

Referenced by sgetc(), snextc(), uflow(), and xsgetn().

00599 {
00600     trace_with_mask("Streambuf::underflow",STRMBUFTRACE);
00601 
00602     return (EOF);
00603 }

int Streambuf::xsgetn (  char *  b_,
int  len_
)  [protected, virtual]
 

Assigns up to len_ characters to successive elements of the array whose first element is designated by b_.

The characters assigned are read from the input sequence as if by repeated calls to sbumpc(). Assigning stops when either len_ characters have been assigned or a call to sbumpc() would return EOF.

Returns:
The number of characters assigned.

Definition at line 128 of file Streambuf.cpp.

References DL, ASSA::io_ptrs::m_read_end, ASSA::io_ptrs::m_read_ptr, ASSA::STRMBUFTRACE, trace_with_mask, and underflow().

Referenced by sgetn().

00129 {
00130     trace_with_mask("Streambuf::xsgetn",STRMBUFTRACE);
00131 
00132     /*
00133       Get area is empty and nothing is on the socket.
00134     */
00135     int count = m_read_end - m_read_ptr; // Bytes in Get area
00136 
00137     if (count == 0 && underflow () == EOF) {
00138         DL((STRMBUFTRACE,"returning %d. count: %d\n", EOF));
00139         return EOF;
00140     }
00141     count = m_read_end - m_read_ptr; // Adjusted bytes in Get area
00142 
00143     DL((STRMBUFTRACE,"Adjusted bytes in Get Area: %d\n",count));
00144 
00145     if (count > len_) {
00146         count = len_;
00147     }
00148 
00149     if (count <= 0) {
00150         count = 0;  // Peer closed connection
00151     }
00152     else if (count > 20) {
00153         memcpy (data_, m_read_ptr, count);
00154         m_read_ptr += count;
00155     }
00156     else {
00157         char* s = data_;
00158         char* p = m_read_ptr;
00159         int i = count;
00160         while (i-- > 0) {
00161             *s++ = *p++;
00162         }
00163         m_read_ptr = p;
00164     }
00165     DL((STRMBUFTRACE,"Transferred %d bytes to user-space buffer\n", count));
00166 
00167     return (count);
00168 }

int Streambuf::xsputn (  const char *  b_,
int  len_
)  [protected, virtual]
 

Writes up to len_ characters to the output sequence as if by repeated calls to sputc (c).

The characters written are obtained from successive elements of the array whose first element is designated by b_. Writing stops when either len_ characters have been written or a call to sputc(c) would return EOF.

Returns:
The number of characters written.

Definition at line 184 of file Streambuf.cpp.

References ASSA::io_ptrs::m_write_end, ASSA::io_ptrs::m_write_ptr, ASSA::STRMBUFTRACE, and trace_with_mask.

Referenced by sputn().

00185 {
00186     trace_with_mask("Streambuf::xsputn",STRMBUFTRACE);
00187 
00188     const char* s = data_;
00189     int more = len_;
00190     if (more <= 0) {
00191         return 0;
00192     }
00193 
00194     for (;;) {
00195         int count = m_write_end - m_write_ptr; // Space available
00196 
00197         if (count > 0) {
00198 
00199             if (count > more) // Enough buffer space
00200                 count = more;
00201 
00202             if (count > 20) {
00203                 memcpy (m_write_ptr, s, count);
00204                 s += count;
00205                 m_write_ptr += count;
00206             }
00207             else if (count <= 0) {
00208                 count = 0;
00209             }
00210             else {
00211                 char* p = m_write_ptr;
00212                 int i;
00213 
00214                 for (i=count; --i >= 0;) {
00215                     *p++ = *s++;
00216                 }
00217                 m_write_ptr = p;
00218             }
00219             more -= count;
00220         } // if (count>0)
00221         
00222         if (more == 0 || overflow ((unsigned char) *s++) == EOF) {
00223             break;
00224         }
00225         more--;
00226 
00227     } // for (;;)
00228 
00229     return (len_ - more);
00230 }

Member Data Documentation

const int ASSA::Streambuf::MAXTCPFRAMESZ = 65536 [static]
 

Size of the internal input/output buffer.

You can use this constant to do application code read/writes to the socket.

Definition at line 106 of file Streambuf.h.

Referenced by ASSA::Socketbuf::doallocate(), ASSA::Socketbuf::flush_output(), and ASSA::Socketbuf::underflow().

The documentation for this class was generated from the following files:
Generated on Sun Aug 13 15:08:22 2006 for libassa by  doxygen 1.4.6