mw::com: make method enabled_ a plain bool instead of optional

Author: KrishaDeshkool

score/mw/com/impl/configuration/BUILD

@@ -214,6 +214,7 @@ cc_library(
     srcs = ["lola_method_instance_deployment.cpp"],
     hdrs = ["lola_method_instance_deployment.h"],
     features = COMPILER_WARNING_FEATURES,
+    implementation_deps = [":configuration_common_resources"],
     tags = ["FFI"],
     deps = ["@score_baselibs//score/json"],
 )
@@ -501,9 +502,13 @@ cc_unit_test(
 cc_unit_test(
     name = "lola_method_instance_deployment_test",
     srcs = ["lola_method_instance_deployment_test.cpp"],
-    features = COMPILER_WARNING_FEATURES,
+    features = COMPILER_WARNING_FEATURES + [
+        # These tests catch exceptions instead of using gtest EXPECT_DEATH so we disable aborts_upon_exception.
+        "-aborts_upon_exception",
+    ],
     deps = [
         ":lola_method_instance_deployment",
+        "@score_baselibs//score/language/futurecpp:futurecpp_test_support",
     ],
 )
 

score/mw/com/impl/configuration/lola_method_instance_deployment.cpp

@@ -12,6 +12,8 @@
  ********************************************************************************/
 #include "score/mw/com/impl/configuration/lola_method_instance_deployment.h"
 
+#include "score/mw/com/impl/configuration/configuration_common_resources.h"
+
 #include <limits>
 #include <string_view>
 
@@ -26,25 +28,17 @@ constexpr auto kMethodEnabledKey = "use"sv;
 }  // namespace
 
 LolaMethodInstanceDeployment::LolaMethodInstanceDeployment(std::optional<QueueSize> queue_size,
-                                                           std::optional<bool> enabled)
+                                                           MethodEnabledType enabled)
     : queue_size_{queue_size}, enabled_{enabled}
 {
 }
 
 LolaMethodInstanceDeployment::LolaMethodInstanceDeployment(
     const score::json::Object& serialized_lola_method_instance_deployment)
-    : queue_size_{std::nullopt}, enabled_{std::nullopt}
+    : queue_size_{std::nullopt}, enabled_{}
 {
-    const auto queue_size_iter = serialized_lola_method_instance_deployment.find(kQueueSizeKey.data());
-    if (queue_size_iter != serialized_lola_method_instance_deployment.cend())
-    {
-        queue_size_ = queue_size_iter->second.As<QueueSize>().value();
-    }
-    const auto enabled_iter = serialized_lola_method_instance_deployment.find(kMethodEnabledKey.data());
-    if (enabled_iter != serialized_lola_method_instance_deployment.cend())
-    {
-        enabled_ = enabled_iter->second.As<bool>().value();
-    }
+    queue_size_ = GetOptionalValueFromJson<QueueSize>(serialized_lola_method_instance_deployment, kQueueSizeKey);
+    enabled_ = GetValueFromJson<MethodEnabledType>(serialized_lola_method_instance_deployment, kMethodEnabledKey);
 }
 
 LolaMethodInstanceDeployment LolaMethodInstanceDeployment::CreateFromJson(
@@ -55,16 +49,14 @@ LolaMethodInstanceDeployment LolaMethodInstanceDeployment::CreateFromJson(
 
 score::json::Object LolaMethodInstanceDeployment::Serialize() const
 {
-    score::json::Object result;
+    score::json::Object json_object;
     if (queue_size_.has_value())
     {
-        result[kQueueSizeKey.data()] = score::json::Any{queue_size_.value()};
-    }
-    if (enabled_.has_value())
-    {
-        result[kMethodEnabledKey.data()] = score::json::Any{enabled_.value()};
+        json_object[kQueueSizeKey] = score::json::Any{queue_size_.value()};
     }
-    return result;
+    json_object[kMethodEnabledKey] = score::json::Any{enabled_};
+
+    return json_object;
 }
 
 }  // namespace score::mw::com::impl

score/mw/com/impl/configuration/lola_method_instance_deployment.h

@@ -34,16 +34,16 @@ class LolaMethodInstanceDeployment
 {
   public:
     using QueueSize = std::uint8_t;
+    using MethodEnabledType = bool;
 
     /**
      * @brief Construct LolaMethodInstanceDeployment with optional queue size, because LolaMethodInstanceDeployment for
      * a consumer will have a value while one for a provider will not.
      * @param queue_size The maximum number of pending method requests that can be queued.
-     * @param enabled Optional flag to disable/enable the method. It is always filled on proxy side and always empty
-     *                on skeleton side.
+     * @param enabled  Flag to disable/enable the method. It is always filled on proxy side and it is unused on skeleton
+     * side.
      */
-    explicit LolaMethodInstanceDeployment(std::optional<QueueSize> queue_size,
-                                          std::optional<bool> enabled = std::nullopt);
+    explicit LolaMethodInstanceDeployment(std::optional<QueueSize> queue_size, MethodEnabledType enabled);
 
     explicit LolaMethodInstanceDeployment(const score::json::Object& serialized_lola_method_instance_deployment);
 
@@ -73,7 +73,7 @@ class LolaMethodInstanceDeployment
      * @brief The maximum number of method requests that can be queued on the server side.
      */
     std::optional<QueueSize> queue_size_;
-    std::optional<bool> enabled_;
+    MethodEnabledType enabled_;
 };
 
 inline bool operator==(const LolaMethodInstanceDeployment& lhs, const LolaMethodInstanceDeployment& rhs) noexcept