Log like stringstream (stdlib)

The write method prefixes the line with the time/date and may or may not write to fp_stream (it may write to the console).

I tried this:

      Log& operator <<(char *p) { write(p); return *this; }
      Log& operator <<(string s)  { write(s); return *this; }
      Log& operator <<(int i)  { stringstream ss; ss << i; write(ss.str()); return *this; }
      Log& operator <<(float f)  { stringstream ss; ss << f; write(ss.str()); return *this; }

but I get something like this:

Oct-27  2:41pm   "This message will self destrict in "
Oct-27  2:41pm   2
Oct-27  2:41pm   Seconds.

Help me EE... you're my only hope!

I was assuming that you were stiing the stream accordingly in your constructor code anyway, just add a 'std::string get_time(); method that writes the time in he respecive overloads of 'operator<<()'.

You could define a manipulator for the class that marks the end of a line and require the user to use it.  The Log object then would have to buffer the string until it saw this manipulator and then call the write function.  The calling code then might look like this, for example:

mylog << "This message will self destruct in " << countdown << "seconds" << logEnd;

This imposes an extra burden on the Log class user, but without it, the Log object can't tell where to end a line.

For information on how to define a manipulator, see:

http://www.awprofessional.com/articles/article.asp?p=171014&seqNum=2&rl=1

An alternative approach is to use a global object of a class that is ostream-insertable to create the timestamp and simply use ostreams for logging.

e.g.

class Timestamp {
    static string toString();  // Creates something like "Oct-27  2:41pm: "
} stamp;

ostream& operator<<(ostream operator& os,const Timestamp& ts) {
    return os << ts.toString();
}

cout << stamp << "This message will self destruct in " << countdown << "seconds\n";

This puts the onus onto the beginning of the insertion rather than then end and it means you don't have to re-invent ostream.

With this approach you can do an evil macro like...

#define LOG_WITH_PREFIX(verbosity,prefix) \
    if (verbosity > level) clog << stamp <<
#define EP LOG_WITH_PREFIX(1,"Error: ")
#define WP LOG_WITH_PREFIX(2,"Warning: ")
#define MP LOG_WITH_PREFIX(3,"Info: ")
#define DP LOG_WITH_PREFIX(4,"Debug: ")

However, you need to warn users to avoid doing things like:

   DP << "Important counter is now " << some_counter++ << '\n';

It isn't obvious that some_counter is only incremented when the verbosity is at the right level. So this isn't really suitable for a library for use by others.

I tried the custom manipulator thing, as I don't want to inserting the timestamp on the stream as I want to be able to turn off the timestamp within the log class -e.g. when writing to the console.  I'd like to avoid macros if I can help it.

I tried this:

public:
      Log& operator <<(char *p)  { m_buffer << p; return *this; }
      Log& operator <<(string s) { m_buffer << s; return *this; }
      Log& operator <<(int i)    { m_buffer<< i; return *this; }
      Log& operator <<(float f)  { m_buffer<< f; return *this; }

private:
        ostringstream m_buffer;


But I couldn't figure out how to define the custom manipulator and get it to write the cache.  I hacked it to work like this:

public:
   Log& operator <<(char c)   { if(c==0) { write(m_buffer.str()); m_buffer.str(""); } else m_buffer << c; return *this; }

main() {
   log << "This message will self destruct in " << countdown << " seconds" << '\0';

which is cheezy.  Is there a neater way to do this by defining a custom entity.  I tried but couldn't get anything to compile.  

I'm really close and it's working, but I just need to figure out how to make it nice and tidy.

Thanks!

As the first step, you can define a (public) Log member function that terminates a line, such as:

void Log::terminateLine()
{
    write(m_buffer.str());
    m_buffer.str("");
}

This is just the same code you had in your char inserter.  I just repackaged it.

Then you can define the manipulator to call the function.

Log& logEnd(Log& stream)
{
    stream.terminateLine();
    return stream;
}

I think this should work, but I haven't tested it.

It mostly worked, but I was getting this compile error:

3>cell.cpp(179) : error C2679: binary '<<' : no operator found which takes a right-hand operand of type 'Log &(__cdecl *)(Log &)' (or there is no acceptable conversion)
3>        log.h(42): could be 'Log &Log::operator <<(char *)'
3>        log.h(43): or 'Log &Log::operator <<(std::string)'
3>        log.h(44): or 'Log &Log::operator <<(int)'
3>        log.h(45): or 'Log &Log::operator <<(float)'
3>        while trying to match the argument list '(Log, Log &(__cdecl *)(Log &))'

So I added this:

public:
    Log& operator <<(Log &(__cdecl *f)(Log &))  { return f(*this);}

I figured the Log class would need an operator that can handle a pointer to that sort of function, and when it sees it, it should run it.

It seems to be working...  did I do right?

Thanks!

P.S. f(*this)  ... how true.

Great, thanks for your help everyone.  This now works just like I want it to.  I've also found I can implement a number of terminators such as "logWarn", "logErr" and "logMsg" which can do different things to the message in the buffer.