core: rename property accessors of participant

4 files changed, 80 insertions, 80 deletions

diff --git a/core/include/turns/core/participant.hpp b/core/include/turns/core/participant.hpp
index c21aa8b..a7eb98d 100644
--- a/core/include/turns/core/participant.hpp
+++ b/core/include/turns/core/participant.hpp
@@ -24,11 +24,11 @@ namespace turns::core
 
     auto operator<=>(participant const & other) const noexcept -> std::partial_ordering;
 
-    auto disposition(this auto && self);
-    auto is_active(this auto && self);
-    auto is_defeated(this auto && self);
-    auto name(this auto && self);
-    auto priority(this auto && self);
+    auto property_disposition(this auto && self);
+    auto property_is_active(this auto && self);
+    auto property_is_defeated(this auto && self);
+    auto property_name(this auto && self);
+    auto property_priority(this auto && self);
 
     auto serialize() -> nlohmann::json;
 
@@ -40,27 +40,27 @@ namespace turns::core
     Glib::Property<float> m_priority{*this, "priority", 0.0f};
   };
 
-  auto participant::disposition(this auto && self)
+  auto participant::property_disposition(this auto && self)
   {
     return self.m_disposition.get_proxy();
   }
 
-  auto participant::is_active(this auto && self)
+  auto participant::property_is_active(this auto && self)
   {
     return self.m_is_active.get_proxy();
   }
 
-  auto participant::is_defeated(this auto && self)
+  auto participant::property_is_defeated(this auto && self)
   {
     return self.m_is_defeated.get_proxy();
   }
 
-  auto participant::name(this auto && self)
+  auto participant::property_name(this auto && self)
   {
     return self.m_name.get_proxy();
   }
 
-  auto participant::priority(this auto && self)
+  auto participant::property_priority(this auto && self)
   {
     return self.m_priority.get_proxy();
   }
diff --git a/core/src/participant.cpp b/core/src/participant.cpp
index b607794..d560789 100644
--- a/core/src/participant.cpp
+++ b/core/src/participant.cpp
@@ -28,8 +28,8 @@ namespace turns::core
     auto name = serialized.value("name", std::string{});
 
     auto instance = create(name, priority, disposition);
-    instance->is_active() = serialized.value("is-active", false);
-    instance->is_defeated() = serialized.value("is-defeated", false);;
+    instance->property_is_active() = serialized.value("is-active", false);
+    instance->property_is_defeated() = serialized.value("is-defeated", false);;
 
     return instance;
   }
diff --git a/core/src/turn_order.cpp b/core/src/turn_order.cpp
index a2c4ce5..d43ac7f 100644
--- a/core/src/turn_order.cpp
+++ b/core/src/turn_order.cpp
@@ -103,7 +103,7 @@ namespace turns::core
   auto turn_order::add(Glib::ustring const & name, float priority, disposition disposition) -> void
   {
     auto entry = participant::create(name, priority, disposition);
-    entry->priority().signal_changed().connect(sigc::bind(sigc::mem_fun(*this, &turn_order::handle_priority_changed), entry));
+    entry->property_priority().signal_changed().connect(sigc::bind(sigc::mem_fun(*this, &turn_order::handle_priority_changed), entry));
     auto position = std::distance(m_data.cbegin(), insert(entry));
     items_changed(position, 0, 1);
 
@@ -135,8 +135,8 @@ namespace turns::core
     m_active = m_active.transform([this](auto index) { return (index + 1) % get_n_items(); });
 
     m_has_previous = true;
-    m_data[old_active]->is_active() = false;
-    m_data[*m_active]->is_active() = true;
+    m_data[old_active]->property_is_active() = false;
+    m_data[*m_active]->property_is_active() = true;
 
     m_progress = (static_cast<float>(*m_active) + 1) / get_n_items();
 
@@ -157,8 +157,8 @@ namespace turns::core
     m_active = m_active.transform([this](auto index) { return index ? index - 1 : get_n_items() - 1; });
 
     m_has_previous = m_round_number > 0 || m_active > 0;
-    m_data[old_active]->is_active() = false;
-    m_data[*m_active]->is_active() = true;
+    m_data[old_active]->property_is_active() = false;
+    m_data[*m_active]->property_is_active() = true;
 
     m_progress = (static_cast<float>(*m_active) + 1) / get_n_items();
 
@@ -191,7 +191,7 @@ namespace turns::core
     if (!m_active)
     {
       m_active = 0;
-      m_data[*m_active]->is_active() = true;
+      m_data[*m_active]->property_is_active() = true;
     }
     if (m_round_number == invalid_round_number)
     {
@@ -225,7 +225,7 @@ namespace turns::core
     auto inserter = std::bind(&turn_order::insert, this, _1);
     std::ranges::for_each(participants | std::views::transform(factory), inserter);
 
-    auto active = std::ranges::find_if(m_data, [](auto participant) { return participant->is_active(); });
+    auto active = std::ranges::find_if(m_data, [](auto participant) { return participant->property_is_active(); });
     if (active != std::ranges::end(m_data))
     {
       m_active = std::ranges::distance(std::ranges::begin(m_data), active);
diff --git a/core/tests/participant.cpp b/core/tests/participant.cpp
index a526582..ed7b435 100644
--- a/core/tests/participant.cpp
+++ b/core/tests/participant.cpp
@@ -31,41 +31,41 @@ namespace turns::core::tests
     SECTION("Can be constructed using default ctor")
     {
       auto instance = participant{};
-      REQUIRE(instance.name() == "");
-      REQUIRE(instance.priority() == 0);
-      REQUIRE(instance.disposition() == disposition::neutral);
-      REQUIRE(!instance.is_active());
-      REQUIRE(!instance.is_defeated());
+      REQUIRE(instance.property_name() == "");
+      REQUIRE(instance.property_priority() == 0);
+      REQUIRE(instance.property_disposition() == disposition::neutral);
+      REQUIRE(!instance.property_is_active());
+      REQUIRE(!instance.property_is_defeated());
     }
 
     SECTION("Can be constructed using ctor")
     {
       auto instance = participant{name, priority, disposition};
-      REQUIRE(instance.name() == name);
-      REQUIRE(instance.priority() == priority);
-      REQUIRE(instance.disposition() == disposition);
-      REQUIRE(!instance.is_active());
-      REQUIRE(!instance.is_defeated());
+      REQUIRE(instance.property_name() == name);
+      REQUIRE(instance.property_priority() == priority);
+      REQUIRE(instance.property_disposition() == disposition);
+      REQUIRE(!instance.property_is_active());
+      REQUIRE(!instance.property_is_defeated());
     }
 
     SECTION("Can be constructed using factory")
     {
       auto instance = participant::create(name, priority, disposition);
-      REQUIRE(instance->name() == name);
-      REQUIRE(instance->priority() == priority);
-      REQUIRE(instance->disposition() == disposition);
-      REQUIRE(!instance->is_active());
-      REQUIRE(!instance->is_defeated());
+      REQUIRE(instance->property_name() == name);
+      REQUIRE(instance->property_priority() == priority);
+      REQUIRE(instance->property_disposition() == disposition);
+      REQUIRE(!instance->property_is_active());
+      REQUIRE(!instance->property_is_defeated());
     }
 
     SECTION("Can be constructed using JSON factory", "[json]")
     {
       auto instance = participant::create(json);
-      REQUIRE(instance->name() == name);
-      REQUIRE(instance->priority() == priority);
-      REQUIRE(instance->disposition() == disposition);
-      REQUIRE(!instance->is_active());
-      REQUIRE(!instance->is_defeated());
+      REQUIRE(instance->property_name() == name);
+      REQUIRE(instance->property_priority() == priority);
+      REQUIRE(instance->property_disposition() == disposition);
+      REQUIRE(!instance->property_is_active());
+      REQUIRE(!instance->property_is_defeated());
     }
   }
 
@@ -79,72 +79,72 @@ namespace turns::core::tests
 
     SECTION("Setting '::disposition' via proxy changes the 'disposition' value")
     {
-      auto old = instance.disposition().get_value();
-      instance.disposition() = static_cast<core::disposition>(static_cast<int>(disposition) - 1);
-      REQUIRE(instance.disposition() != old);
+      auto old = instance.property_disposition().get_value();
+      instance.property_disposition() = static_cast<core::disposition>(static_cast<int>(disposition) - 1);
+      REQUIRE(instance.property_disposition() != old);
     }
 
     SECTION("Setting '::disposition' via glib changes the 'disposition' value")
     {
-      auto old = instance.disposition().get_value();
+      auto old = instance.property_disposition().get_value();
       instance.set_property("disposition", static_cast<core::disposition>(static_cast<int>(disposition) - 1));
-      REQUIRE(instance.disposition() != old);
+      REQUIRE(instance.property_disposition() != old);
     }
 
     SECTION("Setting '::is-active' via proxy changes the 'is_active' value")
     {
-      auto old = instance.is_active().get_value();
-      instance.is_active() = !old;
-      REQUIRE(instance.is_active() != old);
+      auto old = instance.property_is_active().get_value();
+      instance.property_is_active() = !old;
+      REQUIRE(instance.property_is_active() != old);
     }
 
     SECTION("Setting '::is-active' via glib changes the 'is_active' value")
     {
-      auto old = instance.is_active().get_value();
+      auto old = instance.property_is_active().get_value();
       instance.set_property("is-active", !old);
-      REQUIRE(instance.is_active() != old);
+      REQUIRE(instance.property_is_active() != old);
     }
 
     SECTION("Setting '::is-defeated' via proxy changes the 'is_defeated' value")
     {
-      auto old = instance.is_defeated().get_value();
-      instance.is_defeated() = !old;
-      REQUIRE(instance.is_defeated() != old);
+      auto old = instance.property_is_defeated().get_value();
+      instance.property_is_defeated() = !old;
+      REQUIRE(instance.property_is_defeated() != old);
     }
 
     SECTION("Setting '::is-defeated' via glib changes the 'is_defeated' value")
     {
-      auto old = instance.is_defeated().get_value();
+      auto old = instance.property_is_defeated().get_value();
       instance.set_property("is-defeated", !old);
-      REQUIRE(instance.is_defeated() != old);
+      REQUIRE(instance.property_is_defeated() != old);
     }
 
     SECTION("Setting '::name' via proxy changes the 'name' value")
     {
-      auto old = instance.name().get_value();
-      instance.name() = old + " Changed";
-      REQUIRE(instance.name().get_value() != old);
+      auto old = instance.property_name().get_value();
+      instance.property_name() = old + " Changed";
+      REQUIRE(instance.property_name().get_value() != old);
     }
 
     SECTION("Setting '::name' via glib changes the 'name' value")
     {
-      auto old = instance.name().get_value();
+      auto old = instance.property_name().get_value();
       instance.set_property("name", old + " Changed");
-      REQUIRE(instance.name().get_value() != old);
+      REQUIRE(instance.property_name().get_value() != old);
     }
 
     SECTION("Setting '::priority' via proxy changes the 'priority' value")
     {
-      auto old = instance.priority().get_value();
-      instance.priority() = old + 1;
-      REQUIRE(instance.priority() != old);
+      auto old = instance.property_priority().get_value();
+      instance.property_priority() = old + 1;
+      REQUIRE(instance.property_priority() != old);
     }
 
     SECTION("Setting '::priority' via glib changes the 'priority' value")
     {
-      auto old = instance.priority().get_value();
+      auto old = instance.property_priority().get_value();
       instance.set_property("priority", old + 1);
-      REQUIRE(instance.priority() != old);
+      REQUIRE(instance.property_priority() != old);
     }
   }
 
@@ -164,19 +164,19 @@ namespace turns::core::tests
     {
       SECTION("allowing to get it")
       {
-        REQUIRE(instance.disposition() == constructed_disposition);
+        REQUIRE(instance.property_disposition() == constructed_disposition);
       }
 
       SECTION("allowing to get it via a constant object")
       {
         auto const & cref = instance;
-        REQUIRE(cref.disposition() == constructed_disposition);
+        REQUIRE(cref.property_disposition() == constructed_disposition);
       }
 
       SECTION("allowing to set it")
       {
-        instance.disposition() = disposition::hostile;
-        REQUIRE(instance.disposition() == disposition::hostile);
+        instance.property_disposition() = disposition::hostile;
+        REQUIRE(instance.property_disposition() == disposition::hostile);
       }
     }
 
@@ -184,19 +184,19 @@ namespace turns::core::tests
     {
       SECTION("allowing to get it")
       {
-        REQUIRE(instance.name() == constructed_name);
+        REQUIRE(instance.property_name() == constructed_name);
       }
 
       SECTION("allowing to get it via a constant object")
       {
         auto const & cref = instance;
-        REQUIRE(cref.name() == constructed_name);
+        REQUIRE(cref.property_name() == constructed_name);
       }
 
       SECTION("allowing to set it")
       {
-        instance.name() = "replaced";
-        REQUIRE(instance.name() == "replaced");
+        instance.property_name() = "replaced";
+        REQUIRE(instance.property_name() == "replaced");
       }
     }
 
@@ -204,19 +204,19 @@ namespace turns::core::tests
     {
       SECTION("allowing to get it")
       {
-        REQUIRE(instance.priority() == constructed_priority);
+        REQUIRE(instance.property_priority() == constructed_priority);
       }
 
       SECTION("allowing to get it via a constant object")
       {
         auto const & cref = instance;
-        REQUIRE(cref.priority() == constructed_priority);
+        REQUIRE(cref.property_priority() == constructed_priority);
       }
 
       SECTION("allowing to set it")
       {
-        instance.priority() = 4;
-        REQUIRE(instance.priority() == 4);
+        instance.property_priority() = 4;
+        REQUIRE(instance.property_priority() == 4);
       }
     }
 
@@ -288,22 +288,22 @@ namespace turns::core::tests
 
     SECTION("the active state is de-serialized correctly")
     {
-      REQUIRE(instance->is_active());
+      REQUIRE(instance->property_is_active());
     }
 
     SECTION("the disposition is de-serialized correctly")
     {
-      REQUIRE(instance->disposition() == disposition::hostile);
+      REQUIRE(instance->property_disposition() == disposition::hostile);
     }
 
     SECTION("the name is de-serialized correctly")
     {
-      REQUIRE(instance->name() == "Participant #1");
+      REQUIRE(instance->property_name() == "Participant #1");
     }
 
     SECTION("the priority is de-serialized correctly")
     {
-      REQUIRE(instance->priority() == Catch::Approx{-2.3});
+      REQUIRE(instance->property_priority() == Catch::Approx{-2.3});
     }
   }