domain/disposition: replace overcomplicated implementation with enum

3 files changed, 24 insertions, 176 deletions

diff --git a/domain/include/turns/domain/disposition.hpp b/domain/include/turns/domain/disposition.hpp
index b827da4..727369b 100644
--- a/domain/include/turns/domain/disposition.hpp
+++ b/domain/include/turns/domain/disposition.hpp
@@ -4,41 +4,21 @@
 #include <compare>
 #include <cstdint>
 
-#include <glibmm/object.h>
-#include <glibmm/property.h>
-#include <glibmm/refptr.h>
 #include <glibmm/ustring.h>
 
 namespace turns::domain
 {
 
-  struct disposition : Glib::Object
+  enum struct disposition : std::uint8_t
   {
-    enum struct values : std::uint8_t
-    {
-      neutral,
-      friendly,
-      hostile,
-      secret,
-    };
-
-    auto static create(values value) -> Glib::RefPtr<disposition>;
-
-    disposition(values value);
-
-    auto operator<=>(disposition const & other) const -> std::strong_ordering;
-
-    auto property_value() -> Glib::PropertyProxy<values>;
-    auto property_value() const -> Glib::PropertyProxy_ReadOnly<values>;
-    auto get_value() const -> values;
-    auto set_value(values value) -> void;
-
-    auto get_presentation_name() const -> Glib::ustring;
-
-  private:
-    Glib::Property<values> m_value;
+    neutral,
+    friendly,
+    hostile,
+    secret,
   };
 
+  auto presentation_name_for(disposition value) -> Glib::ustring;
+
 }  // namespace turns::domain
 
 #endif
\ No newline at end of file
diff --git a/domain/src/disposition.cpp b/domain/src/disposition.cpp
index 887d70f..d07a03d 100644
--- a/domain/src/disposition.cpp
+++ b/domain/src/disposition.cpp
@@ -1,60 +1,21 @@
 #include "turns/domain/disposition.hpp"
 
-#include <typeinfo>
-
 #include <glibmm/i18n.h>
-#include <glibmm/refptr.h>
 
 namespace turns::domain
 {
 
-  auto disposition::create(values value) -> Glib::RefPtr<disposition>
-  {
-    return Glib::make_refptr_for_instance(new disposition(value));
-  }
-
-  disposition::disposition(values value)
-      : Glib::ObjectBase{typeid(disposition)}
-      , m_value{*this, "value", value}
-  {
-  }
-
-  auto disposition::operator<=>(disposition const & other) const -> std::strong_ordering
-  {
-    return get_value() <=> other.get_value();
-  }
-
-  auto disposition::property_value() -> Glib::PropertyProxy<values>
-  {
-    return m_value.get_proxy();
-  }
-
-  auto disposition::property_value() const -> Glib::PropertyProxy_ReadOnly<values>
-  {
-    return m_value.get_proxy();
-  }
-
-  auto disposition::get_value() const -> values
-  {
-    return m_value;
-  }
-
-  auto disposition::set_value(values value) -> void
-  {
-    m_value = value;
-  }
-
-  auto disposition::get_presentation_name() const -> Glib::ustring
+  auto presentation_name_for(disposition value) -> Glib::ustring
   {
-    switch (get_value())
+    switch (value)
     {
-    case values::neutral:
+    case disposition::neutral:
       return _("Neutral");
-    case values::friendly:
+    case disposition::friendly:
       return _("Friendly");
-    case values::hostile:
+    case disposition::hostile:
       return _("Hostile");
-    case values::secret:
+    case disposition::secret:
       return _("Secret");
     }
 
diff --git a/domain/tests/disposition.cpp b/domain/tests/disposition.cpp
index 487bc5f..0d91867 100644
--- a/domain/tests/disposition.cpp
+++ b/domain/tests/disposition.cpp
@@ -9,116 +9,23 @@
 #include <utility>
 
 #include <glibmm/i18n.h>
-#include <glibmm/init.h>
+#include <glibmm/ustring.h>
 
 namespace turns::domain::tests
 {
 
-  TEST_CASE("A freshly constructed disposition", "[disposition]")
+  TEST_CASE("to_presentation_name returns the correct string for the current language", "[disposition]")
   {
-    auto constexpr constructed_value = disposition::values::friendly;
-    auto instance = disposition{constructed_value};
-
-    SECTION("can be created")
-    {
-      REQUIRE(disposition::create(constructed_value));
-    }
-
-    SECTION("allows access to its value via the associated accessors")
-    {
-      SECTION("allowing to get it")
-      {
-        REQUIRE(instance.get_value() == constructed_value);
-      }
-
-      SECTION("allowing to get it via a constant object")
-      {
-        auto const & cref = instance;
-        REQUIRE(cref.get_value() == constructed_value);
-      }
-
-      SECTION("allowing to set it")
-      {
-        instance.set_value(disposition::values::hostile);
-        REQUIRE(instance.get_value() == disposition::values::hostile);
-      }
-    }
-
-    SECTION("allows access to its value via the associated property")
-    {
-      SECTION("allowing to get it")
-      {
-        REQUIRE(instance.property_value() == constructed_value);
-      }
-
-      SECTION("allowing to get it via a constant object")
-      {
-        auto const & cref = instance;
-        REQUIRE(cref.property_value() == constructed_value);
-      }
-
-      SECTION("allowing to set it")
-      {
-        instance.property_value() = disposition::values::hostile;
-        REQUIRE(instance.get_value() == disposition::values::hostile);
-      }
-    }
-
-    SECTION("allows access to its name via the associated accessors")
-    {
-      SECTION("allowing to get it")
-      {
-        REQUIRE(instance.get_presentation_name() == _("Friendly"));
-      }
-
-      SECTION("allowing to get it via a constant object")
-      {
-        auto const & cref = instance;
-        REQUIRE(cref.get_presentation_name() == _("Friendly"));
-      }
-    }
-
-    SECTION("can be compared with another disposition")
-    {
-      auto equal_instance = disposition{disposition::values::friendly};
-      auto lesser_instance = disposition{disposition::values::neutral};
-      auto greater_instance = disposition{disposition::values::hostile};
-
-      SECTION("yielding std::partial_ordering::equivalent for itself")
-      {
-        REQUIRE((instance <=> instance) == std::strong_ordering::equal);
-      }
-
-      SECTION("yielding std::partial_ordering::equivalent for an equivalent participant")
-      {
-        REQUIRE((instance <=> equal_instance) == std::strong_ordering::equal);
-      }
-
-      SECTION("yielding std::partial_ordering::greater for a lesser participant")
-      {
-        REQUIRE((instance <=> lesser_instance) == std::strong_ordering::greater);
-      }
-
-      SECTION("yielding std::partial_ordering::less for a greater participant")
-      {
-        REQUIRE((instance <=> greater_instance) == std::strong_ordering::less);
-      }
-    }
-  }
-
-  TEST_CASE("disposition::get_presentation_name returns the correct string", "[disposition]")
-  {
-    auto [value, name] =
-        GENERATE(std::pair{disposition::values::neutral, _("Neutral")},
-                 std::pair{disposition::values::friendly, _("Friendly")},
-                 std::pair{disposition::values::hostile, _("Hostile")},
-                 std::pair{disposition::values::secret, _("Secret")},
-                 std::pair{static_cast<disposition::values>(std::numeric_limits<std::underlying_type_t<disposition::values>>::max()),
-                           _("Unknown disposition value")});
-
-    SECTION(std::format("the presentation name for '{}' is '{}'", static_cast<std::underlying_type_t<disposition::values>>(value), name))
+    auto [value, name] = GENERATE(std::pair{disposition::neutral, Glib::ustring{_("Neutral")}},
+                                  std::pair{disposition::friendly, Glib::ustring{_("Friendly")}},
+                                  std::pair{disposition::hostile, Glib::ustring{_("Hostile")}},
+                                  std::pair{disposition::secret, Glib::ustring{_("Secret")}},
+                                  std::pair{static_cast<disposition>(std::numeric_limits<std::underlying_type_t<disposition>>::max()),
+                                            Glib::ustring{_("Unknown disposition value")}});
+
+    SECTION(std::format("the presentation name for '{}' is '{}'", static_cast<std::underlying_type_t<disposition>>(value), name.c_str()))
     {
-      REQUIRE(disposition{value}.get_presentation_name() == name);
+      REQUIRE(presentation_name_for(value) == name);
     }
   }