Issue 37140 - new getters and setters

Author: gabc-cpp

src/app/InteractionModelEngine.cpp

@@ -1761,8 +1761,8 @@ Protocols::InteractionModel::Status InteractionModelEngine::CheckCommandAccess(c
 Protocols::InteractionModel::Status InteractionModelEngine::CheckCommandFlags(const DataModel::InvokeRequest & aRequest,
                                                                               const DataModel::AcceptedCommandEntry & entry)
 {
-    const bool commandNeedsTimedInvoke = entry.FlagsHas(DataModel::CommandQualityFlags::kTimed);
-    const bool commandIsFabricScoped   = entry.FlagsHas(DataModel::CommandQualityFlags::kFabricScoped);
+    const bool commandNeedsTimedInvoke = entry.HasFlags(DataModel::CommandQualityFlags::kTimed);
+    const bool commandIsFabricScoped   = entry.HasFlags(DataModel::CommandQualityFlags::kFabricScoped);
 
     if (commandNeedsTimedInvoke && !aRequest.invokeFlags.Has(DataModel::InvokeFlags::kTimed))
     {

src/app/WriteHandler.cpp

@@ -125,7 +125,7 @@ std::optional<bool> WriteHandler::IsListAttributePath(const ConcreteAttributePat
         return std::nullopt;
     }
 
-    return info->FlagsHas(DataModel::AttributeQualityFlags::kListAttribute);
+    return info->HasFlags(DataModel::AttributeQualityFlags::kListAttribute);
 }
 
 Status WriteHandler::HandleWriteRequestMessage(Messaging::ExchangeContext * apExchangeContext,
@@ -823,7 +823,7 @@ DataModel::ActionReturnStatus WriteHandler::CheckWriteAllowed(const Access::Subj
     }
 
     // validate that timed write is enforced
-    VerifyOrReturnValue(IsTimedWrite() || !attributeEntry->FlagsHas(DataModel::AttributeQualityFlags::kTimed),
+    VerifyOrReturnValue(IsTimedWrite() || !attributeEntry->HasFlags(DataModel::AttributeQualityFlags::kTimed),
                         Status::NeedsTimedInteraction);
 
     return Status::Success;

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

@@ -85,13 +85,10 @@ enum class AttributeQualityFlags : uint32_t
 };
 
 
-// zero is not a valid privilege, just a default initial value for privileges
-constexpr std::underlying_type_t<Access::Privilege> kNoPrivilege(0) ;
 
 
 struct AttributeEntry
 {
-
     AttributeId attributeId;
 
     // Constructor
@@ -102,29 +99,37 @@ struct AttributeEntry
                             ) : attributeId(id), mask{ attrQualityFlags, readPriv, writePriv } {}
 
 
+    enum class ReadWriteFlag : uint8_t
+    {
+        AssignReadPrivilege  = 1 << 0,
+        AssignWritePrivilege = 1 << 1
+    };
+
+    ReadWriteFlag opFlag {ReadWriteFlag::AssignReadPrivilege};
 
-    // Overload assignment operator for mask.readPrivilege
+    
+    // Overload assignment operator for privileges
     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(value)),
-                      "Size of readPrivilege is not able to accomodate parameter (value).");
-
-        this->mask.readPrivilege = chip::to_underlying(value);
-        return *this;
-    }
-
-
-    // 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(value),
-                      "Size of writePrivilege is not able to accomodate parameter (value).");
-
-        this->mask.writePrivilege = value;
+                      "Size of input privilege is not able to accomodate parameter (value).");
+
+        switch (opFlag)
+        {
+            case ReadWriteFlag::AssignReadPrivilege :
+                this->mask.readPrivilege = to_underlying(value);
+                break;
+
+            case ReadWriteFlag::AssignWritePrivilege :
+                this->mask.writePrivilege = to_underlying(value);
+                break;
+
+            default :
+                break;
+        }
+                      
         return *this;
     }
 
@@ -157,14 +162,18 @@ struct AttributeEntry
     }
 
 
-    constexpr bool FlagsHas(AttributeQualityFlags f) const { return (mask.flags & chip::to_underlying(f)) != 0; }   
+    constexpr bool HasFlags(AttributeQualityFlags f) const { return (mask.flags & chip::to_underlying(f)) != 0; }   
 
     bool ReadAllowed() {return mask.readPrivilege != kNoPrivilege;}
     bool WriteAllowed() {return mask.writePrivilege != kNoPrivilege;}
 
 
     private:
 
+        // zero is not a valid privilege, just a default initial value for privileges
+        static constexpr std::underlying_type_t<Access::Privilege> kNoPrivilege{0} ;
+
+
         struct attribute_entry_mask_t {
 
             // attribute quality flags
@@ -200,7 +209,6 @@ enum class CommandQualityFlags : uint32_t
 
 struct AcceptedCommandEntry
 {
-
     CommandId commandId;
 
     // Constructor
@@ -222,7 +230,7 @@ struct AcceptedCommandEntry
         this->mask.invokePrivilege = chip::to_underlying(value);
         return *this;
     }
-                            
+
 
     // Getter for mask.invokePrivilege
     Access::Privilege GetInvokePrivilege() const
@@ -245,11 +253,15 @@ struct AcceptedCommandEntry
     }
 
 
-    constexpr bool FlagsHas(CommandQualityFlags f) const { return (mask.flags & chip::to_underlying(f)) != 0; }   
+    constexpr bool HasFlags(CommandQualityFlags f) const { return (mask.flags & chip::to_underlying(f)) != 0; }   
 
 
     private:
 
+        // zero is not a valid privilege, just a default initial value for privileges
+        static constexpr std::underlying_type_t<Access::Privilege> kNoPrivilege{0} ;
+
+
         struct accepted_command_entry_mask_t {
 
             // command quality flags