Utility: Logging

Added logging utility classes supposed to be used for all your logging
needs, e.g. instead of cout

reviewer=ebsi

src/lib/utility/logging/LogManager.cpp

@@ -0,0 +1,103 @@
+#include "utility/logging/LogManager.h"
+#include "utility/logging/LogMessage.h"
+
+std::shared_ptr<LogManager> LogManager::getInstance()
+{
+	if (s_instance.use_count() == 0)
+	{
+		s_instance = std::shared_ptr<LogManager>(new LogManager());
+	}
+	return s_instance;
+}
+
+void LogManager::destroyInstance()
+{
+	s_instance.reset();
+}
+
+LogManager::~LogManager()
+{
+}
+
+void LogManager::addLogger(std::shared_ptr<Logger> logger)
+{
+	m_loggers.push_back(logger);
+}
+
+void LogManager::removeLogger(std::shared_ptr<Logger> logger)
+{
+	std::vector<std::shared_ptr<Logger>>::iterator it = std::find(m_loggers.begin(), m_loggers.end(), logger);
+	if (it != m_loggers.end())
+	{
+		m_loggers.erase(it);
+	}
+}
+
+void LogManager::removeLoggersByType(const std::string& type)
+{
+	for (int i = 0; i < m_loggers.size(); i++)
+	{
+		if (m_loggers[i]->getType().c_str() == type.c_str())
+		{
+			m_loggers.erase(m_loggers.begin() + i);
+			i--;
+		}
+	}
+}
+
+int LogManager::getLoggerCount() const
+{
+	return m_loggers.size();
+}
+
+void LogManager::logInfo(
+	const std::string& message,
+	const std::string& file,
+	const std::string& function,
+	const unsigned int line
+)
+{
+	for (int i = 0; i < m_loggers.size(); i++)
+	{
+		m_loggers[i]->logInfo(LogMessage(message, file, function, line, getTime()));
+	}
+}
+
+void LogManager::logWarning(
+	const std::string& message,
+	const std::string& file,
+	const std::string& function,
+	const unsigned int line
+)
+{
+	for (int i = 0; i < m_loggers.size(); i++)
+	{
+		m_loggers[i]->logWarning(LogMessage(message, file, function, line, getTime()));
+	}
+}
+
+void LogManager::logError(
+	const std::string& message,
+	const std::string& file,
+	const std::string& function,
+	const unsigned int line
+)
+{
+	for (int i = 0; i < m_loggers.size(); i++)
+	{
+		m_loggers[i]->logError(LogMessage(message, file, function, line, getTime()));
+	}
+}
+
+std::shared_ptr<LogManager> LogManager::s_instance;
+
+LogManager::LogManager()
+{
+}
+
+tm LogManager::getTime()
+{
+	time_t time;
+	std::time(&time);
+	return *std::localtime(&time);
+}

src/lib/utility/logging/LogManager.h

@@ -0,0 +1,53 @@
+#ifndef LOG_MANAGER_H
+#define LOG_MANAGER_H
+
+#include <memory>
+#include <vector>
+
+#include "utility/logging/Logger.h"
+
+class LogManager
+{
+public:
+	static std::shared_ptr<LogManager> getInstance();
+	static void destroyInstance();
+
+	~LogManager();
+
+	void addLogger(std::shared_ptr<Logger> logger);
+	void removeLogger(std::shared_ptr<Logger> logger);
+	void removeLoggersByType(const std::string& type);
+	int getLoggerCount() const;
+
+	void logInfo(
+		const std::string& message,
+		const std::string& file,
+		const std::string& function,
+		const unsigned int line
+	);
+	void logWarning(
+		const std::string& message,
+		const std::string& file,
+		const std::string& function,
+		const unsigned int line
+	);
+	void logError(
+		const std::string& message,
+		const std::string& file,
+		const std::string& function,
+		const unsigned int line
+	);
+
+private:
+	static std::shared_ptr<LogManager> s_instance;
+
+	LogManager();
+	LogManager(const LogManager&);
+	void operator=(const LogManager&);
+
+	tm getTime();
+
+	std::vector<std::shared_ptr<Logger> > m_loggers;
+};
+
+#endif // LOG_MANAGER_H

src/lib/utility/logging/LogMessage.h

@@ -0,0 +1,31 @@
+#ifndef LOG_MESSAGE_H
+#define LOG_MESSAGE_H
+
+#include <ctime>
+#include <string>
+
+struct LogMessage
+{
+public:
+	LogMessage(
+		const std::string& message,
+		const std::string& fileName,
+		const std::string& functionName,
+		const unsigned int line,
+		const std::tm& time
+	)
+		: message(message)
+		, fileName(fileName)
+		, functionName(functionName)
+		, line(line)
+		, time(time)
+	{}
+
+	const std::string message;
+	const std::string fileName;
+	const std::string functionName;
+	const unsigned int line;
+	const std::tm time;
+};
+
+#endif // LOG_MESSAGE_H

src/lib/utility/logging/Logger.cpp

@@ -0,0 +1,15 @@
+#include "utility/logging/Logger.h"
+
+Logger::Logger(const std::string& type)
+	: m_type(type)
+{
+}
+
+Logger::~Logger()
+{
+}
+
+std::string Logger::getType() const
+{
+	return m_type;
+}

src/lib/utility/logging/Logger.h

@@ -0,0 +1,26 @@
+#ifndef LOGGER_H
+#define LOGGER_H
+
+#include <memory>
+#include <vector>
+
+#include "utility/logging/LogMessage.h"
+
+class Logger
+{
+public:
+	Logger(const std::string& type);
+	virtual ~Logger();
+
+	std::string getType() const;
+
+	virtual void logInfo(const LogMessage& message) = 0;
+	virtual void logWarning(const LogMessage& message) = 0;
+	virtual void logError(const LogMessage& message) = 0;
+
+private:
+	const std::string m_type;
+};
+
+
+#endif

src/lib/utility/logging/logging.h

@@ -0,0 +1,33 @@
+#ifndef LOGGING_H
+#define LOGGING_H
+
+#include "utility/logging/LogManager.h"
+
+/**
+* @brief Makros to simplify usage of the log manager
+*/
+#define LOG_INFO(str) \
+	do \
+	{ \
+		std::string s((str)); \
+		LogManager::getInstance()->logInfo(s, __FILE__, __FUNCTION__, __LINE__); \
+	} \
+	while(0) \
+
+#define LOG_WARNING(str) \
+	do \
+	{ \
+		std::string s((str)); \
+		LogManager::getInstance()->logWarning(s, __FILE__, __FUNCTION__, __LINE__); \
+	} \
+	while(0) \
+
+#define LOG_ERROR(str) \
+	do \
+	{ \
+		std::string s((str)); \
+		LogManager::getInstance()->logError(s, __FILE__, __FUNCTION__, __LINE__); \
+	} \
+	while(0) \
+
+#endif // LOGGING_H