defining a custom output facility

[Matt Garman]

I'd like to create a "custom output facility". In other words, I want
an object whose use is similar to std::cout/std::cerr, but offers more
flexibility. Instead of simply writing the parameter to stdout/stderr,
I'd like it to write to stdout, to a file, and/or call a logging
function.

So my output function might look something like this:

OutputFacility& OutputFacility: :put(const std::string& s) {
cout << s; // print to stdout
write_to_logfil e(s); // also calling logging function
return *this;
}

Now I can define the << operator to be an alias for put().

My question is: do I have to define put() for every type of input I
expect to print? I.e., I'd like this to work with all primitive types,
int, char, double, float, etc.

Right now I'm thinking that the OutputFacility class could have a
std::ostringstr eam as a private member; every version of
OutputFacility: :put() would just in turn call the ostringstream put()
method, THEN call the actual output functions (e.g. write_to_logfil e()).

It seems like there should be a simpler method of defining my put
method, i.e. instead of overloading it and defining it multiple times,
if I could just define it once with a "magical" parameter that means
"take anything that can be converted to a string".

Thanks for any advice!
Matt

--
Matt Garman
email at: http://raw-sewage.net/index.php?file=email

[Matt Garman]

On Fri, 16 Jan 2004 13:02:45 +0100, Karl Heinz Buchegger
<kb******@gasca d.at> wrote:

You want to change a string in the behaviour of the transportation
layer, thus your approach should be to write a customized stream
buffer and make the stream use that instead of the one it was born
with.
Okay, I think I'm starting to get it :) Thank you!

Since I want my custom output facility to write to stdout AND a log (or
window or whatever), does that mean that my custom streambuf's
implementation will write to stdout? It seems like I would be
duplicating what the standard library already does. (In other words, is
there a way to say "do what you already do, AND do these other things"?)

Let me re-iterate just to make sure my understanding is correct:

- stream object (e.g. cout) formats data
- stream object passes formatted data to stream buffer
- stream buffer object delivers data to its destination (e.g.
stdout, logfile, window, etc)
there would be some sort of hook in printf, which allows you to get a
grasp at the string printf produces internally before printf sends
this string to the device. In this way you don't need to change any
printf calls but just hook into it, and do whatever you want with the
printf generated string.

That's exactly what sprintf() (and snprintf() on some systems)
does---formats a string and puts it in a buffer. But that opens you up
to all kinds of potential buffer overrun problems. It's a lot of work
to make sure this is done safely. (That's why I'm using c++!)

Thanks again for your help and patience,
Matt

--
Matt Garman
email at: http://raw-sewage.net/index.php?file=email

[Karl Heinz Buchegger]

Matt Garman wrote:

Since I want my custom output facility to write to stdout AND a log (or
window or whatever), does that mean that my custom streambuf's
implementation will write to stdout?
typically yes.
But wait: when you tell the stream object to use a different stream
buffer, you get a hold on the stream buffer actually used by the
stream. So you simply could forward all output to the original stream
buffer AND process it on your own.

Let me re-iterate just to make sure my understanding is correct:

- stream object (e.g. cout) formats data
- stream object passes formatted data to stream buffer
- stream buffer object delivers data to its destination (e.g.
stdout, logfile, window, etc)
yep.

there would be some sort of hook in printf, which allows you to get a
grasp at the string printf produces internally before printf sends
this string to the device. In this way you don't need to change any
printf calls but just hook into it, and do whatever you want with the
printf generated string.

That's exactly what sprintf() (and snprintf() on some systems)
does---formats a string and puts it in a buffer. But that opens you up
to all kinds of potential buffer overrun problems. It's a lot of work
to make sure this is done safely. (That's why I'm using c++!)

OK.
So with that analogy an output operation in a stream does something
like that:

void DoOutput( ..... )
char buffer[whatever];
sprintf( buffer, ..... );
puts( buffer );
}

Throughout your program you always use DoOutput() instead of printf().
If you need to retarget the output, you add the retargeting by
replacing the puts() with something else.
In the above, the puts() would be the equivalent to the stream buffer
object (and of course the whole thing wrapped in a class with some
nicer syntax for using and getting rid of the buffer overflow problem,
etc. But that's not the point right now). For retargeting the output
you replace the stream buffer with something else. And in the same
sense as in the DoOutput() solution the caller of this function doesn't
notice anything of the retargeting, the user of a stream object doesn't
notice anything when the stream buffer is replaced. For him everything
stays the same, even custom operator<< or operator>> work as they ever did.
Only the output is retargeted to somwehere else.

--
Karl Heinz Buchegger
kb******@gascad .at

[Matt Garman]

Okay, thank you for all the verbose feedback! I think I finally
understand the concepts.

So what if I were to take it a step further, and say that my custom
output facility should be able to write to any number of media? In
other words, combine a streambuf with a vector?

I did just that in the code below (tested with g++ under Linux). Is
what I did the "best" way to solve that problem?

Note that I'd actually write a convenience wrapper class for ostream as
well, just to easily facilitate adding and removing streambufs.

Thanks again for all the help!
Matt

#include <iostream>
#include <fstream>
#include <streambuf>
#include <vector>

class streambufvec : public std::streambuf {
public:
typedef std::char_trait s<char> traits_type;
typedef traits_type::in t_type int_type;
typedef std::vector< std::streambuf* > streambufvec_t;

streambufvec()
{ streambufs.push _back(std::cout .rdbuf()); }

streambufvec(st reambufvec_t sbvec)
{ streambufs.inse rt(streambufs.e nd(),
sbvec.begin(), sbvec.end()); }

streambufvec(st d::streambuf* sb)
{ streambufs.push _back(sb); }

virtual ~streambufvec()
{ streambufs.clea r(); }

void push_back(std:: streambuf* sb)
{ streambufs.push _back(sb); }

protected:
inline int_type overflow(int_ty pe c)
{
streambufvec_t: :iterator ii;
for (ii=streambufs. begin(); ii!=streambufs. end(); ++ii) {
if (traits_type::e of() == (*ii)->sputc(c)) {
return traits_type::eo f();
}
}
return c;
}

private:
streambufvec_t streambufs;
};
int main(int argc, char** argv)
{
std::ofstream file1("file1.tx t");
std::ofstream file2("file2.tx t");
std::ofstream file3("file3.tx t");

streambufvec sbvec;
sbvec.push_back (file1.rdbuf()) ;
sbvec.push_back (file2.rdbuf()) ;
sbvec.push_back (file3.rdbuf()) ;

sbvec.push_back (std::cerr.rdbu f());

std::ostream of(&sbvec);

of << "Hello, world!" << std::endl;

return 0;
}

--
Matt Garman
email at: http://raw-sewage.net/index.php?file=email