[nrf toup] simplify Key/Value Get function and add Exist function

Use settings_load_one function to load one key/value settings entry
instead of settings_load_subtree_direct.
This will avoid loading all the keys for some storage backends.
Add as well _Exist function that returns whether a Key exist in the
persistent storage or not and returns the size of ots value.
Simplify as well the Delete function by using _Exist function instead of
_Get.

Signed-off-by: Riadh Ghaddab <[email protected]>

Author: rghaddab

src/platform/Zephyr/KeyValueStoreManagerImpl.cpp

@@ -34,14 +34,6 @@ namespace DeviceLayer {
 namespace PersistedStorage {
 namespace {
 
-struct ReadEntry
-{
-    void * destination;           // destination address
-    size_t destinationBufferSize; // size of destination buffer
-    size_t readSize;              // [out] size of read entry value
-    CHIP_ERROR result;            // [out] read result
-};
-
 struct DeleteSubtreeEntry
 {
     int result;
@@ -87,43 +79,6 @@ CHIP_ERROR MakeFullKey(char (&fullKey)[SETTINGS_MAX_NAME_LEN + 1], const char *
     return CHIP_NO_ERROR;
 }
 
-int LoadEntryCallback(const char * name, size_t entrySize, settings_read_cb readCb, void * cbArg, void * param)
-{
-    ReadEntry & entry = *static_cast<ReadEntry *>(param);
-
-    // If requested key X, process just node X and ignore all its descendants: X/*
-    if (name != nullptr && *name != '\0')
-        return 0;
-
-    // Found requested key.
-    uint8_t emptyValue[kEmptyValueSize];
-
-    if (entrySize == kEmptyValueSize && readCb(cbArg, emptyValue, kEmptyValueSize) == kEmptyValueSize &&
-        memcmp(emptyValue, kEmptyValue, kEmptyValueSize) == 0)
-    {
-        // Special case - an empty value represented by known magic bytes.
-        entry.result = CHIP_NO_ERROR;
-
-        // Return 1 to stop processing further keys
-        return 1;
-    }
-
-    const ssize_t bytesRead = readCb(cbArg, entry.destination, entry.destinationBufferSize);
-    entry.readSize          = bytesRead > 0 ? bytesRead : 0;
-
-    if (entrySize > entry.destinationBufferSize)
-    {
-        entry.result = CHIP_ERROR_BUFFER_TOO_SMALL;
-    }
-    else
-    {
-        entry.result = bytesRead > 0 ? CHIP_NO_ERROR : CHIP_ERROR_PERSISTED_STORAGE_FAILED;
-    }
-
-    // Return 1 to stop processing further keys
-    return 1;
-}
-
 int DeleteSubtreeCallback(const char * name, size_t /* entrySize */, settings_read_cb /* readCb */, void * /* cbArg */,
                           void * param)
 {
@@ -155,23 +110,48 @@ void KeyValueStoreManagerImpl::Init()
 CHIP_ERROR KeyValueStoreManagerImpl::_Get(const char * key, void * value, size_t value_size, size_t * read_bytes_size,
                                           size_t offset_bytes) const
 {
+    CHIP_ERROR result;
+    size_t readSize;
     // Offset and partial reads are not supported, for now just return NOT_IMPLEMENTED.
     // Support can be added in the future if this is needed.
     VerifyOrReturnError(offset_bytes == 0, CHIP_ERROR_NOT_IMPLEMENTED);
 
     char fullKey[SETTINGS_MAX_NAME_LEN + 1];
     ReturnErrorOnFailure(MakeFullKey(fullKey, key));
 
-    ReadEntry entry{ value, value_size, 0, CHIP_ERROR_PERSISTED_STORAGE_VALUE_NOT_FOUND };
-    settings_load_subtree_direct(fullKey, LoadEntryCallback, &entry);
+    // Found requested key.
+    const ssize_t bytesRead = settings_load_one(fullKey, value, value_size);
+    // If the return code is -ENOENT the key is not found
+    VerifyOrReturnError(bytesRead != -ENOENT, CHIP_ERROR_PERSISTED_STORAGE_VALUE_NOT_FOUND);
+
+    if (bytesRead == kEmptyValueSize &&
+        memcmp(value, kEmptyValue, kEmptyValueSize) == 0)
+    {
+        // Special case - an empty value represented by known magic bytes.
+        result = CHIP_NO_ERROR;
+	readSize = 0;
+    }
+    else
+    {
+        readSize = bytesRead > 0 ? bytesRead : 0;
+
+        if ((size_t)bytesRead > value_size)
+        {
+            result = CHIP_ERROR_BUFFER_TOO_SMALL;
+        }
+        else
+        {
+            result = bytesRead > 0 ? CHIP_NO_ERROR : CHIP_ERROR_PERSISTED_STORAGE_FAILED;
+	}
+    }
 
     // Assign readSize only in case read_bytes_size is not nullptr, as it is optional argument
     if (read_bytes_size)
     {
-        *read_bytes_size = entry.readSize;
+        *read_bytes_size = readSize;
     }
 
-    return entry.result;
+    return result;
 }
 
 CHIP_ERROR KeyValueStoreManagerImpl::_Put(const char * key, const void * value, size_t value_size)
@@ -190,12 +170,36 @@ CHIP_ERROR KeyValueStoreManagerImpl::_Put(const char * key, const void * value,
     return CHIP_NO_ERROR;
 }
 
+CHIP_ERROR KeyValueStoreManagerImpl::_Exist(const char * key, size_t * val_len)
+{
+    char fullKey[SETTINGS_MAX_NAME_LEN + 1];
+    ssize_t len;
+
+    ReturnErrorOnFailure(MakeFullKey(fullKey, key));
+
+    len = settings_exist(fullKey);
+
+    if (len > 0)
+    {
+        *val_len = len;
+        return CHIP_NO_ERROR;;
+    }
+    if (len < 0)
+    {
+        return CHIP_ERROR_PERSISTED_STORAGE_FAILED;
+    }
+
+    return CHIP_ERROR_PERSISTED_STORAGE_VALUE_NOT_FOUND;
+}
+
 CHIP_ERROR KeyValueStoreManagerImpl::_Delete(const char * key)
 {
     char fullKey[SETTINGS_MAX_NAME_LEN + 1];
+    size_t val_len;
+
     ReturnErrorOnFailure(MakeFullKey(fullKey, key));
 
-    ReturnErrorCodeIf(Get(key, nullptr, 0) == CHIP_ERROR_PERSISTED_STORAGE_VALUE_NOT_FOUND,
+    ReturnErrorCodeIf(_Exist(key, &val_len) == CHIP_ERROR_PERSISTED_STORAGE_VALUE_NOT_FOUND,
                       CHIP_ERROR_PERSISTED_STORAGE_VALUE_NOT_FOUND);
     ReturnErrorCodeIf(settings_delete(fullKey) != 0, CHIP_ERROR_PERSISTED_STORAGE_FAILED);
 

src/platform/Zephyr/KeyValueStoreManagerImpl.h

@@ -43,6 +43,8 @@ class KeyValueStoreManagerImpl final : public KeyValueStoreManager
     //       these will return CHIP_ERROR_NOT_IMPLEMENTED.
     CHIP_ERROR _Get(const char * key, void * value, size_t value_size, size_t * read_bytes_size = nullptr, size_t offset = 0) const;
 
+    CHIP_ERROR _Exist(const char * key, size_t * val_len);
+
     CHIP_ERROR _Delete(const char * key);
 
     CHIP_ERROR _Put(const char * key, const void * value, size_t value_size);