- Fully integrated new logging API(ERM, Editor, missing parts) - Removed old logger

AI/EmptyAI/CEmptyAI.cpp

@@ -6,7 +6,7 @@ void CEmptyAI::init(CCallback * CB)
 	cb = CB;
 	human=false;
 	playerID = *cb->getMyColor();
-	std::cout << "EmptyAI initialized." << std::endl;
+	logAi->infoStream() << "EmptyAI initialized.";
 }
 void CEmptyAI::yourTurn()
 {
@@ -31,4 +31,4 @@ void CEmptyAI::showBlockingDialog(const std::string &text, const std::vector<Com
 void CEmptyAI::showGarrisonDialog(const CArmedInstance *up, const CGHeroInstance *down, bool removableUnits, int queryID)
 {
 	cb->selectionMade(0, queryID);
-}
+}

Editor/Editor.cpp

@@ -6,14 +6,17 @@
 #include "../lib/CGeneralTextHandler.h"
 #include "../lib/mapping/CMap.h"
 #include "../lib/mapping/CMapService.h"
+#include "../lib/logging/CBasicLogConfigurator.h"
 
 Editor::Editor(QWidget *parent)
 	: QMainWindow(parent)
 {
-	logfile = new std::ofstream((VCMIDirs::get().localPath() + "/VCMI_Editor_log.txt").c_str());
+	// Setup default logging(enough for now)
 	console = new CConsoleHandler;
+	CBasicLogConfigurator logConfig(VCMIDirs::get().localPath() + "/VCMI_Editor_log.txt", console);
+	logConfig.configureDefault();
 
-	preinitDLL(console,logfile);
+	preinitDLL(console);
 	loadDLLClasses();
 
 	VLC->generaltexth->readToVector("DATA/EDITOR", txtEditor);

Editor/Editor.h

@@ -22,7 +22,6 @@ private:
 
 	std::vector<std::string> txtEditor, txtEditorCmd;
 
-	std::ofstream * logfile;
 	CConsoleHandler * console;
 
 	Ui::EditorClass ui;

Global.h

@@ -193,34 +193,34 @@ typedef boost::lock_guard<boost::recursive_mutex> TLockGuardRec;
 
 #define THROW_FORMAT(message, formatting_elems)  throw std::runtime_error(boost::str(boost::format(message) % formatting_elems))
 
-#define ASSERT_IF_CALLED_WITH_PLAYER if(!player) {tlog1 << __FUNCTION__ << "\n"; assert(0);}
+#define ASSERT_IF_CALLED_WITH_PLAYER if(!player) {logGlobal->errorStream() << BOOST_CURRENT_FUNCTION; assert(0);}
 
 //XXX pls dont - 'debug macros' are usually more trouble than it's worth
 #define HANDLE_EXCEPTION  \
     catch (const std::exception& e) {	\
-    tlog1 << e.what() << std::endl;		\
+	logGlobal->errorStream() << e.what();		\
     throw;								\
 }									\
     catch (const std::exception * e)	\
 {									\
-    tlog1 << e->what()<< std::endl;	\
+	logGlobal->errorStream() << e->what();	\
     throw;							\
 }									\
     catch (const std::string& e) {		\
-    tlog1 << e << std::endl;		\
+	logGlobal->errorStream() << e;		\
     throw;							\
 }
 
 #define HANDLE_EXCEPTIONC(COMMAND)  \
     catch (const std::exception& e) {	\
     COMMAND;						\
-    tlog1 << e.what() << std::endl;	\
+	logGlobal->errorStream() << e.what();	\
     throw;							\
 }									\
     catch (const std::string &e)	\
 {									\
     COMMAND;						\
-    tlog1 << e << std::endl;	\
+	logGlobal->errorStream() << e;	\
     throw;							\
 }
 
@@ -575,5 +575,4 @@ using vstd::make_unique;
 /* ---------------------------------------------------------------------------- */
 /* VCMI headers */
 /* ---------------------------------------------------------------------------- */
-#include "lib/CLogger.h"
-#include "lib/logging/CNewLogger.h"
+#include "lib/logging/CLogger.h"

client/CMT.cpp

@@ -253,18 +253,17 @@ int main(int argc, char** argv)
     // Init old logging system and new (temporary) logging system
 	CStopWatch total, pomtime;
 	std::cout.flags(std::ios::unitbuf);
-    logfile = new std::ofstream((VCMIDirs::get().localPath() + "/VCMI_Client_log.txt").c_str());
 	console = new CConsoleHandler;
 	*console->cb = boost::bind(&processCommand, _1);
 	console->start();
 	atexit(dispose);
 
-    CBasicLogConfigurator logConfig(VCMIDirs::get().localPath() + "/VCMI_Client_log2.txt", console);
+	CBasicLogConfigurator logConfig(VCMIDirs::get().localPath() + "/VCMI_Client_log.txt", console);
     logConfig.configureDefault();
-    logGlobal->infoStream() <<"Creating console and logfile: "<<pomtime.getDiff();
+	logGlobal->infoStream() <<"Creating console "<<pomtime.getDiff();
 
     // Init filesystem and settings
-	preinitDLL(::console, logfile);
+	preinitDLL(::console);
     settings.init();
 
     // Initialize logging based on settings
@@ -655,7 +654,6 @@ void dispose()
 {
 	if (console)
 		delete console;
-	delete logfile;
 }
 
 //used only once during initialization

lib/CConsoleHandler.cpp

@@ -15,6 +15,8 @@
 
 boost::mutex CConsoleHandler::smx;
 
+DLL_LINKAGE CConsoleHandler * console = nullptr;
+
 #ifndef _WIN32
 	typedef std::string TColor;
 	#define CONSOLE_GREEN "\x1b[1;32m"

lib/CConsoleHandler.h

@@ -91,3 +91,5 @@ private:
 
     boost::thread * thread;
 };
+
+extern DLL_LINKAGE CConsoleHandler * console;

lib/CGameState.cpp

@@ -1025,7 +1025,6 @@ void CGameState::init(StartInfo * si)
                         map->getTile(pos).extTileFlags |= 128;
 				}
 	}
-	//std::cout<<"\tRandomizing objects: "<<th.getDif()<<std::endl;
 
 	/*********creating players entries in gs****************************************/
     logGlobal->debugStream() << "\tCreating player entries in gs";

lib/CLogger.cpp

@@ -1,72 +0,0 @@
-#include "StdInc.h"
-#include "CLogger.h"
-
-/*
- * CLogger.cpp, part of VCMI engine
- *
- * Authors: listed in file AUTHORS in main folder
- *
- * License: GNU General Public License v2.0 or later
- * Full text of license available in license.txt file, in main folder
- *
- */
-
-// Console, file definitions
-DLL_LINKAGE CConsoleHandler *console = NULL;
-DLL_LINKAGE std::ostream *logfile = NULL;
-
-// CLogger definitions
-DLL_LINKAGE CLogger tlog0(0);
-DLL_LINKAGE CLogger tlog1(1);
-DLL_LINKAGE CLogger tlog2(2);
-DLL_LINKAGE CLogger tlog3(3);
-DLL_LINKAGE CLogger tlog4(4);
-DLL_LINKAGE CLogger tlog5(5);
-DLL_LINKAGE CLogger tlog6(-2);
-
-// Logging level settings
-const int CLogger::CONSOLE_LOGGING_LEVEL = 5;
-const int CLogger::FILE_LOGGING_LEVEL = 6;
-
-CLogger::CLogger(const int Lvl) : lvl(Lvl)
-{
-#ifdef ANDROID
-	androidloglevel = ANDROID_LOG_INFO;
-	switch(lvl) {
-case 0: androidloglevel = ANDROID_LOG_INFO; break;
-case 1: androidloglevel = ANDROID_LOG_FATAL; break;
-case 2: androidloglevel = ANDROID_LOG_ERROR; break;
-case 3: androidloglevel = ANDROID_LOG_WARN; break;
-case 4: androidloglevel = ANDROID_LOG_INFO; break;
-case 5: androidloglevel = ANDROID_LOG_DEBUG; break;
-case 6: case -2: androidloglevel = ANDROID_LOG_VERBOSE; break;
-	}
-#endif
-}
-
-#ifdef ANDROID
-void CLogger::outputAndroid()
-{
-	int pos = buf.str().find("\n");
-	while( pos >= 0 )
-	{
-		__android_log_print(androidloglevel, "VCMI", "%s", buf.str().substr(0, pos).c_str() );
-		buf.str( buf.str().substr(pos+1) );
-		pos = buf.str().find("\n");
-	}
-}
-#endif
-
-CLogger& CLogger::operator<<(std::ostream& (*fun)(std::ostream&))
-{
-#ifdef ANDROID
-	buf << fun;
-	outputAndroid();
-#else
-	if(lvl < CLogger::CONSOLE_LOGGING_LEVEL)
-		std::cout << fun;
-	if((lvl < CLogger::FILE_LOGGING_LEVEL) && logfile)
-		*logfile << fun;
-#endif
-	return *this;
-}

lib/CLogger.h

@@ -1,63 +0,0 @@
-#pragma once
-
-#include "CConsoleHandler.h"
-
-/*
- * CLogger.h, part of VCMI engine
- *
- * Authors: listed in file AUTHORS in main folder
- *
- * License: GNU General Public License v2.0 or later
- * Full text of license available in license.txt file, in main folder
- *
- */
-
-extern DLL_LINKAGE std::ostream *logfile;
-extern DLL_LINKAGE CConsoleHandler *console;
-
-// CLogger, prints log info to console and saves in file
-class DLL_LINKAGE CLogger
-{
-	const int lvl;
-#ifdef ANDROID
-	std::ostringstream buf;
-	int androidloglevel;
-	void outputAndroid();
-#endif
-
-public:
-	static const int CONSOLE_LOGGING_LEVEL;
-	static const int FILE_LOGGING_LEVEL;
-	
-	CLogger& operator<<(std::ostream& (*fun)(std::ostream&));
-
-	template<typename T> 
-	CLogger & operator<<(const T & data)
-	{
-#ifdef ANDROID
-		buf << data;
-		outputAndroid();
-#else
-		if(lvl < CLogger::CONSOLE_LOGGING_LEVEL)
-		{
-			if(console)
-                console->print(data, false, static_cast<EConsoleTextColor::EConsoleTextColor>(lvl));
-			else
-				std::cout << data << std::flush;
-		}
-		if((lvl < CLogger::FILE_LOGGING_LEVEL) && logfile)
-			*logfile << data << std::flush;
-#endif
-		return *this;
-	}
-
-	CLogger(const int Lvl);
-};
-
-extern DLL_LINKAGE CLogger tlog0; //green - standard progress info
-extern DLL_LINKAGE CLogger tlog1; //red - big errors
-extern DLL_LINKAGE CLogger tlog2; //magenta - major warnings
-extern DLL_LINKAGE CLogger tlog3; //yellow - minor warnings
-extern DLL_LINKAGE CLogger tlog4; //white - detailed log info
-extern DLL_LINKAGE CLogger tlog5; //gray - minor log info
-extern DLL_LINKAGE CLogger tlog6; //teal - AI info

lib/CMakeLists.txt

@@ -14,7 +14,7 @@ set(lib_SRCS
 		filesystem/CFileInputStream.cpp
 		filesystem/CCompressedStream.cpp
 		logging/CBasicLogConfigurator.cpp
-		logging/CNewLogger.cpp
+		logging/CLogger.cpp
 		mapping/CCampaignHandler.cpp
 		mapping/CMap.cpp
 		mapping/CMapEditManager.cpp
@@ -39,7 +39,6 @@ set(lib_SRCS
 		CGameState.cpp
 		CGeneralTextHandler.cpp
 		CHeroHandler.cpp
-		CLogger.cpp
 		CModHandler.cpp
 		CObjectHandler.cpp
 		CObstacleInstance.cpp

lib/CObjectHandler.cpp

@@ -270,7 +270,6 @@ PlayerColor CGObjectInstance::getOwner() const
 CGObjectInstance::CGObjectInstance()
 {
 	pos = int3(-1,-1,-1);
-	//std::cout << "Tworze obiekt "<<this<<std::endl;
 	//state = new CLuaObjectScript();
 	ID = Obj::NO_OBJ;
 	subID = -1;
@@ -280,7 +279,6 @@ CGObjectInstance::CGObjectInstance()
 }
 CGObjectInstance::~CGObjectInstance()
 {
-	//std::cout << "Usuwam obiekt "<<this<<std::endl;
 	//if (state)
 	//	delete state;
 	//state=NULL;

lib/Connection.cpp

@@ -208,7 +208,7 @@ bool CConnection::isOpen() const
 	return socket && connected;
 }
 
-void CConnection::reportState(CGLogger * out)
+void CConnection::reportState(CLogger * out)
 {
     out->debugStream() << "CConnection";
 	if(socket && socket->is_open())
@@ -315,7 +315,7 @@ void CSaveFile::openNextFile(const std::string &fname)
 	}
 }
 
-void CSaveFile::reportState(CGLogger * out)
+void CSaveFile::reportState(CLogger * out)
 {
     out->debugStream() << "CSaveFile";
 	if(sfile.get() && *sfile)
@@ -399,7 +399,7 @@ void CLoadFile::openNextFile(const std::string &fname, int minimalVersion)
 	}
 }
 
-void CLoadFile::reportState(CGLogger * out)
+void CLoadFile::reportState(CLogger * out)
 {
     out->debugStream() << "CLoadFile";
 	if(!!sfile && *sfile)

lib/Connection.h

@@ -333,7 +333,7 @@ public:
 	CSerializer();
 	~CSerializer();
 
-    virtual void reportState(CGLogger * out){};
+    virtual void reportState(CLogger * out){};
 
 	template <typename T, typename U>
 	void registerVectoredType(const std::vector<T*> *Vector, const U T::*IdPtr)
@@ -1211,7 +1211,7 @@ public:
 
 	void openNextFile(const std::string &fname); //throws!
 	void clear();
-    void reportState(CGLogger * out);
+    void reportState(CLogger * out);
 
 	void putMagicBytes(const std::string &text);
 };
@@ -1234,7 +1234,7 @@ public:
 
 	void openNextFile(const std::string &fname, int minimalVersion); //throws!
 	void clear();
-    void reportState(CGLogger * out);
+    void reportState(CLogger * out);
 
 	void checkMagicBytes(const std::string &text);
 };
@@ -1263,7 +1263,7 @@ class DLL_LINKAGE CConnection
 	CConnection(void);
 
 	void init();
-    void reportState(CGLogger * out);
+    void reportState(CLogger * out);
 public:
 	boost::mutex *rmx, *wmx; // read/write mutexes
 	TSocket * socket;

lib/VCMI_Lib.cpp

@@ -26,14 +26,13 @@
 #include "CStopWatch.h"
 #include "VCMIDirs.h"
 #include "filesystem/CResourceLoader.h"
-
+#include "CConsoleHandler.h"
 
 LibClasses * VLC = NULL;
 
-DLL_LINKAGE void preinitDLL(CConsoleHandler *Console, std::ostream *Logfile)
+DLL_LINKAGE void preinitDLL(CConsoleHandler *Console)
 {
 	console = Console;
-	logfile = Logfile;
 	VLC = new LibClasses;
 	try
 	{

lib/VCMI_Lib.h

@@ -67,6 +67,6 @@ public:
 
 extern DLL_LINKAGE LibClasses * VLC;
 
-DLL_LINKAGE void preinitDLL(CConsoleHandler *Console, std::ostream *Logfile);
+DLL_LINKAGE void preinitDLL(CConsoleHandler *Console);
 DLL_LINKAGE void loadDLLClasses();
 

lib/VCMI_lib.cbp

@@ -97,8 +97,6 @@
 		<Unit filename="CGeneralTextHandler.h" />
 		<Unit filename="CHeroHandler.cpp" />
 		<Unit filename="CHeroHandler.h" />
-		<Unit filename="CLogger.cpp" />
-		<Unit filename="CLogger.h" />
 		<Unit filename="CModHandler.cpp" />
 		<Unit filename="CModHandler.h" />
 		<Unit filename="CObjectHandler.cpp" />

lib/VCMI_lib.vcxproj

@@ -178,7 +178,6 @@
     <ClCompile Include="CGameState.cpp" />
     <ClCompile Include="CGeneralTextHandler.cpp" />
     <ClCompile Include="CHeroHandler.cpp" />
-    <ClCompile Include="CLogger.cpp" />
     <ClCompile Include="CModHandler.cpp" />
     <ClCompile Include="CObjectHandler.cpp" />
     <ClCompile Include="CObstacleInstance.cpp" />
@@ -204,7 +203,7 @@
     <ClCompile Include="RegisterTypes.cpp" />
     <ClCompile Include="rmg\CMapGenOptions.cpp" />
     <ClCompile Include="rmg\CMapGenerator.cpp" />
-    <ClCompile Include="logging\CNewLogger.cpp" />
+    <ClCompile Include="logging\CLogger.cpp" />
     <ClCompile Include="logging\CBasicLogConfigurator.cpp" />
     <ClCompile Include="HeroBonus.cpp" />
     <ClCompile Include="CBattleCallback.cpp" />
@@ -242,7 +241,6 @@
     <ClInclude Include="CGameState.h" />
     <ClInclude Include="CGeneralTextHandler.h" />
     <ClInclude Include="CHeroHandler.h" />
-    <ClInclude Include="CLogger.h" />
     <ClInclude Include="CModHandler.h" />
     <ClInclude Include="CObjectHandler.h" />
     <ClInclude Include="CObstacleInstance.h" />
@@ -274,7 +272,7 @@
     <ClInclude Include="mapping\MapFormatH3M.h" />
     <ClInclude Include="rmg\CMapGenOptions.h" />
     <ClInclude Include="rmg\CMapGenerator.h" />
-    <ClInclude Include="logging\CNewLogger.h" />
+    <ClInclude Include="logging\CLogger.h" />
     <ClInclude Include="logging\CBasicLogConfigurator.h" />
     <ClInclude Include="GameConstants.h" />
     <ClInclude Include="HeroBonus.h" />
@@ -296,4 +294,4 @@
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
   </ImportGroup>
-</Project>
+</Project>

lib/logging/CBasicLogConfigurator.cpp

@@ -10,8 +10,8 @@ CBasicLogConfigurator::CBasicLogConfigurator(const std::string & filePath, CCons
 
 void CBasicLogConfigurator::configureDefault()
 {
-    CGLogger::getGlobalLogger()->addTarget(make_unique<CLogConsoleTarget>(console));
-    CGLogger::getGlobalLogger()->addTarget(make_unique<CLogFileTarget>(filePath, appendToLogFile));
+    CLogger::getGlobalLogger()->addTarget(make_unique<CLogConsoleTarget>(console));
+    CLogger::getGlobalLogger()->addTarget(make_unique<CLogFileTarget>(filePath, appendToLogFile));
     appendToLogFile = true;
 }
 
@@ -30,13 +30,13 @@ void CBasicLogConfigurator::configure()
             {
                 // Get logger
                 std::string name = loggerNode["domain"].String();
-                CGLogger * logger = CGLogger::getLogger(CLoggerDomain(name));
+                CLogger * logger = CLogger::getLogger(CLoggerDomain(name));
 
                 // Set log level
                 logger->setLevel(getLogLevel(loggerNode["level"].String()));
             }
         }
-        CGLogger::getGlobalLogger()->clearTargets();
+        CLogger::getGlobalLogger()->clearTargets();
 
         // Add console target
         auto consoleTarget = make_unique<CLogConsoleTarget>(console);
@@ -64,7 +64,7 @@ void CBasicLogConfigurator::configure()
             }
             consoleTarget->setColorMapping(colorMapping);
         }
-        CGLogger::getGlobalLogger()->addTarget(std::move(consoleTarget));
+        CLogger::getGlobalLogger()->addTarget(std::move(consoleTarget));
 
         // Add file target
         auto fileTarget = make_unique<CLogFileTarget>(filePath, appendToLogFile);
@@ -74,7 +74,7 @@ void CBasicLogConfigurator::configure()
             const JsonNode & fileFormatNode = fileNode["format"];
             if(!fileFormatNode.isNull()) fileTarget->setFormatter(CLogFormatter(fileFormatNode.String()));
         }
-        CGLogger::getGlobalLogger()->addTarget(std::move(fileTarget));
+        CLogger::getGlobalLogger()->addTarget(std::move(fileTarget));
         appendToLogFile = true;
     }
     catch(const std::exception & e)

lib/logging/CBasicLogConfigurator.h

@@ -11,7 +11,7 @@
 
 #pragma once
 
-#include "../CLogger.h"
+#include "../CConsoleHandler.h"
 
 class CConsoleHandler;
 class JsonNode;

lib/logging/CNewLogger.cpp → lib/logging/CLogger.cpp

@@ -1,5 +1,5 @@
 #include "StdInc.h"
-#include "CNewLogger.h"
+#include "CLogger.h"
 
 const std::string CLoggerDomain::DOMAIN_GLOBAL = "global";
 
@@ -33,7 +33,7 @@ std::string CLoggerDomain::getName() const
     return name;
 }
 
-CLoggerStream::CLoggerStream(const CGLogger & logger, ELogLevel::ELogLevel level) : logger(logger), level(level), sbuffer(nullptr)
+CLoggerStream::CLoggerStream(const CLogger & logger, ELogLevel::ELogLevel level) : logger(logger), level(level), sbuffer(nullptr)
 {
 
 }
@@ -48,28 +48,28 @@ CLoggerStream::~CLoggerStream()
     }
 }
 
-boost::recursive_mutex CGLogger::smx;
+boost::recursive_mutex CLogger::smx;
 
-CGLogger * logGlobal = CGLogger::getGlobalLogger();
+DLL_LINKAGE CLogger * logGlobal = CLogger::getGlobalLogger();
 
-CGLogger * logBonus = CGLogger::getLogger(CLoggerDomain("bonus"));
+DLL_LINKAGE CLogger * logBonus = CLogger::getLogger(CLoggerDomain("bonus"));
 
-CGLogger * logNetwork = CGLogger::getLogger(CLoggerDomain("network"));
+DLL_LINKAGE CLogger * logNetwork = CLogger::getLogger(CLoggerDomain("network"));
 
-CGLogger * logAi = CGLogger::getLogger(CLoggerDomain("ai"));
+DLL_LINKAGE CLogger * logAi = CLogger::getLogger(CLoggerDomain("ai"));
 
-CGLogger * CGLogger::getLogger(const CLoggerDomain & domain)
+CLogger * CLogger::getLogger(const CLoggerDomain & domain)
 {
     boost::lock_guard<boost::recursive_mutex> _(smx);
 
-    CGLogger * logger = CLogManager::get().getLogger(domain);
+	CLogger * logger = CLogManager::get().getLogger(domain);
     if(logger)
     {
         return logger;
     }
     else
     {
-        logger = new CGLogger(domain);
+		logger = new CLogger(domain);
         if(domain.isGlobalDomain())
         {
             logger->setLevel(ELogLevel::INFO);
@@ -79,12 +79,12 @@ CGLogger * CGLogger::getLogger(const CLoggerDomain & domain)
     }
 }
 
-CGLogger * CGLogger::getGlobalLogger()
+CLogger * CLogger::getGlobalLogger()
 {
     return getLogger(CLoggerDomain(CLoggerDomain::DOMAIN_GLOBAL));
 }
 
-CGLogger::CGLogger(const CLoggerDomain & domain) : domain(domain)
+CLogger::CLogger(const CLoggerDomain & domain) : domain(domain)
 {
     if(domain.isGlobalDomain())
     {
@@ -98,57 +98,57 @@ CGLogger::CGLogger(const CLoggerDomain & domain) : domain(domain)
     }
 }
 
-void CGLogger::trace(const std::string & message) const
+void CLogger::trace(const std::string & message) const
 {
     log(ELogLevel::TRACE, message);
 }
 
-CLoggerStream CGLogger::traceStream() const
+CLoggerStream CLogger::traceStream() const
 {
     return CLoggerStream(*this, ELogLevel::TRACE);
 }
 
-void CGLogger::debug(const std::string & message) const
+void CLogger::debug(const std::string & message) const
 {
     log(ELogLevel::DEBUG, message);
 }
 
-CLoggerStream CGLogger::debugStream() const
+CLoggerStream CLogger::debugStream() const
 {
     return CLoggerStream(*this, ELogLevel::DEBUG);
 }
 
-void CGLogger::info(const std::string & message) const
+void CLogger::info(const std::string & message) const
 {
     log(ELogLevel::INFO, message);
 }
 
-CLoggerStream CGLogger::infoStream() const
+CLoggerStream CLogger::infoStream() const
 {
     return CLoggerStream(*this, ELogLevel::INFO);
 }
 
-void CGLogger::warn(const std::string & message) const
+void CLogger::warn(const std::string & message) const
 {
     log(ELogLevel::WARN, message);
 }
 
-CLoggerStream CGLogger::warnStream() const
+CLoggerStream CLogger::warnStream() const
 {
     return CLoggerStream(*this, ELogLevel::WARN);
 }
 
-void CGLogger::error(const std::string & message) const
+void CLogger::error(const std::string & message) const
 {
     log(ELogLevel::ERROR, message);
 }
 
-CLoggerStream CGLogger::errorStream() const
+CLoggerStream CLogger::errorStream() const
 {
     return CLoggerStream(*this, ELogLevel::ERROR);
 }
 
-void CGLogger::log(ELogLevel::ELogLevel level, const std::string & message) const
+void CLogger::log(ELogLevel::ELogLevel level, const std::string & message) const
 {
     if(getEffectiveLevel() <= level)
     {
@@ -156,33 +156,33 @@ void CGLogger::log(ELogLevel::ELogLevel level, const std::string & message) cons
     }
 }
 
-ELogLevel::ELogLevel CGLogger::getLevel() const
+ELogLevel::ELogLevel CLogger::getLevel() const
 {
     TLockGuard _(mx);
     return level;
 }
 
-void CGLogger::setLevel(ELogLevel::ELogLevel level)
+void CLogger::setLevel(ELogLevel::ELogLevel level)
 {
     TLockGuard _(mx);
     if(domain.isGlobalDomain() && level == ELogLevel::NOT_SET) return;
     this->level = level;
 }
 
-const CLoggerDomain & CGLogger::getDomain() const
+const CLoggerDomain & CLogger::getDomain() const
 {
     return domain;
 }
 
-void CGLogger::addTarget(unique_ptr<ILogTarget> && target)
+void CLogger::addTarget(unique_ptr<ILogTarget> && target)
 {
     TLockGuard _(mx);
     targets.push_back(std::move(target));
 }
 
-ELogLevel::ELogLevel CGLogger::getEffectiveLevel() const
+ELogLevel::ELogLevel CLogger::getEffectiveLevel() const
 {
-    for(const CGLogger * logger = this; logger != nullptr; logger = logger->parent)
+	for(const CLogger * logger = this; logger != nullptr; logger = logger->parent)
     {
         if(logger->getLevel() != ELogLevel::NOT_SET) return logger->getLevel();
     }
@@ -191,10 +191,10 @@ ELogLevel::ELogLevel CGLogger::getEffectiveLevel() const
     return ELogLevel::INFO;
 }
 
-void CGLogger::callTargets(const LogRecord & record) const
+void CLogger::callTargets(const LogRecord & record) const
 {
     TLockGuard _(mx);
-    for(const CGLogger * logger = this; logger != nullptr; logger = logger->parent)
+	for(const CLogger * logger = this; logger != nullptr; logger = logger->parent)
     {
         BOOST_FOREACH(auto & target, logger->targets)
         {
@@ -203,18 +203,18 @@ void CGLogger::callTargets(const LogRecord & record) const
     }
 }
 
-void CGLogger::clearTargets()
+void CLogger::clearTargets()
 {
     TLockGuard _(mx);
     targets.clear();
 }
 
-bool CGLogger::isDebugEnabled() const
+bool CLogger::isDebugEnabled() const
 {
     return getEffectiveLevel() <= ELogLevel::DEBUG;
 }
 
-bool CGLogger::isTraceEnabled() const
+bool CLogger::isTraceEnabled() const
 {
     return getEffectiveLevel() <= ELogLevel::TRACE;
 }
@@ -241,13 +241,13 @@ CLogManager::~CLogManager()
     }
 }
 
-void CLogManager::addLogger(CGLogger * logger)
+void CLogManager::addLogger(CLogger * logger)
 {
     TLockGuard _(mx);
     loggers[logger->getDomain().getName()] = logger;
 }
 
-CGLogger * CLogManager::getLogger(const CLoggerDomain & domain)
+CLogger * CLogManager::getLogger(const CLoggerDomain & domain)
 {
     TLockGuard _(mx);
     auto it = loggers.find(domain.getName());

lib/logging/CNewLogger.h → lib/logging/CLogger.h

@@ -11,7 +11,9 @@
 
 #pragma once
 
-class CGLogger;
+#include "../CConsoleHandler.h"
+
+class CLogger;
 struct LogRecord;
 class ILogTarget;
 
@@ -50,7 +52,7 @@ private:
 class DLL_LINKAGE CLoggerStream
 {
 public:
-    CLoggerStream(const CGLogger & logger, ELogLevel::ELogLevel level);
+    CLoggerStream(const CLogger & logger, ELogLevel::ELogLevel level);
     ~CLoggerStream();
 
     template<typename T>
@@ -62,14 +64,13 @@ public:
     }
 
 private:
-    const CGLogger & logger;
+    const CLogger & logger;
     ELogLevel::ELogLevel level;
     std::stringstream * sbuffer;
 };
 
-/// The class CGLogger is used to log messages to certain targets of a specific domain/name.
-/// Temporary name is CGLogger, should be renamed to CLogger after refactoring.
-class DLL_LINKAGE CGLogger
+/// The class CLogger is used to log messages to certain targets of a specific domain/name.
+class DLL_LINKAGE CLogger
 {
 public:
     inline ELogLevel::ELogLevel getLevel() const;
@@ -77,8 +78,8 @@ public:
     const CLoggerDomain & getDomain() const;
 
     /// Logger access methods
-    static CGLogger * getLogger(const CLoggerDomain & domain);
-    static CGLogger * getGlobalLogger();
+    static CLogger * getLogger(const CLoggerDomain & domain);
+    static CLogger * getGlobalLogger();
 
     /// Log methods for various log levels
     void trace(const std::string & message) const;
@@ -107,23 +108,23 @@ public:
     bool isTraceEnabled() const;
 
 private:
-    explicit CGLogger(const CLoggerDomain & domain);
-    CGLogger * getParent() const;
+    explicit CLogger(const CLoggerDomain & domain);
+    CLogger * getParent() const;
     inline ELogLevel::ELogLevel getEffectiveLevel() const; /// Returns the log level applied on this logger whether directly or indirectly.
     inline void callTargets(const LogRecord & record) const;
 
     CLoggerDomain domain;
-    CGLogger * parent;
+    CLogger * parent;
     ELogLevel::ELogLevel level;
     std::list<unique_ptr<ILogTarget> > targets;
     mutable boost::mutex mx;
     static boost::recursive_mutex smx;
 };
 
-extern DLL_LINKAGE CGLogger * logGlobal;
-extern DLL_LINKAGE CGLogger * logBonus;
-extern DLL_LINKAGE CGLogger * logNetwork;
-extern DLL_LINKAGE CGLogger * logAi;
+extern DLL_LINKAGE CLogger * logGlobal;
+extern DLL_LINKAGE CLogger * logBonus;
+extern DLL_LINKAGE CLogger * logNetwork;
+extern DLL_LINKAGE CLogger * logAi;
 
 /// Macros for tracing the control flow of the application conveniently. If the TRACE_BEGIN macro is used it should be the first statement in the function, whereas
 /// the TRACE_END should be last one before a return statement. Logging traces via this macro have almost no impact when the trace is disabled.
@@ -142,14 +143,14 @@ class DLL_LINKAGE CLogManager : public boost::noncopyable
 public:
     static CLogManager & get();
 
-    void addLogger(CGLogger * logger);
-    CGLogger * getLogger(const CLoggerDomain & domain); /// Returns a logger or nullptr if no one is registered for the given domain.
+    void addLogger(CLogger * logger);
+    CLogger * getLogger(const CLoggerDomain & domain); /// Returns a logger or nullptr if no one is registered for the given domain.
 
 private:
     CLogManager();
     ~CLogManager();
 
-    std::map<std::string, CGLogger *> loggers;
+    std::map<std::string, CLogger *> loggers;
     mutable boost::mutex mx;
     static boost::recursive_mutex smx;
 };

server/CVCMIServer.cpp

@@ -507,9 +507,8 @@ int _tmain(int argc, _TCHAR* argv[])
 int main(int argc, char** argv)
 #endif
 {
-	logfile = new std::ofstream((VCMIDirs::get().localPath() + "/VCMI_Server_log.txt").c_str());
 	console = new CConsoleHandler;
-    CBasicLogConfigurator logConfig(VCMIDirs::get().localPath() + "/VCMI_Server_log2.txt", console);
+	CBasicLogConfigurator logConfig(VCMIDirs::get().localPath() + "/VCMI_Server_log.txt", console);
     logConfig.configureDefault();
 	//boost::thread t(boost::bind(&CConsoleHandler::run,::console));
 	if(argc > 1)
@@ -520,7 +519,7 @@ int main(int argc, char** argv)
 		port = _ttoi(argv[1]);
 #endif
 	}
-	preinitDLL(console,logfile);
+	preinitDLL(console);
     settings.init();
     logConfig.configure();