[PATCH] Restyled by clang-format

project-chip · Feb 24, 2025 · 3a551c1 · 3a551c1
1 parent 1e118db
commit 3a551c1
Show file tree

Hide file tree

Showing 20 changed files with 102 additions and 79 deletions.
diff --git a/src/app/AttributePathExpandIterator.cpp b/src/app/AttributePathExpandIterator.cpp
@@ -17,9 +17,9 @@
 #include <app/AttributePathExpandIterator.h>
 
 #include <app/GlobalAttributes.h>
-#include <app/data-model/MetadataList.h>
 #include <app/data-model-provider/MetadataLookup.h>
 #include <app/data-model-provider/MetadataTypes.h>
+#include <app/data-model/MetadataList.h>
 #include <lib/core/DataModelTypes.h>
 #include <lib/support/CodeUtils.h>
 

diff --git a/src/app/CommandHandlerInterface.h b/src/app/CommandHandlerInterface.h
@@ -30,7 +30,7 @@
 namespace chip {
 namespace app {
 namespace DataModel {
-    struct AcceptedCommandEntry;
+struct AcceptedCommandEntry;
 }
 
 /*
@@ -126,7 +126,8 @@ class CommandHandlerInterface
      * This is used by callbacks that just look for a particular value in the
      * list.
      */
-    virtual CHIP_ERROR EnumerateAcceptedCommands(const ConcreteClusterPath & cluster, DataModel::ListBuilder<DataModel::AcceptedCommandEntry> & builder)
+    virtual CHIP_ERROR EnumerateAcceptedCommands(const ConcreteClusterPath & cluster,
+                                                 DataModel::ListBuilder<DataModel::AcceptedCommandEntry> & builder)
     {
         return CHIP_ERROR_NOT_IMPLEMENTED;
     }

diff --git a/src/app/InteractionModelEngine.cpp b/src/app/InteractionModelEngine.cpp
@@ -37,11 +37,11 @@
 #include <app/EventPathParams.h>
 #include <app/RequiredPrivilege.h>
 #include <app/data-model-provider/ActionReturnStatus.h>
-#include <app/data-model/MetadataList.h>
 #include <app/data-model-provider/MetadataLookup.h>
 #include <app/data-model-provider/MetadataTypes.h>
 #include <app/data-model-provider/OperationTypes.h>
 #include <app/data-model/List.h>
+#include <app/data-model/MetadataList.h>
 #include <app/util/IMClusterCommandHandler.h>
 #include <app/util/af-types.h>
 #include <app/util/endpoint-config-api.h>

diff --git a/src/app/clusters/descriptor/descriptor.cpp b/src/app/clusters/descriptor/descriptor.cpp
@@ -23,9 +23,9 @@
 #include <app/AttributeAccessInterface.h>
 #include <app/AttributeAccessInterfaceRegistry.h>
 #include <app/InteractionModelEngine.h>
-#include <app/data-model/MetadataList.h>
 #include <app/data-model-provider/MetadataTypes.h>
 #include <app/data-model/List.h>
+#include <app/data-model/MetadataList.h>
 #include <app/util/attribute-storage.h>
 #include <app/util/endpoint-config-api.h>
 #include <lib/core/CHIPError.h>

diff --git a/src/app/clusters/device-energy-management-server/device-energy-management-server.cpp b/src/app/clusters/device-energy-management-server/device-energy-management-server.cpp
@@ -104,48 +104,53 @@ CHIP_ERROR Instance::Read(const ConcreteReadAttributePath & aPath, AttributeValu
 }
 
 // CommandHandlerInterface
-CHIP_ERROR Instance::EnumerateAcceptedCommands(const ConcreteClusterPath & cluster, DataModel::ListBuilder<DataModel::AcceptedCommandEntry> & builder)
+CHIP_ERROR Instance::EnumerateAcceptedCommands(const ConcreteClusterPath & cluster,
+                                               DataModel::ListBuilder<DataModel::AcceptedCommandEntry> & builder)
 {
     using namespace Commands;
-    using QF = DataModel::CommandQualityFlags;
-    static const auto kDefaultFlags = chip::BitFlags<QF>(QF::kTimed, QF::kLargeMessage, QF::kFabricScoped);
+    using QF                            = DataModel::CommandQualityFlags;
+    static const auto kDefaultFlags     = chip::BitFlags<QF>(QF::kTimed, QF::kLargeMessage, QF::kFabricScoped);
     static const auto kDefaultPrivilege = chip::Access::Privilege::kOperate;
 
     if (HasFeature(Feature::kPowerAdjustment))
     {
         ReturnErrorOnFailure(builder.AppendElements({
-            {PowerAdjustRequest::Id,       kDefaultFlags, kDefaultPrivilege}, //TODO:: WHAT IS THE NEEDED PRIVILEGE AND CommandQualityFlags
-            {CancelPowerAdjustRequest::Id, kDefaultFlags, kDefaultPrivilege}  //TODO:: WHAT IS THE NEEDED PRIVILEGE AND CommandQualityFlags
+            { PowerAdjustRequest::Id, kDefaultFlags,
+              kDefaultPrivilege }, // TODO:: WHAT IS THE NEEDED PRIVILEGE AND CommandQualityFlags
+            { CancelPowerAdjustRequest::Id, kDefaultFlags,
+              kDefaultPrivilege } // TODO:: WHAT IS THE NEEDED PRIVILEGE AND CommandQualityFlags
         }));
     }
 
     if (HasFeature(Feature::kStartTimeAdjustment))
     {
-        ReturnErrorOnFailure(builder.Append({StartTimeAdjustRequest::Id, kDefaultFlags, kDefaultPrivilege})); //TODO:: WHAT IS THE NEEDED PRIVILEGE AND CommandQualityFlags
+        ReturnErrorOnFailure(builder.Append({ StartTimeAdjustRequest::Id, kDefaultFlags,
+                                              kDefaultPrivilege })); // TODO:: WHAT IS THE NEEDED PRIVILEGE AND CommandQualityFlags
     }
 
     if (HasFeature(Feature::kPausable))
     {
-        ReturnErrorOnFailure(builder.AppendElements({
-            {PauseRequest::Id,  kDefaultFlags, kDefaultPrivilege},
-            {ResumeRequest::Id, kDefaultFlags, kDefaultPrivilege}
-        }));
+        ReturnErrorOnFailure(builder.AppendElements(
+            { { PauseRequest::Id, kDefaultFlags, kDefaultPrivilege }, { ResumeRequest::Id, kDefaultFlags, kDefaultPrivilege } }));
     }
 
     if (HasFeature(Feature::kForecastAdjustment))
     {
-        ReturnErrorOnFailure(builder.Append({ModifyForecastRequest::Id, kDefaultFlags, kDefaultPrivilege})); //TODO:: WHAT IS THE NEEDED PRIVILEGE AND CommandQualityFlags
+        ReturnErrorOnFailure(builder.Append({ ModifyForecastRequest::Id, kDefaultFlags,
+                                              kDefaultPrivilege })); // TODO:: WHAT IS THE NEEDED PRIVILEGE AND CommandQualityFlags
     }
 
     if (HasFeature(Feature::kConstraintBasedAdjustment))
     {
-       ReturnErrorOnFailure(builder.Append({ModifyForecastRequest::Id, kDefaultFlags, kDefaultPrivilege})); //TODO:: WHAT IS THE NEEDED PRIVILEGE AND CommandQualityFlags
+        ReturnErrorOnFailure(builder.Append({ ModifyForecastRequest::Id, kDefaultFlags,
+                                              kDefaultPrivilege })); // TODO:: WHAT IS THE NEEDED PRIVILEGE AND CommandQualityFlags
     }
 
     if (HasFeature(Feature::kStartTimeAdjustment) || HasFeature(Feature::kForecastAdjustment) ||
         HasFeature(Feature::kConstraintBasedAdjustment))
     {
-        ReturnErrorOnFailure(builder.Append({CancelRequest::Id, kDefaultFlags, kDefaultPrivilege})); //TODO:: WHAT IS THE NEEDED PRIVILEGE AND CommandQualityFlags
+        ReturnErrorOnFailure(builder.Append({ CancelRequest::Id, kDefaultFlags,
+                                              kDefaultPrivilege })); // TODO:: WHAT IS THE NEEDED PRIVILEGE AND CommandQualityFlags
     }
 
     return CHIP_NO_ERROR;

diff --git a/src/app/clusters/device-energy-management-server/device-energy-management-server.h b/src/app/clusters/device-energy-management-server/device-energy-management-server.h
@@ -235,7 +235,8 @@ class Instance : public AttributeAccessInterface, public CommandHandlerInterface
 
     // CommandHandlerInterface
     void InvokeCommand(HandlerContext & handlerContext) override;
-    CHIP_ERROR EnumerateAcceptedCommands(const ConcreteClusterPath & cluster,  DataModel::ListBuilder<DataModel::AcceptedCommandEntry> & builder) override;
+    CHIP_ERROR EnumerateAcceptedCommands(const ConcreteClusterPath & cluster,
+                                         DataModel::ListBuilder<DataModel::AcceptedCommandEntry> & builder) override;
 
     Protocols::InteractionModel::Status CheckOptOutAllowsRequest(AdjustmentCauseEnum adjustmentCause);
     void HandlePowerAdjustRequest(HandlerContext & ctx, const Commands::PowerAdjustRequest::DecodableType & commandData);

diff --git a/src/app/clusters/energy-evse-server/energy-evse-server.cpp b/src/app/clusters/energy-evse-server/energy-evse-server.cpp
@@ -182,35 +182,36 @@ CHIP_ERROR Instance::Write(const ConcreteDataAttributePath & aPath, AttributeVal
 }
 
 // CommandHandlerInterface
-CHIP_ERROR Instance::EnumerateAcceptedCommands(const ConcreteClusterPath & cluster,  DataModel::ListBuilder<DataModel::AcceptedCommandEntry> & builder)
+CHIP_ERROR Instance::EnumerateAcceptedCommands(const ConcreteClusterPath & cluster,
+                                               DataModel::ListBuilder<DataModel::AcceptedCommandEntry> & builder)
 {
     using namespace Commands;
-    using QF = DataModel::CommandQualityFlags;
-    static const auto kDefaultFlags = chip::BitFlags<QF>(QF::kTimed, QF::kLargeMessage, QF::kFabricScoped);
+    using QF                            = DataModel::CommandQualityFlags;
+    static const auto kDefaultFlags     = chip::BitFlags<QF>(QF::kTimed, QF::kLargeMessage, QF::kFabricScoped);
     static const auto kDefaultPrivilege = chip::Access::Privilege::kOperate;
 
     ReturnErrorOnFailure(builder.AppendElements({
-        {Disable::Id, kDefaultFlags, kDefaultPrivilege},
-        {EnableCharging::Id, kDefaultFlags, kDefaultPrivilege},
+        { Disable::Id, kDefaultFlags, kDefaultPrivilege },
+        { EnableCharging::Id, kDefaultFlags, kDefaultPrivilege },
     }));
 
     if (HasFeature(Feature::kV2x))
     {
-        ReturnErrorOnFailure(builder.Append({EnableDischarging::Id, kDefaultFlags, kDefaultPrivilege}) );
+        ReturnErrorOnFailure(builder.Append({ EnableDischarging::Id, kDefaultFlags, kDefaultPrivilege }));
     }
 
     if (HasFeature(Feature::kChargingPreferences))
     {
         ReturnErrorOnFailure(builder.AppendElements({
-            {SetTargets::Id, kDefaultFlags, kDefaultPrivilege},
-            {GetTargets::Id, kDefaultFlags, kDefaultPrivilege},
-            {ClearTargets::Id, kDefaultFlags, kDefaultPrivilege},
+            { SetTargets::Id, kDefaultFlags, kDefaultPrivilege },
+            { GetTargets::Id, kDefaultFlags, kDefaultPrivilege },
+            { ClearTargets::Id, kDefaultFlags, kDefaultPrivilege },
         }));
     }
 
     if (SupportsOptCmd(OptionalCommands::kSupportsStartDiagnostics))
     {
-        ReturnErrorOnFailure(builder.Append({StartDiagnostics::Id, kDefaultFlags, kDefaultPrivilege}));
+        ReturnErrorOnFailure(builder.Append({ StartDiagnostics::Id, kDefaultFlags, kDefaultPrivilege }));
     }
     return CHIP_NO_ERROR;
 }

diff --git a/src/app/clusters/energy-evse-server/energy-evse-server.h b/src/app/clusters/energy-evse-server/energy-evse-server.h
@@ -200,7 +200,8 @@ class Instance : public AttributeAccessInterface, public CommandHandlerInterface
 
     // CommandHandlerInterface
     void InvokeCommand(HandlerContext & handlerContext) override;
-    CHIP_ERROR EnumerateAcceptedCommands(const ConcreteClusterPath & cluster,  DataModel::ListBuilder<DataModel::AcceptedCommandEntry> & builder) override;
+    CHIP_ERROR EnumerateAcceptedCommands(const ConcreteClusterPath & cluster,
+                                         DataModel::ListBuilder<DataModel::AcceptedCommandEntry> & builder) override;
 
     void HandleDisable(HandlerContext & ctx, const Commands::Disable::DecodableType & commandData);
     void HandleEnableCharging(HandlerContext & ctx, const Commands::EnableCharging::DecodableType & commandData);

diff --git a/src/app/clusters/microwave-oven-control-server/microwave-oven-control-server.cpp b/src/app/clusters/microwave-oven-control-server/microwave-oven-control-server.cpp
@@ -16,7 +16,6 @@
  *
  */
 
-#include <app/data-model/MetadataList.h>
 #include <app-common/zap-generated/attributes/Accessors.h>
 #include <app/AttributeAccessInterfaceRegistry.h>
 #include <app/CommandHandlerInterfaceRegistry.h>
@@ -25,6 +24,7 @@
 #include <app/clusters/microwave-oven-control-server/microwave-oven-control-server.h>
 #include <app/clusters/mode-base-server/mode-base-server.h>
 #include <app/data-model-provider/MetadataTypes.h>
+#include <app/data-model/MetadataList.h>
 #include <app/reporting/reporting.h>
 #include <app/util/attribute-storage.h>
 

diff --git a/src/app/clusters/network-commissioning/network-commissioning.cpp b/src/app/clusters/network-commissioning/network-commissioning.cpp
@@ -1360,32 +1360,33 @@ void Instance::OnFailSafeTimerExpired()
     }
 }
 
-CHIP_ERROR Instance::EnumerateAcceptedCommands(const ConcreteClusterPath & cluster, DataModel::ListBuilder<DataModel::AcceptedCommandEntry> & builder)
+CHIP_ERROR Instance::EnumerateAcceptedCommands(const ConcreteClusterPath & cluster,
+                                               DataModel::ListBuilder<DataModel::AcceptedCommandEntry> & builder)
 {
     using namespace Clusters::NetworkCommissioning::Commands;
-    using QF = DataModel::CommandQualityFlags;
-    static const auto kDefaultFlags = chip::BitFlags<QF>(QF::kTimed, QF::kLargeMessage, QF::kFabricScoped);
+    using QF                            = DataModel::CommandQualityFlags;
+    static const auto kDefaultFlags     = chip::BitFlags<QF>(QF::kTimed, QF::kLargeMessage, QF::kFabricScoped);
     static const auto kDefaultPrivilege = chip::Access::Privilege::kOperate;
 
-    bool hasNet = mFeatureFlags.Has(Feature::kThreadNetworkInterface);
+    bool hasNet  = mFeatureFlags.Has(Feature::kThreadNetworkInterface);
     bool hasWifi = mFeatureFlags.Has(Feature::kWiFiNetworkInterface);
     bool hasCred = mFeatureFlags.Has(Feature::kPerDeviceCredentials);
-    auto netId = hasNet? AddOrUpdateThreadNetwork::Id : AddOrUpdateWiFiNetwork::Id;
-
-    static const DataModel::AcceptedCommandEntry commands [6] = {
-        {ScanNetworks::Id, kDefaultFlags, kDefaultPrivilege},
-        {netId, kDefaultFlags, kDefaultPrivilege},
-        {RemoveNetwork::Id, kDefaultFlags, kDefaultPrivilege},
-        {ConnectNetwork::Id, kDefaultFlags, kDefaultPrivilege},
-        {ReorderNetwork::Id, kDefaultFlags, kDefaultPrivilege},
-        {QueryIdentity::Id, kDefaultFlags, kDefaultPrivilege}
+    auto netId   = hasNet ? AddOrUpdateThreadNetwork::Id : AddOrUpdateWiFiNetwork::Id;
+
+    static const DataModel::AcceptedCommandEntry commands[6] = {
+        { ScanNetworks::Id, kDefaultFlags, kDefaultPrivilege },   { netId, kDefaultFlags, kDefaultPrivilege },
+        { RemoveNetwork::Id, kDefaultFlags, kDefaultPrivilege },  { ConnectNetwork::Id, kDefaultFlags, kDefaultPrivilege },
+        { ReorderNetwork::Id, kDefaultFlags, kDefaultPrivilege }, { QueryIdentity::Id, kDefaultFlags, kDefaultPrivilege }
     };
 
-    if(hasNet | hasWifi) {
-        //Avoid extra memory allocation
-        return builder.ReferenceExisting({commands, size_t{5} + (hasCred? 1 : 0)});
-    } else if(hasCred) {
-        return builder.ReferenceExisting({commands + 5, size_t{1}});
+    if (hasNet | hasWifi)
+    {
+        // Avoid extra memory allocation
+        return builder.ReferenceExisting({ commands, size_t{ 5 } + (hasCred ? 1 : 0) });
+    }
+    else if (hasCred)
+    {
+        return builder.ReferenceExisting({ commands + 5, size_t{ 1 } });
     }
 
     return CHIP_NO_ERROR;
@@ -1397,7 +1398,8 @@ CHIP_ERROR Instance::EnumerateGeneratedCommands(const ConcreteClusterPath & clus
 
     if (mFeatureFlags.HasAny(Feature::kWiFiNetworkInterface, Feature::kThreadNetworkInterface))
     {
-        ReturnErrorOnFailure(builder.AppendElements({ ScanNetworksResponse::Id, NetworkConfigResponse::Id, ConnectNetworkResponse::Id }));
+        ReturnErrorOnFailure(
+            builder.AppendElements({ ScanNetworksResponse::Id, NetworkConfigResponse::Id, ConnectNetworkResponse::Id }));
     }
 
     if (mFeatureFlags.Has(Feature::kPerDeviceCredentials))

diff --git a/src/app/clusters/network-commissioning/network-commissioning.h b/src/app/clusters/network-commissioning/network-commissioning.h
@@ -59,8 +59,10 @@ class Instance : public CommandHandlerInterface,
 
     // CommandHandlerInterface
     void InvokeCommand(HandlerContext & ctx) override;
-    CHIP_ERROR EnumerateAcceptedCommands(const ConcreteClusterPath & cluster,  DataModel::ListBuilder<DataModel::AcceptedCommandEntry> & builder) override;
-    CHIP_ERROR EnumerateGeneratedCommands(const ConcreteClusterPath & cluster, DataModel::ListBuilder<CommandId> & builder) override;
+    CHIP_ERROR EnumerateAcceptedCommands(const ConcreteClusterPath & cluster,
+                                         DataModel::ListBuilder<DataModel::AcceptedCommandEntry> & builder) override;
+    CHIP_ERROR EnumerateGeneratedCommands(const ConcreteClusterPath & cluster,
+                                          DataModel::ListBuilder<CommandId> & builder) override;
 
     // AttributeAccessInterface
     CHIP_ERROR Read(const ConcreteReadAttributePath & aPath, AttributeValueEncoder & aEncoder) override;

diff --git a/src/app/clusters/resource-monitoring-server/resource-monitoring-server.cpp b/src/app/clusters/resource-monitoring-server/resource-monitoring-server.cpp
@@ -187,17 +187,18 @@ void Instance::InvokeCommand(HandlerContext & handlerContext)
 }
 
 // List the commands supported by this instance.
-CHIP_ERROR Instance::EnumerateAcceptedCommands(const ConcreteClusterPath & cluster, DataModel::ListBuilder<DataModel::AcceptedCommandEntry> & builder)
+CHIP_ERROR Instance::EnumerateAcceptedCommands(const ConcreteClusterPath & cluster,
+                                               DataModel::ListBuilder<DataModel::AcceptedCommandEntry> & builder)
 {
     using namespace ResourceMonitoring::Commands;
-    using QF = DataModel::CommandQualityFlags;
-    static const auto kDefaultFlags = chip::BitFlags<QF>(QF::kTimed, QF::kLargeMessage, QF::kFabricScoped);
+    using QF                            = DataModel::CommandQualityFlags;
+    static const auto kDefaultFlags     = chip::BitFlags<QF>(QF::kTimed, QF::kLargeMessage, QF::kFabricScoped);
     static const auto kDefaultPrivilege = chip::Access::Privilege::kOperate;
 
     ChipLogDetail(Zcl, "resourcemonitoring: EnumerateAcceptedCommands");
     if (mResetConditionCommandSupported)
     {
-        return builder.Append({ResetCondition::Id, kDefaultFlags, kDefaultPrivilege});
+        return builder.Append({ ResetCondition::Id, kDefaultFlags, kDefaultPrivilege });
     }
 
     return CHIP_NO_ERROR;

diff --git a/src/app/clusters/resource-monitoring-server/resource-monitoring-server.h b/src/app/clusters/resource-monitoring-server/resource-monitoring-server.h
@@ -132,7 +132,8 @@ class Instance : public CommandHandlerInterface, public AttributeAccessInterface
 
     // CommandHandlerInterface
     void InvokeCommand(HandlerContext & ctx) override;
-    CHIP_ERROR EnumerateAcceptedCommands(const ConcreteClusterPath & cluster,  DataModel::ListBuilder<DataModel::AcceptedCommandEntry> & builder) override;
+    CHIP_ERROR EnumerateAcceptedCommands(const ConcreteClusterPath & cluster,
+                                         DataModel::ListBuilder<DataModel::AcceptedCommandEntry> & builder) override;
 
     // AttributeAccessInterface
     CHIP_ERROR Read(const ConcreteReadAttributePath & aPath, AttributeValueEncoder & aEncoder) override;

diff --git a/src/app/clusters/software-diagnostics-server/software-diagnostics-server.cpp b/src/app/clusters/software-diagnostics-server/software-diagnostics-server.cpp
@@ -62,7 +62,8 @@ class SoftwareDiagnosticsCommandHandler : public CommandHandlerInterface
 
     void InvokeCommand(HandlerContext & handlerContext) override;
 
-    CHIP_ERROR EnumerateAcceptedCommands(const ConcreteClusterPath & cluster,  DataModel::ListBuilder<DataModel::AcceptedCommandEntry> & builder) override;
+    CHIP_ERROR EnumerateAcceptedCommands(const ConcreteClusterPath & cluster,
+                                         DataModel::ListBuilder<DataModel::AcceptedCommandEntry> & builder) override;
 };
 
 SoftwareDiagosticsAttrAccess gAttrAccess;
@@ -168,19 +169,21 @@ void SoftwareDiagnosticsCommandHandler::InvokeCommand(HandlerContext & handlerCo
     handlerContext.mCommandHandler.AddStatus(handlerContext.mRequestPath, status);
 }
 
-CHIP_ERROR SoftwareDiagnosticsCommandHandler::EnumerateAcceptedCommands(const ConcreteClusterPath & cluster, DataModel::ListBuilder<DataModel::AcceptedCommandEntry> & builder)
+CHIP_ERROR
+SoftwareDiagnosticsCommandHandler::EnumerateAcceptedCommands(const ConcreteClusterPath & cluster,
+                                                             DataModel::ListBuilder<DataModel::AcceptedCommandEntry> & builder)
 {
     using namespace Commands;
-    using QF = DataModel::CommandQualityFlags;
-    static const auto kDefaultFlags = chip::BitFlags<QF>(QF::kTimed, QF::kLargeMessage, QF::kFabricScoped);
+    using QF                            = DataModel::CommandQualityFlags;
+    static const auto kDefaultFlags     = chip::BitFlags<QF>(QF::kTimed, QF::kLargeMessage, QF::kFabricScoped);
     static const auto kDefaultPrivilege = chip::Access::Privilege::kOperate;
     if (!DeviceLayer::GetDiagnosticDataProvider().SupportsWatermarks())
     {
         // No commmands.
         return CHIP_NO_ERROR;
     }
 
-    return builder.Append({ResetWatermarks::Id, kDefaultFlags, kDefaultPrivilege});
+    return builder.Append({ ResetWatermarks::Id, kDefaultFlags, kDefaultPrivilege });
 }
 
 } // anonymous namespace

diff --git a/src/app/data-model-provider/MetadataLookup.h b/src/app/data-model-provider/MetadataLookup.h
@@ -19,9 +19,9 @@
 
 #include <app/ConcreteAttributePath.h>
 #include <app/ConcreteClusterPath.h>
-#include <app/data-model/MetadataList.h>
 #include <app/data-model-provider/MetadataTypes.h>
 #include <app/data-model-provider/ProviderMetadataTree.h>
+#include <app/data-model/MetadataList.h>
 #include <lib/core/DataModelTypes.h>
 #include <lib/support/CodeUtils.h>
 

diff --git a/src/app/data-model-provider/ProviderMetadataTree.h b/src/app/data-model-provider/ProviderMetadataTree.h
@@ -21,9 +21,9 @@
 #include <app/ConcreteAttributePath.h>
 #include <app/ConcreteClusterPath.h>
 #include <app/ConcreteCommandPath.h>
-#include <app/data-model/MetadataList.h>
 #include <app/data-model-provider/MetadataTypes.h>
 #include <app/data-model/List.h>
+#include <app/data-model/MetadataList.h>
 #include <lib/support/Span.h>
 
 namespace chip {

diff --git a/src/app/reporting/Engine.cpp b/src/app/reporting/Engine.cpp
@@ -172,7 +172,9 @@ DataModel::ActionReturnStatus RetrieveClusterData(DataModel::Provider * dataMode
     reportBuilder.Checkpoint(checkpoint);
 
     DataModel::ActionReturnStatus status(CHIP_NO_ERROR);
-    AttributeValueEncoder attributeValueEncoder ={reportBuilder, subjectDescriptor, path, version, isFabricFiltered, encoderState};
+    AttributeValueEncoder attributeValueEncoder = {
+        reportBuilder, subjectDescriptor, path, version, isFabricFiltered, encoderState
+    };
 
     // TODO: we explicitly DO NOT validate that path is a valid cluster path (even more, above serverClusterFinder
     //       explicitly ignores that case). This means that global attribute reads as well as ReadAttribute