Create your custom streambuf by providing and ACE_*_Stream object to this template. I have tested it with ACE_SOCK_Stream and it should work fine for others as well. More...

#include <IOStream.h>

Inheritance diagram for ACE_Streambuf:

[legend]

Collaboration diagram for ACE_Streambuf:

[legend]

Public Member Functions
virtual	~ACE_Streambuf (void)

ACE_Time_Value *	recv_timeout (ACE_Time_Value *tv=0)
	Get the current Time_Value pointer and provide a new one. More...

char *	reset_put_buffer (char *newBuffer=0, u_int _streambuf_size=0, u_int _pptr=0)

u_int	put_avail (void)

char *	reset_get_buffer (char *newBuffer=0, u_int _streambuf_size=0, u_int _gptr=0, u_int _egptr=0)

u_int	get_waiting (void)

u_int	get_avail (void)

u_int	streambuf_size (void)
	Query the streambuf for the size of its buffers. More...

u_char	timeout (void)

Protected Member Functions
	ACE_Streambuf (u_int streambuf_size, int io_mode)

virtual int	sync (void)

virtual int	underflow (void)

virtual int	overflow (int c=EOF)

void	reset_base (void)

int	syncin (void)

int	syncout (void)

int	flushbuf (void)

int	fillbuf (void)

virtual int	get_one_byte (void)

virtual ssize_t	send (char *buf, ssize_t len)=0

virtual ssize_t	recv (char buf, ssize_t len, ACE_Time_Value tv=0)=0

virtual ssize_t	recv (char buf, ssize_t len, int flags, ACE_Time_Value tv=0)=0

virtual ssize_t	recv_n (char buf, ssize_t len, int flags=0, ACE_Time_Value tv=0)=0

virtual ACE_HANDLE	get_handle (void)

Protected Attributes
char *	eback_saved_

char *	gptr_saved_

char *	egptr_saved_

char *	pbase_saved_

char *	pptr_saved_

char *	epptr_saved_

u_char	cur_mode_

const u_char	get_mode_

const u_char	put_mode_

int	mode_

const u_int	streambuf_size_

u_char	timeout_
	Did we take an error because of an IO operation timeout? More...

ACE_Time_Value	recv_timeout_value_

ACE_Time_Value *	recv_timeout_

Detailed Description

Create your custom streambuf by providing and ACE_*_Stream object to this template. I have tested it with ACE_SOCK_Stream and it should work fine for others as well.

For any iostream object, the real work is done by the underlying streambuf class. That is what we create here. A streambuf has an internal buffer area into which data is read and written as the iostream requests and provides data. At some point during the read process, the iostream will realize that the streambuf has no more data. The underflow function of the streambuf is then called. Likewise, during the write process, the iostream will eventually notice that the streabuf's buffer has become full and will invoke the overflow function. The empty/full state of the read/write "buffers" are controled by two sets pointers. One set is dedicated to read, the other to write. These pointers, in turn, reference a common buffer that is to be shared by both read and write operations. It is this common buffer to which data is written and from which it is read. The common buffer is used by functions of the streambuf as well as the iostream. Because of this and the fact that it is "shared" by both read and write operators, there is a danger of data corruption if read and write operations are allowed to take place "at the same time". To prevent data corruption, we manipulate the read and write pointer sets so that the streambuf is in either a read-mode or write-mode at all times and can never be in both modes at the same time. In the constructor: set the read and write sets to NULL This causes the underflow or overflow operators to be invoked at the first IO activity of the iostream. In the underflow function we arrange for the common buffer to reference our read buffer and for the write pointer set to be disabled. If a write operation is performed by the iostream this will cause the overflow function to be invoked. In the overflow function we arrange for the common buffer to reference our write buffer and for the read pointer set to be disabled. This causes the underflow function to be invoked when the iostream "changes our mode". The overflow function will also invoke the send_n function to flush the buffered data to our peer. Similarly, the sync and syncout functions will cause send_n to be invoked to send the data. Since socket's and the like do not support seeking, there can be no method for "syncing" the input. However, since we maintain separate read/write buffers, no data is lost by "syncing" the input. It simply remains buffered.

Constructor & Destructor Documentation

ACE_Streambuf::~ACE_Streambuf ( void )

virtual

If the default allocation strategy were used the common buffer would be deleted when the object destructs. Since we are providing separate read/write buffers, it is up to us to manage their memory.

ACE_Streambuf::ACE_Streambuf	(	u_int	streambuf_size,
		int	io_mode
	)

protected

Member Function Documentation

int ACE_Streambuf::fillbuf ( void )

protected

fillbuf is called in a couple of places. This is the worker of underflow. It will attempt to fill the read buffer from the peer.

int ACE_Streambuf::flushbuf ( void )

protected

flushbuf() is the worker of syncout. It is a separate function because it gets used sometimes in different context.

u_int ACE_Streambuf::get_avail ( void )

Return the number of bytes in the get area (includes some already gotten); eback + get_avail = egptr

ACE_HANDLE ACE_Streambuf::get_handle ( void )

protectedvirtual

Reimplemented in ACE_Streambuf_T< STREAM >.

int ACE_Streambuf::get_one_byte ( void )

protectedvirtual

Used by fillbuf and others to get exactly one byte from the peer. recv_n is used to be sure we block until something is available. It is virtual because we really need to override it for datagram-derived objects.

u_int ACE_Streambuf::get_waiting ( void )

Return the number of bytes not yet gotten. eback + get_waiting = gptr

int ACE_Streambuf::overflow ( int c = EOF )

protectedvirtual

The overflow function receives the character which caused the overflow.

u_int ACE_Streambuf::put_avail ( void )

Return the number of bytes to be 'put' onto the stream media. pbase + put_avail = pptr

virtual ssize_t ACE_Streambuf::recv	(	char *	buf,
		ssize_t	len,
		ACE_Time_Value *	tv = `0`
	)

protectedpure virtual

Implemented in ACE_Streambuf_T< STREAM >.

virtual ssize_t ACE_Streambuf::recv	(	char *	buf,
		ssize_t	len,
		int	flags,
		ACE_Time_Value *	tv = `0`
	)

protectedpure virtual

Implemented in ACE_Streambuf_T< STREAM >.

virtual ssize_t ACE_Streambuf::recv_n	(	char *	buf,
		ssize_t	len,
		int	flags = `0`,
		ACE_Time_Value *	tv = `0`
	)

protectedpure virtual

Implemented in ACE_Streambuf_T< STREAM >.

ACE_Time_Value * ACE_Streambuf::recv_timeout ( ACE_Time_Value * tv = 0 )

Get the current Time_Value pointer and provide a new one.

void ACE_Streambuf::reset_base ( void )

protected

Resets the <base> pointer and streambuf mode. This is used internally when get/put buffers are allocatd.

char * ACE_Streambuf::reset_get_buffer	(	char *	newBuffer = `0`,
		u_int	_streambuf_size = `0`,
		u_int	_gptr = `0`,
		u_int	_egptr = `0`
	)

Use this to allocate a new/different buffer for get operations. If you do not provide a buffer pointer, one will be allocated. That is the preferred method. If you do provide a buffer, the size must match that being used by the put buffer. If successful, you will receive a pointer to the current get buffer. It is your responsibility to delete this memory when you are done with it.

char * ACE_Streambuf::reset_put_buffer	(	char *	newBuffer = `0`,
		u_int	_streambuf_size = `0`,
		u_int	_pptr = `0`
	)

Use this to allocate a new/different buffer for put operations. If you do not provide a buffer pointer, one will be allocated. That is the preferred method. If you do provide a buffer, the size must match that being used by the get buffer. If successful, you will receive a pointer to the current put buffer. It is your responsibility to delete this memory when you are done with it.

virtual ssize_t ACE_Streambuf::send	(	char *	buf,
		ssize_t	len
	)

protectedpure virtual

Stream connections and "unconnected connections" (ie – datagrams) need to work just a little differently. We derive custom Streambuf objects for them and provide these functions at that time.

Implemented in ACE_Streambuf_T< STREAM >.

u_int ACE_Streambuf::streambuf_size ( void )

Query the streambuf for the size of its buffers.

int ACE_Streambuf::sync ( void )

protectedvirtual

Sync both input and output. See syncin/syncout below for descriptions.

int ACE_Streambuf::syncin ( void )

protected

syncin is called when the input needs to be synced with the source file. In a filebuf, this results in the <seek> system call being used. We can't do that on socket-like connections, so this does basically nothing. That's safe because we have a separate read buffer to maintain the already-read data. In a filebuf, the single common buffer is used forcing the <seek> call.

int ACE_Streambuf::syncout ( void )

protected

syncout() is called when the output needs to be flushed. This is easily done by calling the peer's send_n function.

u_char ACE_Streambuf::timeout ( void )

Did we take an error because of an IO operation timeout?

Note: Invoking this resets the flag.

int ACE_Streambuf::underflow ( void )

protectedvirtual

Member Data Documentation

u_char ACE_Streambuf::cur_mode_

protected

char* ACE_Streambuf::eback_saved_

protected

char* ACE_Streambuf::egptr_saved_

protected

char* ACE_Streambuf::epptr_saved_

protected

const u_char ACE_Streambuf::get_mode_

protected

char* ACE_Streambuf::gptr_saved_

protected

int ACE_Streambuf::mode_

protected

mode tells us if we're working for an istream, ostream, or iostream.

char* ACE_Streambuf::pbase_saved_

protected

char* ACE_Streambuf::pptr_saved_

protected

const u_char ACE_Streambuf::put_mode_

protected

ACE_Time_Value* ACE_Streambuf::recv_timeout_

protected

ACE_Time_Value ACE_Streambuf::recv_timeout_value_

protected

We want to allow the user to provide Time_Value pointers to prevent infinite blocking while waiting to receive data.

const u_int ACE_Streambuf::streambuf_size_

protected

This defines the size of the input and output buffers. It can be set by the object constructor.

u_char ACE_Streambuf::timeout_

protected

Did we take an error because of an IO operation timeout?

The documentation for this class was generated from the following files:

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation