[DRAFT/TEST] Evaluate cost of flash if switching to a templated abstract iterator on DataModel::Provider

examples/common/pigweed/rpc_services/Attributes.h

@@ -221,7 +221,14 @@ class Attributes : public pw_rpc::nanopb::Attributes::Service<Attributes>
         request.operationFlags.Set(app::DataModel::OperationFlags::kInternal);
         request.subjectDescriptor = &subjectDescriptor;
 
-        std::optional<app::DataModel::ClusterInfo> info = provider->GetServerClusterInfo(path);
+        std::optional<app::DataModel::ClusterInfo> info;
+
+        auto clusters = provider->GetServerClusters(path.mEndpointId);
+        if (clusters->SeekTo(path.mClusterId))
+        {
+            info = clusters->GetMetadata();
+        }
+
         if (!info.has_value())
         {
             return ::pw::Status::NotFound();

src/access/ProviderDeviceTypeResolver.h

@@ -31,8 +31,8 @@ class DynamicProviderDeviceTypeResolver : public chip::Access::AccessControl::De
 
     bool IsDeviceTypeOnEndpoint(chip::DeviceTypeId deviceType, chip::EndpointId endpoint) override
     {
-        app::DataModel::Provider * model = mModelGetter();
-        for (auto type = model->FirstDeviceType(endpoint); type.has_value(); type = model->NextDeviceType(endpoint, *type))
+        auto it = mModelGetter()->GetDeviceTypes(endpoint);
+        for (auto type = it->Next(); type.has_value(); type = it->Next())
         {
             if (type->deviceTypeId == deviceType)
             {

src/app/AttributePathExpandIterator.cpp

@@ -17,7 +17,9 @@
 #include <app/AttributePathExpandIterator.h>
 
 #include <app/GlobalAttributes.h>
+#include <lib/core/DataModelTypes.h>
 #include <lib/support/CodeUtils.h>
+#include <optional>
 
 using namespace chip::app::DataModel;
 
@@ -28,13 +30,9 @@ AttributePathExpandIterator::AttributePathExpandIterator(DataModel::Provider * p
                                                          SingleLinkedListNode<AttributePathParams> * attributePath) :
     mDataModelProvider(provider),
     mpAttributePath(attributePath), mOutputPath(kInvalidEndpointId, kInvalidClusterId, kInvalidAttributeId)
-
 {
-    mOutputPath.mExpanded = true; // this is reset in 'next' if needed
-
-    // Make the iterator ready to emit the first valid path in the list.
-    // TODO: the bool return value here is completely unchecked
-    Next();
+    mOutputPath.mNeedsInitialization = true; // Ensure a Next is called on all public API
+    mOutputPath.mExpanded            = true; // this is reset in 'next' if needed
 }
 
 bool AttributePathExpandIterator::IsValidAttributeId(AttributeId attributeId)
@@ -49,31 +47,26 @@ bool AttributePathExpandIterator::IsValidAttributeId(AttributeId attributeId)
         break;
     }
 
-    const ConcreteAttributePath attributePath(mOutputPath.mEndpointId, mOutputPath.mClusterId, attributeId);
-    return mDataModelProvider->GetAttributeInfo(attributePath).has_value();
+    return mDataModelProvider->GetAttributes(mOutputPath)->SeekTo(attributeId);
 }
 
-std::optional<AttributeId> AttributePathExpandIterator::NextAttributeId()
+std::optional<AttributeId> AttributePathExpandIterator::NextAttributeId(SearchSession & session)
 {
     if (mOutputPath.mAttributeId == kInvalidAttributeId)
     {
-        if (mpAttributePath->mValue.HasWildcardAttributeId())
-        {
-            AttributeEntry entry = mDataModelProvider->FirstAttribute(mOutputPath);
-            return entry.IsValid()                                         //
-                ? entry.path.mAttributeId                                  //
-                : Clusters::Globals::Attributes::GeneratedCommandList::Id; //
-        }
-
-        // We allow fixed attribute IDs if and only if they are valid:
-        //    - they may be GLOBAL attributes OR
-        //    - they are valid attributes for this cluster
-        if (IsValidAttributeId(mpAttributePath->mValue.mAttributeId))
+        if (!mpAttributePath->mValue.HasWildcardAttributeId())
         {
+            // We allow fixed attribute IDs if and only if they are valid:
+            //    - they may be GLOBAL attributes OR
+            //    - they are valid attributes for this cluster
+            if (!IsValidAttributeId(mpAttributePath->mValue.mAttributeId))
+            {
+                return std::nullopt;
+            }
             return mpAttributePath->mValue.mAttributeId;
         }
 
-        return std::nullopt;
+        session.attributes = mDataModelProvider->GetAttributes(mOutputPath);
     }
 
     // advance the existing attribute id if it can be advanced
@@ -97,76 +90,120 @@ std::optional<AttributeId> AttributePathExpandIterator::NextAttributeId()
         return std::nullopt;
     }
 
-    AttributeEntry entry = mDataModelProvider->NextAttribute(mOutputPath);
-    if (entry.IsValid())
+    auto id = session.attributes->Next();
+    if (id.has_value())
     {
-        return entry.path.mAttributeId;
+        return id;
     }
 
     // Finished the data model, start with global attributes
     static_assert(ArraySize(GlobalAttributesNotInMetadata) > 0);
     return GlobalAttributesNotInMetadata[0];
 }
 
-std::optional<ClusterId> AttributePathExpandIterator::NextClusterId()
+std::optional<ClusterId> AttributePathExpandIterator::NextClusterId(SearchSession & session)
 {
-
     if (mOutputPath.mClusterId == kInvalidClusterId)
     {
-        if (mpAttributePath->mValue.HasWildcardClusterId())
+        if (!mpAttributePath->mValue.HasWildcardClusterId())
         {
-            ClusterEntry entry = mDataModelProvider->FirstServerCluster(mOutputPath.mEndpointId);
-            return entry.IsValid() ? std::make_optional(entry.path.mClusterId) : std::nullopt;
+            return mpAttributePath->mValue.mClusterId;
         }
 
-        // only return a cluster if it is valid
-        const ConcreteClusterPath clusterPath(mOutputPath.mEndpointId, mpAttributePath->mValue.mClusterId);
-        if (!mDataModelProvider->GetServerClusterInfo(clusterPath).has_value())
+        // restart iteration over the clusters of the current endpoint
+        session.clusters = mDataModelProvider->GetServerClusters(mOutputPath.mEndpointId);
+    }
+
+    VerifyOrReturnValue(mpAttributePath->mValue.HasWildcardClusterId(), std::nullopt);
+
+    return session.clusters->Next();
+}
+
+AttributePathExpandIterator::SearchSession AttributePathExpandIterator::PrepareSearch()
+{
+    SearchSession session;
+
+    session.endpoints = mDataModelProvider->GetEndpoints();
+
+    // position on the current endpoint to look up
+    if (mOutputPath.mEndpointId != kInvalidEndpointId)
+    {
+        // we are already positioned on a specific endpoint, so start from there
+        if (!session.endpoints->SeekTo(mOutputPath.mEndpointId))
         {
-            return std::nullopt;
+            ChipLogError(InteractionModel, "Endpoint id " ChipLogFormatMEI " is not valid anymore",
+                         ChipLogValueMEI(mOutputPath.mEndpointId));
         }
+    }
 
-        return mpAttributePath->mValue.mClusterId;
+    if (mOutputPath.mEndpointId != kInvalidEndpointId)
+    {
+        session.clusters = mDataModelProvider->GetServerClusters(mOutputPath.mEndpointId);
+        if (mOutputPath.mClusterId != kInvalidClusterId)
+        {
+            // we are already positioned on a specific cluster, so start from there
+            if (!session.clusters->SeekTo(mOutputPath.mClusterId))
+            {
+                ChipLogError(InteractionModel,
+                             "Cluster id " ChipLogFormatMEI " is not valid anymore (in endpoint " ChipLogFormatMEI ")",
+                             ChipLogValueMEI(mOutputPath.mClusterId), ChipLogValueMEI(mOutputPath.mEndpointId));
+            }
+        }
     }
 
-    VerifyOrReturnValue(mpAttributePath->mValue.HasWildcardClusterId(), std::nullopt);
+    if ((mOutputPath.mEndpointId != kInvalidEndpointId) && (mOutputPath.mClusterId != kInvalidClusterId))
+    {
+        session.attributes = mDataModelProvider->GetAttributes(mOutputPath);
+        if (mOutputPath.mAttributeId != kInvalidAttributeId)
+        {
+            // we are already positioned on a specific cluster, so start from there
+            if (!session.attributes->SeekTo(mOutputPath.mAttributeId))
+            {
+                ChipLogError(InteractionModel,
+                             "Attribute id " ChipLogFormatMEI " is not valid anymore (in " ChipLogFormatMEI "/" ChipLogFormatMEI
+                             ")",
+                             ChipLogValueMEI(mOutputPath.mAttributeId), ChipLogValueMEI(mOutputPath.mEndpointId),
+                             ChipLogValueMEI(mOutputPath.mClusterId));
+            }
+        }
+    }
 
-    ClusterEntry entry = mDataModelProvider->NextServerCluster(mOutputPath);
-    return entry.IsValid() ? std::make_optional(entry.path.mClusterId) : std::nullopt;
+    return session;
 }
 
-std::optional<ClusterId> AttributePathExpandIterator::NextEndpointId()
+std::optional<ClusterId> AttributePathExpandIterator::NextEndpointId(SearchSession & session)
 {
     if (mOutputPath.mEndpointId == kInvalidEndpointId)
     {
-        if (mpAttributePath->mValue.HasWildcardEndpointId())
+        if (!mpAttributePath->mValue.HasWildcardEndpointId())
         {
-            EndpointEntry ep = mDataModelProvider->FirstEndpoint();
-            return (ep.id != kInvalidEndpointId) ? std::make_optional(ep.id) : std::nullopt;
+            // use existing value, we are not wildcarding
+            return mpAttributePath->mValue.mEndpointId;
         }
-
-        return mpAttributePath->mValue.mEndpointId;
+        // start a new iteration
+        session.endpoints = mDataModelProvider->GetEndpoints();
     }
 
+    // to advance, we need to be asked for wildcards
     VerifyOrReturnValue(mpAttributePath->mValue.HasWildcardEndpointId(), std::nullopt);
 
-    EndpointEntry ep = mDataModelProvider->NextEndpoint(mOutputPath.mEndpointId);
-    return (ep.id != kInvalidEndpointId) ? std::make_optional(ep.id) : std::nullopt;
+    return session.endpoints->Next();
 }
 
-void AttributePathExpandIterator::ResetCurrentCluster()
+void AttributePathExpandIterator::ResetCurrentCluster(SearchSession & session)
 {
+    EnsureFirstNextCalled(session);
+
     // If this is a null iterator, or the attribute id of current cluster info is not a wildcard attribute id, then this function
     // will do nothing, since we won't be expanding the wildcard attribute ids under a cluster.
     VerifyOrReturn(mpAttributePath != nullptr && mpAttributePath->mValue.HasWildcardAttributeId());
-
     // Reset path expansion to ask for the first attribute of the current cluster
     mOutputPath.mAttributeId = kInvalidAttributeId;
     mOutputPath.mExpanded    = true; // we know this is a wildcard attribute
-    Next();
+    Next(session);
 }
 
-bool AttributePathExpandIterator::AdvanceOutputPath()
+bool AttributePathExpandIterator::AdvanceOutputPath(SearchSession & session)
 {
     if (!mpAttributePath->mValue.IsWildcardPath())
     {
@@ -187,7 +224,7 @@ bool AttributePathExpandIterator::AdvanceOutputPath()
         if (mOutputPath.mClusterId != kInvalidClusterId)
         {
 
-            std::optional<AttributeId> nextAttribute = NextAttributeId();
+            std::optional<AttributeId> nextAttribute = NextAttributeId(session);
             if (nextAttribute.has_value())
             {
                 mOutputPath.mAttributeId = *nextAttribute;
@@ -198,7 +235,7 @@ bool AttributePathExpandIterator::AdvanceOutputPath()
         // no valid attribute, try to advance the cluster, see if a suitable one exists
         if (mOutputPath.mEndpointId != kInvalidEndpointId)
         {
-            std::optional<ClusterId> nextCluster = NextClusterId();
+            std::optional<ClusterId> nextCluster = NextClusterId(session);
             if (nextCluster.has_value())
             {
                 mOutputPath.mClusterId   = *nextCluster;
@@ -208,7 +245,7 @@ bool AttributePathExpandIterator::AdvanceOutputPath()
         }
 
         // no valid cluster, try advance the endpoint, see if a suitable on exists
-        std::optional<EndpointId> nextEndpoint = NextEndpointId();
+        std::optional<EndpointId> nextEndpoint = NextEndpointId(session);
         if (nextEndpoint.has_value())
         {
             mOutputPath.mEndpointId = *nextEndpoint;
@@ -219,20 +256,23 @@ bool AttributePathExpandIterator::AdvanceOutputPath()
     }
 }
 
-bool AttributePathExpandIterator::Next()
+bool AttributePathExpandIterator::Next(SearchSession & session)
 {
+    EnsureFirstNextCalled(session);
     while (mpAttributePath != nullptr)
     {
-        if (AdvanceOutputPath())
+        if (AdvanceOutputPath(session))
         {
             return true;
         }
-        mpAttributePath       = mpAttributePath->mpNext;
-        mOutputPath           = ConcreteReadAttributePath(kInvalidEndpointId, kInvalidClusterId, kInvalidAttributeId);
-        mOutputPath.mExpanded = true; // this is reset to false on advancement if needed
+        mpAttributePath                  = mpAttributePath->mpNext;
+        mOutputPath                      = ConcreteReadAttributePath(kInvalidEndpointId, kInvalidClusterId, kInvalidAttributeId);
+        mOutputPath.mNeedsInitialization = false; // it is final
+        mOutputPath.mExpanded            = true;  // this is reset to false on advancement if needed
     }
 
-    mOutputPath = ConcreteReadAttributePath();
+    mOutputPath                      = ConcreteReadAttributePath();
+    mOutputPath.mNeedsInitialization = false; // it is final
     return false;
 }