root/logger/logger.hh

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

    Copyright © 2009 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_LOGGER_HH
#define GUARD_LOGGER_LOGGER_HH

#include <boost/noncopyable.hpp>
#include <boost/thread/locks.hpp>
#include <boost/thread/recursive_mutex.hpp>

#include <fstream>

namespace logger 
{
        class logger_ : private boost::noncopyable 
        {
                boost::recursive_mutex m;
                
                std::ostream *os;
                
                bool dirty;

                bool ours;

                friend class logline;

        public:
                logger_() : dirty(false), ours(false) {}

                void open(std::string logfile);

                void open(std::ostream &os) {
                        m.lock();
                        if (dirty) this->os->flush();
                        if (ours) delete this->os;
                        this->os = &os;
                        dirty = false;
                        ours = false;
                        m.unlock();
                }

                // ensure that this is not called while the current
                // thread has an open logline object
                void flush() {
                        m.lock();
                        try {
                                if (dirty) os->flush();
                                dirty = false;
                        } catch (...) {
                                m.unlock();
                                throw;
                        }
                        m.unlock();
                }
        };

        extern logger_ logger;
        
};
#endif /* GUARD_LOGGER_LOGGER_HH */