logger.cpp

Go to the documentation of this file.

/*
  CLAW - a C++ Library Absolutely Wonderful
 
  CLAW is a free library without any particular aim but being useful to
  anyone.
 
  Copyright (C) 2005-2011 Julien Jorge
 
  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.
 
  This library 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
  Lesser General Public License for more details.
 
  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
  contact: julien.jorge@stuff-o-matic.com
*/
#include <claw/logger/logger.hpp>
 
#include <algorithm>
 
namespace claw
{
  log_system logger;
}

claw::log_system::log_system()
  : m_log_level(-1)
  , m_message_level(0)
{}

claw::log_system::~log_system()
{
  clear();
}

void claw::log_system::clear()
{
  std::lock_guard<std::mutex> lock(m_mutex);
 
  stream_list_type::iterator it;
 
  for(it = m_stream.begin(); it != m_stream.end(); ++it)
    delete *it;
 
  m_stream.clear();
}

void claw::log_system::merge(stream_type* s)
{
  std::lock_guard<std::mutex> lock(m_mutex);
 
  m_stream.push_front(s);
}

void claw::log_system::remove(const stream_type* s)
{
  std::lock_guard<std::mutex> lock(m_mutex);
 
  stream_list_type::iterator it
      = std::find(m_stream.begin(), m_stream.end(), s);
 
  if(it != m_stream.end())
    m_stream.erase(it);
}

void claw::log_system::set(stream_type* s)
{
  clear();
 
  std::lock_guard<std::mutex> lock(m_mutex);
 
  m_stream.push_front(s);
}

void claw::log_system::set_level(int lvl)
{
  std::lock_guard<std::mutex> lock(m_mutex);
 
  m_log_level = lvl;
}

void claw::log_system::set_level(const log_level& lvl)
{
  std::lock_guard<std::mutex> lock(m_mutex);
 
  m_log_level = lvl.get();
}

void claw::log_system::flush()
{
  std::lock_guard<std::mutex> lock(m_mutex);
 
  if(m_message_level <= m_log_level)
    {
      stream_list_type::iterator it;
 
      for(it = m_stream.begin(); it != m_stream.end(); ++it)
        (*it)->flush();
    }
}

claw::log_system& claw::log_system::operator<<(const log_level& that)
{
  std::lock_guard<std::mutex> lock(m_mutex);
 
  m_message_level = that.get();
 
  if(m_message_level <= m_log_level)
    print(that.get_string());
 
  return *this;
}

claw::log_system& claw::log_system::operator<<(log_system& (*pf)(log_system&))
{
  return pf(*this);
}

void claw::log_system::print(const std::string& s)
{
  stream_list_type::iterator it;
 
  for(it = m_stream.begin(); it != m_stream.end(); ++it)
    (*it)->write(s);
}

claw::log_system& claw::lendl(claw::log_system& log)
{
  return log << std::endl;
}
 
claw::log_system& std::endl(claw::log_system& log)
{
  (log << "\n").flush();
  return log;
}