On Nov 10, 2:28 am, rakesh.use...@gmail.com wrote:
For a particular application of mine - I need a simulation of byte
array output stream.
* write data onto a stream
* getback the contiguous content as an array later for network
transport.
That sounds like stringstream to me. Otherwise, you might want
the old strstream.
Of course, if you really want to (e.g. you have other
constraits), it's pretty trivial to implement a streambuf which
writes to a vector<char>.
My code looks as follows.
#include <iostream>
#include <streambuf>
#include <locale>
#include <cstdio>
using namespace std;
class outbuf : public std::streambuf
{
public:
virtual ~outbuf()
{
sync();
}
Is the contiguous array owned by outbuf, or is it provided by
the client? I don't see any constructor, so it must be owned by
outbuf. On the other hand, I don't see any private data members
either, which makes me wonder: even if the buffer is owned by
the client, you have to save a pointer to it, or something.
Anyway, if the buffer is owned by outbuf, the sych isn't
necessary, since the buffer(s) won't exist after the destructor.
And for in memory streambuf work, sych is normally a no-op
anyway; the buffer is always synchronized.
char * getData() const
{
std::cout << "First " << std::hex << (void *)pbase() ;
std::cout << "Current " << std::hex << (void *)pptr() ;
I have doubts that std::hex actually affects the output of a
pointer. (It's implementation defined, but I'd always output
pointers in hex, regardless of the base.) If you do want to set
it, however, be sure to restore the base field to its initial
value. (Of course, I'm supposing that these statements are only
here for debugging purposes.)
As currently written, it is guaranteed that pbase and pptr are
always null.
return pbase();
}
streamsize getSize() const
{
return pbase() - pptr();
}
};
And where is your data, or the virtual functions you need to
override (overflow, at least).
class myostream : public std::basic_ostream<char>
{
public:
myostream() :
basic_ostream<char>(new outbuf)
{
}
~myostream()
{
delete rdbuf();
}
};
It's not really necessary to use dynamic allocation here,
although the alternatives are a bit tricky (since we should
ensure that outbuf is constructed before passing its address to
the ostream constructor.
int main()
{
myostream out;
out << "31 hexadecimal: " << std::hex << 31 << "\n";
st = out.rdbuf();
buf = dynamic_cast<outbuf *>(st);
if (!buf)
{
cerr << "error: dynamic_Cast failed";
return EXIT_FAILURE;
}
//TODO: At this point - I need to get the pointer to the beginning
of the buffer and the size of the same.
buf->getData();
cerr << "Size: " << buf->getSize() << endl;
return 0;
}
I had gone about creating a rudimentary derived class implementation
of streambuf and an output stream.
After writing data to the output stream I need to get the number of
bytes written and the pointer to the beginning of the stream. How do I
go about doing the same ??
You might start by allocating a buffer somewhere, and managing
it.
The above example does not seem to work btw.
Obviously. How can it if you don't override overflow? Maybe
something like the following:
class ArrayStreambuf : public std::streambuf
{
public:
typedef std::vector<char>::const_iterator
iterator ;
iterator begin() const
{
return myBuffer.begin() ;
}
iterator end() const
{
return myBuffer.end() ;
}
protected:
virtual int overflow( int ch )
{
if ( ch != EOF ) {
myBuffer.push_back( ch ) ;
size_t start = myBuffer.size() ;
myBuffer.resize( myBuffer.capacity() ) ;
setp( &myBuffer[ 0 ] + start,
&myBuffer[ 0 ] + myBuffer.size() ) ;
}
return ch == EOF ? 0 : ch ;
}
private:
std::vector< char myBuffer ;
} ;
The above simply uses the normal std::vector growth scheme. You
may want something different. Maybe add a constructor which
initializes the buffer to a minium size and calls setp, or
resize to std::max( capacity(), size() + someMinimumIncrement ).
or whatever your application requires.
Similarly, you may want to access the buffer otherwise than
through its iterators. Returning the address of the first
element and the size, for example, will allow calling the low
level system write function directly.
--
James Kanze (GABI Software) email:ja*********@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
