Matter SDK Coverage Report
Current view: top level - protocols/interaction_model - StatusCode.h (source / functions) Coverage Total Hit
Test: SHA:08e4733c5b7d416074cba411cbfe5c0588660294 Lines: 100.0 % 16 16
Test Date: 2025-07-01 07:11:45 Functions: 100.0 % 8 8

            Line data    Source code
       1              : /*
       2              :  *    Copyright (c) 2022 Project CHIP Authors
       3              :  *    All rights reserved.
       4              :  *
       5              :  *    Licensed under the Apache License, Version 2.0 (the "License");
       6              :  *    you may not use this file except in compliance with the License.
       7              :  *    You may obtain a copy of the License at
       8              :  *
       9              :  *        http://www.apache.org/licenses/LICENSE-2.0
      10              :  *
      11              :  *    Unless required by applicable law or agreed to in writing, software
      12              :  *    distributed under the License is distributed on an "AS IS" BASIS,
      13              :  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      14              :  *    See the License for the specific language governing permissions and
      15              :  *    limitations under the License.
      16              :  */
      17              : 
      18              : #pragma once
      19              : 
      20              : #include <limits>
      21              : #include <optional>
      22              : #include <type_traits>
      23              : 
      24              : #include <stdint.h>
      25              : 
      26              : #include <lib/core/CHIPConfig.h>
      27              : #include <lib/core/DataModelTypes.h>
      28              : #include <lib/core/Optional.h>
      29              : #include <lib/support/TypeTraits.h>
      30              : 
      31              : #if CHIP_CONFIG_IM_STATUS_CODE_VERBOSE_FORMAT
      32              : #define ChipLogFormatIMStatus "0x%02x (%s)"
      33              : #define ChipLogValueIMStatus(status) chip::to_underlying(status), chip::Protocols::InteractionModel::StatusName(status)
      34              : #else // CHIP_CONFIG_IM_STATUS_CODE_VERBOSE_FORMAT
      35              : #define ChipLogFormatIMStatus "0x%02x"
      36              : #define ChipLogValueIMStatus(status) chip::to_underlying(status)
      37              : #endif // CHIP_CONFIG_IM_STATUS_CODE_VERBOSE_FORMAT
      38              : 
      39              : namespace chip {
      40              : namespace Protocols {
      41              : namespace InteractionModel {
      42              : 
      43              : enum class Status : uint8_t
      44              : {
      45              : #define CHIP_IM_STATUS_CODE(name, spec_name, value) name = value,
      46              : #include <protocols/interaction_model/StatusCodeList.h>
      47              : #undef CHIP_IM_STATUS_CODE
      48              : 
      49              :     InvalidValue = ConstraintError, // Deprecated
      50              : };
      51              : 
      52              : #if CHIP_CONFIG_IM_STATUS_CODE_VERBOSE_FORMAT
      53              : const char * StatusName(Status status);
      54              : #endif // CHIP_CONFIG_IM_STATUS_CODE_VERBOSE_FORMAT
      55              : 
      56              : /**
      57              :  * @brief Class to encapsulate a Status code, including possibly a
      58              :  *        cluster-specific code for generic SUCCESS/FAILURE.
      59              :  *
      60              :  * This abstractions joins together Status and ClusterStatus, which
      61              :  * are the components of a StatusIB, used in many IM actions, in a
      62              :  * way which allows both of them to carry together.
      63              :  *
      64              :  * This class can only be directly constructed from a `Status`. To
      65              :  * attach a cluster-specific-code, please use the `ClusterSpecificFailure()`
      66              :  * and `ClusterSpecificSuccess()` factory methods.
      67              :  */
      68              : class ClusterStatusCode
      69              : {
      70              : public:
      71              :     ClusterStatusCode() = delete;
      72         5244 :     explicit ClusterStatusCode(Status status) : mStatus(status) {}
      73              :     explicit ClusterStatusCode(CHIP_ERROR err);
      74              : 
      75              :     // We only have simple copyable members, so we should be trivially copyable.
      76              :     ClusterStatusCode(const ClusterStatusCode & other)             = default;
      77              :     ClusterStatusCode & operator=(const ClusterStatusCode & other) = default;
      78              : 
      79           44 :     bool operator==(const ClusterStatusCode & other) const
      80              :     {
      81           44 :         return (this->mStatus == other.mStatus) && (this->GetClusterSpecificCode() == other.GetClusterSpecificCode());
      82              :     }
      83              : 
      84              :     bool operator!=(const ClusterStatusCode & other) const { return !(*this == other); }
      85              : 
      86              :     ClusterStatusCode & operator=(const Status & status)
      87              :     {
      88              :         this->mStatus              = status;
      89              :         this->mClusterSpecificCode = std::nullopt;
      90              :         return *this;
      91              :     }
      92              : 
      93              :     /**
      94              :      * @brief Builder for a cluster-specific failure status code.
      95              :      *
      96              :      * @tparam T - enum type for the cluster-specific status code
      97              :      *             (e.g. chip::app::Clusters::AdministratorCommissioning::CommissioningWindowStatusEnum)
      98              :      * @param cluster_specific_code - cluster-specific code to record with the failure
      99              :      *             (e.g. chip::app::Clusters::AdministratorCommissioning::CommissioningWindowStatusEnum::kWindowNotOpen)
     100              :      * @return a ClusterStatusCode instance properly configured.
     101              :      */
     102              :     template <typename T, typename std::enable_if_t<std::is_enum<T>::value, bool> = true>
     103              :     static ClusterStatusCode ClusterSpecificFailure(T cluster_specific_code)
     104              :     {
     105              :         static_assert(std::numeric_limits<std::underlying_type_t<T>>::max() <= std::numeric_limits<ClusterStatus>::max(),
     106              :                       "Type used must fit in uint8_t");
     107              :         return ClusterStatusCode(Status::Failure, chip::to_underlying(cluster_specific_code));
     108              :     }
     109              : 
     110            2 :     static ClusterStatusCode ClusterSpecificFailure(ClusterStatus cluster_specific_code)
     111              :     {
     112            2 :         return ClusterStatusCode(Status::Failure, cluster_specific_code);
     113              :     }
     114              : 
     115              :     /**
     116              :      * @brief Builder for a cluster-specific success status code.
     117              :      *
     118              :      * @tparam T - enum type for the cluster-specific status code
     119              :      *             (e.g. chip::app::Clusters::AdministratorCommissioning::CommissioningWindowStatusEnum)
     120              :      * @param cluster_specific_code - cluster-specific code to record with the success
     121              :      *             (e.g. chip::app::Clusters::AdministratorCommissioning::CommissioningWindowStatusEnum::kBasicWindowOpen)
     122              :      * @return a ClusterStatusCode instance properly configured.
     123              :      */
     124              :     template <typename T, typename std::enable_if_t<std::is_enum<T>::value, bool> = true>
     125              :     static ClusterStatusCode ClusterSpecificSuccess(T cluster_specific_code)
     126              :     {
     127              :         static_assert(std::numeric_limits<std::underlying_type_t<T>>::max() <= std::numeric_limits<ClusterStatus>::max(),
     128              :                       "Type used must fit in uint8_t");
     129              :         return ClusterStatusCode(Status::Success, chip::to_underlying(cluster_specific_code));
     130              :     }
     131              : 
     132            2 :     static ClusterStatusCode ClusterSpecificSuccess(ClusterStatus cluster_specific_code)
     133              :     {
     134            2 :         return ClusterStatusCode(Status::Success, cluster_specific_code);
     135              :     }
     136              : 
     137              :     /// @return true if the core Status associated with this ClusterStatusCode is the one for success.
     138           85 :     bool IsSuccess() const { return mStatus == Status::Success; }
     139              : 
     140              :     /// @return the core Status code associated withi this ClusterStatusCode.
     141          149 :     Status GetStatus() const { return mStatus; }
     142              : 
     143              :     /// @return the cluster-specific code associated with this ClusterStatusCode (std::nullopt if none is associated).
     144          199 :     std::optional<ClusterStatus> GetClusterSpecificCode() const
     145              :     {
     146          199 :         if ((mStatus != Status::Failure) && (mStatus != Status::Success))
     147              :         {
     148           87 :             return std::nullopt;
     149              :         }
     150          112 :         return mClusterSpecificCode;
     151              :     }
     152              : 
     153              : private:
     154            4 :     ClusterStatusCode(Status status, ClusterStatus cluster_specific_code) :
     155            4 :         mStatus(status), mClusterSpecificCode(cluster_specific_code)
     156            4 :     {}
     157              : 
     158              :     Status mStatus;
     159              :     std::optional<ClusterStatus> mClusterSpecificCode;
     160              : };
     161              : 
     162              : static_assert(sizeof(ClusterStatusCode) <= sizeof(uint32_t), "ClusterStatusCode must not grow to be larger than a uint32_t");
     163              : 
     164              : } // namespace InteractionModel
     165              : } // namespace Protocols
     166              : } // namespace chip
        

Generated by: LCOV version 2.0-1