how do I write a logger class with cout style inte

Question

I want to create a logger class such that with a functionality like this:

Logger log;
log << "Error: " << value << "seen" << endl;

This should print me a custom formatted message. E.g. "12-09-2009 11:22:33 Error 5 seen"

My simple class currently looks like this:

class Logger {
    private:
        ostringstream oss;
    public:
        template <typename T>
        Logger& operator<<(T a);
}

template <typename T>
Logger& Logger::operator<<(T a) {
    oss << a;
    return *this;
}

void functionTest(void) {
    Logger log;
    log << "Error: " << 5 << " seen";
}

This will cause oss to correctly have the buffer "Error: 5 seen". But I dont know what other function I need to write/modify so that something prints on the screen. Does anyone know how to get this to work or is there another way to design this class to have my functionality work?

Answer 1

Behind every std::ostream is a streambuf. It cab be retrieved and set via std::stream::rdbuf(). In particular, it can be wrapped - you can provide a streambuf object that post-processes the streamed text. (post-processing means you can't distinguish std::cout << 123; from std::cout << "123"; )

In your particular case, the postprocessing is fairly simple. At the start of every line you want to insert some bytes. This merely means that you should keep track of whether you've already output the prefix for the current line. If not, do so and set the flag. And whenever you see a newline, reset it. Your streambuf wrapper has just a single bool worth of state.

Answer 2

Check out the simple logger proposed in Compile time optimization - removing debug prints from release binaries. Should be sufficient for your needs. Br, Gracjan

Answer 3

This (from this post) does what you want, but it forces you to end each line with std::endl:

class Logger {
    private:
        ostringstream oss;
    public:
        template <typename T>
        Logger& operator<<(T a);

    Logger& operator<<( std::ostream&(*f)(std::ostream&) )
    {
        if( f == std::endl )
        {
            std::cout << "12-09-2009 11:22:33" << oss.str() << std::endl;   
            oss.str("");
        }
        return *this;
    }
};

template <typename T>
Logger& Logger::operator<<(T a) {
    oss << a;
    return *this;
}

void functionTest(void) {
    Logger log;
    log << "Error: " << 5 << " seen" << std::endl;
}

int main()
{
    functionTest();
}

EDIT: Well according to your comment it doesn't seem to be what you want. Then I recommend you do as MSalters say.

Answer 4

The question is to choose when and how informations are to be sync'ed - by line ? So no matter it is buffered or not, there is no choice but to control EOL and the informations on the line - flushing it or direct outputs.

Even if the destructor is to be used as EOL/Flush,

{ log << [anything]; } as inline-local stack brackets syntax to invoke log's destructor exiting the brackets, or as std::endl, either must be used.

Unless implementing meta-object with some append operator such as '<<' or "+', you are ending all the way obligated to use an explicit way to end the line and or flush.

Answer 5

As far as i can see your logger is no different than ostringstream. It just takes what is given and outputs it to the string stream. If you want to use it like this, you can write a destructor for Logger which outputs the string to cout.

Logger::~Logger()
{
    std::cout<<getcurrentDateTimeAsString()<<" "<<oss.str()<<std::endl;
}

But of course, this will make no sense if a Logger* is created and used throughout the program.