Use the right types for enums in Accessors method signatures. (#13111)

bzbarsky-apple · pull[bot] · commit 106680328106 · 2022-03-28T20:12:44.000Z
We're using the underlying integer types right now.  Use the right enum types.

The change to use a "using" declaration for the NumericAttributeTraits
is just to make the code more readable when the template arg is long.
There are no other changes there.
diff --git a/examples/all-clusters-app/esp32/main/main.cpp b/examples/all-clusters-app/esp32/main/main.cpp
@@ -241,9 +241,10 @@ class EditAttributeListModel : public ListScreen::Model
             ESP_LOGI(TAG, "name and cluster: '%s' (%s)", name.c_str(), cluster.c_str());
             if (name == "State" && cluster == "Lock")
             {
+                using namespace chip::app::Clusters;
                 // update the doorlock attribute here
-                uint8_t attributeValue = value == "Closed" ? EMBER_ZCL_DOOR_LOCK_STATE_LOCKED : EMBER_ZCL_DOOR_LOCK_STATE_UNLOCKED;
-                chip::app::Clusters::DoorLock::Attributes::LockState::Set(DOOR_LOCK_SERVER_ENDPOINT, attributeValue);
+                auto attributeValue = value == "Closed" ? DoorLock::DlLockState::kLocked : DoorLock::DlLockState::kUnlocked;
+                DoorLock::Attributes::LockState::Set(DOOR_LOCK_SERVER_ENDPOINT, attributeValue);
             }
         }
     }
@@ -472,7 +473,8 @@ void SetupPretendDevices()
     AddCluster("Lock");
     AddAttribute("State", "Open");
     // write the door lock state
-    chip::app::Clusters::DoorLock::Attributes::LockState::Set(DOOR_LOCK_SERVER_ENDPOINT, EMBER_ZCL_DOOR_LOCK_STATE_UNLOCKED);
+    chip::app::Clusters::DoorLock::Attributes::LockState::Set(DOOR_LOCK_SERVER_ENDPOINT,
+                                                              chip::app::Clusters::DoorLock::DlLockState::kUnlocked);
     AddDevice("Garage 1");
     AddEndpoint("Door 1");
     AddCluster("Door");
diff --git a/src/app/clusters/door-lock-server/door-lock-server.cpp b/src/app/clusters/door-lock-server/door-lock-server.cpp
@@ -70,7 +70,7 @@ bool DoorLockServer::SetLockState(chip::EndpointId endpointId, DlLockState newLo
 
     emberAfDoorLockClusterPrintln("Setting Lock State to '%hhu'", lockState);
 
-    bool status = Attributes::LockState::Set(endpointId, lockState);
+    bool status = (Attributes::LockState::Set(endpointId, newLockState) == EMBER_ZCL_STATUS_SUCCESS);
     if (!status)
     {
         ChipLogError(Zcl, "Unable to set the Lock State to %hhu: internal error", lockState);
@@ -79,13 +79,13 @@ bool DoorLockServer::SetLockState(chip::EndpointId endpointId, DlLockState newLo
     return status;
 }
 
-bool DoorLockServer::SetActuatorState(chip::EndpointId endpointId, bool newActuatorState)
+bool DoorLockServer::SetActuatorEnabled(chip::EndpointId endpointId, bool newActuatorState)
 {
     auto actuatorState = static_cast<uint8_t>(newActuatorState);
 
     emberAfDoorLockClusterPrintln("Setting Actuator State to '%hhu'", actuatorState);
 
-    bool status = Attributes::LockState::Set(endpointId, actuatorState);
+    bool status = (Attributes::ActuatorEnabled::Set(endpointId, newActuatorState) == EMBER_ZCL_STATUS_SUCCESS);
     if (!status)
     {
         ChipLogError(Zcl, "Unable to set the Actuator State to %hhu: internal error", actuatorState);
@@ -94,12 +94,12 @@ bool DoorLockServer::SetActuatorState(chip::EndpointId endpointId, bool newActua
     return false;
 }
 
-bool DoorLockServer::SetDoorState(chip::EndpointId endpointId, DlLockState newDoorState)
+bool DoorLockServer::SetDoorState(chip::EndpointId endpointId, DlDoorState newDoorState)
 {
     auto doorState = static_cast<uint8_t>(newDoorState);
 
     emberAfDoorLockClusterPrintln("Setting Door State to '%hhu'", doorState);
-    bool status = Attributes::DoorState::Set(endpointId, doorState);
+    bool status = (Attributes::DoorState::Set(endpointId, newDoorState) == EMBER_ZCL_STATUS_SUCCESS);
 
     if (!status)
     {
diff --git a/src/app/clusters/door-lock-server/door-lock-server.h b/src/app/clusters/door-lock-server/door-lock-server.h
@@ -39,8 +39,8 @@ class DoorLockServer
     void InitServer(chip::EndpointId endpointId);
 
     bool SetLockState(chip::EndpointId endpointId, chip::app::Clusters::DoorLock::DlLockState newLockState);
-    bool SetActuatorState(chip::EndpointId endpointId, bool newActuatorState);
-    bool SetDoorState(chip::EndpointId endpointId, chip::app::Clusters::DoorLock::DlLockState newDoorState);
+    bool SetActuatorEnabled(chip::EndpointId endpointId, bool newActuatorState);
+    bool SetDoorState(chip::EndpointId endpointId, chip::app::Clusters::DoorLock::DlDoorState newDoorState);
 
     bool SetLanguage(chip::EndpointId endpointId, const char * newLanguage);
     bool SetAutoRelockTime(chip::EndpointId, uint32_t newAutoRelockTimeSec);
diff --git a/src/app/zap-templates/common/attributes/Accessors.js b/src/app/zap-templates/common/attributes/Accessors.js
@@ -18,6 +18,7 @@
 const zapPath      = '../../../../../third_party/zap/repo/dist/src-electron/';
 const ListHelper   = require('../../common/ListHelper.js');
 const StringHelper = require('../../common/StringHelper.js');
+const appHelper    = require('../../templates/app/helper.js');
 const cHelper      = require(zapPath + 'generator/helper-c.js')
 const zclHelper    = require(zapPath + 'generator/helper-zcl.js')
 const templateUtil = require(zapPath + 'generator/template-util.js')
@@ -59,8 +60,8 @@ async function accessorGetterType(attr)
     type = "chip::MutableByteSpan";
   } else {
     mayNeedPointer = true;
-    const options  = { 'hash' : {} };
-    type           = await zclHelper.asUnderlyingZclType.call(this, attr.type, options);
+    const options  = { 'hash' : { forceNotNullable : true, forceNotOptional : true, ns : this.parent.name } };
+    type           = await appHelper.zapTypeToEncodableClusterObjectType.call(this, attr.type, options);
   }
 
   if (attr.isNullable) {
@@ -84,7 +85,9 @@ async function accessorTraitType(type)
       return `OddSizedInteger<${size}, ${signed}>`;
     }
   }
-  return zclHelper.asUnderlyingZclType.call(this, type, { 'hash' : {} });
+
+  const options = { 'hash' : { forceNotNullable : true, forceNotOptional : true, ns : this.parent.name } };
+  return appHelper.zapTypeToEncodableClusterObjectType.call(this, type, options);
 }
 
 async function typeAsDelimitedMacro(type)
diff --git a/src/app/zap-templates/templates/app/attributes/Accessors-src.zapt b/src/app/zap-templates/templates/app/attributes/Accessors-src.zapt
@@ -58,30 +58,31 @@ EmberAfStatus Get(chip::EndpointId endpoint, {{accessorGetterType this}} value)
     {{>value}}.reduce_size(length);
     return status;
     {{else}}
-    NumericAttributeTraits<{{accessorTraitType type}}>::StorageType temp;
-    uint8_t * readable = NumericAttributeTraits<{{accessorTraitType type}}>::ToAttributeStoreRepresentation(temp);
+    using Traits = NumericAttributeTraits<{{accessorTraitType type}}>;
+    Traits::StorageType temp;
+    uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp);
     EmberAfStatus status = emberAfReadServerAttribute(endpoint, {{>clusterId}}, Id, readable, sizeof(temp));
     VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status);
     {{#if isNullable}}
-    if (NumericAttributeTraits<{{accessorTraitType type}}>::IsNullValue(temp))
+    if (Traits::IsNullValue(temp))
     {
         value.SetNull();
     }
     else
     {
-        value.SetNonNull() = NumericAttributeTraits<{{accessorTraitType type}}>::StorageToWorking(temp);
+        value.SetNonNull() = Traits::StorageToWorking(temp);
     }
     {{else}}
-    if (!NumericAttributeTraits<{{accessorTraitType type}}>::CanRepresentValue(/* isNullable = */ {{isNullable}}, temp))
+    if (!Traits::CanRepresentValue(/* isNullable = */ {{isNullable}}, temp))
     {
         return EMBER_ZCL_STATUS_CONSTRAINT_ERROR;
     }
-    *value = NumericAttributeTraits<{{accessorTraitType type}}>::StorageToWorking(temp);
+    *value = Traits::StorageToWorking(temp);
     {{/if}}
     return status;
     {{/if}}
 }
-EmberAfStatus Set(chip::EndpointId endpoint, {{asUnderlyingZclType type}} value)
+EmberAfStatus Set(chip::EndpointId endpoint, {{zapTypeToEncodableClusterObjectType type ns=parent.name forceNotNullable=true forceNotOptional=true}} value)
 {
     {{~#if (isString type)}}
     {{~#*inline "lengthType"}}uint{{#if (isShortString type)}}8{{else}}16{{/if}}_t{{/inline}}
@@ -93,13 +94,14 @@ EmberAfStatus Set(chip::EndpointId endpoint, {{asUnderlyingZclType type}} value)
     memcpy(&zclString[{{>sizingBytes}}], value.data(), value.size());
     return emberAfWriteServerAttribute(endpoint, {{>clusterId}}, Id, zclString, ZCL_{{typeAsDelimitedMacro type}}_ATTRIBUTE_TYPE);
     {{else}}
-    if (!NumericAttributeTraits<{{accessorTraitType type}}>::CanRepresentValue(/* isNullable = */ {{isNullable}}, value))
+    using Traits = NumericAttributeTraits<{{accessorTraitType type}}>;
+    if (!Traits::CanRepresentValue(/* isNullable = */ {{isNullable}}, value))
     {
         return EMBER_ZCL_STATUS_CONSTRAINT_ERROR;
     }
-    NumericAttributeTraits<{{accessorTraitType type}}>::StorageType storageValue;
-    NumericAttributeTraits<{{accessorTraitType type}}>::WorkingToStorage(value, storageValue);
-    uint8_t * writable = NumericAttributeTraits<{{accessorTraitType type}}>::ToAttributeStoreRepresentation(storageValue);
+    Traits::StorageType storageValue;
+    Traits::WorkingToStorage(value, storageValue);
+    uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue);
     return emberAfWriteServerAttribute(endpoint, {{>clusterId}}, Id, writable, ZCL_{{typeAsDelimitedMacro type}}_ATTRIBUTE_TYPE);
     {{/if}}
 }
@@ -111,14 +113,15 @@ EmberAfStatus SetNull(chip::EndpointId endpoint)
     uint8_t zclString[{{>sizingBytes}}] = { {{#if (isShortString type)}}0xFF{{else}}0xFF, 0xFF{{/if}} };
     return emberAfWriteServerAttribute(endpoint, {{>clusterId}}, Id, zclString, ZCL_{{typeAsDelimitedMacro type}}_ATTRIBUTE_TYPE);
     {{else}}
-    NumericAttributeTraits<{{accessorTraitType type}}>::StorageType value;
-    NumericAttributeTraits<{{accessorTraitType type}}>::SetNull(value);
-    uint8_t * writable = NumericAttributeTraits<{{accessorTraitType type}}>::ToAttributeStoreRepresentation(value);
+    using Traits = NumericAttributeTraits<{{accessorTraitType type}}>;
+    Traits::StorageType value;
+    Traits::SetNull(value);
+    uint8_t * writable = Traits::ToAttributeStoreRepresentation(value);
     return emberAfWriteServerAttribute(endpoint, {{>clusterId}}, Id, writable, ZCL_{{typeAsDelimitedMacro type}}_ATTRIBUTE_TYPE);
     {{/if}}
 }
 
-EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable<{{asUnderlyingZclType type}}> & value)
+EmberAfStatus Set(chip::EndpointId endpoint, {{zapTypeToEncodableClusterObjectType type ns=parent.name isArgument=true forceNotOptional=true}} value)
 {
   if (value.IsNull()) {
     return SetNull(endpoint);
diff --git a/src/app/zap-templates/templates/app/attributes/Accessors.zapt b/src/app/zap-templates/templates/app/attributes/Accessors.zapt
@@ -9,6 +9,7 @@
 
 #include <app/data-model/Nullable.h>
 #include <app/util/af-types.h>
+#include <app-common/zap-generated/cluster-objects.h>
 #include <lib/support/Span.h>
 
 namespace chip {
@@ -26,10 +27,10 @@ namespace Attributes {
 {{else if (canHaveSimpleAccessors this)}}
 namespace {{asUpperCamelCase label}} {
 EmberAfStatus Get(chip::EndpointId endpoint, {{accessorGetterType this}} value); // {{type}} {{isArray}}
-EmberAfStatus Set(chip::EndpointId endpoint, {{asUnderlyingZclType type}} value);
+EmberAfStatus Set(chip::EndpointId endpoint, {{zapTypeToEncodableClusterObjectType type ns=parent.name forceNotNullable=true forceNotOptional=true}} value);
 {{#if isNullable}}
 EmberAfStatus SetNull(chip::EndpointId endpoint);
-EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable<{{asUnderlyingZclType type}}> & value);
+EmberAfStatus Set(chip::EndpointId endpoint, {{zapTypeToEncodableClusterObjectType type ns=parent.name isArgument=true forceNotOptional=true}} value);
 {{/if}}
 } // namespace {{asUpperCamelCase label}}
 
diff --git a/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp b/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp
diff --git a/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.h b/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.h

Original file line number	Diff line number	Diff line change
`@@ -241,9 +241,10 @@ class EditAttributeListModel : public ListScreen::Model`
`241`	`241`	`ESP_LOGI(TAG, "name and cluster: '%s' (%s)", name.c_str(), cluster.c_str());`
`242`	`242`	`if (name == "State" && cluster == "Lock")`
`243`	`243`	`{`
	`244`	`+ using namespace chip::app::Clusters;`
`244`	`245`	`// update the doorlock attribute here`
`245`		`- uint8_t attributeValue = value == "Closed" ? EMBER_ZCL_DOOR_LOCK_STATE_LOCKED : EMBER_ZCL_DOOR_LOCK_STATE_UNLOCKED;`
`246`		`- chip::app::Clusters::DoorLock::Attributes::LockState::Set(DOOR_LOCK_SERVER_ENDPOINT, attributeValue);`
	`246`	`+ auto attributeValue = value == "Closed" ? DoorLock::DlLockState::kLocked : DoorLock::DlLockState::kUnlocked;`
	`247`	`+ DoorLock::Attributes::LockState::Set(DOOR_LOCK_SERVER_ENDPOINT, attributeValue);`
`247`	`248`	`}`
`248`	`249`	`}`
`249`	`250`	`}`
`@@ -472,7 +473,8 @@ void SetupPretendDevices()`
`472`	`473`	`AddCluster("Lock");`
`473`	`474`	`AddAttribute("State", "Open");`
`474`	`475`	`// write the door lock state`
`475`		`- chip::app::Clusters::DoorLock::Attributes::LockState::Set(DOOR_LOCK_SERVER_ENDPOINT, EMBER_ZCL_DOOR_LOCK_STATE_UNLOCKED);`
	`476`	`+ chip::app::Clusters::DoorLock::Attributes::LockState::Set(DOOR_LOCK_SERVER_ENDPOINT,`
	`477`	`+ chip::app::Clusters::DoorLock::DlLockState::kUnlocked);`
`476`	`478`	`AddDevice("Garage 1");`
`477`	`479`	`AddEndpoint("Door 1");`
`478`	`480`	`AddCluster("Door");`
Original file line number	Diff line number	Diff line change
`@@ -70,7 +70,7 @@ bool DoorLockServer::SetLockState(chip::EndpointId endpointId, DlLockState newLo`
`70`	`70`
`71`	`71`	`emberAfDoorLockClusterPrintln("Setting Lock State to '%hhu'", lockState);`
`72`	`72`
`73`		`- bool status = Attributes::LockState::Set(endpointId, lockState);`
	`73`	`+ bool status = (Attributes::LockState::Set(endpointId, newLockState) == EMBER_ZCL_STATUS_SUCCESS);`
`74`	`74`	`if (!status)`
`75`	`75`	`{`
`76`	`76`	`ChipLogError(Zcl, "Unable to set the Lock State to %hhu: internal error", lockState);`
`@@ -79,13 +79,13 @@ bool DoorLockServer::SetLockState(chip::EndpointId endpointId, DlLockState newLo`
`79`	`79`	`return status;`
`80`	`80`	`}`
`81`	`81`
`82`		`-bool DoorLockServer::SetActuatorState(chip::EndpointId endpointId, bool newActuatorState)`
	`82`	`+bool DoorLockServer::SetActuatorEnabled(chip::EndpointId endpointId, bool newActuatorState)`
`83`	`83`	`{`
`84`	`84`	`auto actuatorState = static_cast<uint8_t>(newActuatorState);`
`85`	`85`
`86`	`86`	`emberAfDoorLockClusterPrintln("Setting Actuator State to '%hhu'", actuatorState);`
`87`	`87`
`88`		`- bool status = Attributes::LockState::Set(endpointId, actuatorState);`
	`88`	`+ bool status = (Attributes::ActuatorEnabled::Set(endpointId, newActuatorState) == EMBER_ZCL_STATUS_SUCCESS);`
`89`	`89`	`if (!status)`
`90`	`90`	`{`
`91`	`91`	`ChipLogError(Zcl, "Unable to set the Actuator State to %hhu: internal error", actuatorState);`
`@@ -94,12 +94,12 @@ bool DoorLockServer::SetActuatorState(chip::EndpointId endpointId, bool newActua`
`94`	`94`	`return false;`
`95`	`95`	`}`
`96`	`96`
`97`		`-bool DoorLockServer::SetDoorState(chip::EndpointId endpointId, DlLockState newDoorState)`
	`97`	`+bool DoorLockServer::SetDoorState(chip::EndpointId endpointId, DlDoorState newDoorState)`
`98`	`98`	`{`
`99`	`99`	`auto doorState = static_cast<uint8_t>(newDoorState);`
`100`	`100`
`101`	`101`	`emberAfDoorLockClusterPrintln("Setting Door State to '%hhu'", doorState);`
`102`		`- bool status = Attributes::DoorState::Set(endpointId, doorState);`
	`102`	`+ bool status = (Attributes::DoorState::Set(endpointId, newDoorState) == EMBER_ZCL_STATUS_SUCCESS);`
`103`	`103`
`104`	`104`	`if (!status)`
`105`	`105`	`{`