easylogging++.h

namespace internal {
/// @brief Mutex wrapper used when multi-threading is disabled.
class NoMutex : base::NoCopy {
public:
    NoMutex(void) {}
    inline void lock(void) {}
    inline bool try_lock(void) { return true; }
    inline void unlock(void) {}
};
/// @brief Lock guard wrapper used when multi-threading is disabled.
template <typename Mutex>
class NoScopedLock : base::NoCopy {
public:
    explicit NoScopedLock(Mutex&) {
    }
    virtual ~NoScopedLock(void) {
    }
private:
    NoScopedLock(void);
};
}  // namespace internal
static inline std::string getCurrentThreadId(void) {
    return std::string();
}
typedef base::threading::internal::NoMutex Mutex;
typedef base::threading::internal::NoScopedLock<base::threading::Mutex> ScopedLock;
#endif  // _ELPP_THREADING_ENABLED
/// @brief Base of thread safe class, this class is inheritable-only
class ThreadSafe {
public:
    virtual inline void acquireLock(void) ELPP_FINAL { m_mutex.lock(); }
    virtual inline void releaseLock(void) ELPP_FINAL { m_mutex.unlock(); }
    virtual inline base::threading::Mutex& lock(void) ELPP_FINAL { return m_mutex; }
protected:
    ThreadSafe(void) {}
    virtual ~ThreadSafe(void) {}
private:
    base::threading::Mutex m_mutex;
};
}  // namespace threading
namespace utils {
class File : base::StaticClass {
public:
    /// @brief Creates new out file stream for specified filename.
    /// @return Pointer to newly created fstream or nullptr
    static base::type::fstream_t* newFileStream(const std::string& filename) {
        base::type::fstream_t *fs = new base::type::fstream_t(filename.c_str(), 
            base::type::fstream_t::out | base::type::fstream_t::app);
#if defined(_ELPP_UNICODE)
        std::locale elppUnicodeLocale("");
        fs->imbue(elppUnicodeLocale);
#endif  // defined(_ELPP_UNICODE)
        if (fs->is_open()) {
            fs->flush();
        } else {
            base::utils::safeDelete(fs);
            ELPP_INTERNAL_ERROR("Bad file [" << filename << "]", true);
        }
        return fs;
    }

    /// @brief Gets size of file provided in stream
    static std::size_t getSizeOfFile(base::type::fstream_t* fs) {
        if (fs == nullptr) {
            return 0;
        }
        std::streampos currPos = fs->tellg();
        fs->seekg(0, fs->end);
        std::size_t size = static_cast<std::size_t>(fs->tellg());
        fs->seekg(currPos);
        return size;
    }

    /// @brief Determines whether or not provided path exist in current file system
    static inline bool pathExists(const char* path, bool considerFile = false) {
        if (path == nullptr) {
            return false;
        }
#if _ELPP_OS_UNIX
        _ELPP_UNUSED(considerFile);
        struct stat st;
        return (stat(path, &st) == 0);
#elif _ELPP_OS_WINDOWS
        DWORD fileType = GetFileAttributesA(path);
        if (fileType == INVALID_FILE_ATTRIBUTES) {
            return false;
        }
        return considerFile ? true : ((fileType & FILE_ATTRIBUTE_DIRECTORY) == 0 ? false : true);
#endif  // _ELPP_OS_UNIX
    }

    /// @brief Creates specified path on file system
    /// @param path Path to create.
    static bool createPath(const std::string& path) {
        if (path.empty()) {
            return false;
        }
        if (base::utils::File::pathExists(path.c_str())) {
            return true;
        }
        int status = -1;

        char* currPath = const_cast<char*>(path.c_str());
        std::string builtPath = std::string();
#if _ELPP_OS_UNIX
        if (path[0] == '/') {
            builtPath = "/";
        }
        currPath = STRTOK(currPath, base::consts::kFilePathSeperator, 0);
#elif _ELPP_OS_WINDOWS
        // Use secure functions API
        char* nextTok_;
        currPath = STRTOK(currPath, base::consts::kFilePathSeperator, &nextTok_);
        _ELPP_UNUSED(nextTok_);
#endif  // _ELPP_OS_UNIX
        while (currPath != nullptr) {
            builtPath.append(currPath);
            builtPath.append(base::consts::kFilePathSeperator);
#if _ELPP_OS_UNIX
            status = mkdir(builtPath.c_str(), _ELPP_LOG_PERMS);
            currPath = STRTOK(nullptr, base::consts::kFilePathSeperator, 0);
#elif _ELPP_OS_WINDOWS
            status = _mkdir(builtPath.c_str());
            currPath = STRTOK(nullptr, base::consts::kFilePathSeperator, &nextTok_);
#endif  // _ELPP_OS_UNIX
        }
        if (status == -1) {
            ELPP_INTERNAL_ERROR("Error while creating path [" << path << "]", true);
            return false;
        }
        return true;
    }
    /// @brief Extracts path of filename with leading slash
    static std::string extractPathFromFilename(const std::string& fullPath,
            const char* seperator = base::consts::kFilePathSeperator) {
        if ((fullPath == "") || (fullPath.find(seperator) == std::string::npos)) {
            return fullPath;
        }
        std::size_t lastSlashAt = fullPath.find_last_of(seperator);
        if (lastSlashAt == 0) {
            return std::string(seperator);
        }
        return fullPath.substr(0, lastSlashAt + 1);
    }
    /// @brief builds stripped filename and puts it in buff
    static void buildStrippedFilename(const char* filename, char buff[], 
            std::size_t limit = base::consts::kSourceFilenameMaxLength) {
        std::size_t sizeOfFilename = strlen(filename);
        if (sizeOfFilename >= limit) {
            filename += (sizeOfFilename - limit);
            if (filename[0] != '.' && filename[1] != '.') {  // prepend if not already
                filename += 3;  // 3 = '..'
                STRCAT(buff, "..", limit);
            }
        }
        STRCAT(buff, filename, limit);
    }
    /// @brief builds base filename and puts it in buff
    static void buildBaseFilename(const std::string& fullPath, char buff[], 
            std::size_t limit = base::consts::kSourceFilenameMaxLength,
            const char* seperator = base::consts::kFilePathSeperator) {
        const char *filename = fullPath.c_str();
        std::size_t lastSlashAt = fullPath.find_last_of(seperator);
        filename += lastSlashAt ? lastSlashAt+1 : 0;
        std::size_t sizeOfFilename = strlen(filename);
        if (sizeOfFilename >= limit) {
            filename += (sizeOfFilename - limit);
            if (filename[0] != '.' && filename[1] != '.') {  // prepend if not already
                filename += 3;  // 3 = '..'
                STRCAT(buff, "..", limit);
            }
        }
        STRCAT(buff, filename, limit);
    }
};
/// @brief String utilities helper class used internally. You should not use it.
class Str : base::StaticClass {
public:
    /// @brief Checks if character is digit. Dont use libc implementation of it to prevent locale issues.
    static inline bool isDigit(char c) {
        return c >= '0' && c <= '9';
    }

    /// @brief Matches wildcards, '*' and '?' only supported.
    static bool wildCardMatch(const char* str, const char* pattern) {
        while (*pattern) {
            switch (*pattern) {
            case '?':
                if (!*str)
                    return false;
                ++str;
                ++pattern;
                break;
            case '*':
                if (wildCardMatch(str, pattern + 1))
                    return true;
                if (*str && wildCardMatch(str + 1, pattern))
                    return true;
                return false;
                break;
            default:
                if (*str++ != *pattern++)
                    return false;
                break;
            }
        }
        return !*str && !*pattern;
    }

    /// @brief Trims string from start
    /// @param [in,out] str String to trim
    static inline std::string& ltrim(std::string& str) {  // NOLINT
        str.erase(str.begin(), std::find_if(str.begin(), str.end(), std::not1(std::ptr_fun<int, int>(&std::isspace))));
        return str;
    }

    /// @brief Trim string from end
    /// @param [in,out] str String to trim
    static inline std::string& rtrim(std::string& str) {  // NOLINT
        str.erase(std::find_if(str.rbegin(), str.rend(), std::not1(std::ptr_fun<int, int>(&std::isspace))).base(), str.end());
        return str;
    }

    /// @brief Trims string from left and right
    /// @param [in,out] str String to trim
    static inline std::string& trim(std::string& str) {  // NOLINT
        return ltrim(rtrim(str));
    }

    /// @brief Determines whether or not str starts with specified string
    /// @param str String to check
    /// @param start String to check against
    /// @return Returns true if starts with specified string, false otherwise
    static inline bool startsWith(const std::string& str, const std::string& start) {
        return (str.length() >= start.length()) && (str.compare(0, start.length(), start) == 0);
    }

    /// @brief Determines whether or not str ends with specified string
    /// @param str String to check
    /// @param end String to check against
    /// @return Returns true if ends with specified string, false otherwise
    static inline bool endsWith(const std::string& str, const std::string& end) {
        return (str.length() >= end.length()) && (str.compare(str.length() - end.length(), end.length(), end) == 0);
    }

    /// @brief Replaces all instances of replaceWhat with 'replaceWith'. Original variable is changed for performance.
    /// @param [in,out] str String to replace from
    /// @param replaceWhat Character to replace
    /// @param replaceWith Character to replace with
    /// @return Modified version of str
    static inline std::string& replaceAll(std::string& str, char replaceWhat, char replaceWith) {  // NOLINT
        std::replace(str.begin(), str.end(), replaceWhat, replaceWith);
        return str;
    }

    /// @brief Replaces all instances of 'replaceWhat' with 'replaceWith'. (String version) Replaces in place
    /// @param str String to replace from
    /// @param replaceWhat Character to replace
    /// @param replaceWith Character to replace with
    /// @return Modified (original) str
    static inline std::string& replaceAll(std::string& str, const std::string& replaceWhat, // NOLINT
            const std::string& replaceWith) {
        if (replaceWhat == replaceWith)
            return str;
        std::size_t foundAt = std::string::npos;
        while ((foundAt = str.find(replaceWhat, foundAt + 1)) != std::string::npos) {
            str.replace(foundAt, replaceWhat.length(), replaceWith);
        }
        return str;
    }

    static void replaceFirstWithEscape(base::type::string_t& str, const base::type::string_t& replaceWhat, // NOLINT
            const base::type::string_t& replaceWith) {
        std::size_t foundAt = base::type::string_t::npos;
        while ((foundAt = str.find(replaceWhat, foundAt + 1)) != base::type::string_t::npos) {
            if (foundAt > 0 && str[foundAt - 1] == base::consts::kFormatSpecifierChar) {
                str.erase(foundAt > 0 ? foundAt - 1 : 0, 1);
                ++foundAt;
            } else {
                str.replace(foundAt, replaceWhat.length(), replaceWith);
                return;
            }
        }
    }
#if defined(_ELPP_UNICODE)
    static void replaceFirstWithEscape(base::type::string_t& str, const base::type::string_t& replaceWhat, // NOLINT
            const std::string& replaceWith) {
        replaceFirstWithEscape(str, replaceWhat, base::type::string_t(replaceWith.begin(), replaceWith.end()));
    }
#endif  // defined(_ELPP_UNICODE)
    /// @brief Converts string to uppercase
    /// @param str String to convert
    /// @return Uppercase string
    static inline std::string& toUpper(std::string& str) {  // NOLINT
        std::transform(str.begin(), str.end(), str.begin(), ::toupper);
        return str;
    }

    /// @brief Compares cstring equality - uses strcmp
    static inline bool cStringEq(const char* s1, const char* s2) {
        if (s1 == nullptr && s2 == nullptr) return true;
        if (s1 == nullptr || s2 == nullptr) return false;
        return strcmp(s1, s2) == 0;
    }

    /// @brief Compares cstring equality (case-insensitive) - uses toupper(char)
    /// Dont use strcasecmp because of CRT (VC++)
    static bool cStringCaseEq(const char* s1, const char* s2) {
        if (s1 == nullptr && s2 == nullptr) return true;
        if (s1 == nullptr || s2 == nullptr) return false;
        if (strlen(s1) != strlen(s2)) return false;
        while (*s1 != '\0' && *s2 != '\0') {
            if (::toupper(*s1) != ::toupper(*s2)) return false;
            ++s1;
            ++s2;
        }
        return true;
    }

    /// @brief Returns true if c exist in str
    static inline bool contains(const char* str, char c) {
        for (; *str; ++str) {
            if (*str == c)
                return true;
        }
        return false;
    }

    static inline char* convertAndAddToBuff(std::size_t n, int len, char* buf, const char* bufLim, bool zeroPadded = true) {
        char localBuff[10] = "";
        char* p = localBuff + sizeof(localBuff) - 2;
        if (n > 0) {
            for (; n > 0 && p > localBuff && len > 0; n /= 10, --len)
                *--p = static_cast<char>(n % 10 + '0');
        } else {
            *--p = '0';
            --len;
        }
        if (zeroPadded)
            while (p > localBuff && len-- > 0) *--p = static_cast<char>('0');
        return addToBuff(p, buf, bufLim);
    }

    static inline char* addToBuff(const char* str, char* buf, const char* bufLim) {
        while ((buf < bufLim) && ((*buf = *str++) != '\0'))
            ++buf;
        return buf;
    }

    static inline char* clearBuff(char buff[], std::size_t lim) {
        STRCPY(buff, "", lim);
        _ELPP_UNUSED(lim);  // For *nix we dont have anything using lim in above STRCPY macro
        return buff;
    }

    /// @brief Converst wchar* to char*
    ///        NOTE: Need to free return value after use!
    static char* wcharPtrToCharPtr(const wchar_t* line) {
        std::size_t len_ = wcslen(line) + 1;
        char* buff_ = static_cast<char*>(malloc(len_ + 1));
#      if _ELPP_OS_UNIX || (_ELPP_OS_WINDOWS && !_ELPP_CRT_DBG_WARNINGS)
        std::wcstombs(buff_, line, len_);
#      elif _ELPP_OS_WINDOWS
        std::size_t convCount_ = 0;
        mbstate_t mbState_;
        ::memset(static_cast<void*>(&mbState_), 0, sizeof(mbState_));
        wcsrtombs_s(&convCount_, buff_, len_, &line, len_, &mbState_);
#      endif  // _ELPP_OS_UNIX || (_ELPP_OS_WINDOWS && !_ELPP_CRT_DBG_WARNINGS)
       return buff_;
    }
};
/// @brief Operating System helper static class used internally. You should not use it.
class OS : base::StaticClass {
public:
#if _ELPP_OS_WINDOWS
    /// @brief Gets environment variables for Windows based OS. 
    ///        We are not using <code>getenv(const char*)</code> because of CRT deprecation
    /// @param varname Variable name to get environment variable value for
    /// @return If variable exist the value of it otherwise nullptr
    static const char* getWindowsEnvironmentVariable(const char* varname) {
        const DWORD bufferLen = 50;
        static char buffer[bufferLen];
        if (GetEnvironmentVariableA(varname, buffer, bufferLen)) {
            return buffer;
        }
        return nullptr;
    }
#endif  // _ELPP_OS_WINDOWS
#if _ELPP_OS_ANDROID
    /// @brief Reads android property value
    static inline std::string getProperty(const char* prop) {
        char propVal[PROP_VALUE_MAX + 1];
        int ret = __system_property_get(prop, propVal);
        return ret == 0 ? std::string() : std::string(propVal);
    }

    /// @brief Reads android device name
    static std::string getDeviceName(void) {
        std::stringstream ss;
        std::string manufacturer = getProperty("ro.product.manufacturer");
        std::string model = getProperty("ro.product.model");
        if (manufacturer.empty() || model.empty()) {
            return std::string();
        }
        ss << manufacturer << "-" << model;
        return ss.str();
    }
#endif  // _ELPP_OS_ANDROID

    /// @brief Runs command on terminal and returns the output.
    ///
    /// @detail This is applicable only on unix based systems, for all other OS, an empty string is returned.
    /// @param command Bash command
    /// @return Result of bash output or empty string if no result found.
    static const std::string getBashOutput(const char* command) {
#if (_ELPP_OS_UNIX && !_ELPP_OS_ANDROID && !_ELPP_CYGWIN)
        if (command == nullptr) {
            return std::string();
        }
        FILE* proc = nullptr;
        if ((proc = popen(command, "r")) == nullptr) {
            ELPP_INTERNAL_ERROR("\nUnable to run command [" << command << "]", true);
            return std::string();
        }
        char hBuff[4096];
        if (fgets(hBuff, sizeof(hBuff), proc) != nullptr) {
            pclose(proc);
            if (hBuff[strlen(hBuff) - 1] == '\n') {
                hBuff[strlen(hBuff) - 1] = '\0';
            }
            return std::string(hBuff);
        }
        return std::string();
#else
        _ELPP_UNUSED(command);
        return std::string();
#endif  // (_ELPP_OS_UNIX && !_ELPP_OS_ANDROID && !_ELPP_CYGWIN)
    }

    /// @brief Gets environment variable. This is cross-platform and CRT safe (for VC++)
    /// @param variableName Environment variable name
    /// @param defaultVal If no environment variable or value found the value to return by default
    /// @param alternativeBashCommand If environment variable not found what would be alternative bash command
    ///        in order to look for value user is looking for. E.g, for 'user' alternative command will 'whoami'
    static std::string getEnvironmentVariable(const char* variableName, const char* defaultVal, const char* alternativeBashCommand = nullptr) {
#if _ELPP_OS_UNIX
        const char* val = getenv(variableName);
#elif _ELPP_OS_WINDOWS
        const char* val = getWindowsEnvironmentVariable(variableName);
#endif  // _ELPP_OS_UNIX
        if ((val == nullptr) || ((strcmp(val, "") == 0))) {
#if _ELPP_OS_UNIX && defined(_ELPP_FORCE_ENV_VAR_FROM_BASH)
           // Try harder on unix-based systems
            std::string valBash = base::utils::OS::getBashOutput(alternativeBashCommand);
            if (valBash.empty()) {
                return std::string(defaultVal);
            } else {
                return valBash;
            }
#elif _ELPP_OS_WINDOWS || _ELPP_OS_UNIX
            _ELPP_UNUSED(alternativeBashCommand);
            return std::string(defaultVal);
#endif  // _ELPP_OS_UNIX && defined(_ELPP_FORCE_ENV_VAR_FROM_BASH)
        }
        return std::string(val);
    }
   /// @brief Gets current username.
    static inline std::string currentUser(void) {
#if _ELPP_OS_UNIX && !_ELPP_OS_ANDROID
        return getEnvironmentVariable("USER", base::consts::kUnknownUser, "whoami");
#elif _ELPP_OS_WINDOWS
        return getEnvironmentVariable("USERNAME", base::consts::kUnknownUser);
#elif _ELPP_OS_ANDROID
        _ELPP_UNUSED(base::consts::kUnknownUser);
        return std::string("android");
#else
        return std::string();
#endif  // _ELPP_OS_UNIX && !_ELPP_OS_ANDROID
    }

    /// @brief Gets current host name or computer name.
    ///
    /// @detail For android systems this is device name with its manufacturer and model seperated by hyphen
    static inline std::string currentHost(void) {
#if _ELPP_OS_UNIX && !_ELPP_OS_ANDROID
        return getEnvironmentVariable("HOSTNAME", base::consts::kUnknownHost, "hostname");
#elif _ELPP_OS_WINDOWS
        return getEnvironmentVariable("COMPUTERNAME", base::consts::kUnknownHost);
#elif _ELPP_OS_ANDROID
        _ELPP_UNUSED(base::consts::kUnknownHost);
        return getDeviceName();
#else
        return std::string();
#endif  // _ELPP_OS_UNIX && !_ELPP_OS_ANDROID
    }
    /// @brief Whether or not terminal supports colors
    static inline bool termSupportsColor(void) {
        std::string term = getEnvironmentVariable("TERM", "");
        return term == "xterm" || term == "xterm-color" || term == "xterm-256color" ||
                              term == "screen" || term == "linux" || term == "cygwin";
    }
};
extern std::string s_currentUser;
extern std::string s_currentHost;
extern bool s_termSupportsColor;
#define _ELPP_INITI_BASIC_DECLR \
    namespace el {\
        namespace base {\
            namespace utils {\
                std::string s_currentUser = el::base::utils::OS::currentUser(); \
                std::string s_currentHost = el::base::utils::OS::currentHost(); \
                bool s_termSupportsColor = el::base::utils::OS::termSupportsColor(); \
            }\
        }\
   }
/// @brief Contains utilities for cross-platform date/time. This class make use of el::base::utils::Str
class DateTime : base::StaticClass {
public:
    /// @brief Cross platform gettimeofday for Windows and unix platform. This can be used to determine current millisecond.
    ///
    /// @detail For unix system it uses gettimeofday(timeval*, timezone*) and for Windows, a seperate implementation is provided
    /// @param [in,out] tv Pointer that gets updated
    static void gettimeofday(struct timeval* tv) {
#if _ELPP_OS_WINDOWS
        if (tv != nullptr) {
#   if _ELPP_COMPILER_MSVC || defined(_MSC_EXTENSIONS)
            const unsigned __int64 delta_ = 11644473600000000Ui64;
#   else
            const unsigned __int64 delta_ = 11644473600000000ULL;
#   endif  // _ELPP_COMPILER_MSVC || defined(_MSC_EXTENSIONS)
            const double secOffSet = 0.000001;
            const unsigned long usecOffSet = 1000000;  // NOLINT
            FILETIME fileTime;
            GetSystemTimeAsFileTime(&fileTime);
            unsigned __int64 present = 0;
            present |= fileTime.dwHighDateTime;
            present = present << 32;
            present |= fileTime.dwLowDateTime;
            present /= 10;  // mic-sec
           // Subtract the difference
            present -= delta_;
            tv->tv_sec = static_cast<long>(present * secOffSet);  // NOLINT
            tv->tv_usec = static_cast<long>(present % usecOffSet);  // NOLINT
        }
#else
        ::gettimeofday(tv, nullptr);
#endif  // _ELPP_OS_WINDOWS
    }

    /// @brief Gets current date and time with milliseconds.
    /// @param format User provided date/time format
    /// @param msWidth A pointer to base::MillisecondsWidth from configuration (non-null)
    /// @returns string based date time in specified format.
    static inline std::string getDateTime(const char* format, const base::MillisecondsWidth* msWidth) {
        struct timeval currTime;
        gettimeofday(&currTime);
        struct ::tm timeInfo;
        buildTimeInfo(&currTime, &timeInfo);
        const int kBuffSize = 30;
        char buff_[kBuffSize] = "";
        parseFormat(buff_, kBuffSize, format, &timeInfo, static_cast<std::size_t>(currTime.tv_usec / msWidth->m_offset), msWidth);
        return std::string(buff_);
    }

    /// @brief Formats time to get unit accordingly, units like second if > 1000 or minutes if > 60000 etc
    static base::type::string_t formatTime(unsigned long long time, base::TimestampUnit timestampUnit) {  // NOLINT
        double result = static_cast<double>(time);
        base::type::EnumType start = static_cast<base::type::EnumType>(timestampUnit);
        const base::type::char_t* unit = base::consts::kTimeFormats[start].unit;
        for (base::type::EnumType i = start; i < base::consts::kTimeFormatsCount - 1; ++i) {
            if (result <= base::consts::kTimeFormats[i].value) {
                break;
            }
            result /= base::consts::kTimeFormats[i].value;
            unit = base::consts::kTimeFormats[i + 1].unit;
        }
        base::type::stringstream_t ss;
        ss << result << " " << unit;
        return ss.str();
    }

    /// @brief Gets time difference in milli/micro second depending on timestampUnit
    static inline unsigned long long getTimeDifference(const struct timeval& endTime, const struct timeval& startTime, base::TimestampUnit timestampUnit) {  // NOLINT
        if (timestampUnit == base::TimestampUnit::Microsecond) {
            return static_cast<unsigned long long>(static_cast<unsigned long long>(1000000 * endTime.tv_sec + endTime.tv_usec) -  // NOLINT
                    static_cast<unsigned long long>(1000000 * startTime.tv_sec + startTime.tv_usec));  // NOLINT
        } else {
            return static_cast<unsigned long long>((((endTime.tv_sec - startTime.tv_sec) * 1000000) + (endTime.tv_usec - startTime.tv_usec)) / 1000);  // NOLINT
        }
    }

private:
    static inline struct ::tm* buildTimeInfo(struct timeval* currTime, struct ::tm* timeInfo) {
#if _ELPP_OS_UNIX
        time_t rawTime = currTime->tv_sec;
        ::localtime_r(&rawTime, timeInfo);
        return timeInfo;
#else
#   if _ELPP_COMPILER_MSVC
        _ELPP_UNUSED(currTime);
        time_t t;
        _time64(&t);
        localtime_s(timeInfo, &t);
        return timeInfo;
#   else
        // For any other compilers that don't have CRT warnings issue e.g, MinGW or TDM GCC- we use different method
        time_t rawTime = currTime->tv_sec;  // NOLINT
        struct tm* tmInf = localtime(&rawTime);  // NOLINT
        *timeInfo = *tmInf;
        return timeInfo;
#   endif  // _ELPP_COMPILER_MSVC
#endif  // _ELPP_OS_UNIX
    }
    static char* parseFormat(char* buf, std::size_t bufSz, const char* format, const struct tm* tInfo,
            std::size_t msec, const base::MillisecondsWidth* msWidth) {
        const char* bufLim = buf + bufSz;
        for (; *format; ++format) {
            if (*format == base::consts::kFormatSpecifierChar) {
                switch (*++format) {
                case base::consts::kFormatSpecifierChar:  // Escape
                    break;
                case '\0':  // End
                    --format;
                    break;
                case 'd':  // Day
                    buf = base::utils::Str::convertAndAddToBuff(tInfo->tm_mday, 2, buf, bufLim);
                    continue;
                case 'a':  // Day of week (short)
                    buf = base::utils::Str::addToBuff(base::consts::kDaysAbbrev[tInfo->tm_wday], buf, bufLim);
                    continue;
                case 'A':  // Day of week (long)
                    buf = base::utils::Str::addToBuff(base::consts::kDays[tInfo->tm_wday], buf, bufLim);
                    continue;
                case 'M':  // month
                    buf = base::utils::Str::convertAndAddToBuff(tInfo->tm_mon + 1, 2, buf, bufLim);
                    continue;
                case 'b':  // month (short)
                    buf = base::utils::Str::addToBuff(base::consts::kMonthsAbbrev[tInfo->tm_mon], buf, bufLim);
                    continue;
                case 'B':  // month (long)
                    buf = base::utils::Str::addToBuff(base::consts::kMonths[tInfo->tm_mon], buf, bufLim);
                    continue;
                case 'y':  // year (two digits)
                    buf = base::utils::Str::convertAndAddToBuff(tInfo->tm_year + base::consts::kYearBase, 2, buf, bufLim);
                    continue;
                case 'Y':  // year (four digits)
                    buf = base::utils::Str::convertAndAddToBuff(tInfo->tm_year + base::consts::kYearBase, 4, buf, bufLim);
                    continue;
                case 'h':  // hour (12-hour)
                    buf = base::utils::Str::convertAndAddToBuff(tInfo->tm_hour % 12, 2, buf, bufLim);
                    continue;
                case 'H':  // hour (24-hour)
                    buf = base::utils::Str::convertAndAddToBuff(tInfo->tm_hour, 2, buf, bufLim);
                    continue;
                case 'm':  // minute
                    buf = base::utils::Str::convertAndAddToBuff(tInfo->tm_min, 2, buf, bufLim);
                    continue;
                case 's':  // second
                    buf = base::utils::Str::convertAndAddToBuff(tInfo->tm_sec, 2, buf, bufLim);
                    continue;
                case 'z':  // milliseconds
                case 'g':
                    buf = base::utils::Str::convertAndAddToBuff(msec, msWidth->m_width, buf, bufLim);
                    continue;
                case 'F':  // AM/PM
                    buf = base::utils::Str::addToBuff((tInfo->tm_hour >= 12) ? base::consts::kPm : base::consts::kAm, buf, bufLim);
                    continue;
                default:
                    continue;
                }
            }
            if (buf == bufLim) break;
            *buf++ = *format;
        }
        return buf;
    }
};
/// @brief Command line arguments for application if specified using el::Helpers::setArgs(..) or _START_EASYLOGGINGPP(..)
class CommandLineArgs {
public:
    CommandLineArgs(void) {
        setArgs(0, static_cast<char**>(nullptr));
    }
    CommandLineArgs(int argc, const char** argv) {
        setArgs(argc, argv);
    }
    CommandLineArgs(int argc, char** argv) {
        setArgs(argc, argv);
    }
    virtual ~CommandLineArgs(void) {}
    /// @brief Sets arguments and parses them
    inline void setArgs(int argc, const char** argv) {
        setArgs(argc, const_cast<char**>(argv));
    }
    /// @brief Sets arguments and parses them
    inline void setArgs(int argc, char** argv) {
        m_params.clear();
        m_paramsWithValue.clear();
        if (argc == 0 || argv == nullptr) {
            return;
        }
        m_argc = argc;
        m_argv = argv;
        for (int i = 1; i < m_argc; ++i) {
            const char* v = (strstr(m_argv[i], "="));
            if (v != nullptr && strlen(v) > 0) {
                std::string key = std::string(m_argv[i]);
                key = key.substr(0, key.find_first_of('='));
                if (hasParamWithValue(key.c_str())) {
                    ELPP_INTERNAL_INFO(1, "Skipping [" << key << "] arg since it already has value [" 
                        << getParamValue(key.c_str()) << "]");
                } else {
                    m_paramsWithValue.insert(std::make_pair(key, std::string(v + 1)));
                }
            }
            if (v == nullptr) {
                if (hasParam(m_argv[i])) {
                    ELPP_INTERNAL_INFO(1, "Skipping [" << m_argv[i] << "] arg since it already exists");
                } else {
                    m_params.push_back(std::string(m_argv[i]));
                }
            }
        }
    }
    /// @brief Returns true if arguments contain paramKey with a value (seperated by '=')
    inline bool hasParamWithValue(const char* paramKey) const {
        return m_paramsWithValue.find(std::string(paramKey)) != m_paramsWithValue.end();
    }
    /// @brief Returns value of arguments
    /// @see hasParamWithValue(const char*)
    inline const char* getParamValue(const char* paramKey) const {
        return m_paramsWithValue.find(std::string(paramKey))->second.c_str();
    }
    /// @brief Return true if arguments has a param (not having a value) i,e without '='
    inline bool hasParam(const char* paramKey) const {
        return std::find(m_params.begin(), m_params.end(), std::string(paramKey)) != m_params.end();
    }
    /// @brief Returns true if no params available. This exclude argv[0]
    inline bool empty(void) const {
        return m_params.empty() && m_paramsWithValue.empty();
    }
    /// @brief Returns total number of arguments. This exclude argv[0]
    inline std::size_t size(void) const {
        return m_params.size() + m_paramsWithValue.size();
    }
    inline friend base::type::ostream_t& operator<<(base::type::ostream_t& os, const CommandLineArgs& c) {
        for (int i = 1; i < c.m_argc; ++i) {
            os << ELPP_LITERAL("[") << c.m_argv[i] << ELPP_LITERAL("]");
            if (i < c.m_argc - 1) {
                os << ELPP_LITERAL(" ");
            }
        }
        return os;
    }

private:
    int m_argc;
    char** m_argv;
    std::map<std::string, std::string> m_paramsWithValue;
    std::vector<std::string> m_params;
};
/// @brief Abstract registry (aka repository) that provides basic interface for pointer repository specified by T_Ptr type.
///
/// @detail Most of the functions are virtual final methods but anything implementing this abstract class should implement
/// unregisterAll() and deepCopy(const AbstractRegistry<T_Ptr, Container>&) and write registerNew() method according to container
/// and few more methods; get() to find element, unregister() to unregister single entry.
/// Please note that this is thread-unsafe and should also implement thread-safety mechanisms in implementation.
template <typename T_Ptr, typename Container>
class AbstractRegistry : public base::threading::ThreadSafe {
public:
    typedef typename Container::iterator iterator;
    typedef typename Container::const_iterator const_iterator;

    /// @brief Default constructor
    AbstractRegistry(void) {}

    /// @brief Move constructor that is useful for base classes
    AbstractRegistry(AbstractRegistry&& sr) {
        if (this == &sr) {
            return;
        }
        unregisterAll();
        m_list = std::move(sr.m_list);
    }

    bool operator==(const AbstractRegistry<T_Ptr, Container>& other) {
        if (size() != other.size()) {
            return false;
        }
        for (std::size_t i = 0; i < m_list.size(); ++i) {
            if (m_list.at(i) != other.m_list.at(i)) {
                return false;
            }
        }
        return true;
    }

    bool operator!=(const AbstractRegistry<T_Ptr, Container>& other) {
        if (size() != other.size()) {
            return true;
        }
        for (std::size_t i = 0; i < m_list.size(); ++i) {
            if (m_list.at(i) != other.m_list.at(i)) {
                return true;
            }
        }
        return false;
    }

    /// @brief Assignment move operator
    AbstractRegistry& operator=(AbstractRegistry&& sr) {
        if (this == &sr) {
            return *this;
        }
        unregisterAll();
        m_list = std::move(sr.m_list);
        return *this;
    }

    virtual ~AbstractRegistry(void) {
    }

    /// @return Iterator pointer from start of repository
    virtual inline iterator begin(void) ELPP_FINAL {
        return m_list.begin();
    }

    /// @return Iterator pointer from end of repository
    virtual inline iterator end(void) ELPP_FINAL {
        return m_list.end();
    }


    /// @return Constant iterator pointer from start of repository
    virtual inline const_iterator cbegin(void) const ELPP_FINAL {
        return m_list.cbegin();
    }

    /// @return End of repository
    virtual inline const_iterator cend(void) const ELPP_FINAL {
        return m_list.cend();
    }

    /// @return Whether or not repository is empty
    virtual inline bool empty(void) const ELPP_FINAL {
        return m_list.empty();
    }

    /// @return Size of repository
    virtual inline std::size_t size(void) const ELPP_FINAL {
        return m_list.size();
    }

    /// @brief Returns underlying container by reference
    virtual inline Container& list(void) ELPP_FINAL {
        return m_list;
    }

    /// @brief Returns underlying container by constant reference.
    virtual inline const Container& list(void) const ELPP_FINAL {
        return m_list;
    }

    /// @brief Unregisters all the pointers from current repository.
    virtual void unregisterAll(void) = 0;

protected:
    virtual void deepCopy(const AbstractRegistry<T_Ptr, Container>&) = 0;
    void reinitDeepCopy(const AbstractRegistry<T_Ptr, Container>& sr) {
        unregisterAll();
        deepCopy(sr);
    }

private:
    Container m_list;
};

/// @brief A pointer registry mechanism to manage memory and provide search functionalities. (non-predicate version)
///
/// @detail NOTE: This is thread-unsafe implementation (although it contains lock function, it does not use these functions)
///         of AbstractRegistry<T_Ptr, Container>. Any implementation of this class should be  
///         explicitly (by using lock functions)
template <typename T_Ptr, typename T_Key = const char*>
class Registry : public AbstractRegistry<T_Ptr, std::map<T_Key, T_Ptr*>> {
public:
    typedef typename Registry<T_Ptr, T_Key>::iterator iterator;
    typedef typename Registry<T_Ptr, T_Key>::const_iterator const_iterator;

    Registry(void) {}

    /// @brief Copy constructor that is useful for base classes. Try to avoid this constructor, use move constructor.
    Registry(const Registry& sr) : AbstractRegistry<T_Ptr, std::vector<T_Ptr*>>() {
        if (this == &sr) {
            return;
        }
        this->reinitDeepCopy(sr);
    }

    /// @brief Assignment operator that unregisters all the existing registeries and deeply copies each of repo element
    /// @see unregisterAll()
    /// @see deepCopy(const AbstractRegistry&)
    Registry& operator=(const Registry& sr) {
        if (this == &sr) {
            return *this;
        }
        this->reinitDeepCopy(sr);
        return *this;
    }

    virtual ~Registry(void) {
        unregisterAll();
    }

protected:
    virtual inline void unregisterAll(void) ELPP_FINAL {
        if (!this->empty()) {
            for (auto&& curr : this->list()) {
                base::utils::safeDelete(curr.second);
            }
            this->list().clear();
        }
    }

    /// @brief Registers new registry to repository.
    virtual inline void registerNew(const T_Key& uniqKey, T_Ptr* ptr) ELPP_FINAL {
        unregister(uniqKey);
        this->list().insert(std::make_pair(uniqKey, ptr));
    }

    /// @brief Unregisters single entry mapped to specified unique key
    inline void unregister(const T_Key& uniqKey) {
        T_Ptr* existing = get(uniqKey);
        if (existing != nullptr) {
            base::utils::safeDelete(existing);
            this->list().erase(uniqKey);
        }
    }

    /// @brief Gets pointer from repository. If none found, nullptr is returned.
    inline T_Ptr* get(const T_Key& uniqKey) {
        iterator it = this->list().find(uniqKey);
        return it == this->list().end()
                ? nullptr
                : it->second;
    }

private:
    virtual inline void deepCopy(const AbstractRegistry<T_Ptr, std::map<T_Key, T_Ptr*>>& sr) ELPP_FINAL {
        for (const_iterator it = sr.cbegin(); it != sr.cend(); ++it) {
            registerNew(it->first, new T_Ptr(*it->second));
        }
    }
};

/// @brief A pointer registry mechanism to manage memory and provide search functionalities. (predicate version)
///
/// @detail NOTE: This is thread-unsafe implementation of AbstractRegistry<T_Ptr, Container>. Any implementation of this class
/// should be made thread-safe explicitly
template <typename T_Ptr, typename Pred>
class RegistryWithPred : public AbstractRegistry<T_Ptr, std::vector<T_Ptr*>> {
public:
    typedef typename RegistryWithPred<T_Ptr, Pred>::iterator iterator;
    typedef typename RegistryWithPred<T_Ptr, Pred>::const_iterator const_iterator;

    RegistryWithPred(void) {
    }

    virtual ~RegistryWithPred(void) {
        unregisterAll();
    }

    /// @brief Copy constructor that is useful for base classes. Try to avoid this constructor, use move constructor.
    RegistryWithPred(const RegistryWithPred& sr) : AbstractRegistry<T_Ptr, std::vector<T_Ptr*>>() {
        if (this == &sr) {
            return;
        }
        this->reinitDeepCopy(sr);
    }

    /// @brief Assignment operator that unregisters all the existing registeries and deeply copies each of repo element
    /// @see unregisterAll()
    /// @see deepCopy(const AbstractRegistry&)
    RegistryWithPred& operator=(const RegistryWithPred& sr) {
        if (this == &sr) {
            return *this;
        }
        this->reinitDeepCopy(sr);
        return *this;
    }

    friend inline base::type::ostream_t& operator<<(base::type::ostream_t& os, const RegistryWithPred& sr) {
        for (const_iterator it = sr.list().begin(); it != sr.list().end(); ++it) {
            os << ELPP_LITERAL("    ") << **it << ELPP_LITERAL("\n");
        }
        return os;
    }

protected:
    virtual inline void unregisterAll(void) ELPP_FINAL {
        if (!this->empty()) {