Functions
bool	IsAppConfig (std::string_view fileName)

bool	IsLoggingSystemOptions (std::string_view optionName)

template<typename Format , typename... Args>
void	PrintError (std::string_view filename, Format &&fmt, Args &&... args)

void	AddKey (std::string const &optionName, std::string const &optionKey, std::string_view fileName, bool isOptional, bool isReload)

bool	ParseFile (std::string const &file, bool isOptional, bool isReload)

bool	LoadFile (std::string const &file, bool isOptional, bool isReload)

std::string	IniKeyToEnvVarKey (std::string const &key)

std::string	GetEnvVarName (std::string const &configName)

Optional< std::string >	EnvVarForIniKey (std::string const &key)

Variables
std::string	_filename

std::vector< std::string >	_additonalFiles

std::vector< std::string >	_args

std::unordered_map< std::string, std::string >	_configOptions

std::unordered_map< std::string, std::string >	_envVarCache

std::mutex	_configLock

Function Documentation

◆ AddKey()

void anonymous_namespace{Config.cpp}::AddKey	(	std::string const &	optionName,
		std::string const &	optionKey,
		std::string_view	fileName,
		bool	isOptional,
		bool	isReload
	)

    {
        auto const& itr = _configOptions.find(optionName);
 
        // Check old option
        if (isOptional && itr == _configOptions.end())
        {
            if (!IsLoggingSystemOptions(optionName) && !isReload)
            {
                PrintError(fileName, "> Config::LoadFile: Found incorrect option '{}' in config file '{}'. Skip", optionName, fileName);
 
#ifdef CONFIG_ABORT_INCORRECT_OPTIONS
                ABORT("> Core can't start if found incorrect options");
#endif
 
                return;
            }
        }
 
        // Check exit option
        if (itr != _configOptions.end())
        {
            _configOptions.erase(optionName);
        }
 
        _configOptions.emplace(optionName, optionKey);
    }

References _configOptions, ABORT, IsLoggingSystemOptions(), and PrintError().

Referenced by ConfigMgr::GetValueDefault< std::string >(), and ParseFile().

◆ EnvVarForIniKey()

Optional< std::string > anonymous_namespace{Config.cpp}::EnvVarForIniKey ( std::string const & key )

    {
        std::string envKey = GetEnvVarName(key);
        char* val = std::getenv(envKey.c_str());
        if (!val)
            return std::nullopt;
 
        return std::string(val);
    }

References GetEnvVarName().

Referenced by GetEnvFromCache().

◆ GetEnvVarName()

std::string anonymous_namespace{Config.cpp}::GetEnvVarName ( std::string const & configName )

    {
        return "AC_" + IniKeyToEnvVarKey(configName);
    }

References IniKeyToEnvVarKey().

Referenced by ConfigMgr::GetValueDefault< std::string >(), and EnvVarForIniKey().

◆ IniKeyToEnvVarKey()

std::string anonymous_namespace{Config.cpp}::IniKeyToEnvVarKey ( std::string const & key )

    {
        std::string result;
 
        const char* str = key.c_str();
        size_t n = key.length();
 
        char curr;
        bool isEnd;
        bool nextIsUpper;
        bool currIsNumeric;
        bool nextIsNumeric;
 
        for (size_t i = 0; i < n; ++i)
        {
            curr = str[i];
            if (curr == ' ' || curr == '.' || curr == '-')
            {
                result += '_';
                continue;
            }
 
            isEnd = i == n - 1;
            if (!isEnd)
            {
                nextIsUpper = isupper(str[i + 1]);
 
                // handle "aB" to "A_B"
                if (!isupper(curr) && nextIsUpper)
                {
                    result += static_cast<char>(std::toupper(curr));
                    result += '_';
                    continue;
                }
 
                currIsNumeric = isNumeric(curr);
                nextIsNumeric = isNumeric(str[i + 1]);
 
                // handle "a1" to "a_1"
                if (!currIsNumeric && nextIsNumeric)
                {
                    result += static_cast<char>(std::toupper(curr));
                    result += '_';
                    continue;
                }
 
                // handle "1a" to "1_a"
                if (currIsNumeric && !nextIsNumeric)
                {
                    result += static_cast<char>(std::toupper(curr));
                    result += '_';
                    continue;
                }
            }
 
            result += static_cast<char>(std::toupper(curr));
        }
        return result;
    }

References isNumeric().

Referenced by GetEnvVarName().

◆ IsAppConfig()

bool anonymous_namespace{Config.cpp}::IsAppConfig ( std::string_view fileName )

    {
        size_t foundAuth = fileName.find("authserver.conf");
        size_t foundWorld = fileName.find("worldserver.conf");
        size_t foundImport = fileName.find("dbimport.conf");
 
        return foundAuth != std::string_view::npos || foundWorld != std::string_view::npos || foundImport != std::string_view::npos;
    }

Referenced by PrintError().

◆ IsLoggingSystemOptions()

bool anonymous_namespace{Config.cpp}::IsLoggingSystemOptions ( std::string_view optionName )

    {
        size_t foundAppender = optionName.find("Appender.");
        size_t foundLogger = optionName.find("Logger.");
 
        return foundAppender != std::string_view::npos || foundLogger != std::string_view::npos;
    }

Referenced by AddKey().

◆ LoadFile()

bool anonymous_namespace{Config.cpp}::LoadFile	(	std::string const &	file,
		bool	isOptional,
		bool	isReload
	)

    {
        try
        {
            return ParseFile(file, isOptional, isReload);
        }
        catch (const std::exception& e)
        {
            PrintError(file, "> {}", e.what());
        }
 
        return false;
    }

References ParseFile(), and PrintError().

◆ ParseFile()

bool anonymous_namespace{Config.cpp}::ParseFile	(	std::string const &	file,
		bool	isOptional,
		bool	isReload
	)

    {
        std::ifstream in(file);
 
        if (in.fail())
        {
            if (isOptional)
            {
                // No display erorr if file optional
                return false;
            }
 
            throw ConfigException(Acore::StringFormatFmt("Config::LoadFile: Failed open {}file '{}'", isOptional ? "optional " : "", file));
        }
 
        uint32 count = 0;
        uint32 lineNumber = 0;
        std::unordered_map<std::string /*name*/, std::string /*value*/> fileConfigs;
 
        auto IsDuplicateOption = [&](std::string const& confOption)
        {
            auto const& itr = fileConfigs.find(confOption);
            if (itr != fileConfigs.end())
            {
                PrintError(file, "> Config::LoadFile: Duplicate key name '{}' in config file '{}'", confOption, file);
                return true;
            }
 
            return false;
        };
 
        while (in.good())
        {
            lineNumber++;
            std::string line;
            std::getline(in, line);
 
            // read line error
            if (!in.good() && !in.eof())
            {
                throw ConfigException(Acore::StringFormatFmt("> Config::LoadFile: Failure to read line number {} in file '{}'", lineNumber, file));
            }
 
            // remove whitespace in line
            line = Acore::String::Trim(line, in.getloc());
 
            if (line.empty())
            {
                continue;
            }
 
            // comments
            if (line[0] == '#' || line[0] == '[')
            {
                continue;
            }
 
            size_t found = line.find_first_of('#');
            if (found != std::string::npos)
            {
                line = line.substr(0, found);
            }
 
            auto const equal_pos = line.find('=');
 
            if (equal_pos == std::string::npos || equal_pos == line.length())
            {
                PrintError(file, "> Config::LoadFile: Failure to read line number {} in file '{}'. Skip this line", lineNumber, file);
                continue;
            }
 
            auto entry = Acore::String::Trim(line.substr(0, equal_pos), in.getloc());
            auto value = Acore::String::Trim(line.substr(equal_pos + 1, std::string::npos), in.getloc());
 
            value.erase(std::remove(value.begin(), value.end(), '"'), value.end());
 
            // Skip if 2+ same options in one config file
            if (IsDuplicateOption(entry))
            {
                continue;
            }
 
            // Add to temp container
            fileConfigs.emplace(entry, value);
            count++;
        }
 
        // No lines read
        if (!count)
        {
            if (isOptional)
            {
                // No display erorr if file optional
                return false;
            }
 
            throw ConfigException(Acore::StringFormatFmt("Config::LoadFile: Empty file '{}'", file));
        }
 
        // Add correct keys if file load without errors
        for (auto const& [entry, key] : fileConfigs)
        {
            AddKey(entry, key, file, isOptional, isReload);
        }
 
        return true;
    }

References AddKey(), PrintError(), Acore::StringFormatFmt(), and Acore::String::Trim().

Referenced by LoadFile().

◆ PrintError()

template<typename Format , typename... Args>

void anonymous_namespace{Config.cpp}::PrintError	(	std::string_view	filename,
		Format &&	fmt,
		Args &&...	args
	)

inline

    {
        std::string message = Acore::StringFormatFmt(std::forward<Format>(fmt), std::forward<Args>(args)...);
 
        if (IsAppConfig(filename))
        {
            fmt::print("{}\n", message);
        }
        else
        {
            LOG_ERROR("server.loading", message);
        }
    }

References IsAppConfig(), LOG_ERROR, and Acore::StringFormatFmt().

Referenced by AddKey(), LoadFile(), and ParseFile().

Variable Documentation

◆ _additonalFiles

std::vector<std::string> anonymous_namespace{Config.cpp}::_additonalFiles

◆ _args

std::vector<std::string> anonymous_namespace{Config.cpp}::_args

◆ _configLock

std::mutex anonymous_namespace{Config.cpp}::_configLock

◆ _configOptions

std::unordered_map<std::string , std::string > anonymous_namespace{Config.cpp}::_configOptions

Referenced by AddKey(), and ConfigMgr::GetValueDefault< std::string >().

◆ _envVarCache

std::unordered_map<std::string , std::string > anonymous_namespace{Config.cpp}::_envVarCache