Writing classes which are "streamable"
 

Hi!

I have written a logging class for my project and I want to support the
stream syntax, that is I would like to write like this in my code:

Log log("MYPREFIX");

log << "This is a message, which is being sent to syslog, value ="
<< 5;

I have created a friend function:

Log& operator<< (Log& log, std::string& str);

So now I can write:

log << "Only strings are supported";

However this doesn't work (of course):

log << "This will create two log messages" << " why isn't this
concatenated?";

I wonder if someone knows about some documentation which could aid me
in making my log class stream-compatible.


Regards,

Mikael

Re: Writing classes which are "streamable"
 

Mikael wrote:

> Hi!
>
> I have written a logging class for my project and I want to support the
> stream syntax, that is I would like to write like this in my code:
>
> Log log("MYPREFIX");
>
> log << "This is a message, which is being sent to syslog, value ="
> << 5;
>
> I have created a friend function:
>
> Log& operator<< (Log& log, std::string& str);

Are you sure that your function needs to modify str? If not, why isn't it a
const reference?

> So now I can write:
>
> log << "Only strings are supported";
>
> However this doesn't work (of course):
>
> log << "This will create two log messages" << " why isn't this
> concatenated?";

What do you mean by "doesn't work", and why "of course"?

> I wonder if someone knows about some documentation which could aid me
> in making my log class stream-compatible.

You could derive it from std::ostream, which will automatically give you all
the stream operators defined for the standard output streams.

Re: Writing classes which are "streamable"
 

Mikael wrote:
> Hi!
>
> I have written a logging class for my project and I want to support the
> stream syntax, that is I would like to write like this in my code:
>
> Log log("MYPREFIX");
>
> log << "This is a message, which is being sent to syslog, value ="
> << 5;
>
> I have created a friend function:
>
> Log& operator<< (Log& log, std::string& str);
>
> So now I can write:
>
> log << "Only strings are supported";
>
> However this doesn't work (of course):

Post more code, what does

Log& operator<< (Log& log, std::string& str);

return ???
>
> log << "This will create two log messages" << " why isn't this
> concatenated?";
>
> I wonder if someone knows about some documentation which could aid me
> in making my log class stream-compatible.
>
>
> Regards,
>
> Mikael

Re: Writing classes which are "streamable"
 

The operator<< is defined as follows (I have added the const as you
pointed out):

Log& operator<< (Log& log, std::string const& str)
{
log.logMessage(str.c_str());
return log;
}

Sorry if my question was too unspecific, I will try to be more verbose
the next time.

The above function generates two log messages when I write the
following code:

log << "message 1" << "message 2";

because operator<<() calls log.logMessage() directly.

If I derive from std::ostream, how do I actually get the formatted
string into my log? If you could please clarify how it should work
then?

I am sorry if these are stupid questions, I am pretty new to streams (I
have only used them sofar).


With kind regards,

Mikael

Re: Writing classes which are "streamable"
 

Mikael wrote:
> The operator<< is defined as follows (I have added the const as you
> pointed out):
>
> Log& operator<< (Log& log, std::string const& str)
> {
> log.logMessage(str.c_str());
> return log;
> }
>
> Sorry if my question was too unspecific, I will try to be more verbose
> the next time.
>
> The above function generates two log messages when I write the
> following code:
>
> log << "message 1" << "message 2";
>
> because operator<<() calls log.logMessage() directly.
>
> If I derive from std::ostream, how do I actually get the formatted
> string into my log? If you could please clarify how it should work
> then?
>
> I am sorry if these are stupid questions, I am pretty new to streams (I
> have only used them sofar).
>
>
> With kind regards,
>
> Mikael

Sorry, I'm not clear what you're question is anymore, if

log << "message 1" << "message 2";

generates two messages, then it would seem to be working correctly,
what did you hope it would do ?

You need to give an example of the output you are getting, the output
you hoped to get and some detail of what logMessage(...) does if what
you are seeing is not what you expected.

Re: Writing classes which are "streamable"
 

Mikael wrote:
> I wonder if someone knows about some documentation which could aid me
> in making my log class stream-compatible.

Google for articles "James Kanze" or I have written about "streambuf".
--
<mailto:dietmar_kuehl@yahoo.com> <http://www.dietmar-kuehl.de/>
<http://www.eai-systems.com> - Efficient Artificial Intelligence

Re: Writing classes which are "streamable"
 

Mikael wrote:

>
> The operator<< is defined as follows (I have added the const as you
> pointed out):
>
> Log& operator<< (Log& log, std::string const& str)
> {
> log.logMessage(str.c_str());
> return log;
> }
>
> Sorry if my question was too unspecific, I will try to be more verbose
> the next time.
>
> The above function generates two log messages when I write the
> following code:
>
> log << "message 1" << "message 2";

Yes exactly, which is exactly the behaviour you are expected to get.

> because operator<<() calls log.logMessage() directly.

Yes of course. The above statement is (nearly) equivalent to the following
two:

log << "message 1";
log << "message 2";

I can only guess, but I think you belive that the "<<" operator concanates
two char arrays? right? Well it does not. It sends a char array to a
stream, and returns the stream. So what happens when you do
log << "message 1" << "message 2";
is:
Log& tmplog = operator<<(log, "message 1");
operator<<(tmplog, "message 2");
And not:
operator<<(log,"message1message2")
as you suposedly expected.


> If I derive from std::ostream, how do I actually get the formatted
> string into my log? If you could please clarify how it should work
> then?

If you use std::strings instead of char arrays you can use the + operator:
log << std::string("message 1") + "message 2";

Or if you insist on using "<<", you have to change your Log::logMessage()
member function to accumulate everything that it gets until you give it a
special object, like (I have not checked if this compiles, just to get the
idea):

struct new_log_entry {};

Log& operator<< (Log& log, new_log_entry const& d)
{
log.flush();
return log;
}

....
log << "message 1" << "message 2" << new_log_entry;


HTH

Fabio

Re: Writing classes which are "streamable"
 

Mikael <Mikael.Olenfalk@gmail.com> wrote:
> The operator<< is defined as follows (I have added the const as you
> pointed out):
>
> Log& operator<< (Log& log, std::string const& str)
> {
> log.logMessage(str.c_str());
> return log;
> }
>
> Sorry if my question was too unspecific, I will try to be more verbose
> the next time.
>
> The above function generates two log messages when I write the
> following code:
>
> log << "message 1" << "message 2";
>
> because operator<<() calls log.logMessage() directly.

My guess would be to check your log.logMessage() function to see if it
is automatically adding a newline at the end of the message.

--
Marcus Kwok

Re: Writing classes which are "streamable"
 

Okay, I will try your proposal with the special object which flushes
the accumulated string.

I was also wondering if I could subclass or encapsulate a certain class
to get all the different <<-operators for free as well as all
modifiers, so that my log class has all formatting features from the
ostream-class.

I will try this approach:

class Log : std::strstream
{
struct endl {};

// other members

friend Log& operator <<(Log& log, endl const& e);
}

Log& operator <<(Log& log, endl const& e)
{
char *message = str();
log.logMessage (message);
delete message;

return log;
}

// test

Log log;

log << "This is a test i=" << 5 << Log::endl;
^_ std::strstream<<
^_ std::stream<<
^_ prints message


With kind regards,

Mikael

Re: Writing classes which are "streamable"
 

Mikael wrote:
> Hi!
>
> I have written a logging class for my project and I want to support the
> stream syntax, that is I would like to write like this in my code:
>
> Log log("MYPREFIX");
>
> log << "This is a message, which is being sent to syslog, value ="
> << 5;
>
> I have created a friend function:
>
> Log& operator<< (Log& log, std::string& str);
>
> So now I can write:
>
> log << "Only strings are supported";
>
> However this doesn't work (of course):
>
> log << "This will create two log messages" << " why isn't this
> concatenated?";
>
> I wonder if someone knows about some documentation which could aid me
> in making my log class stream-compatible.
>
>
> Regards,
>
> Mikael
>

What you need is a function prototype like this

std::ostream &operator << (std::ostream &str, Log &inp);

then handle via a member function of Log or directly by making it a
friend of Log.

Once you've done this Log objects can be streamed via fstream, std::cout
and stringstream.

Similarly for input streaming use the following:-

std::istream &operator >> (std::ostream &str, Log &inp);

JB