config/lua: fix device bool int reads (#14313)

* config/lua: fix device bool int reads

* config/lua: fix device typed reads

src/config/lua/ConfigManager.cpp

@@ -712,18 +712,18 @@ ILuaConfigValue* CConfigManager::findDeviceValue(const std::string& dev, const s
 int CConfigManager::getDeviceInt(const std::string& dev, const std::string& field, const std::string& fb) {
     std::string fallback = luaConfigValueName(fb);
     if (auto* v = findDeviceValue(normalizeDeviceName(dev), luaConfigValueName(field)); v && v->setByUser())
-        return (int)*sc<const Config::INTEGER*>(v->data());
+        return v->asInt();
     if (!fallback.empty() && m_configValues.contains(fallback))
-        return (int)*sc<const Config::INTEGER*>(m_configValues.at(fallback)->data());
+        return m_configValues.at(fallback)->asInt();
     return 0;
 }
 
 float CConfigManager::getDeviceFloat(const std::string& dev, const std::string& field, const std::string& fb) {
     std::string fallback = luaConfigValueName(fb);
     if (auto* v = findDeviceValue(normalizeDeviceName(dev), luaConfigValueName(field)); v && v->setByUser())
-        return *sc<const Config::FLOAT*>(v->data());
+        return v->asFloat();
     if (!fallback.empty() && m_configValues.contains(fallback))
-        return *sc<const Config::FLOAT*>(m_configValues.at(fallback)->data());
+        return m_configValues.at(fallback)->asFloat();
     return 0.F;
 }
 
@@ -731,9 +731,9 @@ Vector2D CConfigManager::getDeviceVec(const std::string& dev, const std::string&
     std::string fallback = luaConfigValueName(fb);
     auto        toVec    = [](const Config::VEC2& v) -> Vector2D { return {v.x, v.y}; };
     if (auto* v = findDeviceValue(normalizeDeviceName(dev), luaConfigValueName(field)); v && v->setByUser())
-        return toVec(*sc<const Config::VEC2*>(v->data()));
+        return toVec(v->asVec2());
     if (!fallback.empty() && m_configValues.contains(fallback))
-        return toVec(*sc<const Config::VEC2*>(m_configValues.at(fallback)->data()));
+        return toVec(m_configValues.at(fallback)->asVec2());
     return {0, 0};
 }
 
@@ -741,9 +741,9 @@ std::string CConfigManager::getDeviceString(const std::string& dev, const std::s
     std::string fallback = luaConfigValueName(fb);
     auto        clean    = [](const Config::STRING& s) -> std::string { return s == STRVAL_EMPTY ? "" : s; };
     if (auto* v = findDeviceValue(normalizeDeviceName(dev), luaConfigValueName(field)); v && v->setByUser())
-        return clean(*sc<const Config::STRING*>(v->data()));
+        return clean(v->asString());
     if (!fallback.empty() && m_configValues.contains(fallback))
-        return clean(*sc<const Config::STRING*>(m_configValues.at(fallback)->data()));
+        return clean(m_configValues.at(fallback)->asString());
     return "";
 }
 

src/config/lua/types/LuaConfigBool.cpp

@@ -43,6 +43,10 @@ void CLuaConfigBool::push(lua_State* s) {
     lua_pushboolean(s, m_data);
 }
 
+Config::INTEGER CLuaConfigBool::asInt() {
+    return m_data ? 1 : 0;
+}
+
 const Config::BOOL& CLuaConfigBool::parsed() {
     return m_data;
 }

src/config/lua/types/LuaConfigBool.hpp

@@ -14,6 +14,7 @@ namespace Config::Lua {
         virtual std::string           toString();
         virtual void                  push(lua_State* s);
         virtual void                  reset();
+        virtual Config::INTEGER       asInt();
 
         const Config::BOOL&           parsed();
 

src/config/lua/types/LuaConfigFloat.cpp

@@ -71,6 +71,10 @@ void CLuaConfigFloat::push(lua_State* s) {
     lua_pushnumber(s, m_data);
 }
 
+Config::FLOAT CLuaConfigFloat::asFloat() {
+    return m_data;
+}
+
 const Config::FLOAT& CLuaConfigFloat::parsed() {
     return m_data;
 }

src/config/lua/types/LuaConfigFloat.hpp

@@ -16,6 +16,7 @@ namespace Config::Lua {
         virtual std::string           toString();
         virtual void                  push(lua_State* s);
         virtual void                  reset();
+        virtual Config::FLOAT         asFloat();
 
         const Config::FLOAT&          parsed();
 

src/config/lua/types/LuaConfigInt.cpp

@@ -79,6 +79,10 @@ void CLuaConfigInt::push(lua_State* s) {
     lua_pushinteger(s, m_data);
 }
 
+Config::INTEGER CLuaConfigInt::asInt() {
+    return m_data;
+}
+
 const Config::INTEGER& CLuaConfigInt::parsed() {
     return m_data;
 }

src/config/lua/types/LuaConfigInt.hpp

@@ -19,6 +19,7 @@ namespace Config::Lua {
         virtual std::string           toString();
         virtual void                  push(lua_State* s);
         virtual void                  reset();
+        virtual Config::INTEGER       asInt();
 
         const Config::INTEGER&        parsed();
 

src/config/lua/types/LuaConfigString.cpp

@@ -47,6 +47,10 @@ void CLuaConfigString::push(lua_State* s) {
         lua_pushstring(s, m_data.c_str());
 }
 
+Config::STRING CLuaConfigString::asString() {
+    return m_data;
+}
+
 const Config::STRING& CLuaConfigString::parsed() {
     return m_data;
 }

src/config/lua/types/LuaConfigString.hpp

@@ -18,6 +18,7 @@ namespace Config::Lua {
         virtual std::string           toString();
         virtual void                  push(lua_State* s);
         virtual void                  reset();
+        virtual Config::STRING        asString();
 
         const Config::STRING&         parsed();
 

src/config/lua/types/LuaConfigUtils.hpp

@@ -6,4 +6,4 @@
 
 namespace Config::Lua {
     UP<ILuaConfigValue> fromGenericValue(SP<Config::Values::IValue> v);
-};
+};

src/config/lua/types/LuaConfigValue.cpp

@@ -1,5 +1,7 @@
 #include "LuaConfigValue.hpp"
 
+#include "../../../macros.hpp"
+
 using namespace Config;
 using namespace Config::Lua;
 
@@ -18,3 +20,23 @@ void ILuaConfigValue::setRefreshBits(Supplementary::PropRefreshBits bits) {
 Supplementary::PropRefreshBits ILuaConfigValue::refreshBits() const {
     return m_refreshBits;
 }
+
+Config::INTEGER ILuaConfigValue::asInt() {
+    RASSERT(false, "Lua config value cannot be read as int");
+    return 0;
+}
+
+Config::FLOAT ILuaConfigValue::asFloat() {
+    RASSERT(false, "Lua config value cannot be read as float");
+    return 0.F;
+}
+
+Config::VEC2 ILuaConfigValue::asVec2() {
+    RASSERT(false, "Lua config value cannot be read as vec2");
+    return {};
+}
+
+Config::STRING ILuaConfigValue::asString() {
+    RASSERT(false, "Lua config value cannot be read as string");
+    return {};
+}

src/config/lua/types/LuaConfigValue.hpp

@@ -41,6 +41,10 @@ namespace Config::Lua {
         virtual void                           push(lua_State* s)  = 0;
 
         virtual void                           reset() = 0;
+        virtual Config::INTEGER                asInt();
+        virtual Config::FLOAT                  asFloat();
+        virtual Config::VEC2                   asVec2();
+        virtual Config::STRING                 asString();
         virtual void                           resetSetByUser();
         virtual bool                           setByUser();
         virtual void                           setRefreshBits(Supplementary::PropRefreshBits bits);

src/config/lua/types/LuaConfigVec2.cpp

@@ -91,6 +91,10 @@ void CLuaConfigVec2::push(lua_State* s) {
     lua_setfield(s, -2, "y");
 }
 
+Config::VEC2 CLuaConfigVec2::asVec2() {
+    return m_data;
+}
+
 const Config::VEC2& CLuaConfigVec2::parsed() {
     return m_data;
 }

src/config/lua/types/LuaConfigVec2.hpp

@@ -18,6 +18,7 @@ namespace Config::Lua {
         virtual std::string           toString();
         virtual void                  push(lua_State* s);
         virtual void                  reset();
+        virtual Config::VEC2          asVec2();
 
         const Config::VEC2&           parsed();
 

tests/config/lua/LuaConfigUtils.cpp

@@ -103,3 +103,22 @@ TEST(ConfigLuaUtils, fromGenericValueCopiesRefreshBits) {
     ASSERT_NE(out.get(), nullptr);
     EXPECT_EQ(out->refreshBits(), REFRESH);
 }
+
+TEST(ConfigLuaUtils, typedAccessorsReadStoredValues) {
+    CLuaConfigBool   boolFalse(false);
+    CLuaConfigBool   boolTrue(true);
+    CLuaConfigInt    intValue(2);
+    CLuaConfigFloat  floatValue(1.25F);
+    CLuaConfigVec2   vecValue({3, 4});
+    CLuaConfigString stringValue("value");
+
+    EXPECT_EQ(boolFalse.asInt(), 0);
+    EXPECT_EQ(boolTrue.asInt(), 1);
+    EXPECT_EQ(intValue.asInt(), 2);
+    EXPECT_FLOAT_EQ(floatValue.asFloat(), 1.25F);
+
+    const auto vec = vecValue.asVec2();
+    EXPECT_EQ(vec.x, 3);
+    EXPECT_EQ(vec.y, 4);
+    EXPECT_EQ(stringValue.asString(), "value");
+}