log_manager.cpp

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2008 by Kutumov Alexey                                  *
 *   ru.pixel@gmail.com                                                    *
 *                                                                         *
 *   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.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#include "gpucalc/log_manager.h"

namespace gpucalc
{
 template<> LogManager * Singleton<LogManager>::mSingleton = 0;


 LogManager * LogManager::getSingletonPtr()
 {
  return mSingleton;
 }


 LogManager & LogManager::getSingleton()
 {
  assert(mSingleton);
  return(* mSingleton);
 }


 LogManager::LogManager(): Singleton<LogManager>(_LogManagerObjectName), mLogMap(), mDefaultLog(0)
 {
 }


 LogManager::~LogManager()
 {
  clearContainer(mLogMap);
 }


 Log * LogManager::createLog(const std::string & name, bool defaultLog, unsigned int LogClassNameAlignment, unsigned int LogObjectNameAlignment,
  bool DebugOutput, bool SuppressFileOutput, bool SuppressObjectInfo)
 {
  Log * newLog = new Log(name, LogClassNameAlignment, LogObjectNameAlignment, DebugOutput, SuppressFileOutput, SuppressObjectInfo);
  if( !mDefaultLog || defaultLog )
  {
   mDefaultLog = newLog;
  }
  addToContainer(newLog, name, mLogMap);
  return newLog;
 }


 Log * LogManager::getDefaultLog()
 {
  return mDefaultLog;
 }


 Log * LogManager::setDefaultLog(Log * newLog)
 {
  Log * oldLog = mDefaultLog;
  mDefaultLog = newLog;
  return oldLog;
 }


 Log * LogManager::getLog(const std::string & name)
 {
  LogMap::iterator i = mLogMap.find(name);
  if (i != mLogMap.end())
  {
   return i->second;
  }
  else
  {
   Except<ERR_INVALIDPARAMS>(this, "Log not found. ", "LogManager::getLog", __FILE__, __LINE__);
   return NULL;
  }
 }


 void LogManager::destroyLog(const std::string & name)
 {
  LogMap::iterator i = mLogMap.find(name);
  if (i != mLogMap.end())
  {
   if (mDefaultLog == i->second)
   {
    mDefaultLog = NULL;
   }
   delete i->second;
   mLogMap.erase(i);
  }

  if (!mDefaultLog && !mLogMap.empty())
  {
   mDefaultLog = mLogMap.begin()->second;
  }
 }


 void LogManager::destroyLog(Log * log)
 {
  destroyLog(log->getObjectName());
 }


 void LogManager::logMessage(const Object & object, const std::string & Message,
  LogMessageLevel lml, bool maskDebug)
 {
  if (mDefaultLog)
  {
   mDefaultLog->logMessage(object, Message, lml, maskDebug);
  }
 }

 
 
 void LogManager::logMessage(const Object * object, const std::string & Message,
  LogMessageLevel lml, bool maskDebug)
 {
  if (mDefaultLog)
  {
   mDefaultLog->logMessage(object, Message, lml, maskDebug);
  }
 }


 void LogManager::logMessage(const std::string & LogId, const Object * object, const std::string & Message,
  LogMessageLevel lml, bool maskDebug)
 {
  LogMap::iterator i = mLogMap.find(LogId);
  if (i != mLogMap.end())
  {
   i->second->logMessage(object, Message, lml, maskDebug);
  }
  else
  {
   Except<ERR_ITEM_NOT_FOUND>(this, "Log with Id \"" + LogId + "\" cannot be found.", "LogManager::logMessage()", __FILE__, __LINE__);
  }
 }

 void LogManager::logMessage(const std::string & LogId, const Object & object, const std::string & Message,
  LogMessageLevel lml, bool maskDebug)
 {
  LogMap::iterator i = mLogMap.find(LogId);
  if (i != mLogMap.end())
  {
   i->second->logMessage(object, Message, lml, maskDebug);
  }
  else
  {
   Except<ERR_ITEM_NOT_FOUND>(this, "Log with Id \"" + LogId + "\" cannot be found.", "LogManager::logMessage()", __FILE__, __LINE__);
  }
 }



 void LogManager::setLogDetail(LoggingLevel ll)
 {
  if (mDefaultLog)
  {
   mDefaultLog->setLogDetail(ll);
  }
 }


 LoggingLevel LogManager::getLogDetail()
 {
  if (mDefaultLog)
  {
   return mDefaultLog->getLogDetail();
  }
  return LL_Low;
 }
}