ConfigValueCache< ConfigEnum > Class Template Reference

#include "ConfigValueCache.h"

Public Types
enum class	Reloadable : bool {   No = false ,   Yes = true }

Public Member Functions
	ConfigValueCache (ConfigEnum const configCount)
void	Initialize (bool reload)
template<class T >
void	SetConfigValue (ConfigEnum const config, std::string const &configName, T const &defaultValue, Reloadable reloadable=Reloadable::Yes, std::function< bool(T const &value)> &&checker={}, std::string const &validationErrorText="")
template<class T >
void	OverwriteConfigValue (ConfigEnum const config, T const &value)
template<class T >
T	GetConfigValue (ConfigEnum const config) const
std::string_view	GetConfigValue (ConfigEnum const config) const

Protected Member Functions
virtual void	BuildConfigCache ()=0

Private Member Functions
void	VerifyAllConfigsLoaded ()

Private Attributes
std::vector< std::variant< std::monostate, float, bool, uint32, std::string > >	_configs
bool	_reloading

Detailed Description

template<typename ConfigEnum>
class ConfigValueCache< ConfigEnum >

Member Enumeration Documentation

Reloadable

template<typename ConfigEnum >

enum class ConfigValueCache::Reloadable : bool

strong

Enumerator
No
Yes

    {
        No = false,
        Yes = true
    };

Constructor & Destructor Documentation

ConfigValueCache()

template<typename ConfigEnum >

ConfigValueCache< ConfigEnum >::ConfigValueCache ( ConfigEnum const  configCount )

inline

    {
        _configs.resize(static_cast<uint32>(configCount));
        _reloading = false;
    }

References ConfigValueCache< ConfigEnum >::_configs, and ConfigValueCache< ConfigEnum >::_reloading.

Member Function Documentation

BuildConfigCache()

template<typename ConfigEnum >

virtual void ConfigValueCache< ConfigEnum >::BuildConfigCache ( )

protectedpure virtual

Implemented in WorldConfig.

Referenced by ConfigValueCache< ConfigEnum >::Initialize().

GetConfigValue() [1/2]

template<typename ConfigEnum >

template<class T >

T ConfigValueCache< ConfigEnum >::GetConfigValue ( ConfigEnum const  config ) const

inline

    {
        uint32 const configIndex = static_cast<uint32>(config);
        ASSERT(configIndex < _configs.size(), "Config index out of bounds");
        ASSERT(_configs[configIndex].index() != 0, "Config value must already be set");
 
        T const* value = std::get_if<T>(&_configs[configIndex]);
        ASSERT(value, "Wrong config variant type");
 
        return *value;
    }

References ConfigValueCache< ConfigEnum >::_configs, and ASSERT.

Referenced by World::getBoolConfig(), World::getFloatConfig(), World::getIntConfig(), and World::getStringConfig().

GetConfigValue() [2/2]

template<typename ConfigEnum >

std::string_view ConfigValueCache< ConfigEnum >::GetConfigValue ( ConfigEnum const  config ) const

inline

    {
        uint32 const configIndex = static_cast<uint32>(config);
        ASSERT(configIndex < _configs.size(), "Config index out of bounds");
        ASSERT(_configs[configIndex].index() != 0, "Config value must already be set");
 
        std::string const* stringValue = std::get_if<std::string>(&_configs[configIndex]);
        ASSERT(stringValue, "Wrong config variant type");
 
        return std::string_view(*stringValue);
    }

References ConfigValueCache< ConfigEnum >::_configs, and ASSERT.

Initialize()

template<typename ConfigEnum >

void ConfigValueCache< ConfigEnum >::Initialize ( bool  reload )

inline

    {
        _reloading = reload;
        BuildConfigCache();
        _reloading = false;
        VerifyAllConfigsLoaded();
    }

References ConfigValueCache< ConfigEnum >::_reloading, ConfigValueCache< ConfigEnum >::BuildConfigCache(), and ConfigValueCache< ConfigEnum >::VerifyAllConfigsLoaded().

Referenced by World::LoadConfigSettings().

OverwriteConfigValue()

template<typename ConfigEnum >

template<class T >

void ConfigValueCache< ConfigEnum >::OverwriteConfigValue ( ConfigEnum const  config, T const &  value  )

inline

    {
        uint32 const configIndex = static_cast<uint32>(config);
        ASSERT(configIndex < _configs.size(), "Config index out of bounds");
        size_t const oldValueTypeIndex = _configs[configIndex].index();
        ASSERT(oldValueTypeIndex != 0, "Config value must already be set");
        _configs[configIndex] = value;
        ASSERT(oldValueTypeIndex == _configs[configIndex].index(), "Config value type changed");
    }

References ConfigValueCache< ConfigEnum >::_configs, and ASSERT.

Referenced by World::LoadConfigSettings(), World::setBoolConfig(), World::setFloatConfig(), World::setIntConfig(), and World::setStringConfig().

SetConfigValue()

template<typename ConfigEnum >

template<class T >

void ConfigValueCache< ConfigEnum >::SetConfigValue ( ConfigEnum const  config, std::string const &  configName, T const &  defaultValue, Reloadable  reloadable = Reloadable::Yes, std::function< bool(T const &value)> &&  checker = {}, std::string const &  validationErrorText = ""  )

inline

                                                                                                                                                                                          {}, std::string const& validationErrorText = "")
    {
        uint32 const configIndex = static_cast<uint32>(config);
        ASSERT(configIndex < _configs.size(), "Config index out of bounds");
        T const& configValue = sConfigMgr->GetOption<T>(configName, defaultValue);
 
        bool configValueChanged = false;
        if (_reloading)
        {
            if (std::get<T>(_configs[configIndex]) != configValue)
                configValueChanged = true;
 
            if (reloadable == Reloadable::No)
            {
                if (configValueChanged)
                    LOG_ERROR("server.loading", "Server Config (Name: {}) cannot be changed by reload. A server restart is required to update this config value.", configName);
                return;
            }
        }
        else
            ASSERT(_configs[configIndex].index() == 0, "Config overwriting an existing value");
 
        if (checker && !checker(configValue))
        {
            LOG_ERROR("server.loading", "Server Config (Name: {}) failed validation check '{}'. Default value '{}' will be used instead.", configName, validationErrorText, defaultValue);
            _configs[configIndex] = defaultValue;
        }
        else
            _configs[configIndex] = configValue;
    }

VerifyAllConfigsLoaded()

template<typename ConfigEnum >

void ConfigValueCache< ConfigEnum >::VerifyAllConfigsLoaded ( )

inlineprivate

    {
        uint32 configIndex = 0;
        for (auto const& variant : _configs)
        {
            if (variant.index() == 0)
            {
                LOG_ERROR("server.loading", "Server Config (Index: {}) is defined but not loaded, unable to continue.", configIndex);
                ASSERT(false);
            }
 
            ++configIndex;
        }
    }

References ConfigValueCache< ConfigEnum >::_configs, ASSERT, and LOG_ERROR.

Referenced by ConfigValueCache< ConfigEnum >::Initialize().

Member Data Documentation

_configs

template<typename ConfigEnum >

std::vector<std::variant<std::monostate, float, bool, uint32, std::string> > ConfigValueCache< ConfigEnum >::_configs

private

Referenced by ConfigValueCache< ConfigEnum >::ConfigValueCache(), ConfigValueCache< ConfigEnum >::GetConfigValue(), ConfigValueCache< ConfigEnum >::OverwriteConfigValue(), and ConfigValueCache< ConfigEnum >::VerifyAllConfigsLoaded().

_reloading

template<typename ConfigEnum >

bool ConfigValueCache< ConfigEnum >::_reloading

private

Referenced by ConfigValueCache< ConfigEnum >::ConfigValueCache(), and ConfigValueCache< ConfigEnum >::Initialize().

---

The documentation for this class was generated from the following file:

• azerothcore-wotlk/src/common/Configuration/ConfigValueCache.h