Test: Logging

Enabled logging in unit tests.
Seperated LogManager into LogManager (singleton stuff) and LogManagerImplementation (actual logging stuff)
Implemented simple FileLogger

review id = 13

src/lib/CMakeLists.txt

@@ -74,11 +74,15 @@ add_files(
 
 	utility/logging/ConsoleLogger.cpp
 	utility/logging/ConsoleLogger.h
+	utility/logging/FileLogger.cpp
+	utility/logging/FileLogger.h
 	utility/logging/Logger.cpp
 	utility/logging/Logger.h
 	utility/logging/logging.h
 	utility/logging/LogManager.cpp
 	utility/logging/LogManager.h
+	utility/logging/LogManagerImplementation.cpp
+	utility/logging/LogManagerImplementation.h
 	utility/logging/LogMessage.h
 
 	utility/math/Vector2.h

src/lib/utility/logging/FileLogger.cpp

@@ -0,0 +1,57 @@
+#include "FileLogger.h"
+
+#include <fstream>
+#include <sstream>
+
+const std::string FileLogger::s_filePath = "data/log/";
+
+FileLogger::FileLogger()
+	: Logger("FileLogger")
+{
+	setupFileName();
+}
+
+FileLogger::~FileLogger()
+{
+}
+
+void FileLogger::logInfo(const LogMessage& message)
+{
+	logMessage("INFO", message);
+}
+
+void FileLogger::logWarning(const LogMessage& message)
+{
+	logMessage("WARNING", message);
+}
+
+void FileLogger::logError(const LogMessage& message)
+{
+	logMessage("ERROR", message);
+}
+
+void FileLogger::setupFileName()
+{
+	time_t time;
+	std::time(&time);
+	tm localTime = *std::localtime(&time);
+
+	std::stringstream filename;
+	filename << "log_";
+	filename << localTime.tm_mon << "-" << localTime.tm_mday << "_";
+	filename << localTime.tm_hour << "-" << localTime.tm_min << "-" << localTime.tm_sec << ".txt";
+
+	m_fileName = filename.str();
+}
+
+void FileLogger::logMessage(const std::string& type, const LogMessage& message)
+{
+	std::ofstream fileStream;
+	fileStream.open(s_filePath + m_fileName, std::ios::app);
+	fileStream
+		<< message.getTimeString("%H:%M:%S") << " | "
+		<< message.getFileName() << ':' << message.line << ' ' << message.functionName << "() | "
+		<< type << ": " << message.message
+		<< std::endl;
+	fileStream.close();
+}

src/lib/utility/logging/FileLogger.h

@@ -0,0 +1,28 @@
+#ifndef FILE_LOGGER_H
+#define FILE_LOGGER_H
+
+#include <string>
+
+#include "utility/logging/Logger.h"
+#include "utility/logging/LogMessage.h"
+
+class FileLogger: public Logger
+{
+public:
+	FileLogger();
+	virtual ~FileLogger();
+
+	virtual void logInfo(const LogMessage& message);
+	virtual void logWarning(const LogMessage& message);
+	virtual void logError(const LogMessage& message);
+
+private:
+	static const std::string s_filePath;
+
+	void setupFileName();
+	void logMessage(const std::string& type, const LogMessage& message);
+
+	std::string m_fileName;
+};
+
+#endif // FILE_LOGGER_H

src/lib/utility/logging/LogManager.cpp

@@ -26,37 +26,22 @@ LogManager::~LogManager()
 
 void LogManager::addLogger(std::shared_ptr<Logger> logger)
 {
-	std::lock_guard<std::mutex> lockGuard(m_loggerMutex);
-	m_loggers.push_back(logger);
+	m_logManagerImplementation.addLogger(logger);
 }
 
 void LogManager::removeLogger(std::shared_ptr<Logger> logger)
 {
-	std::lock_guard<std::mutex> lockGuard(m_loggerMutex);
-	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);
-	}
+	m_logManagerImplementation.removeLogger(logger);
 }
 
 void LogManager::removeLoggersByType(const std::string& type)
 {
-	std::lock_guard<std::mutex> lockGuard(m_loggerMutex);
-	for (unsigned int i = 0; i < m_loggers.size(); i++)
-	{
-		if (m_loggers[i]->getType() == type)
-		{
-			m_loggers.erase(m_loggers.begin() + i);
-			i--;
-		}
-	}
+	m_logManagerImplementation.removeLoggersByType(type);
 }
 
 int LogManager::getLoggerCount() const
 {
-	std::lock_guard<std::mutex> lockGuard(m_loggerMutex);
-	return m_loggers.size();
+	return m_logManagerImplementation.getLoggerCount();
 }
 
 void LogManager::logInfo(
@@ -66,11 +51,7 @@ void LogManager::logInfo(
 	const unsigned int line
 )
 {
-	std::lock_guard<std::mutex> lockGuardLogger(m_loggerMutex);
-	for (unsigned int i = 0; i < m_loggers.size(); i++)
-	{
-		m_loggers[i]->logInfo(LogMessage(message, file, function, line, getTime()));
-	}
+	m_logManagerImplementation.logInfo(message, file, function, line);
 }
 
 void LogManager::logWarning(
@@ -80,11 +61,7 @@ void LogManager::logWarning(
 	const unsigned int line
 )
 {
-	std::lock_guard<std::mutex> lockGuardLogger(m_loggerMutex);
-	for (unsigned int i = 0; i < m_loggers.size(); i++)
-	{
-		m_loggers[i]->logWarning(LogMessage(message, file, function, line, getTime()));
-	}
+	m_logManagerImplementation.logWarning(message, file, function, line);
 }
 
 void LogManager::logError(
@@ -94,11 +71,7 @@ void LogManager::logError(
 	const unsigned int line
 )
 {
-	std::lock_guard<std::mutex> lockGuardLogger(m_loggerMutex);
-	for (unsigned int i = 0; i < m_loggers.size(); i++)
-	{
-		m_loggers[i]->logError(LogMessage(message, file, function, line, getTime()));
-	}
+	m_logManagerImplementation.logError(message, file, function, line);
 }
 
 std::shared_ptr<LogManager> LogManager::s_instance;
@@ -107,12 +80,3 @@ std::mutex LogManager::s_instanceMutex;
 LogManager::LogManager()
 {
 }
-
-tm LogManager::getTime()
-{
-	time_t time;
-	std::time(&time);
-	tm result;
-	result = *localtime(&time);
-	return result;
-}

src/lib/utility/logging/LogManager.h

@@ -3,9 +3,9 @@
 
 #include <memory>
 #include <mutex>
-#include <vector>
 
 #include "utility/logging/Logger.h"
+#include "utility/logging/LogManagerImplementation.h"
 
 class LogManager
 {
@@ -47,11 +47,7 @@ private:
 	LogManager(const LogManager&);
 	void operator=(const LogManager&);
 
-	tm getTime();
-
-	std::vector<std::shared_ptr<Logger> > m_loggers;
-
-	mutable std::mutex m_loggerMutex;
+	LogManagerImplementation m_logManagerImplementation;
 };
 
 #endif // LOG_MANAGER_H

src/lib/utility/logging/LogManagerImplementation.cpp

@@ -0,0 +1,104 @@
+#include "LogManagerImplementation.h"
+
+LogManagerImplementation::LogManagerImplementation()
+{
+}
+
+LogManagerImplementation::LogManagerImplementation(const LogManagerImplementation& other)
+{
+	m_loggers = other.m_loggers;
+}
+
+void LogManagerImplementation::operator=(const LogManagerImplementation& other)
+{
+	m_loggers = other.m_loggers;
+}
+
+LogManagerImplementation::~LogManagerImplementation()
+{
+}
+
+void LogManagerImplementation::addLogger(std::shared_ptr<Logger> logger)
+{
+	std::lock_guard<std::mutex> lockGuard(m_loggerMutex);
+	m_loggers.push_back(logger);
+}
+
+void LogManagerImplementation::removeLogger(std::shared_ptr<Logger> logger)
+{
+	std::lock_guard<std::mutex> lockGuard(m_loggerMutex);
+	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 LogManagerImplementation::removeLoggersByType(const std::string& type)
+{
+	std::lock_guard<std::mutex> lockGuard(m_loggerMutex);
+	for (unsigned int i = 0; i < m_loggers.size(); i++)
+	{
+		if (m_loggers[i]->getType() == type)
+		{
+			m_loggers.erase(m_loggers.begin() + i);
+			i--;
+		}
+	}
+}
+
+int LogManagerImplementation::getLoggerCount() const
+{
+	std::lock_guard<std::mutex> lockGuard(m_loggerMutex);
+	return m_loggers.size();
+}
+
+void LogManagerImplementation::logInfo(
+	const std::string& message,
+	const std::string& file,
+	const std::string& function,
+	const unsigned int line
+)
+{
+	std::lock_guard<std::mutex> lockGuardLogger(m_loggerMutex);
+	for (unsigned int i = 0; i < m_loggers.size(); i++)
+	{
+		m_loggers[i]->logInfo(LogMessage(message, file, function, line, getTime()));
+	}
+}
+
+void LogManagerImplementation::logWarning(
+	const std::string& message,
+	const std::string& file,
+	const std::string& function,
+	const unsigned int line
+)
+{
+	std::lock_guard<std::mutex> lockGuardLogger(m_loggerMutex);
+	for (unsigned int i = 0; i < m_loggers.size(); i++)
+	{
+		m_loggers[i]->logWarning(LogMessage(message, file, function, line, getTime()));
+	}
+}
+
+void LogManagerImplementation::logError(
+	const std::string& message,
+	const std::string& file,
+	const std::string& function,
+	const unsigned int line
+)
+{
+	std::lock_guard<std::mutex> lockGuardLogger(m_loggerMutex);
+	for (unsigned int i = 0; i < m_loggers.size(); i++)
+	{
+		m_loggers[i]->logError(LogMessage(message, file, function, line, getTime()));
+	}
+}
+
+tm LogManagerImplementation::getTime()
+{
+	time_t time;
+	std::time(&time);
+	tm result = *std::localtime(&time); // this is done because localtime returns a pointer to a statically allocated object
+	return result;
+}

src/lib/utility/logging/LogManagerImplementation.h

@@ -0,0 +1,55 @@
+#ifndef LOG_MANAGER_IMPLEMENTATION_H
+#define LOG_MANAGER_IMPLEMENTATION_H
+
+#include <memory>
+#include <mutex>
+#include <vector>
+
+#include "utility/logging/Logger.h"
+
+class LogManagerImplementation
+{
+public:
+	LogManagerImplementation();
+
+	// Must be implemented because std::mutex is non-copyable, see
+	// http://stackoverflow.com/questions/14263836/why-does-stdmutex-create-a-c2248-when-used-in-a-struct-with-windows-socket
+	// for more details
+	LogManagerImplementation(const LogManagerImplementation& other);
+	void operator=(const LogManagerImplementation& other);
+
+	~LogManagerImplementation();
+
+	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:
+	tm getTime();
+
+	std::vector<std::shared_ptr<Logger> > m_loggers;
+
+	mutable std::mutex m_loggerMutex;
+};
+
+#endif // LOG_MANAGER_IMPLEMENTATION_H