Expand attribute persistence provider api

src/app/AttributePersistenceProvider.h

@@ -15,8 +15,13 @@
  */
 #pragma once
 
+#include <app-common/zap-generated/attribute-type.h>
 #include <app/ConcreteAttributePath.h>
+#include <app/data-model/Nullable.h>
 #include <app/util/attribute-metadata.h>
+#include <cstring>
+#include <lib/support/BufferReader.h>
+#include <lib/support/BufferWriter.h>
 #include <lib/support/Span.h>
 
 namespace chip {
@@ -56,17 +61,111 @@ class AttributePersistenceProvider
      * Read an attribute value from non-volatile memory.
      *
      * @param [in]     aPath the attribute path for the data being persisted.
-     * @param [in]     aMetadata the attribute metadata, as a convenience.
+     * @param [in]     aType the attribute type.
+     * @param [in]     aSize the attribute size.
      * @param [in,out] aValue where to place the data.  The size of the buffer
-     *                 will be equal to `size` member of aMetadata.
+     *                 will be equal to `size`.
      *
      *                 The data is expected to be in native endianness for
      *                 integers and floats.  For strings, see the string
      *                 representation description in the WriteValue
      *                 documentation.
      */
-    virtual CHIP_ERROR ReadValue(const ConcreteAttributePath & aPath, const EmberAfAttributeMetadata * aMetadata,
+    virtual CHIP_ERROR ReadValue(const ConcreteAttributePath & aPath, EmberAfAttributeType aType, uint16_t aSize,
                                  MutableByteSpan & aValue) = 0;
+
+    // The following API provides helper functions to simplify the access of commonly used types.
+    // The API may not be complete.
+    // Currently implemented write and read types are: uint8_t, uint16_t, uint32_t, unit64_t and
+    // their nullable varieties, and bool.
+
+    /**
+     * Write an attribute value of type unsigned intX or bool to non-volatile memory.
+     *
+     * @param [in] aPath the attribute path for the data being written.
+     * @param [in] aValue the data to write.
+     */
+    template <typename T, std::enable_if_t<std::is_unsigned<T>::value, bool> = true>
+    CHIP_ERROR WriteValue(const ConcreteAttributePath & aPath, T & aValue)
+    {
+        uint8_t value[sizeof(T)];
+        auto w = Encoding::LittleEndian::BufferWriter(value, sizeof(T));
+        w.EndianPut(aValue, sizeof(T));
+
+        return WriteValue(aPath, ByteSpan(value));
+    }
+
+    /**
+     * Read an attribute of type unsigned intX or bool from non-volatile memory.
+     *
+     * @param [in]     aPath the attribute path for the data being persisted.
+     * @param [in,out] aValue where to place the data.
+     */
+    template <typename T, std::enable_if_t<std::is_unsigned<T>::value, bool> = true>
+    CHIP_ERROR ReadValue(const ConcreteAttributePath & aPath, T & aValue)
+    {
+        uint8_t attrData[sizeof(T)];
+        MutableByteSpan tempVal(attrData, sizeof(T));
+        // **Note** aType in the ReadValue function is only used to check if the value is of a string type. Since this template
+        // function is only enabled for integral values, we know that this case will not occur, so we can pass the enum of an
+        // arbitrary integral type.
+        auto err = ReadValue(aPath, ZCL_INT8U_ATTRIBUTE_TYPE, sizeof(T), tempVal);
+        if (err != CHIP_NO_ERROR)
+        {
+            return err;
+        }
+
+        chip::Encoding::LittleEndian::Reader r(tempVal.data(), tempVal.size());
+        r.RawRead(&aValue);
+        return r.StatusCode();
+    }
+
+    /**
+     * Write an attribute value of type nullable unsigned intX to non-volatile memory.
+     *
+     * @param [in] aPath the attribute path for the data being written.
+     * @param [in] aValue the data to write.
+     */
+    template <typename T, std::enable_if_t<std::is_unsigned<T>::value && !std::is_same<bool, T>::value, bool> = true>
+    CHIP_ERROR WriteValue(const ConcreteAttributePath & aPath, DataModel::Nullable<T> & aValue)
+    {
+        if (aValue.IsNull())
+        {
+            T nullValue = 0;
+            nullValue   = ~nullValue;
+            return WriteValue(aPath, nullValue);
+        }
+        return WriteValue(aPath, aValue.Value());
+    }
+
+    /**
+     * Read an attribute of type nullable unsigned intX from non-volatile memory.
+     *
+     * @param [in]     aPath the attribute path for the data being persisted.
+     * @param [in,out] aValue where to place the data.
+     */
+    template <typename T, std::enable_if_t<std::is_unsigned<T>::value && !std::is_same<bool, T>::value, bool> = true>
+    CHIP_ERROR ReadValue(const ConcreteAttributePath & aPath, DataModel::Nullable<T> & aValue)
+    {
+        T tempIntegral;
+        T nullValue = 0;
+        nullValue   = ~nullValue;
+
+        CHIP_ERROR err = ReadValue(aPath, tempIntegral);
+        if (err != CHIP_NO_ERROR)
+        {
+            return err;
+        }
+
+        if (tempIntegral == nullValue)
+        {
+            aValue.SetNull();
+            return CHIP_NO_ERROR;
+        }
+
+        aValue.SetNonNull(tempIntegral);
+        return CHIP_NO_ERROR;
+    }
 };
 
 /**

src/app/DefaultAttributePersistenceProvider.cpp

@@ -38,16 +38,16 @@ CHIP_ERROR DefaultAttributePersistenceProvider::WriteValue(const ConcreteAttribu
         aValue.data(), static_cast<uint16_t>(aValue.size()));
 }
 
-CHIP_ERROR DefaultAttributePersistenceProvider::ReadValue(const ConcreteAttributePath & aPath,
-                                                          const EmberAfAttributeMetadata * aMetadata, MutableByteSpan & aValue)
+CHIP_ERROR DefaultAttributePersistenceProvider::ReadValue(const ConcreteAttributePath & aPath, EmberAfAttributeType aType,
+                                                          uint16_t aSize, MutableByteSpan & aValue)
 {
     VerifyOrReturnError(mStorage != nullptr, CHIP_ERROR_INCORRECT_STATE);
 
     uint16_t size = static_cast<uint16_t>(min(aValue.size(), static_cast<size_t>(UINT16_MAX)));
     ReturnErrorOnFailure(mStorage->SyncGetKeyValue(
         DefaultStorageKeyAllocator::AttributeValue(aPath.mEndpointId, aPath.mClusterId, aPath.mAttributeId).KeyName(),
         aValue.data(), size));
-    EmberAfAttributeType type = aMetadata->attributeType;
+    EmberAfAttributeType type = aType;
     if (emberAfIsStringAttributeType(type))
     {
         // Ensure that we've read enough bytes that we are not ending up with
@@ -65,7 +65,7 @@ CHIP_ERROR DefaultAttributePersistenceProvider::ReadValue(const ConcreteAttribut
     else
     {
         // Ensure we got the expected number of bytes for all other types.
-        VerifyOrReturnError(size == aMetadata->size, CHIP_ERROR_INCORRECT_STATE);
+        VerifyOrReturnError(size == aSize, CHIP_ERROR_INCORRECT_STATE);
     }
     aValue.reduce_size(size);
     return CHIP_NO_ERROR;

src/app/DefaultAttributePersistenceProvider.h

@@ -50,7 +50,7 @@ class DefaultAttributePersistenceProvider : public AttributePersistenceProvider
 
     // AttributePersistenceProvider implementation.
     CHIP_ERROR WriteValue(const ConcreteAttributePath & aPath, const ByteSpan & aValue) override;
-    CHIP_ERROR ReadValue(const ConcreteAttributePath & aPath, const EmberAfAttributeMetadata * aMetadata,
+    CHIP_ERROR ReadValue(const ConcreteAttributePath & aPath, EmberAfAttributeType aType, uint16_t aSize,
                          MutableByteSpan & aValue) override;
 
 protected:

src/app/DeferredAttributePersistenceProvider.cpp

@@ -42,25 +42,25 @@ void DeferredAttribute::Flush(AttributePersistenceProvider & persister)
     mValue.Release();
 }
 
-CHIP_ERROR DeferredAttributePersistenceProvider::WriteValue(const ConcreteAttributePath & path, const ByteSpan & value)
+CHIP_ERROR DeferredAttributePersistenceProvider::WriteValue(const ConcreteAttributePath & aPath, const ByteSpan & aValue)
 {
     for (DeferredAttribute & da : mDeferredAttributes)
     {
-        if (da.Matches(path))
+        if (da.Matches(aPath))
         {
-            ReturnErrorOnFailure(da.PrepareWrite(System::SystemClock().GetMonotonicTimestamp() + mWriteDelay, value));
+            ReturnErrorOnFailure(da.PrepareWrite(System::SystemClock().GetMonotonicTimestamp() + mWriteDelay, aValue));
             FlushAndScheduleNext();
             return CHIP_NO_ERROR;
         }
     }
 
-    return mPersister.WriteValue(path, value);
+    return mPersister.WriteValue(aPath, aValue);
 }
 
-CHIP_ERROR DeferredAttributePersistenceProvider::ReadValue(const ConcreteAttributePath & path,
-                                                           const EmberAfAttributeMetadata * metadata, MutableByteSpan & value)
+CHIP_ERROR DeferredAttributePersistenceProvider::ReadValue(const ConcreteAttributePath & aPath, EmberAfAttributeType aType,
+                                                           uint16_t aSize, MutableByteSpan & aValue)
 {
-    return mPersister.ReadValue(path, metadata, value);
+    return mPersister.ReadValue(aPath, aType, aSize, aValue);
 }
 
 void DeferredAttributePersistenceProvider::FlushAndScheduleNext()

src/app/DeferredAttributePersistenceProvider.h

@@ -66,9 +66,9 @@ class DeferredAttributePersistenceProvider : public AttributePersistenceProvider
      *
      * For other attributes, immediately pass the write operation to the decorated persister.
      */
-    CHIP_ERROR WriteValue(const ConcreteAttributePath & path, const ByteSpan & value) override;
-    CHIP_ERROR ReadValue(const ConcreteAttributePath & path, const EmberAfAttributeMetadata * metadata,
-                         MutableByteSpan & value) override;
+    CHIP_ERROR WriteValue(const ConcreteAttributePath & aPath, const ByteSpan & aValue) override;
+    CHIP_ERROR ReadValue(const ConcreteAttributePath & aPath, EmberAfAttributeType aType, uint16_t aSize,
+                         MutableByteSpan & aValue) override;
 
 private:
     void FlushAndScheduleNext();

src/app/util/attribute-storage.cpp

@@ -1215,8 +1215,9 @@ void emAfLoadAttributeDefaults(EndpointId endpoint, bool ignoreStorage, Optional
                 {
                     VerifyOrDie(attrStorage && "Attribute persistence needs a persistence provider");
                     MutableByteSpan bytes(attrData);
-                    CHIP_ERROR err = attrStorage->ReadValue(
-                        app::ConcreteAttributePath(de->endpoint, cluster->clusterId, am->attributeId), am, bytes);
+                    CHIP_ERROR err =
+                        attrStorage->ReadValue(app::ConcreteAttributePath(de->endpoint, cluster->clusterId, am->attributeId),
+                                               am->attributeType, am->size, bytes);
                     if (err == CHIP_NO_ERROR)
                     {
                         ptr = attrData;

src/lib/support/BufferReader.cpp

@@ -27,6 +27,10 @@ namespace {
 // These helper methods return void and put the value being read into an
 // outparam because that allows us to easily overload on the type of the
 // thing being read.
+void ReadHelper(const uint8_t *& p, bool * dest)
+{
+    *dest = !!Read8(p);
+}
 void ReadHelper(const uint8_t *& p, uint8_t * dest)
 {
     *dest = Read8(p);
@@ -84,6 +88,7 @@ Reader & Reader::ReadBytes(uint8_t * dest, size_t size)
 }
 
 // Explicit Read instantiations for the data types we want to support.
+template void Reader::RawRead(bool *);
 template void Reader::RawRead(uint8_t *);
 template void Reader::RawRead(uint16_t *);
 template void Reader::RawRead(uint32_t *);