Restyled by clang-format

Author: restyled-commits

src/app/clusters/occupancy-sensor-server/occupancy-sensor-server.cpp

@@ -15,17 +15,15 @@
  *    limitations under the License.
  */
 
-#include "occupancy-hal.h"
 #include "occupancy-sensor-server.h"
+#include "occupancy-hal.h"
 
 #include <app/AttributeAccessInterfaceRegistry.h>
-#include <app/data-model/Encode.h>
 #include <app/EventLogging.h>
+#include <app/data-model/Encode.h>
 #include <app/util/attribute-storage.h>
 #include <lib/core/CHIPError.h>
 
-
-
 using chip::Protocols::InteractionModel::Status;
 
 namespace chip {
@@ -35,19 +33,19 @@ namespace OccupancySensing {
 
 Structs::HoldTimeLimitsStruct::Type * HoldTimeLimitsManager::HoldTimeLimits::GetHoldTimeLimitsStruct(EndpointId endpoint)
 {
-	size_t endpointIndex = 0;
-	Structs::HoldTimeLimitsStruct::Type * holdTimeLimitsStruct = nullptr;
-	CHIP_ERROR status = FindHoldTimeLimitsIndex(endpoint, endpointIndex);
-	if (CHIP_NO_ERROR == status)
+    size_t endpointIndex                                       = 0;
+    Structs::HoldTimeLimitsStruct::Type * holdTimeLimitsStruct = nullptr;
+    CHIP_ERROR status                                          = FindHoldTimeLimitsIndex(endpoint, endpointIndex);
+    if (CHIP_NO_ERROR == status)
     {
         holdTimeLimitsStruct = &mHoldTimeLimitsStructs[endpointIndex];
     }
     return holdTimeLimitsStruct;
 }
 
-
-CHIP_ERROR HoldTimeLimitsManager::HoldTimeLimits::SetHoldTimeLimitsStruct(EndpointId endpoint,
-                                                             Structs::HoldTimeLimitsStruct::Type & holdTimeLimitsStruct)
+CHIP_ERROR
+HoldTimeLimitsManager::HoldTimeLimits::SetHoldTimeLimitsStruct(EndpointId endpoint,
+                                                               Structs::HoldTimeLimitsStruct::Type & holdTimeLimitsStruct)
 {
     VerifyOrReturnError(kInvalidEndpointId != endpoint, CHIP_ERROR_INVALID_ARGUMENT);
 
@@ -67,8 +65,8 @@ CHIP_ERROR HoldTimeLimitsManager::HoldTimeLimits::FindHoldTimeLimitsIndex(Endpoi
 {
     VerifyOrReturnError(kInvalidEndpointId != endpoint, CHIP_ERROR_INVALID_ARGUMENT);
 
-    uint16_t index =
-        emberAfGetClusterServerEndpointIndex(endpoint, OccupancySensing::Id, MATTER_DM_OCCUPANCY_SENSING_CLUSTER_SERVER_ENDPOINT_COUNT);
+    uint16_t index = emberAfGetClusterServerEndpointIndex(endpoint, OccupancySensing::Id,
+                                                          MATTER_DM_OCCUPANCY_SENSING_CLUSTER_SERVER_ENDPOINT_COUNT);
 
     if (index < ArraySize(mHoldTimeLimitsStructs))
     {
@@ -90,41 +88,41 @@ CHIP_ERROR HoldTimeLimitsManager::Init()
     // Prevents re-initializing
     VerifyOrReturnError(!mIsInitialized, CHIP_ERROR_INCORRECT_STATE);
 
-    for(size_t  i = 0; i <= kOccupancySensingServerMaxEndpointCount; i++)
+    for (size_t i = 0; i <= kOccupancySensingServerMaxEndpointCount; i++)
     {
-        if(emberAfContainsServer(EndpointId(i), OccupancySensing::Id))
-		{
-			Structs::HoldTimeLimitsStruct::Type holdTimeLimitsInit;
+        if (emberAfContainsServer(EndpointId(i), OccupancySensing::Id))
+        {
+            Structs::HoldTimeLimitsStruct::Type holdTimeLimitsInit;
 
-      // Set up some sane initial values for hold time limits structures
-			holdTimeLimitsInit.holdTimeMin = 1;
-			holdTimeLimitsInit.holdTimeMax = 300;
-			holdTimeLimitsInit.holdTimeDefault = 10;
+            // Set up some sane initial values for hold time limits structures
+            holdTimeLimitsInit.holdTimeMin     = 1;
+            holdTimeLimitsInit.holdTimeMax     = 300;
+            holdTimeLimitsInit.holdTimeDefault = 10;
 
-			HoldTimeLimitsManager::Instance().SetHoldTimeLimitsStruct(EndpointId(i),holdTimeLimitsInit);
-		}
-	}
+            HoldTimeLimitsManager::Instance().SetHoldTimeLimitsStruct(EndpointId(i), holdTimeLimitsInit);
+        }
+    }
 
     VerifyOrReturnError(registerAttributeAccessOverride(this), CHIP_ERROR_INCORRECT_STATE);
 
-
     mIsInitialized = true;
     return CHIP_NO_ERROR;
 }
 
-//AttributeAccessInterface
+// AttributeAccessInterface
 CHIP_ERROR HoldTimeLimitsManager::Read(const ConcreteReadAttributePath & aPath, AttributeValueEncoder & aEncoder)
 {
     switch (aPath.mAttributeId)
     {
     case Attributes::HoldTimeLimits::Id: {
 
-		Structs::HoldTimeLimitsStruct::Type * holdTimeLimitsStruct = HoldTimeLimitsManager::Instance().mHoldTimeLimits.GetHoldTimeLimitsStruct(aPath.mEndpointId);
-		Structs::HoldTimeLimitsStruct::Type res;
-		res.holdTimeMin = holdTimeLimitsStruct->holdTimeMin;
-		res.holdTimeMax = holdTimeLimitsStruct->holdTimeMax;
-		res.holdTimeDefault = holdTimeLimitsStruct->holdTimeDefault;
-		return aEncoder.Encode(res);
+        Structs::HoldTimeLimitsStruct::Type * holdTimeLimitsStruct =
+            HoldTimeLimitsManager::Instance().mHoldTimeLimits.GetHoldTimeLimitsStruct(aPath.mEndpointId);
+        Structs::HoldTimeLimitsStruct::Type res;
+        res.holdTimeMin     = holdTimeLimitsStruct->holdTimeMin;
+        res.holdTimeMax     = holdTimeLimitsStruct->holdTimeMax;
+        res.holdTimeDefault = holdTimeLimitsStruct->holdTimeDefault;
+        return aEncoder.Encode(res);
     }
     default:
         return CHIP_NO_ERROR;
@@ -138,7 +136,7 @@ Structs::HoldTimeLimitsStruct::Type * HoldTimeLimitsManager::GetHoldTimeLimitsSt
 }
 
 CHIP_ERROR HoldTimeLimitsManager::SetHoldTimeLimitsStruct(EndpointId endpoint,
-                                            Structs::HoldTimeLimitsStruct::Type & holdTimeLimitsStruct)
+                                                          Structs::HoldTimeLimitsStruct::Type & holdTimeLimitsStruct)
 {
     ReturnErrorOnFailure(mHoldTimeLimits.SetHoldTimeLimitsStruct(endpoint, holdTimeLimitsStruct));
     return CHIP_NO_ERROR;
@@ -214,15 +212,14 @@ void halOccupancyStateChangedCallback(EndpointId endpoint, HalOccupancyState occ
     Attributes::Occupancy::Set(endpoint, occupancyState);
 }
 
-
 HalOccupancySensorType __attribute__((weak)) halOccupancyGetSensorType(EndpointId endpoint)
 {
     return HAL_OCCUPANCY_SENSOR_TYPE_PIR;
 }
 
 void MatterOccupancySensingPluginServerInitCallback()
 {
-	CHIP_ERROR err = HoldTimeLimitsManager::Instance().Init();
+    CHIP_ERROR err = HoldTimeLimitsManager::Instance().Init();
     if (err != CHIP_NO_ERROR)
     {
         ChipLogError(Zcl, "HoldTimeLimitsManager::Instance().Init() error: %" CHIP_ERROR_FORMAT, err.Format());

src/app/clusters/occupancy-sensor-server/occupancy-sensor-server.h

@@ -25,7 +25,6 @@
 #include <app/util/config.h>
 #include <lib/core/DataModelTypes.h>
 
-
 namespace chip {
 namespace app {
 namespace Clusters {
@@ -37,19 +36,19 @@ namespace OccupancySensing {
 class HoldTimeLimitsManager : public AttributeAccessInterface
 {
 public:
-	static constexpr size_t kOccupancySensingServerMaxEndpointCount =
+    static constexpr size_t kOccupancySensingServerMaxEndpointCount =
         MATTER_DM_OCCUPANCY_SENSING_CLUSTER_SERVER_ENDPOINT_COUNT + CHIP_DEVICE_CONFIG_DYNAMIC_ENDPOINT_COUNT;
     static_assert(kOccupancySensingServerMaxEndpointCount <= kInvalidEndpointId, "Occupancy Sensing endpoint count error");
 
-	//HoldTimeLimits
+    // HoldTimeLimits
     class HoldTimeLimits
     {
     public:
-		Structs::HoldTimeLimitsStruct::Type * GetHoldTimeLimitsStruct(EndpointId endpoint);
+        Structs::HoldTimeLimitsStruct::Type * GetHoldTimeLimitsStruct(EndpointId endpoint);
         CHIP_ERROR SetHoldTimeLimitsStruct(EndpointId endpoint, Structs::HoldTimeLimitsStruct::Type & holdTimeLimitsStruct);
 
     private:
-		/// @brief Returns the index of the HoldTimeLimits associated to an endpoint
+        /// @brief Returns the index of the HoldTimeLimits associated to an endpoint
         /// @param[in] endpoint target endpoint
         /// @param[out] endpointIndex index of the corresponding HoldTimeLimits for an endpoint
         /// @return CHIP_NO_ERROR or CHIP_ERROR_NOT_FOUND, CHIP_ERROR_INVALID_ARGUMENT if invalid endpoint
@@ -58,27 +57,27 @@ class HoldTimeLimitsManager : public AttributeAccessInterface
         Structs::HoldTimeLimitsStruct::Type mHoldTimeLimitsStructs[kOccupancySensingServerMaxEndpointCount];
     };
 
-	static HoldTimeLimitsManager & Instance();
+    static HoldTimeLimitsManager & Instance();
 
-	CHIP_ERROR Init();
+    CHIP_ERROR Init();
 
-	// AttributeAccessInterface
+    // AttributeAccessInterface
     CHIP_ERROR Read(const ConcreteReadAttributePath & aPath, AttributeValueEncoder & aEncoder) override;
 
-	// HoldTimeLimitsStruct Accessors
+    // HoldTimeLimitsStruct Accessors
     Structs::HoldTimeLimitsStruct::Type * GetHoldTimeLimitsStruct(EndpointId endpoint);
     CHIP_ERROR SetHoldTimeLimitsStruct(EndpointId endpoint, Structs::HoldTimeLimitsStruct::Type & holdTimeLimitsStruct);
 
 private:
     HoldTimeLimitsManager() : AttributeAccessInterface(Optional<EndpointId>(), Id) {}
-    ~HoldTimeLimitsManager() { }
+    ~HoldTimeLimitsManager() {}
 
     bool mIsInitialized = false;
 
-	// HoldTimeLimits
+    // HoldTimeLimits
     HoldTimeLimits mHoldTimeLimits;
 
-	// Instance
+    // Instance
     static HoldTimeLimitsManager mInstance;
 };