Add field tags

score/mw/com/impl/BUILD

@@ -223,6 +223,7 @@ cc_library(
         "//score/mw/com:__subpackages__",
     ],
     deps = [
+        ":field_tags",
         ":method_type",
         ":skeleton_event",
         ":skeleton_field_base",
@@ -247,6 +248,7 @@ cc_library(
         "//score/mw/com:__subpackages__",
     ],
     deps = [
+        ":field_tags",
         ":flag_owner",
         ":proxy_base",
         ":proxy_event",
@@ -286,6 +288,7 @@ cc_library(
         "//score/mw/com:__subpackages__",
     ],
     deps = [
+        ":field_tags",
         ":method_type",
         ":proxy_event",
         ":proxy_event_binding",
@@ -689,6 +692,15 @@ cc_library(
     visibility = ["//score/mw/com:__subpackages__"],
 )
 
+cc_library(
+    name = "field_tags",
+    srcs = ["field_tags.cpp"],
+    hdrs = ["field_tags.h"],
+    features = COMPILER_WARNING_FEATURES,
+    tags = ["FFI"],
+    visibility = ["//score/mw/com:__subpackages__"],
+)
+
 cc_library(
     name = "service_element_type",
     srcs = ["service_element_type.cpp"],

score/mw/com/impl/field_tags.cpp

@@ -0,0 +1,13 @@
+/********************************************************************************
+ * Copyright (c) 2026 Contributors to the Eclipse Foundation
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information regarding copyright ownership.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Apache License Version 2.0 which is available at
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ ********************************************************************************/
+#include "score/mw/com/impl/field_tags.h"

score/mw/com/impl/field_tags.h

@@ -0,0 +1,62 @@
+/********************************************************************************
+ * Copyright (c) 2026 Contributors to the Eclipse Foundation
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information regarding copyright ownership.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Apache License Version 2.0 which is available at
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ ********************************************************************************/
+#ifndef PLATFORM_AAS_MW_COM_IMPL_FIELD_TAGS_H
+#define PLATFORM_AAS_MW_COM_IMPL_FIELD_TAGS_H
+
+#include <type_traits>
+
+namespace score::mw::com::impl
+{
+
+/// \brief Tag types used on ProxyField/SkeletonField level to accomplish overload-resolution for various signatures,
+/// which depend on the availability of Get/Set/Notifier. A field must enable WithGetter or WithNotifier
+/// (a write-only field would be invisible to consumers).
+struct WithGetter
+{
+};
+
+struct WithSetter
+{
+};
+
+struct WithNotifier
+{
+};
+
+namespace detail
+{
+
+template <typename TargetType, typename... Tags>
+struct contains_type : std::disjunction<std::is_same<TargetType, Tags>...>
+{
+};
+
+// SFINAE only works when the condition depends on the function-template parameters, not the class-template
+// parameters. The std::is_same<FieldType, ClassFieldType> line ties substitution to a function-template
+// parameter so the check fires at overload resolution instead of class instantiation.
+template <typename FieldType, typename ClassFieldType, typename TargetTag, typename... Tags>
+struct is_tag_enabled : std::conjunction<contains_type<TargetTag, Tags...>, std::is_same<FieldType, ClassFieldType>>
+{
+};
+
+/// \brief Marker used as a disambiguator on test-only ctors to keep them distinct from production overloads.
+/// Lives in detail to signal "not part of the public API"; tests reach into the detail namespace knowingly.
+struct WithTestTag
+{
+};
+
+}  // namespace detail
+
+}  // namespace score::mw::com::impl
+
+#endif  // PLATFORM_AAS_MW_COM_IMPL_FIELD_TAGS_H

score/mw/com/impl/generic_proxy_event.cpp

@@ -21,9 +21,9 @@ namespace score::mw::com::impl
 
 GenericProxyEvent::GenericProxyEvent(ProxyBase& base, const std::string_view event_name)
     : ProxyEventBase{base,
+                     event_name,
                      ProxyBaseView{base}.GetBinding(),
-                     GenericProxyEventBindingFactory::Create(base, event_name),
-                     event_name}
+                     GenericProxyEventBindingFactory::Create(base, event_name)}
 {
     ProxyBaseView proxy_base_view{base};
     if (!binding_base_)
@@ -34,9 +34,9 @@ GenericProxyEvent::GenericProxyEvent(ProxyBase& base, const std::string_view eve
 }
 
 GenericProxyEvent::GenericProxyEvent(ProxyBase& base,
-                                     std::unique_ptr<GenericProxyEventBinding> proxy_binding,
-                                     const std::string_view event_name)
-    : ProxyEventBase{base, ProxyBaseView{base}.GetBinding(), std::move(proxy_binding), event_name}
+                                     const std::string_view event_name,
+                                     std::unique_ptr<GenericProxyEventBinding> proxy_binding)
+    : ProxyEventBase{base, event_name, ProxyBaseView{base}.GetBinding(), std::move(proxy_binding)}
 {
     ProxyBaseView proxy_base_view{base};
     if (!binding_base_)

score/mw/com/impl/generic_proxy_event.h

@@ -47,8 +47,8 @@ class GenericProxyEvent : public ProxyEventBase
     ///
     /// \param proxy_binding The binding that shall be associated with this proxy.
     explicit GenericProxyEvent(ProxyBase& base,
-                               std::unique_ptr<GenericProxyEventBinding> proxy_binding,
-                               const std::string_view event_name);
+                               const std::string_view event_name,
+                               std::unique_ptr<GenericProxyEventBinding> proxy_binding);
 
     /// \brief Constructs a ProxyEvent by querying the base proxie's ProxyBinding for the respective ProxyEventBinding.
     ///

score/mw/com/impl/generic_proxy_event_test.cpp

@@ -87,7 +87,7 @@ TEST(GenericProxyEventTest, SamplePtrsToSlotDataAreConst)
     ProxyBase empty_proxy(std::make_unique<mock_binding::Proxy>(),
                           make_HandleType(make_InstanceIdentifier(kEmptyInstanceDeployment, kEmptyTypeDeployment)));
     GenericProxyEvent proxy_event{
-        empty_proxy, std::unique_ptr<GenericProxyEventBinding>{std::move(mock_proxy_event_ptr)}, kEventName};
+        empty_proxy, kEventName, std::unique_ptr<GenericProxyEventBinding>{std::move(mock_proxy_event_ptr)}};
 
     EXPECT_CALL(mock_proxy_event, Subscribe(max_num_samples));
     EXPECT_CALL(mock_proxy_event, GetNewSamples(_, _));
@@ -120,7 +120,7 @@ TEST(GenericProxyEventDeathTest, DieOnProxyDestructionWhileHoldingSamplePtrs)
     ProxyBase empty_proxy(std::make_unique<mock_binding::Proxy>(),
                           make_HandleType(make_InstanceIdentifier(kEmptyInstanceDeployment, kEmptyTypeDeployment)));
     auto proxy_event = std::make_unique<GenericProxyEvent>(
-        empty_proxy, std::unique_ptr<GenericProxyEventBinding>{std::move(mock_proxy_event_ptr)}, kEventName);
+        empty_proxy, kEventName, std::unique_ptr<GenericProxyEventBinding>{std::move(mock_proxy_event_ptr)});
 
     EXPECT_CALL(mock_proxy_event, Subscribe(max_num_samples));
     EXPECT_CALL(mock_proxy_event, GetNewSamples(_, _));
@@ -158,7 +158,7 @@ TEST(GenericProxyEventGetSampleSizeTest, GetSampleSizeDispatchesToBinding)
     ProxyBase empty_proxy(std::make_unique<mock_binding::Proxy>(),
                           make_HandleType(make_InstanceIdentifier(kEmptyInstanceDeployment, kEmptyTypeDeployment)));
     GenericProxyEvent proxy_event{
-        empty_proxy, std::unique_ptr<GenericProxyEventBinding>{std::move(mock_proxy_event_ptr)}, kEventName};
+        empty_proxy, kEventName, std::unique_ptr<GenericProxyEventBinding>{std::move(mock_proxy_event_ptr)}};
 
     // Expect that GetSampleSize is called once on the binding
     EXPECT_CALL(mock_proxy_event, GetSampleSize()).WillOnce(Return(expected_sample_size));
@@ -186,7 +186,7 @@ TEST(GenericProxyEventHasSerializedFormatTest, HasSerializedFormatDispatchesToBi
     ProxyBase empty_proxy(std::make_unique<mock_binding::Proxy>(),
                           make_HandleType(make_InstanceIdentifier(kEmptyInstanceDeployment, kEmptyTypeDeployment)));
     GenericProxyEvent proxy_event{
-        empty_proxy, std::unique_ptr<GenericProxyEventBinding>{std::move(mock_proxy_event_ptr)}, kEventName};
+        empty_proxy, kEventName, std::unique_ptr<GenericProxyEventBinding>{std::move(mock_proxy_event_ptr)}};
 
     // Expect that HasSerializedFormat is called once on the binding
     EXPECT_CALL(mock_proxy_event, HasSerializedFormat()).WillOnce(Return(expected_has_serialized_format));
@@ -217,7 +217,7 @@ TEST(GenericProxyEventGetNewSamplesTest, GetNewSamplesContainsCorrectReceiverSig
     ProxyBase empty_proxy(std::make_unique<mock_binding::Proxy>(),
                           make_HandleType(make_InstanceIdentifier(kEmptyInstanceDeployment, kEmptyTypeDeployment)));
     GenericProxyEvent proxy_event{
-        empty_proxy, std::unique_ptr<GenericProxyEventBinding>{std::move(mock_proxy_event_ptr)}, kEventName};
+        empty_proxy, kEventName, std::unique_ptr<GenericProxyEventBinding>{std::move(mock_proxy_event_ptr)}};
 
     // Expect that GetNewSamples is called once on the binding
     EXPECT_CALL(mock_proxy_event, GetNewSamples(_, _))

score/mw/com/impl/method_type.h

@@ -19,26 +19,6 @@
 namespace score::mw::com::impl
 {
 
-namespace detail
-{
-
-/// \brief Tag types used on ProxyField/SkeletonField level to accomplish overload-resolution for various signatures,
-/// which depend on the availability of Get/Set/Notifier.
-struct EnableBothTag
-{
-};
-struct EnableGetOnlyTag
-{
-};
-struct EnableSetOnlyTag
-{
-};
-struct EnableNeitherTag
-{
-};
-
-}  // namespace detail
-
 /// \brief Enum used to differentiate between regular service methods and field Get/Set methods.
 enum class MethodType : std::uint8_t
 {

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

@@ -32,8 +32,8 @@ class ProxyMethodBase
 {
   public:
     ProxyMethodBase(ProxyBase& proxy_base,
-                    std::unique_ptr<ProxyMethodBinding> proxy_method_binding,
                     std::string_view method_name,
+                    std::unique_ptr<ProxyMethodBinding> proxy_method_binding,
                     MethodType method_type = MethodType::kMethod) noexcept
         : proxy_base_{proxy_base},
           method_name_{method_name},

score/mw/com/impl/methods/proxy_method_test.cpp

@@ -88,7 +88,7 @@ class ProxyMethodTestFixture : public ::testing::Test
     ProxyMethodTestFixture& GivenAValidProxyMethod()
     {
         unit_ = std::make_unique<ProxyServiceMethodType>(
-            proxy_base_, std::make_unique<mock_binding::ProxyMethodFacade>(proxy_method_binding_mock_), kMethodName);
+            proxy_base_, kMethodName, std::make_unique<mock_binding::ProxyMethodFacade>(proxy_method_binding_mock_));
         return *this;
     }
 
@@ -160,8 +160,8 @@ TYPED_TEST(ProxyMethodAllArgCombinationsTestFixture, Construction)
     // Then the ProxyMethod can be constructed
     using ProxyMethodType = ProxyMethod<TypeParam>;
     ProxyMethodType{this->proxy_base_,
-                    std::make_unique<mock_binding::ProxyMethodFacade>(this->proxy_method_binding_mock_),
-                    kMethodName};
+                    kMethodName,
+                    std::make_unique<mock_binding::ProxyMethodFacade>(this->proxy_method_binding_mock_)};
 }
 
 TYPED_TEST(ProxyMethodAllArgCombinationsTestFixture, WhenMoveConstructingProxyMethodUpdateMethodIsCalled)
@@ -171,8 +171,8 @@ TYPED_TEST(ProxyMethodAllArgCombinationsTestFixture, WhenMoveConstructingProxyMe
     // Given a proxy method
     auto proxy_method =
         ProxyMethodType{this->proxy_base_,
-                        std::make_unique<mock_binding::ProxyMethodFacade>(this->proxy_method_binding_mock_),
-                        kMethodName};
+                        kMethodName,
+                        std::make_unique<mock_binding::ProxyMethodFacade>(this->proxy_method_binding_mock_)};
 
     // When movie-constructing this method
     auto moved_method{std::move(proxy_method)};
@@ -190,15 +190,15 @@ TYPED_TEST(ProxyMethodAllArgCombinationsTestFixture, WhenMoveAssigningProxyMetho
     // Given a proxy method
     auto proxy_method =
         ProxyMethodType{this->proxy_base_,
-                        std::make_unique<mock_binding::ProxyMethodFacade>(this->proxy_method_binding_mock_),
-                        kMethodName};
+                        kMethodName,
+                        std::make_unique<mock_binding::ProxyMethodFacade>(this->proxy_method_binding_mock_)};
 
     ProxyBase other_proxy_base = {std::make_unique<mock_binding::Proxy>(), this->config_store_.GetHandle()};
 
     auto other_proxy_method =
         ProxyMethodType{other_proxy_base,
-                        std::make_unique<mock_binding::ProxyMethodFacade>(this->proxy_method_binding_mock_),
-                        "this_method_will_be_overwritten_soon"};
+                        "this_method_will_be_overwritten_soon",
+                        std::make_unique<mock_binding::ProxyMethodFacade>(this->proxy_method_binding_mock_)};
 
     // When move-assigning this method
     other_proxy_method = std::move(proxy_method);
@@ -218,8 +218,8 @@ TYPED_TEST(ProxyMethodAllArgCombinationsTestFixture,
     // Given a proxy method
     auto proxy_method =
         ProxyMethodType{this->proxy_base_,
-                        std::make_unique<mock_binding::ProxyMethodFacade>(this->proxy_method_binding_mock_),
-                        kMethodName};
+                        kMethodName,
+                        std::make_unique<mock_binding::ProxyMethodFacade>(this->proxy_method_binding_mock_)};
 
     auto same_method_ptr = &proxy_method;
     // When move-assigning this method to itself
@@ -263,7 +263,7 @@ TYPED_TEST(ProxyMethodAllArgCombinationsTestFixture, InvalidBindingInConstructor
     using ProxyMethodType = ProxyMethod<TypeParam>;
 
     // When a proxy method is created with an invalid binding
-    auto proxy_method = std::make_unique<ProxyMethodType>(this->proxy_base_, nullptr, kMethodName);
+    auto proxy_method = std::make_unique<ProxyMethodType>(this->proxy_base_, kMethodName, nullptr);
 
     // Then calling AreBindingsValid returns false
     EXPECT_FALSE(ProxyBaseView{this->proxy_base_}.AreBindingsValid());

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

@@ -52,18 +52,18 @@ class ProxyMethod<void(ArgTypes...)> final : public ProxyMethodBase
   public:
     ProxyMethod(ProxyBase& proxy_base, std::string_view method_name) noexcept
         : ProxyMethod(proxy_base,
+                      method_name,
                       ProxyMethodBindingFactory<void(ArgTypes...)>::Create(proxy_base.GetHandle(),
                                                                            ProxyBaseView{proxy_base}.GetBinding(),
                                                                            method_name,
-                                                                           MethodType::kMethod),
-                      method_name)
+                                                                           MethodType::kMethod))
     {
     }
 
     ProxyMethod(ProxyBase& proxy_base,
-                std::unique_ptr<ProxyMethodBinding> proxy_method_binding,
-                std::string_view method_name) noexcept
-        : ProxyMethodBase(proxy_base, std::move(proxy_method_binding), method_name, MethodType::kMethod),
+                std::string_view method_name,
+                std::unique_ptr<ProxyMethodBinding> proxy_method_binding) noexcept
+        : ProxyMethodBase(proxy_base, method_name, std::move(proxy_method_binding), MethodType::kMethod),
           are_in_arg_ptrs_active_(kCallQueueSize)
     {
         auto proxy_base_view = ProxyBaseView{proxy_base};

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

@@ -40,7 +40,7 @@
 namespace score::mw::com::impl
 {
 
-template <typename, bool, bool, bool>
+template <typename, typename...>
 class ProxyField;
 
 /// \brief Partial specialization of ProxyMethod for function signatures with arguments and non-void return
@@ -55,10 +55,10 @@ 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>;
+    // ProxyField needs to instantiate ProxyMethod via the private FieldOnlyConstructorEnabler tag.
+    // coverity[autosar_cpp14_a11_3_1_violation]
+    template <typename, typename...>
+    friend class ProxyField;
 
     struct FieldOnlyConstructorEnabler
     {
@@ -68,11 +68,11 @@ class ProxyMethod<ReturnType(ArgTypes...)> final : public ProxyMethodBase
     ProxyMethod(ProxyBase& proxy_base, std::string_view method_name) noexcept
         : ProxyMethodBase(
               proxy_base,
+              method_name,
               ProxyMethodBindingFactory<ReturnType(ArgTypes...)>::Create(proxy_base.GetHandle(),
                                                                          ProxyBaseView{proxy_base}.GetBinding(),
                                                                          method_name,
                                                                          MethodType::kMethod),
-              method_name,
               MethodType::kMethod),
           are_in_arg_ptrs_active_(kCallQueueSize)
     {
@@ -86,9 +86,9 @@ class ProxyMethod<ReturnType(ArgTypes...)> final : public ProxyMethodBase
     }
 
     ProxyMethod(ProxyBase& proxy_base,
-                std::unique_ptr<ProxyMethodBinding> proxy_method_binding,
-                std::string_view method_name) noexcept
-        : ProxyMethodBase(proxy_base, std::move(proxy_method_binding), method_name, MethodType::kMethod),
+                std::string_view method_name,
+                std::unique_ptr<ProxyMethodBinding> proxy_method_binding) noexcept
+        : ProxyMethodBase(proxy_base, method_name, std::move(proxy_method_binding), MethodType::kMethod),
           are_in_arg_ptrs_active_(kCallQueueSize)
     {
         auto proxy_base_view = ProxyBaseView{proxy_base};
@@ -101,10 +101,10 @@ class ProxyMethod<ReturnType(ArgTypes...)> final : public ProxyMethodBase
     }
 
     ProxyMethod(ProxyBase& proxy_base,
-                std::unique_ptr<ProxyMethodBinding> proxy_method_binding,
                 std::string_view method_name,
+                std::unique_ptr<ProxyMethodBinding> proxy_method_binding,
                 FieldOnlyConstructorEnabler) noexcept
-        : ProxyMethodBase(proxy_base, std::move(proxy_method_binding), method_name, MethodType::kSet),
+        : ProxyMethodBase(proxy_base, method_name, std::move(proxy_method_binding), MethodType::kSet),
           are_in_arg_ptrs_active_(kCallQueueSize)
     {
         auto proxy_base_view = ProxyBaseView{proxy_base};