root/logger/logline.hh

/*  This file is part of Alue, the multiprotocol Internet discussion daemon

    Copyright © 2009, 2010 Antti-Juhani Kaijanaho

    Alue is free software: you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    Alue is distributed in the hope that it will be useful, but
    WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Alue.  If not, see <http://www.gnu.org/licenses/>.

 */

#ifndef GUARD_LOGGER_LOGLINE_HH
#define GUARD_LOGGER_LOGLINE_HH

#include "logger.hh"

#include <cassert>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/noncopyable.hpp>

namespace logger 
{
        class logline : private boost::noncopyable
        {
                bool valid;

                void prefix();
                void suffix();
        public:
                logline(bool doOpen = true)
                        : valid(false)
                        { if (doOpen) open(); }
                ~logline() {
                        try
                        {
                                if (valid) close();
                        }
                        catch (std::exception)
                        {}
                }

                void open();
                void close();

                void nl() { suffix(); prefix(); }

                template <typename T>
                logline &operator<<(T t) {
                        assert(valid);
                        *logger.os << t;
                        logger.dirty = true;
                        return *this;
                }
        };

        inline void logline::prefix()
        {
                using namespace boost::posix_time;
         
                assert(valid);
                ptime lt = second_clock::local_time();
                std::string s = to_iso_extended_string(lt);
                *logger.os << s << ' ';
                logger.dirty = true;
        }

        inline void logline::suffix()
        {
                assert(valid);
                logger.os->put('\n');
                logger.dirty = true;
        }

        inline void logline::open()
        {
                if (valid) return;
                logger.m.lock();
                valid = true;
                prefix();
        }

        inline void logline::close()
        {
                if (!valid) return;
                suffix();
                logger.m.unlock();
                valid = false;
        }
};
#endif /* GUARD_LOGGER_LOGLINE_HH */