/home/vlg/develop/libASSA/libassa/assa/Streambuf.h

Go to the documentation of this file.

// -*- c++ -*-
//------------------------------------------------------------------------------
//                         Streambuf.h
//------------------------------------------------------------------------------
//  Copyright (c) 1999 by Vladislav Grinchenko
//
//  This library is free software; you can redistribute it and/or
//  modify it under the terms of the GNU Library General Public
//  License as published by the Free Software Foundation; either
//  version 2 of the License, or (at your option) any later version.
//------------------------------------------------------------------------------
//  Created: 12/02/1999
//------------------------------------------------------------------------------
#ifndef STREAM_BUF_H
#define STREAM_BUF_H

#include <stdio.h>      // EOF
#include "assa/Assure.h"        // trace() & Assert family

namespace ASSA {

class io_ptrs
{
public:
    char* m_read_base;
    char* m_read_ptr;
    char* m_read_end;

    char* m_write_base;
    char* m_write_ptr;
    char* m_write_end;

    char* m_buf_base;
    char* m_buf_end;

    enum { USER_BUF = 1, UNBUFFERED = 2, EOF_SEEN = 4, ERR_SEEN = 8 };

    int   m_flags;
    char  m_shortbuf[1];

    io_ptrs () : m_read_base (0), m_read_ptr (0), m_read_end (0),
             m_write_base (0), m_write_ptr (0), m_write_end (0),
             m_buf_base (0), m_buf_end (0), m_flags (0)
        { 
            m_shortbuf [0] = 0; 
        }

    void dump () const;
};

class Streambuf : public io_ptrs
{
public:

//  Old comment:
//
//  "Maximum frame size that can be transmitted unfragmented by TCP
//   with MTU 1500 (1500-20-60). TCP frame can have options
//   (up to 60 bytes) which, if ignored, might cause fragmentation.
//   Also, the length of the IP packet must be evenly divisible by 8."
//
//  On 100Mb networks, the reasonable buffer size seems to be 64K.

    static const int MAXTCPFRAMESZ = 65536; // 64K

    virtual ~Streambuf ();

    Streambuf* pubsetbuf (char* s_, int n_);

    int        pubsync ();

    int        in_avail ();

    int        snextc ();

    int        sbumpc ();

    int        sgetc ();

    int        sgetn (char* b_, int len_);

    int        sputc (char c_);

    int        sputn (char* b_, int len_);


    void       unbuffered (int i_);
    
    int        unbuffered ();

protected:
    Streambuf ();

    Streambuf (const Streambuf&);
    Streambuf& operator= (const Streambuf&);

    char*      base () const;

    char*      gptr ()  const;

    char*      egptr () const;

    void       setg (char* gbeg_, char* gnext_, char* gend_);

    char*      pbase () const;

    char*      pptr ()  const;

    char*      epptr () const;

    void       setp (char* pbeg_, char* pend_);

    void       pbump (int n_);

    void       setb (char* b_, char* eb_, int del_);

    void       init ();

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

    virtual int        sync ();
    
    virtual int        showmanyc ();

    virtual int        xsgetn (char* b_, int len_);

    virtual int        underflow ();

    virtual int        uflow ();

    virtual int        xsputn (const char* b_, int len_);

    virtual int        overflow (int c = EOF);

    virtual int        doallocate ();
};

inline Streambuf* 
Streambuf::
pubsetbuf (char* s_, int n_) 
{ 
    trace_with_mask("Streambuf::pubsetbuf",STRMBUFTRACE);
    
    return setbuf (s_, n_); 
}

inline int        
Streambuf::
pubsync () 
{ 
    trace_with_mask("Streambuf::pubsync",STRMBUFTRACE);

    return sync (); 
}

inline int
Streambuf::
in_avail () 
{ 
    trace_with_mask("Streambuf::in_avail",STRMBUFTRACE);

    return m_read_end - m_read_ptr; 
}

inline int
Streambuf::
unbuffered () 
{ 
    trace_with_mask("Streambuf::unbuffered",STRMBUFTRACE);
    
    return m_flags & UNBUFFERED ? 1 : 0; 
}

inline void
Streambuf::
unbuffered (int i_)
{
    trace_with_mask("Streambuf::unbuffered",STRMBUFTRACE);

    if (i_) 
        m_flags |= UNBUFFERED; // set
    else
        m_flags &= ~ UNBUFFERED; // unset
}

inline
Streambuf::
Streambuf () 
{ 
    trace_with_mask("Streambuf::Streambuf",STRMBUFTRACE);

    init (); 
}

inline void
Streambuf::
init ()
{
    trace_with_mask("Streambuf::init", STRMBUFTRACE);

    m_read_base = m_read_ptr = m_read_end = 0;
    m_write_base = m_write_ptr = m_write_end = 0;
    m_buf_base = m_buf_end = 0;
    m_flags = 0;

    m_shortbuf[0] = 0;
}

inline 
Streambuf::
~Streambuf ()
{
    trace_with_mask("Streambuf::~Streambuf",STRMBUFTRACE);

    if (!(m_flags & USER_BUF)) {
        delete [] m_buf_base;
        m_buf_base = m_buf_end = 0;
    }
}

inline char*
Streambuf::
base () const 
{ 
    trace_with_mask("Streambuf::base",STRMBUFTRACE);

    return m_read_base; 
}

inline char* 
Streambuf::
gptr ()  const 
{ 
    trace_with_mask("Streambuf::gptr",STRMBUFTRACE);

    return m_read_ptr; 
}

inline char*
Streambuf::
egptr () const 
{ 
    trace_with_mask("Streambuf::egptr",STRMBUFTRACE);

    return m_read_end; 
}

inline char*      
Streambuf::
pbase () const 
{ 
    trace_with_mask("Streambuf::pbase",STRMBUFTRACE);
    return m_write_base; 
}

inline char*
Streambuf::
pptr ()  const 
{ 
    trace_with_mask("Streambuf::pptr",STRMBUFTRACE);
    return m_write_ptr; 
}

inline char*
Streambuf::
epptr () const 
{ 
    trace_with_mask("Streambuf::epptr",STRMBUFTRACE);
    return m_write_end; 
}

inline void       
Streambuf::
pbump (int n_) 
{ 
    trace_with_mask("Streambuf::pbump",STRMBUFTRACE);
    m_write_ptr += n_; 
}

inline int        
Streambuf::
sync () 
{ 
    trace_with_mask("Streambuf::sync",STRMBUFTRACE);
    return 0; 
}

inline int
Streambuf::
showmanyc () 
{ 
    trace_with_mask("Streambuf::showmanyc",STRMBUFTRACE);
    return -1; 
}

inline int 
Streambuf::
sbumpc ()
{
    trace_with_mask("Streambuf::sbumpc",STRMBUFTRACE);

    return (m_read_ptr >= m_read_end ? uflow ()
            : *(unsigned char *) m_read_ptr++);
}

inline int
Streambuf::
sgetc ()
{
    trace_with_mask("Streambuf::sgetc",STRMBUFTRACE);

    return (m_read_ptr >= m_read_end && underflow () == EOF 
            ? EOF : *(unsigned char*) m_read_ptr);
}

inline int 
Streambuf::
sgetn (char* data_, int len_)
{
    trace_with_mask("Streambuf::sgetn",STRMBUFTRACE);

    return xsgetn (data_, len_);
}

inline int 
Streambuf::
sputc (char c_)
{
    trace_with_mask("Streambuf::sputc",STRMBUFTRACE);

    return (m_write_ptr >= m_write_end
            ? overflow (c_)
            : (unsigned char) (*m_write_ptr++ = c_));
}

inline int
Streambuf::
sputn (char* b_, int len_)
{
    trace_with_mask("Streambuf::sputn",STRMBUFTRACE);

    return xsputn (b_, len_);
}

inline void
Streambuf::
setp (char* pbeg_, char* pend_)
{
    trace_with_mask("Streambuf::setp",STRMBUFTRACE);

    m_write_base = m_write_ptr = pbeg_;
    m_write_end  = pend_;
}

inline int
Streambuf::
underflow ()
{
    trace_with_mask("Streambuf::underflow",STRMBUFTRACE);

    return (EOF);
}

inline int
Streambuf::
overflow (int /* c_ */)
{
    trace_with_mask("Streambuf::overflow",STRMBUFTRACE);

    return (EOF);
}

} // end namespace ASSA

#endif /* STREAM_BUF_H */  

---