FastLogger.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 FastLogger.cpp
 * @Description FastLogger implementation
 * @Status Finished
 * @Version $Id: FastLogger.cpp 1 2011-03-04 18:13:18Z jreis $
 * @Maintainer Joao Reis (joaocgreis@gmail.com)
 */

#include "config.h"

#include <ctime>

#include "Logger.hpp"

#ifdef MERMAID_LOGGER_QUICK_PROFILING
#include <sys/time.h>
#include <time.h>
bool hasTime_ = false;
struct timeval firstTime_;
#endif //MERMAID_LOGGER_QUICK_PROFILING



using namespace mermaid::support::logging;



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



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



FastLogger::FastLogger() :
    indentation_ (0),
    prefix_(),
    levelOutputs_ (std::map<LogLevel, std::list<shared_ptr<LogOutput> > >())
{
#ifdef MERMAID_LOGGER_QUICK_PROFILING
  struct timeval time;
  gettimeofday (&time, NULL);
  if (!hasTime_) {
    firstTime_ = time;
    hasTime_ = true;
  }
  beginTimes_.push (time);
#endif //MERMAID_LOGGER_QUICK_PROFILING
}



FastLogger::FastLogger (const std::string& prefix) :
    indentation_ (0),
    prefix_ (prefix),
    levelOutputs_ (std::map<LogLevel, std::list<shared_ptr<LogOutput> > >())
{
#ifdef MERMAID_LOGGER_QUICK_PROFILING
  struct timeval time;
  gettimeofday (&time, NULL);
  if (!hasTime_) {
    firstTime_ = time;
    hasTime_ = true;
  }
  beginTimes_.push (time);
#endif //MERMAID_LOGGER_QUICK_PROFILING
}



void FastLogger::enableLogLevel (const LogLevel& logLevel,
                                 shared_ptr<LogOutput> logOutput)
{
  levelOutputs_[logLevel].push_back (logOutput);
}



void FastLogger::disableLogLevel (const LogLevel& logLevel,
                                  shared_ptr<LogOutput> logOutput)
{
  levelOutputs_[logLevel].remove (logOutput);
}



void FastLogger::disableLogLevel (const LogLevel& logLevel)
{
  levelOutputs_[logLevel].clear();
}



void FastLogger::setPrefix (const std::string& prefix)
{
  prefix_ = prefix;
}



int FastLogger::updateIndentation_ (const LogLevel& logLevel)
{
  // Indentation is calculated so that 0 is valid for all levels.
  // LOG_BEGIN with indentation 0 means we are going from 0 to 1
  // LOG_END with indentation 0 means we are going from 1 to 0
  int ret;
  if ( (logLevel == LOG_END) && (indentation_ > 0)) {
    indentation_--;
#ifdef MERMAID_LOGGER_QUICK_PROFILING
    beginTimes_.pop();
#endif //MERMAID_LOGGER_QUICK_PROFILING
  }
  ret = indentation_;
  if (logLevel == LOG_BEGIN) {
    indentation_++;
#ifdef MERMAID_LOGGER_QUICK_PROFILING
    struct timeval time;
    gettimeofday (&time, NULL);
    beginTimes_.push (time);
#endif //MERMAID_LOGGER_QUICK_PROFILING
  }
  return ret;
}



void FastLogger::log (const LogLevel& logLevel,
                      const std::string& message)
{
  time_t t = time (NULL);
  int indentation = updateIndentation_ (logLevel);
  
#ifdef MERMAID_LOGGER_QUICK_PROFILING
  struct timeval time;
  gettimeofday (&time, NULL);
  unsigned long long sec, usec;
  
  std::stringstream p;
  // time from the instantiation of the first logger
  if (time.tv_usec >= firstTime_.tv_usec) {
    sec = time.tv_sec - firstTime_.tv_sec;
    usec = time.tv_usec - firstTime_.tv_usec;
  }
  else {
    sec = time.tv_sec - firstTime_.tv_sec - 1;
    usec = ( (unsigned long long) 1000000) + time.tv_usec
           - firstTime_.tv_usec;
  }
  p.width (0);
  p << sec << ".";
  p.fill ('0');
  p.width (6);
  p << usec << " ";
  p << prefix_;
  std::string thePrefix = prefix_;
  prefix_ = p.str();
  
  if ( (logLevel == LOG_END)
       || (logLevel == LOG_STEP)
       || (logLevel == LOG_SEPARATOR)) {
    std::stringstream s;
    s << message;
    s << " ("; // time from the last begin
    if (time.tv_usec >= beginTimes_.top().tv_usec) {
      sec = time.tv_sec - beginTimes_.top().tv_sec;
      usec = time.tv_usec - beginTimes_.top().tv_usec;
    }
    else {
      sec = time.tv_sec - beginTimes_.top().tv_sec - 1;
      usec = ( (unsigned long long) 1000000) + time.tv_usec
             - beginTimes_.top().tv_usec;
    }
    s.width (0);
    s << sec << ".";
    s.fill ('0');
    s.width (6);
    s << usec << "s)";
    message = s.str();
  }
  
  if ( (logLevel == LOG_END) && (beginTimes_.size() > 1)) {
    beginTimes_.pop();
  }
  if (logLevel == LOG_BEGIN) {
    struct timeval time;
    gettimeofday (&time, NULL);
    beginTimes_.push (time);
  }
#endif //MERMAID_LOGGER_QUICK_PROFILING
  
  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));
  }
  
#ifdef MERMAID_LOGGER_QUICK_PROFILING
  prefix_ = thePrefix;
#endif //MERMAID_LOGGER_QUICK_PROFILING
}