settings: implement reset(). Fix setting_mangle::copyFrom()

We can't use the string serialization/deserialization trick because setting_mangle transforms
the value upon parsing

common/settings.cc

@@ -34,19 +34,6 @@ setting_base::setting_base(
     }
 }
 
-bool setting_base::copyFrom(const setting_base& other)
-{
-    const std::string temp_value = other.stringValue();
-    parser_t temp_parser(temp_value);
-
-    if (!parse("", temp_parser)) {
-        return false;
-    }
-
-    _source = other._source;
-    return true;
-}
-
 setting_group performance_group{"Performance", 10};
 setting_group logging_group{"Logging", 5};
 setting_group game_group{"Game", 15};

common/test.cc

@@ -230,6 +230,24 @@ TEST(settings, copy)
     EXPECT_EQ(2.5, waitSetting.value());
 }
 
+TEST(settings, copyMangle)
+{
+    settings::setting_container settings;
+    settings::setting_mangle sunvec{&settings, {"sunlight_mangle"}, 0.0, 0.0, 0.0};
+
+    EXPECT_TRUE(sunvec.parse("", parser_t(std::string_view("0.0 -90.0 0.0"))));
+    EXPECT_NEAR(0, sunvec.value()[0], 1e-6);
+    EXPECT_NEAR(0, sunvec.value()[1], 1e-6);
+    EXPECT_NEAR(-1, sunvec.value()[2], 1e-6);
+
+    settings::setting_mangle sunvec2{&settings, {"sunlight_mangle2"}, 0.0, 0.0, 0.0};
+    sunvec2.copyFrom(sunvec);
+
+    EXPECT_NEAR(0, sunvec2.value()[0], 1e-6);
+    EXPECT_NEAR(0, sunvec2.value()[1], 1e-6);
+    EXPECT_NEAR(-1, sunvec2.value()[2], 1e-6);
+}
+
 TEST(settings, copyContainer)
 {
     settings::setting_container settings1;
@@ -286,6 +304,51 @@ TEST(settings, copyContainerSubclass)
     EXPECT_EQ(settings::source::DEFAULT, s2.stringSetting.getSource());
 }
 
+TEST(settings, resetBool)
+{
+    settings::setting_container settings;
+    settings::setting_bool boolSetting1(&settings, "boolSetting", false);
+
+    boolSetting1.setValue(true);
+    EXPECT_EQ(settings::source::MAP, boolSetting1.getSource());
+    EXPECT_TRUE(boolSetting1.value());
+
+    boolSetting1.reset();
+    EXPECT_EQ(settings::source::DEFAULT, boolSetting1.getSource());
+    EXPECT_FALSE(boolSetting1.value());
+}
+
+TEST(settings, resetScalar)
+{
+    settings::setting_container settings;
+    settings::setting_scalar scalarSetting1(&settings, "scalarSetting", 12.34);
+
+    scalarSetting1.setValue(-2);
+    EXPECT_EQ(settings::source::MAP, scalarSetting1.getSource());
+    EXPECT_EQ(-2, scalarSetting1.value());
+
+    scalarSetting1.reset();
+    EXPECT_EQ(settings::source::DEFAULT, scalarSetting1.getSource());
+    EXPECT_EQ(12.34, scalarSetting1.value());
+}
+
+TEST(settings, resetContainer)
+{
+    settings::setting_container settings;
+    settings::setting_vec3 vec3Setting1(&settings, "vec", 3, 4, 5);
+    settings::setting_string stringSetting1(&settings, "name", "abc");
+
+    vec3Setting1.setValue(qvec3d(-1, -2, -3));
+    stringSetting1.setValue("test");
+    settings.reset();
+
+    EXPECT_EQ(settings::source::DEFAULT, vec3Setting1.getSource());
+    EXPECT_EQ(qvec3d(3, 4, 5), vec3Setting1.value());
+
+    EXPECT_EQ(settings::source::DEFAULT, stringSetting1.getSource());
+    EXPECT_EQ("abc", stringSetting1.value());
+}
+
 int main(int argc, char **argv)
 {
     ::testing::InitGoogleTest(&argc, argv);

include/common/settings.hh

@@ -172,10 +172,10 @@ public:
     }
 
     // copies value and source
-    bool copyFrom(const setting_base& other);
+    virtual bool copyFrom(const setting_base& other) = 0;
 
     // resets value to default, and source to source::DEFAULT
-    virtual void reset() {}; // fixme: = 0;
+    virtual void reset() = 0;
     virtual bool parse(const std::string &settingName, parser_base_t &parser, bool locked = false) = 0;
     virtual std::string stringValue() const = 0;
     virtual std::string format() const = 0;
@@ -196,6 +196,12 @@ public:
     {
     }
 
+    inline bool copyFrom(const setting_base& other) override {
+        return true;
+    }
+
+    inline void reset() override {}
+
     virtual bool parse(const std::string &settingName, parser_base_t &parser, bool locked = false) override
     {
         _func();
@@ -212,6 +218,7 @@ template<typename T>
 class setting_value : public setting_base
 {
 protected:
+    T _default;
     T _value;
 
     virtual void setValueInternal(T value, source newSource)
@@ -233,7 +240,7 @@ protected:
 public:
     inline setting_value(setting_container *dictionary, const nameset &names, T v, const setting_group *group = nullptr,
         const char *description = "")
-        : setting_base(dictionary, names, group, description), _value(v)
+        : setting_base(dictionary, names, group, description), _default(v), _value(v)
     {
     }
 
@@ -242,13 +249,24 @@ public:
     inline void setValueLocked(T f) { setValueInternal(f, source::COMMANDLINE); }
 
     inline void setValue(T f) { setValueInternal(f, source::MAP); }
+
+    inline bool copyFrom(const setting_base& other) override {
+        if (auto *casted = dynamic_cast<const setting_value<T> *>(&other)) {
+            _value = casted->_value;
+            _source = casted->_source;
+            return true;
+        }
+        return false;
+    }
+
+    inline void reset() override {
+        _value = _default;
+        _source = source::DEFAULT;
+    }
 };
 
 class setting_bool : public setting_value<bool>
 {
-private:
-    bool _default;
-
 protected:
     bool parseInternal(parser_base_t &parser, bool locked, bool truthValue)
     {
@@ -277,7 +295,7 @@ protected:
 public:
     inline setting_bool(setting_container *dictionary, const nameset &names, bool v,
         const setting_group *group = nullptr, const char *description = "")
-        : setting_value(dictionary, names, v, group, description), _default(v)
+        : setting_value(dictionary, names, v, group, description)
     {
     }
 
@@ -333,6 +351,12 @@ public:
     {
     }
 
+    inline bool copyFrom(const setting_base& other) override {
+        return true;
+    }
+
+    inline void reset() override {}
+
     virtual bool parse(const std::string &settingName, parser_base_t &parser, bool locked = false) override
     {
         // this is a bit ugly, but we run the parse function for

include/qbsp/qbsp.hh

@@ -90,6 +90,20 @@ public:
 
     constexpr const std::set<wadpath> &pathsValue() const { return _paths; }
 
+    inline bool copyFrom(const setting_base& other) override {
+        if (auto *casted = dynamic_cast<const setting_wadpathset *>(&other)) {
+            _paths = casted->_paths;
+            _source = casted->_source;
+            return true;
+        }
+        return false;
+    }
+
+    inline void reset() override {
+        _paths = {};
+        _source = source::DEFAULT;
+    }
+
     virtual bool parse(const std::string &settingName, parser_base_t &parser, bool locked = false) override
     {
         if (auto value = parseString(parser)) {