Merge branch 'master' of github.com:TrinityCore/TrinityCore into mmaps_rw

Conflicts:
	src/server/collision/Management/MMapManager.cpp
	src/server/game/Maps/Map.cpp
	src/server/game/Movement/PathGenerator.cpp

1 files changed, 77 insertions, 40 deletions

diff --git a/src/server/shared/Logging/Log.h b/src/server/shared/Logging/Log.h
index e35e4f3ab7f..0eb54546aab 100644
--- a/src/server/shared/Logging/Log.h
+++ b/src/server/shared/Logging/Log.h
@@ -21,18 +21,21 @@
 
 #include "Define.h"
 #include "Appender.h"
-#include "LogWorker.h"
 #include "Logger.h"
+#include "LogWorker.h"
 #include "Dynamic/UnorderedMap.h"
 
 #include <string>
 #include <ace/Singleton.h>
 
+#define LOGGER_ROOT "root"
+
 class Log
 {
     friend class ACE_Singleton<Log, ACE_Thread_Mutex>;
 
-    typedef UNORDERED_MAP<uint8, Logger> LoggerMap;
+    typedef UNORDERED_MAP<std::string, Logger> LoggerMap;
+    typedef UNORDERED_MAP<std::string, Logger const*> CachedLoggerContainer;
 
     private:
         Log();
@@ -41,36 +44,32 @@ class Log
     public:
         void LoadFromConfig();
         void Close();
-        bool ShouldLog(LogFilterType type, LogLevel level) const;
+        bool ShouldLog(std::string const& type, LogLevel level);
         bool SetLogLevel(std::string const& name, char const* level, bool isLogger = true);
 
-        void outTrace(LogFilterType f, char const* str, ...) ATTR_PRINTF(3, 4);
-        void outDebug(LogFilterType f, char const* str, ...) ATTR_PRINTF(3, 4);
-        void outInfo(LogFilterType f, char const* str, ...) ATTR_PRINTF(3, 4);
-        void outWarn(LogFilterType f, char const* str, ...) ATTR_PRINTF(3, 4);
-        void outError(LogFilterType f, char const* str, ...) ATTR_PRINTF(3, 4);
-        void outFatal(LogFilterType f, char const* str, ...) ATTR_PRINTF(3, 4);
+        void outMessage(std::string const& f, LogLevel level, char const* str, ...) ATTR_PRINTF(4, 5);
 
         void outCommand(uint32 account, const char * str, ...) ATTR_PRINTF(3, 4);
         void outCharDump(char const* str, uint32 account_id, uint32 guid, char const* name);
-        static std::string GetTimestampStr();
 
         void SetRealmId(uint32 id);
 
     private:
-        void vlog(LogFilterType f, LogLevel level, char const* str, va_list argptr);
+        static std::string GetTimestampStr();
+        void vlog(std::string const& f, LogLevel level, char const* str, va_list argptr);
         void write(LogMessage* msg);
 
-        Logger* GetLoggerByType(LogFilterType filter);
+        Logger const* GetLoggerByType(std::string const& type);
         Appender* GetAppenderByName(std::string const& name);
         uint8 NextAppenderId();
-        void CreateAppenderFromConfig(const char* name);
-        void CreateLoggerFromConfig(const char* name);
+        void CreateAppenderFromConfig(std::string const& name);
+        void CreateLoggerFromConfig(std::string const& name);
         void ReadAppendersFromConfig();
         void ReadLoggersFromConfig();
 
         AppenderMap appenders;
         LoggerMap loggers;
+        CachedLoggerContainer cachedLoggers;
         uint8 AppenderId;
 
         std::string m_logsDir;
@@ -79,56 +78,94 @@ class Log
         LogWorker* worker;
 };
 
-inline bool Log::ShouldLog(LogFilterType type, LogLevel level) const
+inline Logger const* Log::GetLoggerByType(std::string const& originalType)
 {
-    LoggerMap::const_iterator it = loggers.find(uint8(type));
-    if (it != loggers.end())
+    // Check if already cached
+    CachedLoggerContainer::const_iterator itCached = cachedLoggers.find(originalType);
+    if (itCached != cachedLoggers.end())
+        return itCached->second;
+
+    Logger const* logger = NULL;
+    std::string type(originalType);
+
+    do
     {
-        LogLevel logLevel = it->second.getLogLevel();
-        return logLevel != LOG_LEVEL_DISABLED && logLevel <= level;
+        // Search for the logger "type.subtype"
+        LoggerMap::const_iterator it = loggers.find(type);
+        if (it == loggers.end())
+        {
+            // Search for the logger "type", if our logger contains '.', otherwise search for LOGGER_ROOT
+            size_t found = type.find_last_of(".");
+            type = found != std::string::npos ? type.substr(0, found) : LOGGER_ROOT;
+        }
+        else
+            logger = &(it->second);
     }
+    while (!logger);
+
+    cachedLoggers[type] = logger;
+    return logger;
+}
 
-    if (type != LOG_FILTER_GENERAL)
-        return ShouldLog(LOG_FILTER_GENERAL, level);
-    else
+inline bool Log::ShouldLog(std::string const& type, LogLevel level)
+{
+    // TODO: Use cache to store "Type.sub1.sub2": "Type" equivalence, should
+    // Speed up in cases where requesting "Type.sub1.sub2" but only configured
+    // Logger "Type"
+
+    Logger const* logger = GetLoggerByType(type);
+    if (!logger)
         return false;
+
+    LogLevel logLevel = logger->getLogLevel();
+    return logLevel != LOG_LEVEL_DISABLED && logLevel <= level;
+}
+
+inline void Log::outMessage(std::string const& filter, LogLevel level, const char * str, ...)
+{
+    va_list ap;
+    va_start(ap, str);
+
+    vlog(filter, level, str, ap);
+
+    va_end(ap);
 }
 
 #define sLog ACE_Singleton<Log, ACE_Thread_Mutex>::instance()
 
-#if COMPILER != COMPILER_MICROSOFT
-#define TC_LOG_MESSAGE_BODY(level__, call__, filterType__, ...)     \
-        do {                                                        \
-            if (sLog->ShouldLog(filterType__, level__))             \
-                sLog->call__(filterType__, __VA_ARGS__);            \
+#if PLATFORM != PLATFORM_WINDOWS
+#define TC_LOG_MESSAGE_BODY(filterType__, level__, ...)                 \
+        do {                                                            \
+            if (sLog->ShouldLog(filterType__, level__))                 \
+                sLog->outMessage(filterType__, level__, __VA_ARGS__);   \
         } while (0)
 #else
-#define TC_LOG_MESSAGE_BODY(level__, call__, filterType__, ...)     \
-        __pragma(warning(push))                                     \
-        __pragma(warning(disable:4127))                             \
-        do {                                                        \
-            if (sLog->ShouldLog(filterType__, level__))             \
-                sLog->call__(filterType__, __VA_ARGS__);            \
-        } while (0)                                                 \
+#define TC_LOG_MESSAGE_BODY(filterType__, level__, ...)                 \
+        __pragma(warning(push))                                         \
+        __pragma(warning(disable:4127))                                 \
+        do {                                                            \
+            if (sLog->ShouldLog(filterType__, level__))                 \
+                sLog->outMessage(filterType__, level__, __VA_ARGS__);   \
+        } while (0)                                                     \
         __pragma(warning(pop))
 #endif
 
 #define TC_LOG_TRACE(filterType__, ...) \
-    TC_LOG_MESSAGE_BODY(LOG_LEVEL_TRACE, outTrace, filterType__, __VA_ARGS__)
+    TC_LOG_MESSAGE_BODY(filterType__, LOG_LEVEL_TRACE, __VA_ARGS__)
 
 #define TC_LOG_DEBUG(filterType__, ...) \
-    TC_LOG_MESSAGE_BODY(LOG_LEVEL_DEBUG, outDebug, filterType__, __VA_ARGS__)
+    TC_LOG_MESSAGE_BODY(filterType__, LOG_LEVEL_DEBUG, __VA_ARGS__)
 
 #define TC_LOG_INFO(filterType__, ...)  \
-    TC_LOG_MESSAGE_BODY(LOG_LEVEL_INFO, outInfo, filterType__, __VA_ARGS__)
+    TC_LOG_MESSAGE_BODY(filterType__, LOG_LEVEL_INFO, __VA_ARGS__)
 
 #define TC_LOG_WARN(filterType__, ...)  \
-    TC_LOG_MESSAGE_BODY(LOG_LEVEL_WARN, outWarn, filterType__, __VA_ARGS__)
+    TC_LOG_MESSAGE_BODY(filterType__, LOG_LEVEL_WARN, __VA_ARGS__)
 
 #define TC_LOG_ERROR(filterType__, ...) \
-    TC_LOG_MESSAGE_BODY(LOG_LEVEL_ERROR, outError, filterType__, __VA_ARGS__)
+    TC_LOG_MESSAGE_BODY(filterType__, LOG_LEVEL_ERROR, __VA_ARGS__)
 
 #define TC_LOG_FATAL(filterType__, ...) \
-    TC_LOG_MESSAGE_BODY(LOG_LEVEL_FATAL, outFatal, filterType__, __VA_ARGS__)
+    TC_LOG_MESSAGE_BODY(filterType__, LOG_LEVEL_FATAL, __VA_ARGS__)
 
 #endif