Issue 37140 - new getters and setters

Author: gabc-cpp

src/app/data-model-provider/MetadataTypes.h

@@ -95,34 +95,48 @@ struct AttributeEntry
     AttributeId attributeId;
 
     // Constructor
-    constexpr AttributeEntry() : attributeId(0), mask{ 0, kNoPrivilege, kNoPrivilege } {}
+    constexpr AttributeEntry(AttributeId id = 0,
+                             std::underlying_type_t<AttributeQualityFlags> attrQualityFlags = 0,
+                             std::underlying_type_t<Access::Privilege> readPriv = kNoPrivilege,
+                             std::underlying_type_t<Access::Privilege> writePriv = kNoPrivilege
+                            ) : attributeId(id), mask{ attrQualityFlags, readPriv, writePriv } {}
 
-    
-    void SetReadPrivilege(Access::Privilege r)
+
+
+    // Overload assignment operator for mask.readPrivilege
+    AttributeEntry& operator=(Access::Privilege value) 
     {
         // Static ASSERT to check size of readPrivilege type vs entry parameter.
         static_assert(sizeof(std::underlying_type_t<Access::Privilege>) >= 
-                      sizeof(chip::to_underlying(r)),
-                      "Size of readPrivilege is not able to accomodate parameter (r).");
+                      sizeof(chip::to_underlying(value)),
+                      "Size of readPrivilege is not able to accomodate parameter (value).");
 
-        mask.readPrivilege = chip::to_underlying(r);
+        this->mask.readPrivilege = chip::to_underlying(value);
+        return *this;
     }
 
-    Access::Privilege GetReadPrivilege() const
-    {
-        return static_cast< Access::Privilege >(mask.readPrivilege);
-    }
 
-    void SetWritePrivilege(Access::Privilege w)
+    // Overload assignment operator for mask.writePrivilege
+    AttributeEntry& operator=(std::underlying_type_t<Access::Privilege> value)
     {
         // Static ASSERT to check size of writePrivilege type vs entry parameter.
         static_assert(sizeof(std::underlying_type_t<Access::Privilege>) >= 
-                      sizeof(chip::to_underlying(w)),
-                      "Size of writePrivilege is not able to accomodate parameter (w).");
+                      sizeof(value),
+                      "Size of writePrivilege is not able to accomodate parameter (value).");
 
-        mask.writePrivilege = chip::to_underlying(w);
+        this->mask.writePrivilege = value;
+        return *this;
     }
 
+
+    // Getter for mask.readPrivilege
+    Access::Privilege GetReadPrivilege() const
+    {
+        return static_cast< Access::Privilege >(mask.readPrivilege);
+    }
+
+    
+    // Getter for mask.writePrivilege
     Access::Privilege GetWritePrivilege() const
     {
         return static_cast< Access::Privilege >(mask.writePrivilege);
@@ -186,25 +200,31 @@ enum class CommandQualityFlags : uint32_t
 
 struct AcceptedCommandEntry
 {
-    CommandId commandId;
 
+    CommandId commandId;
 
     // Constructor
-    constexpr AcceptedCommandEntry() : commandId(0),
-                                       mask{ 0, chip::to_underlying(Access::Privilege::kOperate) } {}
+    constexpr AcceptedCommandEntry(CommandId id = 0,
+                                   std::underlying_type_t<CommandQualityFlags> cmdQualityFlags = 0,
+                                   std::underlying_type_t<Access::Privilege> invokePriv = kNoPrivilege
+                                ) : commandId(id), mask{ cmdQualityFlags, invokePriv } {}
 
 
-    void SetInvokePrivilege(Access::Privilege i)
+
+    // Overload assignment operator for mask.invokePrivilege
+    AcceptedCommandEntry& operator=(Access::Privilege value)
     {
         // Static ASSERT to check size of invokePrivilege type vs entry parameter.
         static_assert(sizeof(std::underlying_type_t<Access::Privilege>) >= 
-                      sizeof(chip::to_underlying(i)),
-                      "Size of invokePrivilege is not able to accomodate parameter (i).");
+                             sizeof(chip::to_underlying(value)),
+                             "Size of invokePrivilege is not able to accomodate parameter (value).");
 
-        mask.invokePrivilege = chip::to_underlying(i);
+        this->mask.invokePrivilege = chip::to_underlying(value);
+        return *this;
     }
-                                       
+                            
 
+    // Getter for mask.invokePrivilege
     Access::Privilege GetInvokePrivilege() const
     {
         return static_cast< Access::Privilege >(mask.invokePrivilege);

src/data-model-providers/codegen/CodegenDataModelProvider.cpp

@@ -58,7 +58,7 @@ DataModel::AcceptedCommandEntry AcceptedCommandEntryFor(const ConcreteCommandPat
     DataModel::AcceptedCommandEntry entry;
 
     entry.commandId       = path.mCommandId;
-    entry.SetInvokePrivilege( RequiredPrivilege::ForInvokeCommand(path) );
+    entry = RequiredPrivilege::ForInvokeCommand(path);
     entry.SetFlags(DataModel::CommandQualityFlags::kTimed, CommandNeedsTimedInvoke(path.mClusterId, commandId));
     entry.SetFlags(DataModel::CommandQualityFlags::kFabricScoped, CommandIsFabricScoped(path.mClusterId, commandId));
     entry.SetFlags(DataModel::CommandQualityFlags::kLargeMessage, CommandHasLargePayload(path.mClusterId, commandId));
@@ -99,10 +99,10 @@ DataModel::AttributeEntry AttributeEntryFrom(const ConcreteClusterPath & cluster
     const ConcreteAttributePath attributePath(clusterPath.mEndpointId, clusterPath.mClusterId, attribute.attributeId);
 
     entry.attributeId   = attribute.attributeId;
-    entry.SetReadPrivilege(RequiredPrivilege::ForReadAttribute(attributePath));
+    entry = RequiredPrivilege::ForReadAttribute(attributePath);
     if (!attribute.IsReadOnly())
     {
-        entry.SetWritePrivilege(RequiredPrivilege::ForWriteAttribute(attributePath));
+        entry = chip::to_underlying(RequiredPrivilege::ForWriteAttribute(attributePath));
     }
 
     entry.SetFlags(DataModel::AttributeQualityFlags::kListAttribute, (attribute.attributeType == ZCL_ARRAY_ATTRIBUTE_TYPE));
@@ -294,7 +294,7 @@ CHIP_ERROR CodegenDataModelProvider::Attributes(const ConcreteClusterPath & path
     //   - fixed value (no such flag exists, so this is not a quality flag we set/track)
     DataModel::AttributeEntry globalListEntry;
 
-    globalListEntry.SetReadPrivilege(Access::Privilege::kView);
+    globalListEntry = Access::Privilege::kView;
     globalListEntry.SetFlags(DataModel::AttributeQualityFlags::kListAttribute);
 
     for (auto & attribute : GlobalAttributesNotInMetadata)