mw/com/impl: Add get/set to field

Added Get/Set support to ProxyField.

Issue: SWP-249574

Author: crimson11

score/mw/com/impl/BUILD

@@ -208,6 +208,7 @@ cc_library(
         ":proxy_event",
         ":proxy_event_binding",
         ":proxy_field_base",
+        "//score/mw/com/impl/methods:proxy_method",
         "//score/mw/com/impl/mocking:i_proxy_event",
         "//score/mw/com/impl/plumbing:field",
         "@score_baselibs//score/language/futurecpp",
@@ -964,6 +965,7 @@ cc_gtest_unit_test(
     deps = [
         ":impl",
         ":runtime_mock",
+        "//score/mw/com/impl/mocking:proxy_event_mock",
         "//score/mw/com/impl/plumbing:proxy_field_binding_factory_mock",
         "//score/mw/com/impl/test:binding_factory_resources",
         "//score/mw/com/impl/test:proxy_resources",

score/mw/com/impl/methods/proxy_method_with_in_args_and_return.h

@@ -39,6 +39,9 @@
 namespace score::mw::com::impl
 {
 
+template <typename, bool, bool, bool>
+class ProxyField;
+
 /// \brief Partial specialization of ProxyMethod for function signatures with arguments and non-void return
 /// \tparam ReturnType return type of the method
 /// \tparam ArgTypes argument types of the method
@@ -51,6 +54,16 @@ class ProxyMethod<ReturnType(ArgTypes...)> final : public ProxyMethodBase
     // coverity[autosar_cpp14_a11_3_1_violation]
     friend class ProxyMethodView;
 
+    friend class ProxyField<ReturnType, true, true, true>;
+    friend class ProxyField<ReturnType, true, true, false>;
+    friend class ProxyField<ReturnType, false, true, false>;
+    friend class ProxyField<ReturnType, false, true, true>;
+
+    // Empty struct that is used to make the non-registering ctor only accessible to ProxyField (as it is a friend).
+    struct FieldOnlyConstructorEnabler
+    {
+    };
+
   public:
     ProxyMethod(ProxyBase& proxy_base, std::string_view method_name) noexcept
         : ProxyMethodBase(
@@ -85,6 +98,26 @@ class ProxyMethod<ReturnType(ArgTypes...)> final : public ProxyMethodBase
         }
     }
 
+    /// \brief Ctor for ProxyMethod that is used by ProxyField for the "dispatch method" of a field-setter. This method
+    /// does not register the method in the ProxyBase's method map, since registration in the correct field map is done
+    /// by ProxyField ctor. This is achieved by the FieldOnlyConstructorEnabler tag type, which makes clear, that this
+    /// ctor should only be used by ProxyField (this is enforced by FieldOnlyConstructorEnabler only visible to
+    /// ProxyField due to it being a friend).
+    ProxyMethod(ProxyBase& proxy_base,
+                std::unique_ptr<ProxyMethodBinding> proxy_method_binding,
+                std::string_view method_name,
+                FieldOnlyConstructorEnabler) noexcept
+        : ProxyMethodBase(proxy_base, std::move(proxy_method_binding), method_name),
+          are_in_arg_ptrs_active_(kCallQueueSize)
+    {
+        auto proxy_base_view = ProxyBaseView{proxy_base};
+        if (binding_ == nullptr)
+        {
+            proxy_base_view.MarkServiceElementBindingInvalid();
+            return;
+        }
+    }
+
     ~ProxyMethod() final = default;
 
     /// \brief A ProxyMethod shall not be copyable.

score/mw/com/impl/methods/proxy_method_with_return_type.h

@@ -35,6 +35,9 @@
 namespace score::mw::com::impl
 {
 
+template <typename, bool, bool, bool>
+class ProxyField;
+
 /// \brief Partial specialization of ProxyMethod for function signatures with no arguments and non-void return
 /// \tparam ReturnType return type of the method
 template <typename ReturnType>
@@ -45,6 +48,15 @@ class ProxyMethod<ReturnType()> final : public ProxyMethodBase
     // This enables us to hide unnecessary internals from the end-user.
     // coverity[autosar_cpp14_a11_3_1_violation]
     friend class ProxyMethodView;
+    friend class ProxyField<ReturnType, true, true, true>;
+    friend class ProxyField<ReturnType, true, false, false>;
+    friend class ProxyField<ReturnType, true, true, false>;
+    friend class ProxyField<ReturnType, true, false, true>;
+
+    // Empty struct that is used to make the non-registering ctor only accessible to ProxyField (as it is a friend).
+    struct FieldOnlyConstructorEnabler
+    {
+    };
 
   public:
     ProxyMethod(ProxyBase& proxy_base, std::string_view method_name) noexcept
@@ -77,6 +89,25 @@ class ProxyMethod<ReturnType()> final : public ProxyMethodBase
         }
     }
 
+    /// \brief Ctor for ProxyMethod that is used by ProxyField for the "dispatch method" of a field-getter. This method
+    /// does not register the method in the ProxyBase's method map, since registration in the correct field map is done
+    /// by ProxyField ctor. This is achieved by the FieldOnlyConstructorEnabler tag type, which makes clear, that this
+    /// ctor should only be used by ProxyField (this is enforced by FieldOnlyConstructorEnabler only visible to
+    /// ProxyField due to it being a friend).
+    ProxyMethod(ProxyBase& proxy_base,
+                std::unique_ptr<ProxyMethodBinding> proxy_method_binding,
+                std::string_view method_name,
+                FieldOnlyConstructorEnabler) noexcept
+        : ProxyMethodBase(proxy_base, std::move(proxy_method_binding), method_name)
+    {
+        auto proxy_base_view = ProxyBaseView{proxy_base};
+        if (binding_ == nullptr)
+        {
+            proxy_base_view.MarkServiceElementBindingInvalid();
+            return;
+        }
+    }
+
     ~ProxyMethod() final = default;
 
     /// \brief A ProxyMethod shall not be copyable.

score/mw/com/impl/mocking/proxy_wrapper_class_test_view_test.cpp

@@ -170,7 +170,7 @@ TEST_F(ProxyWrapperTestClassCreateFixture, CallingFunctionsOnMockProxyDispatches
     auto& proxy_field_mock = std::get<0>(fields_tuple).mock;
     proxy.some_event.InjectMock(proxy_event_mock);
     proxy.some_event_2.InjectMock(proxy_event_mock_2);
-    proxy.some_field.InjectMock(proxy_field_mock);
+    proxy.some_field.InjectEventMock(proxy_field_mock);
 
     // Expecting that OfferService will be called on the Proxy mock and Unsubscribe on the event and field mocks
     EXPECT_CALL(proxy_event_mock, Unsubscribe());
@@ -254,7 +254,7 @@ TEST_F(ProxyWrapperTestClassFieldsOnlyCreateFixture, CallingFunctionsOnMockProxy
     // and given a mocked proxy was created
     auto proxy = ProxyWrapperClassTestView<FieldOnlyProxy>::Create(fields_tuple);
     auto& proxy_field_mock = (std::get<0>(fields_tuple).mock);
-    proxy.some_field.InjectMock(proxy_field_mock);
+    proxy.some_field.InjectEventMock(proxy_field_mock);
 
     // Expecting that Unsubscribe is called on the field
     EXPECT_CALL(proxy_field_mock, Unsubscribe());

score/mw/com/impl/plumbing/BUILD

@@ -302,6 +302,7 @@ cc_library(
     tags = ["FFI"],
     deps = [
         ":i_proxy_field_binding_factory",
+        ":proxy_method_binding_factory_impl",
         ":proxy_service_element_binding_factory_impl",
         "@score_baselibs//score/language/futurecpp",
     ],

score/mw/com/impl/plumbing/i_proxy_field_binding_factory.h

@@ -14,6 +14,7 @@
 #define SCORE_MW_COM_IMPL_PLUMBING_I_PROXY_FIELD_BINDING_FACTORY_H
 
 #include "score/mw/com/impl/instance_identifier.h"
+#include "score/mw/com/impl/methods/proxy_method_binding.h"
 #include "score/mw/com/impl/proxy_base.h"
 #include "score/mw/com/impl/proxy_event_binding.h"
 
@@ -45,6 +46,20 @@ class IProxyFieldBindingFactory
     /// \return An instance of ProxyEventBinding or nullptr in case of an error.
     virtual auto CreateEventBinding(ProxyBase& parent, const std::string_view field_name) noexcept
         -> std::unique_ptr<ProxyEventBinding<SampleType>> = 0;
+
+    ///
+    /// @param parent
+    /// @param field_name
+    /// @return
+    virtual auto CreateGetMethodBinding(ProxyBase& parent, const std::string_view field_name) noexcept
+        -> std::unique_ptr<ProxyMethodBinding> = 0;
+
+    ///
+    /// @param parent
+    /// @param field_name
+    /// @return
+    virtual auto CreateSetMethodBinding(ProxyBase& parent, const std::string_view field_name) noexcept
+        -> std::unique_ptr<ProxyMethodBinding> = 0;
 };
 }  // namespace score::mw::com::impl
 

score/mw/com/impl/plumbing/proxy_field_binding_factory.h

@@ -13,6 +13,7 @@
 #ifndef SCORE_MW_COM_IMPL_PLUMBING_PROXY_FIELD_BINDING_FACTORY_H
 #define SCORE_MW_COM_IMPL_PLUMBING_PROXY_FIELD_BINDING_FACTORY_H
 
+#include "score/mw/com/impl/methods/proxy_method_binding.h"
 #include "score/mw/com/impl/plumbing/i_proxy_field_binding_factory.h"
 #include "score/mw/com/impl/plumbing/proxy_field_binding_factory_impl.h"
 #include "score/mw/com/impl/proxy_base.h"
@@ -39,6 +40,18 @@ class ProxyFieldBindingFactory final
         return instance().CreateEventBinding(parent, field_name);
     }
 
+    static std::unique_ptr<ProxyMethodBinding> CreateGetMethodBinding(ProxyBase& parent,
+                                                                      std::string_view field_name) noexcept
+    {
+        return instance().CreateGetMethodBinding(parent, field_name);
+    }
+
+    static std::unique_ptr<ProxyMethodBinding> CreateSetMethodBinding(ProxyBase& parent,
+                                                                      std::string_view field_name) noexcept
+    {
+        return instance().CreateSetMethodBinding(parent, field_name);
+    }
+
     /// \brief Inject a mock IProxyFieldBindingFactory. If a mock is injected, then all calls on
     /// ProxyFieldBindingFactory will be dispatched to the mock.
     static void InjectMockBinding(IProxyFieldBindingFactory<SampleType>* const mock) noexcept

score/mw/com/impl/plumbing/proxy_field_binding_factory_impl.h

@@ -13,21 +13,25 @@
 #ifndef SCORE_MW_COM_IMPL_PLUMBING_PROXY_FIELD_BINDING_FACTORY_IMPL_H
 #define SCORE_MW_COM_IMPL_PLUMBING_PROXY_FIELD_BINDING_FACTORY_IMPL_H
 
-#include "score/mw/com/impl/bindings/lola/element_fq_id.h"
 #include "score/mw/com/impl/bindings/lola/proxy_event.h"
 #include "score/mw/com/impl/plumbing/i_proxy_field_binding_factory.h"
+#include "score/mw/com/impl/plumbing/proxy_method_binding_factory_impl.h"
 #include "score/mw/com/impl/plumbing/proxy_service_element_binding_factory_impl.h"
 #include "score/mw/com/impl/proxy_base.h"
 #include "score/mw/com/impl/proxy_event_binding.h"
 
-#include <score/overload.hpp>
-
 #include <memory>
 #include <string_view>
 
 namespace score::mw::com::impl
 {
 
+namespace detail
+{
+constexpr char kGetMethodName[] = "Get";
+constexpr char kSetMethodName[] = "Set";
+}  // namespace detail
+
 /// \brief Factory class that dispatches calls to the appropriate binding based on binding information in the
 /// deployment configuration.
 template <typename SampleType>
@@ -42,11 +46,17 @@ class ProxyFieldBindingFactoryImpl final : public IProxyFieldBindingFactory<Samp
     std::unique_ptr<ProxyEventBinding<SampleType>> CreateEventBinding(
         ProxyBase& parent,
         const std::string_view field_name) noexcept override;
+
+    std::unique_ptr<ProxyMethodBinding> CreateGetMethodBinding(ProxyBase& parent,
+                                                               const std::string_view field_name) noexcept override;
+
+    std::unique_ptr<ProxyMethodBinding> CreateSetMethodBinding(ProxyBase& parent,
+                                                               const std::string_view field_name) noexcept override;
 };
 
 template <typename SampleType>
 // Suppress "AUTOSAR C++14 A15-5-3" rule finding. This rule states: "The std::terminate() function shall
-// not be called implicitly.". std::visit Throws std::bad_variant_access if
+// not be called implicitly". std::visit Throws std::bad_variant_access if
 // as-variant(vars_i).valueless_by_exception() is true for any variant vars_i in vars. The variant may only become
 // valueless if an exception is thrown during different stages. Since we don't throw exceptions, it's not possible
 // that the variant can return true from valueless_by_exception and therefore not possible that std::visit throws
@@ -62,6 +72,24 @@ inline std::unique_ptr<ProxyEventBinding<SampleType>> ProxyFieldBindingFactoryIm
                                      ServiceElementType::FIELD>(parent, field_name);
 }
 
+template <typename SampleType>
+inline std::unique_ptr<ProxyMethodBinding> ProxyFieldBindingFactoryImpl<SampleType>::CreateGetMethodBinding(
+    ProxyBase& parent,
+    const std::string_view field_name) noexcept
+{
+    return ProxyMethodBindingFactoryImpl<SampleType()>::Create(
+        parent.GetHandle(), ProxyBaseView{parent}.GetBinding(), detail::kGetMethodName);
+}
+
+template <typename SampleType>
+inline std::unique_ptr<ProxyMethodBinding> ProxyFieldBindingFactoryImpl<SampleType>::CreateSetMethodBinding(
+    ProxyBase& parent,
+    const std::string_view field_name) noexcept
+{
+    return ProxyMethodBindingFactoryImpl<SampleType(SampleType)>::Create(
+        parent.GetHandle(), ProxyBaseView{parent}.GetBinding(), detail::kSetMethodName);
+}
+
 }  // namespace score::mw::com::impl
 
 #endif  // SCORE_MW_COM_IMPL_PLUMBING_PROXY_FIELD_BINDING_FACTORY_IMPL_H

score/mw/com/impl/plumbing/proxy_service_element_binding_factory_impl.h

@@ -35,7 +35,7 @@
 namespace score::mw::com::impl
 {
 
-template <typename ProxyServiceElementBinding, typename ProxyServiceElement, ServiceElementType element_type>
+template <typename ProxyServiceElementBindingInterface, typename ProxyServiceElementBinding, ServiceElementType element_type>
 // "AUTOSAR C++14 A15-5-3" triggered by std::bad_variant_access.
 // Additionally the variant might be valueless_by_exception, which would also cause a std::bad_variant_access, this
 // can only happen if any of the variants throw exception during construction. Since we do not throw exceptions,
@@ -49,11 +49,11 @@ template <typename ProxyServiceElementBinding, typename ProxyServiceElement, Ser
 //
 // coverity[autosar_cpp14_a15_5_3_violation]
 // coverity[autosar_cpp14_a8_2_1_violation]
-std::unique_ptr<ProxyServiceElementBinding> CreateProxyServiceElement(
+std::unique_ptr<ProxyServiceElementBindingInterface> CreateProxyServiceElement(
     ProxyBase& parent,
     const std::string_view service_element_name) noexcept
 {
-    using ReturnType = std::unique_ptr<ProxyServiceElementBinding>;
+    using ReturnType = std::unique_ptr<ProxyServiceElementBindingInterface>;
 
     const HandleType& handle = parent.GetHandle();
     const auto& type_deployment = handle.GetServiceTypeDeployment();
@@ -80,7 +80,7 @@ std::unique_ptr<ProxyServiceElementBinding> CreateProxyServiceElement(
                                                   lola_service_element_id,
                                                   lola_service_instance_id->GetId(),
                                                   element_type};
-            return std::make_unique<ProxyServiceElement>(*lola_parent, element_fq_id, service_element_name);
+            return std::make_unique<ProxyServiceElementBinding>(*lola_parent, element_fq_id, service_element_name);
         },
         [](const score::cpp::blank&) noexcept -> ReturnType {
             return nullptr;

score/mw/com/impl/proxy_event.h

@@ -40,7 +40,7 @@ namespace score::mw::com::impl
 // False Positive: this is a normal forward declaration.
 // Which is used to avoid cyclic dependency with proxy_field.h
 // coverity[autosar_cpp14_m3_2_3_violation]
-template <typename>
+template <typename, bool, bool, bool>
 class ProxyField;
 
 /// \brief This is the user-visible class of an event that is part of a proxy. It contains ProxyEvent functionality that
@@ -54,15 +54,22 @@ template <typename SampleDataType>
 class ProxyEvent final : public ProxyEventBase
 {
     template <typename T>
-    // Design decission: This friend class provides a view on the internals of ProxyEvent.
-    // This enables us to hide unncecessary internals from the enduser.
+    // Design decision: This friend class provides a view on the internals of ProxyEvent.
+    // This enables us to hide unnecessary internals from the end user.
     // coverity[autosar_cpp14_a11_3_1_violation]
     friend class ProxyEventView;
 
-    // Design decission: ProxyField uses composition pattern to reuse code from ProxyEvent. These two classes also have
+    // Design decision: ProxyField uses composition pattern to reuse code from ProxyEvent. These two classes also have
     // shared private APIs which necessitates the use of the friend keyword.
     // coverity[autosar_cpp14_a11_3_1_violation]
-    friend class ProxyField<SampleDataType>;
+    friend class ProxyField<SampleDataType, true, true, true>;
+    friend class ProxyField<SampleDataType, true, false, false>;
+    friend class ProxyField<SampleDataType, true, true, false>;
+    friend class ProxyField<SampleDataType, true, false, true>;
+    friend class ProxyField<SampleDataType, false, true, true>;
+    friend class ProxyField<SampleDataType, false, false, false>;
+    friend class ProxyField<SampleDataType, false, true, false>;
+    friend class ProxyField<SampleDataType, false, false, true>;
 
     // Empty struct that is used to make the second constructor only accessible to ProxyField (as it is a friend).
     struct FieldOnlyConstructorEnabler