ThreadSafeLogger.cpp

Go to the documentation of this file.

/*
Copyright 2007, 2008, 2009, 2010, 2011 Instituto de Sistemas e Robotica, Instituto Superior Tecnico

This file is part of MeRMaID.

MeRMaID 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 3 of the License, or
(at your option) any later version.

MeRMaID 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 MeRMaID.  If not, see <http://www.gnu.org/licenses/>.
*/



/**
 * @Filename ThreadSafeLogger.cpp
 * @Description ThreadSafeLogger implementation
 * @Status Finished
 * @Version $Id: ThreadSafeLogger.cpp 1 2011-03-04 18:13:18Z jreis $
 * @Maintainer Joao Reis (joaocgreis@gmail.com)
 */

#include "config.h"

#include <ctime>

#include "Logger.hpp"



using namespace mermaid::support::logging;



shared_ptr<Logger> ThreadSafeLogger::build()
{
  return shared_ptr<Logger> (new ThreadSafeLogger());
}



shared_ptr<Logger> ThreadSafeLogger::build (const std::string& prefix)
{
  return shared_ptr<Logger> (new ThreadSafeLogger (prefix));
}



ThreadSafeLogger::ThreadSafeLogger() :
    mutex_(),
    indentation_ (0),
    prefix_(),
    levelOutputs_ (std::map<LogLevel, std::list<shared_ptr<LogOutput> > >())
{
}



ThreadSafeLogger::ThreadSafeLogger (const std::string& prefix) :
    mutex_(),
    indentation_ (0),
    prefix_ (prefix),
    levelOutputs_ (std::map<LogLevel, std::list<shared_ptr<LogOutput> > >())
{
}

void ThreadSafeLogger::enableLogLevel (const LogLevel& logLevel,
                                       shared_ptr<LogOutput> logOutput)
{
  ACE_Write_Guard<ACE_RW_Mutex> guard (mutex_);
  levelOutputs_[logLevel].push_back (logOutput);
}



void ThreadSafeLogger::disableLogLevel (const LogLevel& logLevel,
                                        shared_ptr<LogOutput> logOutput)
{
  ACE_Write_Guard<ACE_RW_Mutex> guard (mutex_);
  levelOutputs_[logLevel].remove (logOutput);
}



void ThreadSafeLogger::disableLogLevel (const LogLevel& logLevel)
{
  ACE_Write_Guard<ACE_RW_Mutex> guard (mutex_);
  levelOutputs_[logLevel].clear();
}



void ThreadSafeLogger::setPrefix (const std::string& prefix)
{
  ACE_Write_Guard<ACE_RW_Mutex> guard (mutex_);
  prefix_ = prefix;
}



void ThreadSafeLogger::log (const LogLevel& logLevel,
                            const std::string& message)
{
  time_t t = time (NULL);
  
  // BEGIN and END are write locks because of the indentation update
  if ( (logLevel == LOG_BEGIN) || (logLevel == LOG_END)) {
    mutex_.acquire_write();
  }
  else {
    mutex_.acquire_read();
  }
  
  // Update and get the right indentation
  if ( (logLevel == LOG_END) && (indentation_ > 0)) {
    indentation_--;
  }
  int indentation = indentation_;
  if (logLevel == LOG_BEGIN) {
    indentation_++;
  }
  
  std::list<shared_ptr<LogOutput> >& logList = levelOutputs_[logLevel];
  for (std::list<shared_ptr<LogOutput> >::iterator i = logList.begin();
       i != logList.end();
       i++) {
    (*i)->outputMessage (LogMessage (logLevel,
                                     t,
                                     indentation,
                                     prefix_,
                                     message));
  }
  
  mutex_.release();
}