Restyled by whitespace

Author: restyled-commits

src/app/clusters/closure-control-server/closure-control-server.cpp

@@ -22,7 +22,7 @@
  #include <app/ConcreteAttributePath.h>
  #include <app/InteractionModelEngine.h>
  #include <app/util/attribute-storage.h>
- 
+
  using namespace chip;
  using namespace chip::app;
  using namespace chip::app::DataModel;
@@ -31,47 +31,47 @@
  using namespace chip::app::Clusters::ClosureControl::Attributes;
  using namespace chip::app::Clusters::ClosureControl::Commands;
  using chip::Protocols::InteractionModel::Status;
- 
+
  namespace chip {
  namespace app {
  namespace Clusters {
  namespace ClosureControl {
- 
+
  CHIP_ERROR Instance::Init()
  {
      ReturnErrorOnFailure(CommandHandlerInterfaceRegistry::Instance().RegisterCommandHandler(this));
      VerifyOrReturnError(AttributeAccessInterfaceRegistry::Instance().Register(this), CHIP_ERROR_INCORRECT_STATE);
- 
+
      return CHIP_NO_ERROR;
  }
- 
+
  void Instance::Shutdown()
  {
      CommandHandlerInterfaceRegistry::Instance().UnregisterCommandHandler(this);
      AttributeAccessInterfaceRegistry::Instance().Unregister(this);
  }
- 
+
  bool Instance::HasFeature(Feature aFeature) const
  {
      return mFeature.Has(aFeature);
  }
- 
+
  bool Instance::SupportsOptAttr(OptionalAttributes aOptionalAttrs) const
  {
      return mOptionalAttrs.Has(aOptionalAttrs);
  }
- 
+
  // AttributeAccessInterface
  CHIP_ERROR Instance::Read(const ConcreteReadAttributePath & aPath, AttributeValueEncoder & aEncoder)
  {
      VerifyOrDie(aPath.mClusterId == ClosureControl::Id);
-     
+
      switch (aPath.mAttributeId)
      {
      case CountdownTime::Id:
          if (SupportsOptAttr(OptionalAttributes::kCountdownTime))
          {
-             return aEncoder.Encode(mDelegate.GetCountdownTime());  
+             return aEncoder.Encode(mDelegate.GetCountdownTime());
          }
          return CHIP_IM_GLOBAL_STATUS(UnsupportedAttribute);
      case MainState::Id:
@@ -120,37 +120,37 @@
      /* Allow all other unhandled attributes to fall through to Ember */
      return CHIP_NO_ERROR;
  }
- 
+
  CHIP_ERROR Instance::EncodeCurrentErrorList(const AttributeValueEncoder::ListEncodeHelper & encoder)
  {
      CHIP_ERROR err = CHIP_NO_ERROR;
- 
+
      ReturnErrorOnFailure(mDelegate.StartCurrentErrorListRead());
      for (size_t i = 0; true; i++)
      {
          ClosureErrorEnum error;
- 
+
          err = mDelegate.GetCurrentErrorListAtIndex(i, error);
          if (err == CHIP_ERROR_PROVIDER_LIST_EXHAUSTED)
          {
              // Convert end of list to CHIP_NO_ERROR
              err = CHIP_NO_ERROR;
              goto exit;
          }
- 
+
          // Check if another error occurred before trying to encode
          SuccessOrExit(err);
- 
+
          err = encoder.Encode(error);
          SuccessOrExit(err);
      }
- 
+
  exit:
      // Tell the delegate the read is complete
      err = mDelegate.EndCurrentErrorListRead();
      return err;
  }
- 
+
  CHIP_ERROR Instance::Write(const ConcreteDataAttributePath & aPath, AttributeValueDecoder & aDecoder)
  {
      switch (aPath.mAttributeId)
@@ -162,19 +162,19 @@
          return CHIP_IM_GLOBAL_STATUS(UnsupportedAttribute);
      }
  }
- 
+
  // CommandHandlerInterface
  void Instance::InvokeCommand(HandlerContext & handlerContext)
  {
      using namespace Commands;
- 
+
      switch (handlerContext.mRequestPath.mCommandId)
      {
      case Stop::Id:
          if (!HasFeature(Feature::kInstantaneous))
          {
              HandleCommand<Stop::DecodableType>(
-                 handlerContext, [this](HandlerContext & ctx, const auto & commandData) { HandleStop(ctx, commandData); });     
+                 handlerContext, [this](HandlerContext & ctx, const auto & commandData) { HandleStop(ctx, commandData); });
          }
          else
          {
@@ -220,65 +220,65 @@
          return;
      }
  }
- 
+
  void Instance::HandleStop(HandlerContext & ctx, const Commands::Stop::DecodableType & commandData)
  {
      // No parameters for this command
      // Call the delegate
      Status status = mDelegate.Stop();
- 
+
      ctx.mCommandHandler.AddStatus(ctx.mRequestPath, status);
  }
- 
+
  void Instance::HandleMoveTo(HandlerContext & ctx, const Commands::MoveTo::DecodableType & commandData)
  {
      const Optional<TagPositionEnum> tag = commandData.tag;
      const Optional<TagLatchEnum> latch = commandData.latch;
      const Optional<Globals::ThreeLevelAutoEnum> speed = commandData.speed;
-     
+
      // Call the delegate
      Status status = mDelegate.MoveTo(tag, latch, speed);
- 
+
      ctx.mCommandHandler.AddStatus(ctx.mRequestPath, status);
  }
- 
+
  void Instance::HandleCalibrate(HandlerContext & ctx, const Commands::Calibrate::DecodableType & commandData)
  {
      // No parameters for this command
      // Call the delegate
      Status status = mDelegate.Calibrate();
- 
+
      ctx.mCommandHandler.AddStatus(ctx.mRequestPath, status);
  }
- 
+
  void Instance::HandleConfigureFallback(HandlerContext & ctx, const Commands::ConfigureFallback::DecodableType & commandData)
  {
      const Optional<RestingProcedureEnum> restingProcedure = commandData.restingProcedure;
      const Optional<TriggerConditionEnum> triggerCondition = commandData.triggerCondition;
      const Optional<TriggerPositionEnum> triggerPosition = commandData.triggerPosition;
      const Optional<uint32_t> waitingDelay = commandData.waitingDelay;
-     
+
      // Call the delegate
      Status status = mDelegate.ConfigureFallback(restingProcedure, triggerCondition, triggerPosition, waitingDelay);
- 
+
      ctx.mCommandHandler.AddStatus(ctx.mRequestPath, status);
  }
- 
+
  void Instance::HandleCancelFallback(HandlerContext & ctx, const Commands::CancelFallback::DecodableType & commandData)
  {
      // No parameters for this command
      // Call the delegate
      Status status = mDelegate.CancelFallback();
- 
+
      ctx.mCommandHandler.AddStatus(ctx.mRequestPath, status);
  }
- 
+
  } // namespace ClosureControl
  } // namespace Clusters
  } // namespace app
  } // namespace chip
- 
+
  // -----------------------------------------------------------------------------
  // Plugin initialization
- 
- void MatterClosureControlPluginServerInitCallback() {}
+
+ void MatterClosureControlPluginServerInitCallback() {}

src/app/clusters/closure-control-server/closure-control-server.h

@@ -28,7 +28,7 @@
  #include <app/util/attribute-storage.h>
  #include <lib/core/CHIPError.h>
  #include <protocols/interaction_model/StatusCode.h>
- 
+
  namespace chip {
  namespace app {
  namespace Clusters {
@@ -41,35 +41,35 @@
  {
  public:
      virtual ~Delegate() = default;
- 
+
      void SetEndpointId(EndpointId aEndpoint) { mEndpointId = aEndpoint; }
      EndpointId GetEndpointId() { return mEndpointId; }
- 
+
     // ------------------------------------------------------------------
     // Commands
-     virtual Protocols::InteractionModel::Status Stop() = 0; 
+     virtual Protocols::InteractionModel::Status Stop() = 0;
      virtual Protocols::InteractionModel::Status MoveTo(const Optional<TagPositionEnum> tag,
                                                         const Optional<TagLatchEnum> latch,
-                                                        const Optional<Globals::ThreeLevelAutoEnum> speed) = 0; 
-     virtual Protocols::InteractionModel::Status Calibrate() = 0; 
+                                                        const Optional<Globals::ThreeLevelAutoEnum> speed) = 0;
+     virtual Protocols::InteractionModel::Status Calibrate() = 0;
      virtual Protocols::InteractionModel::Status ConfigureFallback(const Optional<RestingProcedureEnum> restingProcedure,
                                                                    const Optional<TriggerConditionEnum> triggerCondition,
                                                                    const Optional<TriggerPositionEnum> triggerPosition,
-                                                                   const Optional<uint32_t> waitingDelay) = 0; 
-     virtual Protocols::InteractionModel::Status CancelFallback() = 0; 
- 
+                                                                   const Optional<uint32_t> waitingDelay) = 0;
+     virtual Protocols::InteractionModel::Status CancelFallback() = 0;
+
      // ------------------------------------------------------------------
      // Get attribute methods
      virtual DataModel::Nullable<uint32_t> GetCountdownTime() = 0;
-     virtual MainStateEnum GetMainState() = 0; 
-     virtual DataModel::Nullable<Structs::OverallStateStruct::Type> GetOverallState() = 0; 
-     virtual DataModel::Nullable<Structs::OverallTargetStruct::Type> GetOverallTarget() = 0; 
-     virtual RestingProcedureEnum GetRestingProcedure() = 0; 
-     virtual TriggerConditionEnum GetTriggerCondition() = 0; 
-     virtual TriggerPositionEnum GetTriggerPosition() = 0; 
-     virtual uint32_t GetWaitingDelay() = 0; 
+     virtual MainStateEnum GetMainState() = 0;
+     virtual DataModel::Nullable<Structs::OverallStateStruct::Type> GetOverallState() = 0;
+     virtual DataModel::Nullable<Structs::OverallTargetStruct::Type> GetOverallTarget() = 0;
+     virtual RestingProcedureEnum GetRestingProcedure() = 0;
+     virtual TriggerConditionEnum GetTriggerCondition() = 0;
+     virtual TriggerPositionEnum GetTriggerPosition() = 0;
+     virtual uint32_t GetWaitingDelay() = 0;
      virtual uint32_t GetKickoffTimer() = 0;
-     
+
      /* These functions are called by the ReadAttribute handler to iterate through lists
       * The cluster server will call Start<Type>Read to allow the delegate to create a temporary
       * lock on the data.
@@ -79,58 +79,58 @@
      virtual CHIP_ERROR StartCurrentErrorListRead() = 0;
      virtual CHIP_ERROR GetCurrentErrorListAtIndex(size_t,ClosureErrorEnum  &) = 0;
      virtual CHIP_ERROR EndCurrentErrorListRead() = 0;
- 
+
  protected:
      EndpointId mEndpointId = 0;
  };
- 
+
  enum class OptionalAttributes : uint32_t
  {
      kCountdownTime = 0x1
  };
- 
+
  class Instance : public AttributeAccessInterface, public CommandHandlerInterface
  {
  public:
      Instance(EndpointId aEndpointId, Delegate & aDelegate, Feature aFeature,
              OptionalAttributes aOptionalAttrs) :
          AttributeAccessInterface(MakeOptional(aEndpointId), Id),
-         CommandHandlerInterface(MakeOptional(aEndpointId), Id), mDelegate(aDelegate), 
+         CommandHandlerInterface(MakeOptional(aEndpointId), Id), mDelegate(aDelegate),
          mFeature(aFeature), mOptionalAttrs(aOptionalAttrs)
      {
          /* set the base class delegates endpointId */
          mDelegate.SetEndpointId(aEndpointId);
      }
      ~Instance() { Shutdown(); }
- 
+
      CHIP_ERROR Init();
      void Shutdown();
- 
+
      bool HasFeature(Feature aFeature) const;
      bool SupportsOptAttr(OptionalAttributes aOptionalAttrs) const;
- 
+
  private:
      Delegate & mDelegate;
      BitMask<Feature> mFeature;
      BitMask<OptionalAttributes> mOptionalAttrs;
- 
+
      // AttributeAccessInterface
      CHIP_ERROR Read(const ConcreteReadAttributePath & aPath, AttributeValueEncoder & aEncoder) override;
      CHIP_ERROR Write(const ConcreteDataAttributePath & aPath, AttributeValueDecoder & aDecoder) override;
-     
+
      CHIP_ERROR EncodeCurrentErrorList(const AttributeValueEncoder::ListEncodeHelper & aEncoder);
- 
+
      // CommandHandlerInterface
      void InvokeCommand(HandlerContext & handlerContext) override;
- 
+
      void HandleStop(HandlerContext & ctx, const Commands::Stop::DecodableType & commandData);
      void HandleMoveTo(HandlerContext & ctx, const Commands::MoveTo::DecodableType & commandData);
      void HandleCalibrate(HandlerContext & ctx, const Commands::Calibrate::DecodableType & commandData);
      void HandleConfigureFallback(HandlerContext & ctx, const Commands::ConfigureFallback::DecodableType & commandData);
      void HandleCancelFallback(HandlerContext & ctx, const Commands::CancelFallback::DecodableType & commandData);
  };
- 
+
  } // namespace ClosureControl
  } // namespace Clusters
  } // namespace app
- } // namespace chip
+ } // namespace chip