easylogging++.h

            for (auto&& curr : this->list()) {
                base::utils::safeDelete(curr);
            }
            this->list().clear();
        }
    }

    virtual void unregister(T_Ptr*& ptr) ELPP_FINAL {  // NOLINT
        if (ptr) {
            iterator iter = this->begin();
            for (; iter != this->end(); ++iter) {
                if (ptr == *iter) {
                    break;
                }
            }
            if (iter != this->end() && *iter != nullptr) {
                this->list().erase(iter);
                base::utils::safeDelete(*iter);
            }
        }
    }

    virtual inline void registerNew(T_Ptr* ptr) ELPP_FINAL {
        this->list().push_back(ptr);
    }

    /// @brief Gets pointer from repository with speicifed arguments. Arguments are passed to predicate
    /// in order to validate pointer.
    template <typename T, typename T2>
    inline T_Ptr* get(const T& arg1, const T2 arg2) {
        iterator iter = std::find_if(this->list().begin(), this->list().end(), Pred(arg1, arg2));
        if (iter != this->list().end() && *iter != nullptr) {
            return *iter;
        }
        return nullptr;
    }

private:
    virtual inline void deepCopy(const AbstractRegistry<T_Ptr, std::vector<T_Ptr*>>& sr) {
        for (const_iterator it = sr.list().begin(); it != sr.list().end(); ++it) {
            registerNew(new T_Ptr(**it));
        }
    }
};

}  // namespace utils
} // namespace base
/// @brief Base of Easylogging++ friendly class
///
/// @detail After inheriting this class publicly, implement pure-virtual function `void log(std::ostream&) const`
class Loggable {
public:
    virtual ~Loggable(void) {}
    virtual void log(el::base::type::ostream_t&) const = 0;
private:
    friend inline el::base::type::ostream_t& operator<<(el::base::type::ostream_t& os, const Loggable& loggable) {
        loggable.log(os);
        return os;
    }
};
namespace base {
/// @brief Represents log format containing flags and date format. This is used internally to start initial log
class LogFormat : public Loggable {
public:
    LogFormat(void) :
        m_level(Level::Unknown),
        m_userFormat(base::type::string_t()),
        m_format(base::type::string_t()),
        m_dateTimeFormat(std::string()),
        m_flags(0x0) {
    }

    LogFormat(Level level, const base::type::string_t& format)
            : m_level(level), m_userFormat(format) {
        parseFromFormat(m_userFormat);
    }

    LogFormat(const LogFormat& logFormat) {
        m_level = logFormat.m_level;
        m_userFormat = logFormat.m_userFormat;
        m_format = logFormat.m_format;
        m_dateTimeFormat = logFormat.m_dateTimeFormat;
        m_flags = logFormat.m_flags;
    }

    LogFormat(LogFormat&& logFormat) {
        m_level = std::move(logFormat.m_level);
        m_userFormat = std::move(logFormat.m_userFormat);
        m_format = std::move(logFormat.m_format);
        m_dateTimeFormat = std::move(logFormat.m_dateTimeFormat);
        m_flags = std::move(logFormat.m_flags);
    }

    LogFormat& operator=(const LogFormat& logFormat) {
        m_level = logFormat.m_level;
        m_userFormat = logFormat.m_userFormat;
        m_dateTimeFormat = logFormat.m_dateTimeFormat;
        m_flags = logFormat.m_flags;
        return *this;
    }

    virtual ~LogFormat(void) {
    }

    inline bool operator==(const LogFormat& other) {
        return m_level == other.m_level && m_userFormat == other.m_userFormat && m_format == other.m_format &&
                m_dateTimeFormat == other.m_dateTimeFormat && m_flags == other.m_flags;
    }

    /// @brief Updates format to be used while logging.
    /// @param userFormat User provided format
    void parseFromFormat(const base::type::string_t& userFormat) {
        // We make copy because we will be changing the format
        // i.e, removing user provided date format from original format
        // and then storing it.
        base::type::string_t formatCopy = userFormat;
        m_flags = 0x0;
        auto conditionalAddFlag = [&](const base::type::char_t* specifier, base::FormatFlags flag) {
            std::size_t foundAt = base::type::string_t::npos;
            while ((foundAt = formatCopy.find(specifier, foundAt + 1)) != base::type::string_t::npos){
                if (foundAt > 0 && formatCopy[foundAt - 1] == base::consts::kFormatSpecifierChar) {
                    if (hasFlag(flag)) {
                        // If we already have flag we remove the escape chars so that '%%' is turned to '%'
                        // even after specifier resolution - this is because we only replaceFirst specifier
                        formatCopy.erase(foundAt > 0 ? foundAt - 1 : 0, 1);
                        ++foundAt;
                    }
                } else {
                    if (!hasFlag(flag)) addFlag(flag);
                }
            }
        };  // NOLINT
        conditionalAddFlag(base::consts::kAppNameFormatSpecifier, base::FormatFlags::AppName);
        conditionalAddFlag(base::consts::kSeverityLevelFormatSpecifier, base::FormatFlags::Level);
        conditionalAddFlag(base::consts::kSeverityLevelShortFormatSpecifier, base::FormatFlags::LevelShort);
        conditionalAddFlag(base::consts::kLoggerIdFormatSpecifier, base::FormatFlags::LoggerId);
        conditionalAddFlag(base::consts::kThreadIdFormatSpecifier, base::FormatFlags::ThreadId);
        conditionalAddFlag(base::consts::kLogFileFormatSpecifier, base::FormatFlags::File);
        conditionalAddFlag(base::consts::kLogFileBaseFormatSpecifier, base::FormatFlags::FileBase);
        conditionalAddFlag(base::consts::kLogLineFormatSpecifier, base::FormatFlags::Line);
        conditionalAddFlag(base::consts::kLogLocationFormatSpecifier, base::FormatFlags::Location);
        conditionalAddFlag(base::consts::kLogFunctionFormatSpecifier, base::FormatFlags::Function);
        conditionalAddFlag(base::consts::kCurrentUserFormatSpecifier, base::FormatFlags::User);
        conditionalAddFlag(base::consts::kCurrentHostFormatSpecifier, base::FormatFlags::Host);
        conditionalAddFlag(base::consts::kMessageFormatSpecifier, base::FormatFlags::LogMessage);
        conditionalAddFlag(base::consts::kVerboseLevelFormatSpecifier, base::FormatFlags::VerboseLevel);
        // For date/time we need to extract user's date format first
        std::size_t dateIndex = std::string::npos;
        if ((dateIndex = formatCopy.find(base::consts::kDateTimeFormatSpecifier)) != std::string::npos) {
            while (dateIndex > 0 && formatCopy[dateIndex - 1] == base::consts::kFormatSpecifierChar) {
                dateIndex = formatCopy.find(base::consts::kDateTimeFormatSpecifier, dateIndex + 1);
            }
            if (dateIndex != std::string::npos) {
                addFlag(base::FormatFlags::DateTime);
                updateDateFormat(dateIndex, formatCopy);
            }
        }
        m_format = formatCopy;
        updateFormatSpec();
    }

    inline Level level(void) const {
        return m_level;
    }

    inline const base::type::string_t& userFormat(void) const {
        return m_userFormat;
    }

    inline const base::type::string_t& format(void) const {
       return m_format;
    }

    inline const std::string& dateTimeFormat(void) const {
       return m_dateTimeFormat;
    }

    inline base::type::EnumType flags(void) const {
       return m_flags;
    }

    inline bool hasFlag(base::FormatFlags flag) const {
        return base::utils::hasFlag(flag, m_flags);
    }

    virtual void log(el::base::type::ostream_t& os) const {
        os << m_format;
    }

protected:
    /// @brief Updates date time format if available in currFormat.
    /// @param index Index where %datetime, %date or %time was found
    /// @param [in,out] currFormat current format that is being used to format
    virtual void updateDateFormat(std::size_t index, base::type::string_t& currFormat) ELPP_FINAL {  // NOLINT
        if (hasFlag(base::FormatFlags::DateTime)) {
            index += ELPP_STRLEN(base::consts::kDateTimeFormatSpecifier);
        }
        const base::type::char_t* ptr = currFormat.c_str() + index;
        if ((currFormat.size() > index) && (ptr[0] == '{')) {
            // User has provided format for date/time
            ++ptr;
            int count = 1;  // Start by 1 in order to remove starting brace
            std::stringstream ss;
            for (; *ptr; ++ptr, ++count) {
                if (*ptr == '}') {
                    ++count;  // In order to remove ending brace
                    break;
                }
                ss << *ptr;
            }
            currFormat.erase(index, count);
            m_dateTimeFormat = ss.str();
        } else {
            // No format provided, use default
            if (hasFlag(base::FormatFlags::DateTime)) {
                m_dateTimeFormat = std::string(base::consts::kDefaultDateTimeFormat);
            }
        }
    }

    /// @brief Updates %level from format. This is so that we dont have to do it at log-writing-time. It uses m_format and m_level
    virtual void updateFormatSpec(void) ELPP_FINAL {
        // Do not use switch over strongly typed enums because Intel C++ compilers dont support them yet.
        if (m_level == Level::Debug) {
            base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier,
                    base::consts::kDebugLevelLogValue);
            base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier,
                    base::consts::kDebugLevelShortLogValue);
        } else if (m_level == Level::Info) {
            base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier,
                    base::consts::kInfoLevelLogValue);
            base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier,
                    base::consts::kInfoLevelShortLogValue);
        } else if (m_level == Level::Warning) {
            base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier,
                    base::consts::kWarningLevelLogValue);
            base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier,
                    base::consts::kWarningLevelShortLogValue);
        } else if (m_level == Level::Error) {
            base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier,
                    base::consts::kErrorLevelLogValue);
            base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier,
                    base::consts::kErrorLevelShortLogValue);
        } else if (m_level == Level::Fatal) {
            base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier,
                    base::consts::kFatalLevelLogValue);
            base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier,
                    base::consts::kFatalLevelShortLogValue);
        } else if (m_level == Level::Verbose) {
            base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier,
                    base::consts::kVerboseLevelLogValue);
            base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier,
                    base::consts::kVerboseLevelShortLogValue);
        } else if (m_level == Level::Trace) {
            base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier,
                    base::consts::kTraceLevelLogValue);
            base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier,
                    base::consts::kTraceLevelShortLogValue);
        }
        if (hasFlag(base::FormatFlags::User)) {
            std::string s = base::utils::s_currentUser;
            base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kCurrentUserFormatSpecifier,
                    base::utils::s_currentUser);
        }
        if (hasFlag(base::FormatFlags::Host)) {
            base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kCurrentHostFormatSpecifier,
                    base::utils::s_currentHost);
        }
        // Ignore Level::Global and Level::Unknown
    }

    inline void addFlag(base::FormatFlags flag) {
        base::utils::addFlag(flag, &m_flags);
    }

private:
    Level m_level;
    base::type::string_t m_userFormat;
    base::type::string_t m_format;
    std::string m_dateTimeFormat;
    base::type::EnumType m_flags;
    friend class el::Logger;  // To resolve loggerId format specifier easily
};
}  // namespace base
/// @brief Resolving function for format specifier
typedef std::function<const char*(void)> FormatSpecifierValueResolver;
/// @brief User-provided custom format specifier
/// @see el::Helpers::installCustomFormatSpecifier
/// @see FormatSpecifierValueResolver
class CustomFormatSpecifier {
public:
    CustomFormatSpecifier(const char* formatSpecifier, const FormatSpecifierValueResolver& resolver) :
        m_formatSpecifier(formatSpecifier), m_resolver(resolver) {}
    inline const char* formatSpecifier(void) const { return m_formatSpecifier; }
    inline const FormatSpecifierValueResolver& resolver(void) const { return m_resolver; }
    inline bool operator==(const char* formatSpecifier) {
        return strcmp(m_formatSpecifier, formatSpecifier) == 0;
    }

private:
    const char* m_formatSpecifier;
    FormatSpecifierValueResolver m_resolver;
};
/// @brief Represents single configuration that has representing level, configuration type and a string based value.
///
/// @detail String based value means any value either its boolean, integer or string itself, it will be embedded inside quotes
/// and will be parsed later.
///
/// Consider some examples below:
///   * el::Configuration confEnabledInfo(el::Level::Info, el::ConfigurationType::Enabled, "true");
///   * el::Configuration confMaxLogFileSizeInfo(el::Level::Info, el::ConfigurationType::MaxLogFileSize, "2048");
///   * el::Configuration confFilenameInfo(el::Level::Info, el::ConfigurationType::Filename, "/var/log/my.log");
class Configuration : public Loggable {
public:
    Configuration(const Configuration& c) :
            m_level(c.m_level),
            m_configurationType(c.m_configurationType),
            m_value(c.m_value) {
    }

    Configuration& operator=(const Configuration& c) {
        m_level = c.m_level;
        m_configurationType = c.m_configurationType;
        m_value = c.m_value;
        return *this;
    }

    virtual ~Configuration(void) {
    }

    /// @brief Full constructor used to sets value of configuration
    Configuration(Level level, ConfigurationType configurationType, const std::string& value) :
        m_level(level),
        m_configurationType(configurationType),
        m_value(value) {
    }

    /// @brief Gets level of current configuration
    inline Level level(void) const {
        return m_level;
    }

    /// @brief Gets configuration type of current configuration
    inline ConfigurationType configurationType(void) const {
        return m_configurationType;
    }

    /// @brief Gets string based configuration value
    inline const std::string& value(void) const {
        return m_value;
    }

    /// @brief Set string based configuration value
    /// @param value Value to set. Values have to be std::string; For boolean values use "true", "false", for any integral values
    ///        use them in quotes. They will be parsed when configuring
    inline void setValue(const std::string& value) {
        m_value = value;
    }

    virtual inline void log(el::base::type::ostream_t& os) const {
        os << LevelHelper::convertToString(m_level)
            << ELPP_LITERAL(" ") << ConfigurationTypeHelper::convertToString(m_configurationType)
            << ELPP_LITERAL(" = ") << m_value.c_str();
    }

    /// @brief Used to find configuration from configuration (pointers) repository. Avoid using it.
    class Predicate {
    public:
        Predicate(Level level, ConfigurationType configurationType) :
            m_level(level),
            m_configurationType(configurationType) {
        }

        inline bool operator()(const Configuration* conf) const {
            return ((conf != nullptr) && (conf->level() == m_level) && (conf->configurationType() == m_configurationType));
        }

    private:
        Level m_level;
        ConfigurationType m_configurationType;
    };

private:
    Level m_level;
    ConfigurationType m_configurationType;
    std::string m_value;
};

/// @brief Thread-safe Configuration repository
///
/// @detail This repository represents configurations for all the levels and configuration type mapped to a value.
class Configurations : public base::utils::RegistryWithPred<Configuration, Configuration::Predicate> {
public:
    /// @brief Default constructor with empty repository
    Configurations(void) :
            m_configurationFile(std::string()),
            m_isFromFile(false) {
    }

    /// @brief Constructor used to set configurations using configuration file.
    /// @param configurationFile Full path to configuration file
    /// @param useDefaultsForRemaining Lets you set the remaining configurations to default.
    /// @param base If provided, this configuration will be based off existing repository that this argument is pointing to.
    /// @see parseFromFile(const std::string&, Configurations* base)
    /// @see setRemainingToDefault()
    Configurations(const std::string& configurationFile, bool useDefaultsForRemaining = true, Configurations* base = nullptr) :
            m_configurationFile(configurationFile),
            m_isFromFile(false) {
        parseFromFile(configurationFile, base);
        if (useDefaultsForRemaining) {
            setRemainingToDefault();
        }
    }

    virtual ~Configurations(void) {
    }

    /// @brief Parses configuration from file.
    /// @param configurationFile Full path to configuration file
    /// @param base Configurations to base new configuration repository off. This value is used when you want to use
    ///        existing Configurations to base all the values and then set rest of configuration via configuration file.
    /// @return True if successfully parsed, false otherwise. You may define '_ELPP_DEBUG_ASSERT_FAILURE' to make sure you
    ///         do not proceed without successful parse.
    inline bool parseFromFile(const std::string& configurationFile, Configurations* base = nullptr) {
        bool assertionPassed = false;
        ELPP_ASSERT((assertionPassed = base::utils::File::pathExists(configurationFile.c_str(), true)),
                "Configuration file [" << configurationFile << "] does not exist!");
        if (!assertionPassed) {
            return false;
        }
        bool success = Parser::parseFromFile(configurationFile, this, base);
        m_isFromFile = success;
        return success;
    }

    /// @brief Parse configurations from configuration string.
    ///
    /// @detail This configuration string has same syntax as configuration file contents. Make sure all the necessary
    /// new line characters are provided.
    /// @param base Configurations to base new configuration repository off. This value is used when you want to use
    ///        existing Configurations to base all the values and then set rest of configuration via configuration text.
    /// @return True if successfully parsed, false otherwise. You may define '_ELPP_DEBUG_ASSERT_FAILURE' to make sure you
    ///         do not proceed without successful parse.
    inline bool parseFromText(const std::string& configurationsString, Configurations* base = nullptr) {
        bool success = Parser::parseFromText(configurationsString, this, base);
        if (success) {
            m_isFromFile = false;
        }
        return success;
    }

    /// @brief Sets configuration based-off an existing configurations.
    /// @param base Pointer to existing configurations.
    inline void setFromBase(Configurations* base) {
        if (base == nullptr || base == this) {
            return;
        }
        base::threading::ScopedLock scopedLock(base->lock());
        for (Configuration*& conf : base->list()) {
            set(conf);
        }
    }

    /// @brief Determines whether or not specified configuration type exists in the repository.
    ///
    /// @detail Returns as soon as first level is found.
    /// @param configurationType Type of configuration to check existence for.
    bool hasConfiguration(ConfigurationType configurationType) {
        base::type::EnumType lIndex = LevelHelper::kMinValid;
        bool result = false;
        LevelHelper::forEachLevel(&lIndex, [&](void) -> bool {
            if (hasConfiguration(LevelHelper::castFromInt(lIndex), configurationType)) {
                result = true;
            }
            return result;
        });
        return result;
    }

    /// @brief Determines whether or not specified configuration type exists for specified level
    /// @param level Level to check
    /// @param configurationType Type of configuration to check existence for.
    inline bool hasConfiguration(Level level, ConfigurationType configurationType) {
        base::threading::ScopedLock scopedLock(lock());
#if _ELPP_COMPILER_INTEL
        // We cant specify template types here, Intel C++ throws compilation error
        // "error: type name is not allowed"
        return RegistryWithPred::get(level, configurationType) != nullptr;
#else
        return RegistryWithPred<Configuration, Configuration::Predicate>::get(level, configurationType) != nullptr;
#endif  // _ELPP_COMPILER_INTEL
    }

    /// @brief Sets value of configuration for specified level.
    ///
    /// @detail Any existing configuration for specified level will be replaced. Also note that configuration types
    /// ConfigurationType::MillisecondsWidth and ConfigurationType::PerformanceTracking will be ignored if not set for
    /// Level::Global because these configurations are not dependant on level.
    /// @param level Level to set configuration for (el::Level).
    /// @param configurationType Type of configuration (el::ConfigurationType)
    /// @param value A string based value. Regardless of what the data type of configuration is, it will always be string
    /// from users' point of view. This is then parsed later to be used internally.
    /// @see Configuration::setValue(const std::string& value)
    /// @see el::Level
    /// @see el::ConfigurationType
    inline void set(Level level, ConfigurationType configurationType, const std::string& value) {
        base::threading::ScopedLock scopedLock(lock());
        unsafeSet(level, configurationType, value);  // This is not unsafe anymore as we have locked mutex
        if (level == Level::Global) {
            unsafeSetGlobally(configurationType, value, false);  // Again this is not unsafe either
        }
    }

    /// @brief Sets single configuration based on other single configuration.
    /// @see set(Level level, ConfigurationType configurationType, const std::string& value)
    inline void set(Configuration* conf) {
        if (conf == nullptr) {
            return;
        }
        set(conf->level(), conf->configurationType(), conf->value());
    }

    inline Configuration* get(Level level, ConfigurationType configurationType) {
        base::threading::ScopedLock scopedLock(lock());
        return RegistryWithPred<Configuration, Configuration::Predicate>::get(level, configurationType);
    }

    /// @brief Sets configuration for all levels.
    /// @param configurationType Type of configuration
    /// @param value String based value
    /// @see Configurations::set(Level level, ConfigurationType configurationType, const std::string& value)
    inline void setGlobally(ConfigurationType configurationType, const std::string& value) {
        setGlobally(configurationType, value, false);
    }

    /// @brief Clears repository so that all the configurations are unset
    inline void clear(void) {
        base::threading::ScopedLock scopedLock(lock());
        unregisterAll();
    }

    /// @brief Gets configuration file used in parsing this configurations.
    ///
    /// @detail If this repository was set manually or by text this returns empty string.
    inline const std::string& configurationFile(void) const {
        return m_configurationFile;
    }

    /// @brief Sets configurations to "factory based" configurations.
    void setToDefault(void) {
        setGlobally(ConfigurationType::Enabled, std::string("true"), true);
#if !defined(_ELPP_NO_DEFAULT_LOG_FILE)
        setGlobally(ConfigurationType::Filename, std::string(base::consts::kDefaultLogFile), true);
#else
        _ELPP_UNUSED(base::consts::kDefaultLogFile);
#endif  // !defined(_ELPP_NO_DEFAULT_LOG_FILE)
        setGlobally(ConfigurationType::ToFile, std::string("true"), true);
        setGlobally(ConfigurationType::ToStandardOutput, std::string("true"), true);
        setGlobally(ConfigurationType::MillisecondsWidth, std::string("3"), true);
        setGlobally(ConfigurationType::PerformanceTracking, std::string("true"), true);
        setGlobally(ConfigurationType::MaxLogFileSize, std::string("0"), true);
        setGlobally(ConfigurationType::LogFlushThreshold, std::string("0"), true);

        setGlobally(ConfigurationType::Format, std::string("%datetime %level [%logger] %msg"), true);
        set(Level::Debug, ConfigurationType::Format, std::string("%datetime %level [%logger] [%user@%host] [%func] [%loc] %msg"));
        // INFO and WARNING are set to default by Level::Global
        set(Level::Error, ConfigurationType::Format, std::string("%datetime %level [%logger] %msg"));
        set(Level::Fatal, ConfigurationType::Format, std::string("%datetime %level [%logger] %msg"));
        set(Level::Verbose, ConfigurationType::Format, std::string("%datetime %level-%vlevel [%logger] %msg"));
        set(Level::Trace, ConfigurationType::Format, std::string("%datetime %level [%logger] [%func] [%loc] %msg"));
    }

    /// @brief Lets you set the remaining configurations to default.
    ///
    /// @detail By remaining, it means that the level/type a configuration does not exist for.
    /// This function is useful when you want to minimize chances of failures, e.g, if you have a configuration file that sets
    /// configuration for all the configurations except for Enabled or not, we use this so that ENABLED is set to default i.e,
    /// true. If you dont do this explicitley (either by calling this function or by using second param in Constructor
    /// and try to access a value, an error is thrown
    void setRemainingToDefault(void) {
        base::threading::ScopedLock scopedLock(lock());
        unsafeSetIfNotExist(Level::Global, ConfigurationType::Enabled, std::string("true"));
#if !defined(_ELPP_NO_DEFAULT_LOG_FILE)
        unsafeSetIfNotExist(Level::Global, ConfigurationType::Filename, std::string(base::consts::kDefaultLogFile));
#endif  // !defined(_ELPP_NO_DEFAULT_LOG_FILE)
        unsafeSetIfNotExist(Level::Global, ConfigurationType::ToFile, std::string("true"));
        unsafeSetIfNotExist(Level::Global, ConfigurationType::ToStandardOutput, std::string("true"));
        unsafeSetIfNotExist(Level::Global, ConfigurationType::MillisecondsWidth, std::string("3"));
        unsafeSetIfNotExist(Level::Global, ConfigurationType::PerformanceTracking, std::string("true"));
        unsafeSetIfNotExist(Level::Global, ConfigurationType::MaxLogFileSize, std::string("0"));
        unsafeSetIfNotExist(Level::Global, ConfigurationType::Format, std::string("%datetime %level [%logger] %msg"));
        unsafeSetIfNotExist(Level::Debug, ConfigurationType::Format, 
            std::string("%datetime %level [%logger] [%user@%host] [%func] [%loc] %msg"));
        // INFO and WARNING are set to default by Level::Global
        unsafeSetIfNotExist(Level::Error, ConfigurationType::Format, std::string("%datetime %level [%logger] %msg"));
        unsafeSetIfNotExist(Level::Fatal, ConfigurationType::Format, std::string("%datetime %level [%logger] %msg"));
        unsafeSetIfNotExist(Level::Verbose, ConfigurationType::Format, std::string("%datetime %level-%vlevel [%logger] %msg"));
        unsafeSetIfNotExist(Level::Trace, ConfigurationType::Format, std::string("%datetime %level [%logger] [%func] [%loc] %msg"));
    }

    /// @brief Parser used internally to parse configurations from file or text.
    ///
    /// @detail This class makes use of base::utils::Str.
    /// You should not need this unless you are working on some tool for Easylogging++
    class Parser : base::StaticClass {
    public:
        /// @brief Parses configuration from file.
        /// @param configurationFile Full path to configuration file
        /// @param sender Sender configurations pointer. Usually 'this' is used from calling class
        /// @param base Configurations to base new configuration repository off. This value is used when you want to use
        ///        existing Configurations to base all the values and then set rest of configuration via configuration file.
        /// @return True if successfully parsed, false otherwise. You may define '_STOP_ON_FIRST_ELPP_ASSERTION' to make sure you
        ///         do not proceed without successful parse.
        static bool parseFromFile(const std::string& configurationFile, Configurations* sender, Configurations* base = nullptr) {
            sender->setFromBase(base);
            std::ifstream fileStream_(configurationFile.c_str(), std::ifstream::in);
            ELPP_ASSERT(fileStream_.is_open(), "Unable to open configuration file [" << configurationFile << "] for parsing.");
            bool parsedSuccessfully = false;
            std::string line = std::string();
            Level currLevel = Level::Unknown;
            std::string currConfigStr = std::string();
            std::string currLevelStr = std::string();
            while (fileStream_.good()) {
                std::getline(fileStream_, line);
                parsedSuccessfully = parseLine(&line, &currConfigStr, &currLevelStr, &currLevel, sender);
                ELPP_ASSERT(parsedSuccessfully, "Unable to parse configuration line: " << line);
            }
            return parsedSuccessfully;
        }

        /// @brief Parse configurations from configuration string.
        ///
        /// @detail This configuration string has same syntax as configuration file contents. Make sure all the necessary
        /// new line characters are provided. You may define '_STOP_ON_FIRST_ELPP_ASSERTION' to make sure you
        /// do not proceed without successful parse (This is recommended)
        /// @param configurationsString
        /// @param sender Sender configurations pointer. Usually 'this' is used from calling class
        /// @param base Configurations to base new configuration repository off. This value is used when you want to use
        ///        existing Configurations to base all the values and then set rest of configuration via configuration text.
        /// @return True if successfully parsed, false otherwise.
        static bool parseFromText(const std::string& configurationsString, Configurations* sender, Configurations* base = nullptr) {
            sender->setFromBase(base);
            bool parsedSuccessfully = false;
            std::stringstream ss(configurationsString);
            std::string line = std::string();
            Level currLevel = Level::Unknown;
            std::string currConfigStr = std::string();
            std::string currLevelStr = std::string();
            while (std::getline(ss, line)) {
                parsedSuccessfully = parseLine(&line, &currConfigStr, &currLevelStr, &currLevel, sender);
                ELPP_ASSERT(parsedSuccessfully, "Unable to parse configuration line: " << line);
            }
            return parsedSuccessfully;
        }

    private:
        friend class el::Loggers;
        static void ignoreComments(std::string* line) {
            std::size_t foundAt = 0;
            std::size_t quotesStart = line->find("\"");
            std::size_t quotesEnd = std::string::npos;
            if (quotesStart != std::string::npos) {
                quotesEnd = line->find("\"", quotesStart + 1);
                while (quotesEnd != std::string::npos && line->at(quotesEnd - 1) == '\\') {
                    // Do not erase slash yet - we will erase it in parseLine(..) while loop
                    quotesEnd = line->find("\"", quotesEnd + 2);
                }
            }
            if ((foundAt = line->find(base::consts::kConfigurationComment)) != std::string::npos) {
                if (foundAt < quotesEnd) {
                    foundAt = line->find(base::consts::kConfigurationComment, quotesEnd + 1);
                }
                *line = line->substr(0, foundAt);
            }
        }
        static inline bool isLevel(const std::string& line) {
            return base::utils::Str::startsWith(line, std::string(base::consts::kConfigurationLevel));
        }

        static inline bool isComment(const std::string& line) {
            return base::utils::Str::startsWith(line, std::string(base::consts::kConfigurationComment));
        }

        static inline bool isConfig(const std::string& line) {
            std::size_t assignment = line.find('=');
            return line != "" &&
                    (line[0] >= 65 || line[0] <= 90 || line[0] >= 97 || line[0] <= 122) &&
                    (assignment != std::string::npos) &&
                    (line.size() > assignment);
        }

        static bool parseLine(std::string* line, std::string* currConfigStr, std::string* currLevelStr, Level* currLevel, Configurations* conf) {
            ConfigurationType currConfig = ConfigurationType::Unknown;
            std::string currValue = std::string();
            *line = base::utils::Str::trim(*line);
            if (isComment(*line)) return true;
            ignoreComments(line);
            *line = base::utils::Str::trim(*line);
            if (line->empty()) {
                // Comment ignored
                return true;
            }
            if (isLevel(*line)) {
                if (line->size() <= 2) {
                    return true;
                }
                *currLevelStr = line->substr(1, line->size() - 2);
                *currLevelStr = base::utils::Str::toUpper(*currLevelStr);
                *currLevelStr = base::utils::Str::trim(*currLevelStr);
                *currLevel = LevelHelper::convertFromString(currLevelStr->c_str());
                return true;
            }
            if (isConfig(*line)) {
                std::size_t assignment = line->find('=');
                *currConfigStr = line->substr(0, assignment);
                *currConfigStr = base::utils::Str::toUpper(*currConfigStr);
                *currConfigStr = base::utils::Str::trim(*currConfigStr);
                currConfig = ConfigurationTypeHelper::convertFromString(currConfigStr->c_str());
                currValue = line->substr(assignment + 1);
                currValue = base::utils::Str::trim(currValue);
                std::size_t quotesStart = currValue.find("\"", 0);
                std::size_t quotesEnd = std::string::npos;
                if (quotesStart != std::string::npos) {
                    quotesEnd = currValue.find("\"", quotesStart + 1);
                    while (quotesEnd != std::string::npos && currValue.at(quotesEnd - 1) == '\\') {
                        currValue = currValue.erase(quotesEnd - 1, 1);
                        quotesEnd = currValue.find("\"", quotesEnd + 2);
                    }
                }
                if (quotesStart != std::string::npos && quotesEnd != std::string::npos) {
                    // Quote provided - check and strip if valid
                    ELPP_ASSERT((quotesStart < quotesEnd), "Configuration error - No ending quote found in [" 
                        << currConfigStr << "]");
                    ELPP_ASSERT((quotesStart + 1 != quotesEnd), "Empty configuration value for [" << currConfigStr << "]");
                    if ((quotesStart != quotesEnd) && (quotesStart + 1 != quotesEnd)) {
                        // Explicit check in case if assertion is disabled
                        currValue = currValue.substr(quotesStart + 1, quotesEnd - 1);
                    }
                }
            }
            ELPP_ASSERT(*currLevel != Level::Unknown, "Unrecognized severity level [" << *currLevelStr << "]");
            ELPP_ASSERT(currConfig != ConfigurationType::Unknown, "Unrecognized configuration [" << *currConfigStr << "]");
            if (*currLevel == Level::Unknown || currConfig == ConfigurationType::Unknown) {
                return false;  // unrecognizable level or config
            }
            conf->set(*currLevel, currConfig, currValue);
            return true;
        }
    };

private:
    std::string m_configurationFile;
    bool m_isFromFile;
    friend class el::Loggers;

    /// @brief Unsafely sets configuration if does not already exist
    void unsafeSetIfNotExist(Level level, ConfigurationType configurationType, const std::string& value) {
        Configuration* conf = RegistryWithPred<Configuration, Configuration::Predicate>::get(level, configurationType);
        if (conf == nullptr) {
            unsafeSet(level, configurationType, value);
        }
    }

    /// @brief Thread unsafe set
    void unsafeSet(Level level, ConfigurationType configurationType, const std::string& value) {
        Configuration* conf = RegistryWithPred<Configuration, Configuration::Predicate>::get(level, configurationType);
        if (conf == nullptr) {
            registerNew(new Configuration(level, configurationType, value));
        } else {
            conf->setValue(value);
        }
        if (level == Level::Global) {
            unsafeSetGlobally(configurationType, value, false);
        }
    }

    /// @brief Sets configurations for all levels including Level::Global if includeGlobalLevel is true
    /// @see Configurations::setGlobally(ConfigurationType configurationType, const std::string& value)
    void setGlobally(ConfigurationType configurationType, const std::string& value, bool includeGlobalLevel) {
        if (includeGlobalLevel) {
            set(Level::Global, configurationType, value);
        }
        base::type::EnumType lIndex = LevelHelper::kMinValid;
        LevelHelper::forEachLevel(&lIndex, [&](void) -> bool {
            set(LevelHelper::castFromInt(lIndex), configurationType, value);
            return false;  // Do not break lambda function yet as we need to set all levels regardless
        });
    }

    /// @brief Sets configurations (Unsafely) for all levels including Level::Global if includeGlobalLevel is true
    /// @see Configurations::setGlobally(ConfigurationType configurationType, const std::string& value)
    void unsafeSetGlobally(ConfigurationType configurationType, const std::string& value, bool includeGlobalLevel) {
        if (includeGlobalLevel) {
            unsafeSet(Level::Global, configurationType, value);
        }
        base::type::EnumType lIndex = LevelHelper::kMinValid;
        LevelHelper::forEachLevel(&lIndex, [&](void) -> bool  {
            unsafeSet(LevelHelper::castFromInt(lIndex), configurationType, value);
            return false;  // Do not break lambda function yet as we need to set all levels regardless
        });
    }
};

namespace base {
typedef std::shared_ptr<base::type::fstream_t> FileStreamPtr;
typedef std::map<std::string, FileStreamPtr> LogStreamsReferenceMap;
/// @brief Configurations with data types.
///
/// @detail el::Configurations have string based values. This is whats used internally in order to read correct configurations.
/// This is to perform faster while writing logs using correct configurations.
///
/// This is thread safe and final class containing non-virtual destructor (means nothing should inherit this class)
class TypedConfigurations : public base::threading::ThreadSafe {
public:
    /// @brief Constructor to initialize (construct) the object off el::Configurations
    /// @param configurations Configurations pointer/reference to base this typed configurations off.
    /// @param logStreamsReference Use ELPP->registeredLoggers()->logStreamsReference()
    TypedConfigurations(Configurations* configurations, base::LogStreamsReferenceMap* logStreamsReference) {
        m_configurations = configurations;
        m_logStreamsReference = logStreamsReference;
        build(m_configurations);
    }

    TypedConfigurations(const TypedConfigurations& other) {
        this->m_configurations = other.m_configurations;
        this->m_logStreamsReference = other.m_logStreamsReference;
        build(m_configurations);
    }

    virtual ~TypedConfigurations(void) {
    }

    const Configurations* configurations(void) const {
        return m_configurations;
    }

    inline bool enabled(Level level) {
        return getConfigByVal<bool>(level, &m_enabledMap, "enabled");
    }

    inline bool toFile(Level level) {
        return getConfigByVal<bool>(level, &m_toFileMap, "toFile");
    }

    inline const std::string& filename(Level level) {
        return getConfigByRef<std::string>(level, &m_filenameMap, "filename");
    }

    inline bool toStandardOutput(Level level) {
        return getConfigByVal<bool>(level, &m_toStandardOutputMap, "toStandardOutput");
    }

    inline const base::LogFormat& logFormat(Level level) {
        return getConfigByRef<base::LogFormat>(level, &m_logFormatMap, "logFormat");
    }

    inline const base::MillisecondsWidth& millisecondsWidth(Level level = Level::Global) {
        return getConfigByRef<base::MillisecondsWidth>(level, &m_millisecondsWidthMap, "millisecondsWidth");
    }

    inline bool performanceTracking(Level level = Level::Global) {
        return getConfigByVal<bool>(level, &m_performanceTrackingMap, "performanceTracking");
    }

    inline base::type::fstream_t* fileStream(Level level) {
        return getConfigByRef<base::FileStreamPtr>(level, &m_fileStreamMap, "fileStream").get();
    }

    inline std::size_t maxLogFileSize(Level level) {
        return getConfigByVal<std::size_t>(level, &m_maxLogFileSizeMap, "maxLogFileSize");
    }

    inline std::size_t logFlushThreshold(Level level) {
        return getConfigByVal<std::size_t>(level, &m_logFlushThresholdMap, "logFlushThreshold");
    }

private:
    Configurations* m_configurations;
    std::map<Level, bool> m_enabledMap;
    std::map<Level, bool> m_toFileMap;
    std::map<Level, std::string> m_filenameMap;
    std::map<Level, bool> m_toStandardOutputMap;
    std::map<Level, base::LogFormat> m_logFormatMap;
    std::map<Level, base::MillisecondsWidth> m_millisecondsWidthMap;
    std::map<Level, bool> m_performanceTrackingMap;
    std::map<Level, base::FileStreamPtr> m_fileStreamMap;
    std::map<Level, std::size_t> m_maxLogFileSizeMap;
    std::map<Level, std::size_t> m_logFlushThresholdMap;
    base::LogStreamsReferenceMap* m_logStreamsReference;

    friend class el::Helpers;
    friend class el::base::MessageBuilder;
    friend class el::base::Writer;
    friend class el::base::DefaultLogDispatchCallback;
    friend class el::base::LogDispatcher;

    template <typename Conf_T>
    inline Conf_T getConfigByVal(Level level, const std::map<Level, Conf_T>* confMap, const char* confName) {
        base::threading::ScopedLock scopedLock(lock());
        return unsafeGetConfigByVal(level, confMap, confName);  // This is not unsafe anymore - mutex locked in scope
    }

    template <typename Conf_T>
    inline Conf_T& getConfigByRef(Level level, std::map<Level, Conf_T>* confMap, const char* confName) {
        base::threading::ScopedLock scopedLock(lock());
        return unsafeGetConfigByRef(level, confMap, confName);  // This is not unsafe anymore - mutex locked in scope
    }

    template <typename Conf_T>
    inline Conf_T unsafeGetConfigByVal(Level level, const std::map<Level, Conf_T>* confMap, const char* confName) {
        _ELPP_UNUSED(confName);
        typename std::map<Level, Conf_T>::const_iterator it = confMap->find(level);
        if (it == confMap->end()) {
            try {
                return confMap->at(Level::Global);
            } catch (...) {
                ELPP_INTERNAL_ERROR("Unable to get configuration [" << confName << "] for level [" 
                    << LevelHelper::convertToString(level) << "]"
                        << std::endl << "Please ensure you have properly configured logger.", false);
                return Conf_T();
            }
        }
        return it->second;
    }

    template <typename Conf_T>
    inline Conf_T& unsafeGetConfigByRef(Level level, std::map<Level, Conf_T>* confMap, const char* confName) {
        _ELPP_UNUSED(confName);
        typename std::map<Level, Conf_T>::iterator it = confMap->find(level);
        if (it == confMap->end()) {
            try {
                return confMap->at(Level::Global);
            } catch (...) {
                ELPP_INTERNAL_ERROR("Unable to get configuration [" << confName << "] for level [" 
                    << LevelHelper::convertToString(level) << "]"
                        << std::endl << "Please ensure you have properly configured logger.", false);
            }
        }
        return it->second;
    }

    template <typename Conf_T>
    void setValue(Level level, const Conf_T& value, std::map<Level, Conf_T>* confMap, bool includeGlobalLevel = true) {
        // If map is empty and we are allowed to add into generic level (Level::Global), do it!
        if (confMap->empty() && includeGlobalLevel) {
            confMap->insert(std::make_pair(Level::Global, value));
            return;
        }
        // If same value exist in generic level already, dont add it to explicit level
        typename std::map<Level, Conf_T>::iterator it = confMap->find(Level::Global);
        if (it != confMap->end() && it->second == value) {
            return;
        }
        // Now make sure we dont double up values if we really need to add it to explicit level
        it = confMap->find(level);
        if (it == confMap->end()) {
            // Value not found for level, add new
            confMap->insert(std::make_pair(level, value));
        } else {
            // Value found, just update value
            confMap->at(level) = value;
        }
    }

    void build(Configurations* configurations) {
        base::threading::ScopedLock scopedLock(lock());
        auto getBool = [] (std::string boolStr) -> bool {  // Pass by value for trimming
            base::utils::Str::trim(boolStr);
            return (boolStr == "TRUE" || boolStr == "true" || boolStr == "1");
        };
        std::vector<Configuration*> withFileSizeLimit;
        for (Configurations::const_iterator it = configurations->begin(); it != configurations->end(); ++it) {
            Configuration* conf = *it;
            // We cannot use switch on strong enums because Intel C++ dont support them yet
            if (conf->configurationType() == ConfigurationType::Enabled) {
                setValue(conf->level(), getBool(conf->value()), &m_enabledMap);
            } else if (conf->configurationType() == ConfigurationType::ToFile) {
                setValue(conf->level(), getBool(conf->value()), &m_toFileMap);
            } else if (conf->configurationType() == ConfigurationType::ToStandardOutput) {
                setValue(conf->level(), getBool(conf->value()), &m_toStandardOutputMap);
            } else if (conf->configurationType() == ConfigurationType::Filename) {
            // We do not yet configure filename but we will configure in another
            // loop. This is because if file cannot be created, we will force ToFile
            // to be false. Because configuring logger is not necessarily performance
            // sensative operation, we can live with another loop; (by the way this loop
            // is not very heavy either)
            } else if (conf->configurationType() == ConfigurationType::Format) {
                setValue(conf->level(), base::LogFormat(conf->level(), 
                    base::type::string_t(conf->value().begin(), conf->value().end())), &m_logFormatMap);
            } else if (conf->configurationType() == ConfigurationType::MillisecondsWidth) {
                setValue(Level::Global, 
                    base::MillisecondsWidth(static_cast<int>(getULong(conf->value()))), &m_millisecondsWidthMap);
            } else if (conf->configurationType() == ConfigurationType::PerformanceTracking) {
                setValue(Level::Global, getBool(conf->value()), &m_performanceTrackingMap);
            } else if (conf->configurationType() == ConfigurationType::MaxLogFileSize) {
                setValue(conf->level(), static_cast<std::size_t>(getULong(conf->value())), &m_maxLogFileSizeMap);
#if !defined(_ELPP_NO_DEFAULT_LOG_FILE)
                withFileSizeLimit.push_back(conf);
#endif  // !defined(_ELPP_NO_DEFAULT_LOG_FILE)
            } else if (conf->configurationType() == ConfigurationType::LogFlushThreshold) {