Subversion Repositories HomeAutomation

/*

 *

 *  Copyright (C) 2012  Mattias Runge

 *

 *  This program 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 2 of the License, or

 *  (at your option) any later version.

 *

 *  This program 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 this program; if not, write to the Free Software Foundation, Inc.,

 *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 */

#include "log.h"

#include <iostream>

#include <stdarg.h>

#include <string.h>

#include <boost/date_time.hpp>

#include <boost/thread/mutex.hpp>

namespace atom {

namespace log {

static boost::mutex   mutex_;

static std::ofstream  file_;

static Level          level_ = (Level)(LOG_LEVEL_ERROR | LOG_LEVEL_EXCEPTION | LOG_LEVEL_WARNING | LOG_LEVEL_INFO);

static const uint32_t kMaxBufferSize = 4096;

void SetLevel(Level level)

{

  level_ = level;

}

void SetLevelByString(std::string level_string)

{

  level_ = LOG_LEVEL_NONE;

  if (level_string.find("LOG_LEVEL_ERROR") != std::string::npos)

  {

    level_ = (Level)(level_ | LOG_LEVEL_ERROR);

  }

  if (level_string.find("LOG_LEVEL_EXCEPTION") != std::string::npos)

  {

    level_ = (Level)(level_ | LOG_LEVEL_EXCEPTION);

  }

  if (level_string.find("LOG_LEVEL_WARNING") != std::string::npos)

  {

    level_ = (Level)(level_ | LOG_LEVEL_WARNING);

  }

  if (level_string.find("LOG_LEVEL_INFO") != std::string::npos)

  {

    level_ = (Level)(level_ | LOG_LEVEL_INFO);

  }

  if (level_string.find("LOG_LEVEL_DEBUG") != std::string::npos)

  {

    level_ = (Level)(level_ | LOG_LEVEL_DEBUG);

  }

  if (level_string.find("LOG_LEVEL_EXTREME") != std::string::npos)

  {

    level_ = (Level)(level_ | LOG_LEVEL_EXTREME);

  }

  if (level_string.find("LOG_LEVEL_ALL") != std::string::npos)

  {

    level_ = (Level)(level_ | LOG_LEVEL_ALL);

  }

}

bool OpenFile(std::string filepath)

{

  CloseFile();

  file_.open(filepath.data(), std::ios::app);

  return file_.is_open();

}

void CloseFile(void)

{

  if (file_.is_open())

  {

    file_.close();

  }

}

void Print(Level level, std::string module, std::string message)

{

  std::string               log_string;

  std::string               level_string;

  boost::posix_time::ptime  date_and_time(boost::posix_time::second_clock::local_time());

  /* Check log level */

  if (0 == (level & level_))

  {

    return;

  }

  /* Convert log level to string */

  if (0 != (level & LOG_LEVEL_ERROR))

  {

    level_string = "ERROR";

  }

  else if (0 != (level & LOG_LEVEL_INFO))

  {

    level_string = "INFO";

  }

  else if (0 != (level & LOG_LEVEL_DEBUG))

  {

    level_string = "DEBUG";

  }

  else if (0 != (level & LOG_LEVEL_EXCEPTION))

  {

    level_string = "EXCEPTION";

  }

  else if (0 != (level & LOG_LEVEL_WARNING))

  {

    level_string = "WARNING";

  }

  else if (0 != (level & LOG_LEVEL_EXTREME))

  {

    level_string = "EXTREME";

  }

  else

  {

    level_string = "UNKNOWN";

  }

  /* Adjust lengths of sub strings */

  level_string.insert(level_string.end(), 9 - level_string.size(), ' ');

  module.insert(module.end(), 25 - module.size(), ' ');

  /* Create log string */

  log_string = boost::posix_time::to_simple_string(date_and_time) + " " + level_string + " " + module + " " + message;

  /* Print message */

  mutex_.lock();

  std::cout << log_string << std::endl;

  if (file_.is_open())

  {

    file_ << log_string << std::endl;

  }

  std::cout.imbue(std::locale::classic());

  mutex_.unlock();

}

void Info(std::string module, char* format, ...)

{

  char    buffer[kMaxBufferSize];

  va_list parameters;

  /* Initialize variables */

  memset(&buffer[0], 0, sizeof(buffer));

  /* Construct message */

  va_start(parameters, format);

  vsnprintf(&buffer[0], sizeof(buffer), format, parameters);

  va_end(parameters);

  Print(LOG_LEVEL_INFO, module, &buffer[0]);

}

void Info(std::string module, std::string message)

{

  Print(LOG_LEVEL_INFO, module, message);

}

void Debug(std::string module, char* format, ...)

{

  char    buffer[kMaxBufferSize];

  va_list parameters;

  /* Initialize variables */

  memset(&buffer[0], 0, sizeof(buffer));

  /* Construct message */

  va_start(parameters, format);

  vsnprintf(&buffer[0], sizeof(buffer), format, parameters);

  va_end(parameters);

  Print(LOG_LEVEL_DEBUG, module, &buffer[0]);

}

void Debug(std::string module, std::string message)

{

  Print(LOG_LEVEL_DEBUG, module, message);

}

void Extreme(std::string module, char* format, ...)

{

  char    buffer[kMaxBufferSize];

  va_list parameters;

  /* Initialize variables */

  memset(&buffer[0], 0, sizeof(buffer));

  /* Construct message */

  va_start(parameters, format);

  vsnprintf(&buffer[0], sizeof(buffer), format, parameters);

  va_end(parameters);

  Print(LOG_LEVEL_EXTREME, module, &buffer[0]);

}

void Extreme(std::string module, std::string message)

{

  Print(LOG_LEVEL_EXTREME, module, message);

}

void Error(std::string module, char* format, ...)

{

  char    buffer[kMaxBufferSize];

  va_list parameters;

  /* Initialize variables */

  memset(&buffer[0], 0, sizeof(buffer));

  /* Construct message */

  va_start(parameters, format);

  vsnprintf(&buffer[0], sizeof(buffer), format, parameters);

  va_end(parameters);

  Print(LOG_LEVEL_ERROR, module, &buffer[0]);

}

void Error(std::string module, std::string message)

{

  Print(LOG_LEVEL_ERROR, module, message);

}

void Warning(std::string module, char* format, ...)

{

  char    buffer[kMaxBufferSize];

  va_list parameters;

  /* Initialize variables */

  memset(&buffer[0], 0, sizeof(buffer));

  /* Construct message */

  va_start(parameters, format);

  vsnprintf(&buffer[0], sizeof(buffer), format, parameters);

  va_end(parameters);

  Print(LOG_LEVEL_WARNING, module, &buffer[0]);

}

void Warning(std::string module, std::string message)

{

  Print(LOG_LEVEL_WARNING, module, message);

}

void Exception(std::string module, std::exception& exception)

{

  Print(LOG_LEVEL_EXCEPTION, module, exception.what());

}

}; // namespace log

}; // namespace atom