lib: add participant-count property

6 files changed, 67 insertions, 3 deletions

diff --git a/lib/src/turns-turn-order.cpp b/lib/src/turns-turn-order.cpp
index 538ff11..287e19c 100644
--- a/lib/src/turns-turn-order.cpp
+++ b/lib/src/turns-turn-order.cpp
@@ -5,6 +5,7 @@
 
 #include <array>
 #include <cstddef>
+#include <limits>
 
 G_BEGIN_DECLS
 
@@ -12,6 +13,7 @@ struct _TurnsTurnOrder
 {
   GObject parent_instance;
 
+  gsize participant_count;
   gboolean running;
 };
 
@@ -23,7 +25,8 @@ namespace
 {
   enum struct property
   {
-    Running = 1,
+    ParticipantCount = 1,
+    Running,
     N_PROPERTIES,
   };
 
@@ -35,6 +38,8 @@ namespace
 
     switch (static_cast<property>(id))
     {
+    case property::ParticipantCount:
+      return g_value_set_uint64(value, turns_turn_order_get_participant_count(instance));
     case property::Running:
       return g_value_set_boolean(value, turns_turn_order_get_running(instance));
     default:
@@ -52,18 +57,29 @@ static void turns_turn_order_class_init(TurnsTurnOrderClass * klass)
 
   object_class->get_property = get_property;
 
+  properties[static_cast<std::size_t>(property::ParticipantCount)] =
+      g_param_spec_uint64("participant-count",
+                          "Participant Count",
+                          "The number of participants in this turn order.",
+                          0,
+                          std::numeric_limits<gsize>::max(),
+                          0,
+                          static_cast<GParamFlags>(G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_EXPLICIT_NOTIFY));
+
   properties[static_cast<std::size_t>(property::Running)] =
       g_param_spec_boolean("running",
                            "Running",
                            "Whether or not the turn order is running (e.g. has been started)",
                            false,
-                           static_cast<GParamFlags>(G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY));
+                           static_cast<GParamFlags>(G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_EXPLICIT_NOTIFY));
 
   g_object_class_install_properties(object_class, properties.size(), properties.data());
 }
 
-static void turns_turn_order_init(TurnsTurnOrder *)
+static void turns_turn_order_init(TurnsTurnOrder * self)
 {
+  self->participant_count = 0;
+  self->running = false;
 }
 
 TurnsTurnOrder * turns_turn_order_new()
@@ -71,6 +87,12 @@ TurnsTurnOrder * turns_turn_order_new()
   return TURNS_TURN_ORDER(g_object_new(TURNS_TYPE_TURN_ORDER, nullptr));
 }
 
+gsize turns_turn_order_get_participant_count(TurnsTurnOrder const * self)
+{
+  g_return_val_if_fail(TURNS_IS_TURN_ORDER(const_cast<TurnsTurnOrder *>(self)), 0);
+  return self->participant_count;
+}
+
 gboolean turns_turn_order_get_running(TurnsTurnOrder const * self)
 {
   g_return_val_if_fail(TURNS_IS_TURN_ORDER(const_cast<TurnsTurnOrder *>(self)), false);
diff --git a/lib/src/turns-turn-order.h b/lib/src/turns-turn-order.h
index 2370445..3af566b 100644
--- a/lib/src/turns-turn-order.h
+++ b/lib/src/turns-turn-order.h
@@ -11,6 +11,7 @@ G_DECLARE_FINAL_TYPE(TurnsTurnOrder, turns_turn_order, TURNS, TURN_ORDER, GObjec
 
 TurnsTurnOrder * turns_turn_order_new(void) G_GNUC_WARN_UNUSED_RESULT;
 
+gsize turns_turn_order_get_participant_count(TurnsTurnOrder const * self) G_GNUC_WARN_UNUSED_RESULT;
 gboolean turns_turn_order_get_running(TurnsTurnOrder const * self) G_GNUC_WARN_UNUSED_RESULT;
 
 G_END_DECLS
diff --git a/lib/src/turnsmm/turn-order.cpp b/lib/src/turnsmm/turn-order.cpp
index 8dbcd9c..8e1914d 100644
--- a/lib/src/turnsmm/turn-order.cpp
+++ b/lib/src/turnsmm/turn-order.cpp
@@ -14,6 +14,7 @@
 #include <glib-object.h>
 
 #include <bit>
+#include <cstddef>
 
 namespace Turns
 {
@@ -66,11 +67,21 @@ namespace Turns
     return gobj();
   }
 
+  auto TurnOrder::get_participant_count() const noexcept -> std::size_t
+  {
+    return turns_turn_order_get_participant_count(const_cast<BaseObjectType *>(unwrap(this)));
+  }
+
   auto TurnOrder::get_running() const noexcept -> bool
   {
     return turns_turn_order_get_running(const_cast<BaseObjectType *>(unwrap(this)));
   }
 
+  auto TurnOrder::property_participant_count() const noexcept -> Glib::PropertyProxy_ReadOnly<std::size_t>
+  {
+    return {this, "participant-count"};
+  }
+
   auto TurnOrder::property_running() const noexcept -> Glib::PropertyProxy_ReadOnly<bool>
   {
     return {this, "running"};
diff --git a/lib/src/turnsmm/turn-order.hpp b/lib/src/turnsmm/turn-order.hpp
index 822e879..25fc0b5 100644
--- a/lib/src/turnsmm/turn-order.hpp
+++ b/lib/src/turnsmm/turn-order.hpp
@@ -8,6 +8,8 @@
 #include <glibmm/refptr.h>
 #include <glibmm/ustring.h>
 
+#include <cstddef>
+
 namespace Turns
 {
 
@@ -25,8 +27,10 @@ namespace Turns
     [[nodiscard]] auto gobj() const -> BaseObjectType const *;
     [[nodiscard]] auto gobj_copy() noexcept -> BaseObjectType *;
 
+    [[nodiscard]] auto get_participant_count() const noexcept -> std::size_t;
     [[nodiscard]] auto get_running() const noexcept -> bool;
 
+    [[nodiscard]] auto property_participant_count() const noexcept -> Glib::PropertyProxy_ReadOnly<std::size_t>;
     [[nodiscard]] auto property_running() const noexcept -> Glib::PropertyProxy_ReadOnly<bool>;
 
   protected:
diff --git a/lib/tests/turns-turn-order.cpp b/lib/tests/turns-turn-order.cpp
index feb0aa1..f204847 100644
--- a/lib/tests/turns-turn-order.cpp
+++ b/lib/tests/turns-turn-order.cpp
@@ -2,15 +2,32 @@
 
 #include <catch2/catch_test_macros.hpp>
 
+#include <glib-object.h>
+
 SCENARIO("Creating a turn order", "[lib][object][lifetime]")
 {
   GIVEN("A turn order constructed using turns_turn_order_new()")
   {
     g_autoptr(TurnsTurnOrder) instance = turns_turn_order_new();
 
+    THEN("it's participant count is 0")
+    {
+      REQUIRE(turns_turn_order_get_participant_count(instance) == 0uz);
+
+      auto property_value = decltype(turns_turn_order_get_participant_count(instance)){};
+      g_object_get(instance, "participant-count", &property_value, nullptr);
+
+      REQUIRE(property_value == 0);
+    }
+
     THEN("it's running state is false")
     {
       REQUIRE_FALSE(turns_turn_order_get_running(instance));
+
+      auto property_value = decltype(turns_turn_order_get_participant_count(instance)){};
+      g_object_get(instance, "running", &property_value, nullptr);
+
+      REQUIRE_FALSE(property_value);
     }
   }
 }
\ No newline at end of file
diff --git a/lib/tests/turnsmm/turn-order.cpp b/lib/tests/turnsmm/turn-order.cpp
index d6178ba..ad8306b 100644
--- a/lib/tests/turnsmm/turn-order.cpp
+++ b/lib/tests/turnsmm/turn-order.cpp
@@ -2,15 +2,24 @@
 
 #include <catch2/catch_test_macros.hpp>
 
+#include <cstddef>
+
 SCENARIO("Creating a turn order", "[lib][object][lifetime]")
 {
   GIVEN("A turn order constructed using the default constructor")
   {
     auto instance = Turns::TurnOrder{};
 
+    THEN("it's participant count is 0")
+    {
+      REQUIRE(instance.get_participant_count() == 0uz);
+      REQUIRE(instance.get_property<std::size_t>("participant-count") == 0);
+    }
+
     THEN("it's running state is false")
     {
       REQUIRE_FALSE(instance.get_running());
+      REQUIRE_FALSE(instance.get_property<std::size_t>("running"));
     }
   }
 }
\ No newline at end of file