kvstore_global_api.cpp

00001 /*
00002  * Copyright (c) 2018 ARM Limited. All rights reserved.
00003  * SPDX-License-Identifier: Apache-2.0
00004  * Licensed under the Apache License, Version 2.0 (the License); you may
00005  * not use this file except in compliance with the License.
00006  * You may obtain a copy of the License at
00007  *
00008  * http://www.apache.org/licenses/LICENSE-2.0
00009  *
00010  * Unless required by applicable law or agreed to in writing, software
00011  * distributed under the License is distributed on an AS IS BASIS, WITHOUT
00012  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00013  * See the License for the specific language governing permissions and
00014  * limitations under the License.
00015  */
00016 #include "kvstore_global_api.h"
00017 
00018 #include "features/storage/kvstore/conf/kv_config.h"
00019 #include "features/storage/kvstore/kv_map/KVMap.h"
00020 #include "features/storage/kvstore/include/KVStore.h"
00021 #include "mbed_error.h"
00022 
00023 using namespace mbed;
00024 
00025 // iterator handle
00026 struct _opaque_kv_key_iterator {
00027     bool iterator_is_open;
00028     KVStore *kvstore_intance;
00029     KVStore::iterator_t *iterator_handle;
00030     char *path;
00031 };
00032 
00033 int kv_set(const char *full_name_key, const void *buffer, size_t size, uint32_t create_flags)
00034 {
00035     int ret = kv_init_storage_config();
00036     if (MBED_SUCCESS != ret) {
00037         return ret;
00038     }
00039 
00040     KVMap &kv_map = KVMap::get_instance();
00041     KVStore *kv_instance = NULL;
00042     uint32_t flags_mask = 0;
00043     size_t key_index = 0;
00044     ret = kv_map.lookup(full_name_key, &kv_instance, &key_index, &flags_mask);
00045     if (ret != MBED_SUCCESS) {
00046         return ret;
00047     }
00048 
00049     ret = kv_instance->set(full_name_key + key_index, buffer, size, create_flags & flags_mask);
00050     return ret;
00051 }
00052 
00053 int kv_get(const char *full_name_key, void *buffer, size_t buffer_size, size_t *actual_size)
00054 {
00055     int ret = kv_init_storage_config();
00056     if (MBED_SUCCESS != ret) {
00057         return ret;
00058     }
00059 
00060     KVMap &kv_map = KVMap::get_instance();
00061     KVStore *kv_instance = NULL;
00062     size_t key_index = 0;
00063     ret = kv_map.lookup(full_name_key, &kv_instance, &key_index);
00064     if (ret != MBED_SUCCESS) {
00065         return ret;
00066     }
00067 
00068     return kv_instance->get(full_name_key + key_index, buffer, buffer_size, actual_size);
00069 }
00070 
00071 int kv_get_info(const char *full_name_key, kv_info_t *info)
00072 {
00073     int ret = kv_init_storage_config();
00074     if (MBED_SUCCESS != ret) {
00075         return ret;
00076     }
00077 
00078     KVMap &kv_map = KVMap::get_instance();
00079     KVStore *kv_instance = NULL;
00080     size_t key_index = 0;
00081     ret = kv_map.lookup(full_name_key, &kv_instance, &key_index);
00082     if (ret != MBED_SUCCESS) {
00083         return ret;
00084     }
00085 
00086     KVStore::info_t inner_info;
00087     ret =  kv_instance->get_info(full_name_key + key_index, &inner_info);
00088     if (MBED_SUCCESS != ret) {
00089         return ret;
00090     }
00091     info->flags = inner_info.flags;
00092     info->size =  inner_info.size;
00093     return ret;
00094 }
00095 
00096 int kv_remove(const char *full_name_key)
00097 {
00098     int ret = kv_init_storage_config();
00099     if (MBED_SUCCESS != ret) {
00100         return ret;
00101     }
00102 
00103     KVMap &kv_map = KVMap::get_instance();
00104     KVStore *kv_instance = NULL;
00105     size_t key_index = 0;
00106     ret  = kv_map.lookup(full_name_key, &kv_instance, &key_index);
00107     if (ret != MBED_SUCCESS) {
00108         return ret;
00109     }
00110 
00111     return kv_instance->remove(full_name_key + key_index);
00112 }
00113 
00114 int kv_iterator_open(kv_iterator_t *it, const char *full_prefix)
00115 {
00116     if (it == NULL) {
00117         return MBED_ERROR_INVALID_ARGUMENT;
00118     }
00119 
00120     int ret = kv_init_storage_config();
00121     if (MBED_SUCCESS != ret) {
00122         return ret;
00123     }
00124 
00125     (*it) = new _opaque_kv_key_iterator;
00126     if (*it == NULL) {
00127         return MBED_ERROR_FAILED_OPERATION;
00128     }
00129     (*it)->iterator_is_open = false;
00130 
00131     KVMap &kv_map = KVMap::get_instance();
00132     KVStore *kv_instance = NULL;
00133     size_t key_index = 0;
00134     ret  = kv_map.lookup(full_prefix, &kv_instance, &key_index);
00135     if (ret != MBED_SUCCESS) {
00136         delete (*it);
00137         return ret;
00138     }
00139 
00140     (*it)->kvstore_intance = kv_instance;
00141     KVStore::iterator_t *inner_it = new KVStore::iterator_t;
00142     ret = kv_instance->iterator_open(inner_it, full_prefix + key_index);
00143     if (MBED_SUCCESS != ret) {
00144         delete inner_it;
00145         delete (*it);
00146         return ret;
00147     }
00148 
00149     (*it)->iterator_handle = inner_it;
00150     (*it)->iterator_is_open = true;
00151     (*it)->path = new char[key_index + 1];
00152     strncpy((*it)->path, full_prefix, key_index);
00153     (*it)->path[key_index] = '\0';
00154     return ret;
00155 
00156 }
00157 
00158 int kv_iterator_next(kv_iterator_t it, char *key, size_t key_size)
00159 {
00160     if (!it->iterator_is_open) {
00161         return MBED_ERROR_INVALID_ARGUMENT;
00162     }
00163 
00164     strcpy(key, it->path);
00165     int path_len = strlen(key);
00166     return it->kvstore_intance->iterator_next(*it->iterator_handle, key + path_len, key_size - path_len);
00167 }
00168 
00169 int kv_iterator_close(kv_iterator_t it)
00170 {
00171     if (!it->iterator_is_open) {
00172         return MBED_ERROR_INVALID_ARGUMENT;
00173     }
00174 
00175     int ret = it->kvstore_intance->iterator_close(*it->iterator_handle);
00176 
00177     delete it->iterator_handle;
00178     delete[] it->path;
00179     delete it;
00180 
00181     return ret;
00182 }
00183 
00184 int kv_reset(const char *kvstore_name)
00185 {
00186     int ret = kv_init_storage_config();
00187     if (MBED_SUCCESS != ret) {
00188         return ret;
00189     }
00190 
00191     KVMap &kv_map = KVMap::get_instance();
00192     KVStore *kv_instance = NULL;
00193     size_t key_index = 0;
00194     ret  = kv_map.lookup(kvstore_name, &kv_instance, &key_index);
00195     if (ret != MBED_SUCCESS) {
00196         return ret;
00197     }
00198 
00199     ret = kv_instance->reset();
00200 
00201     return ret;
00202 
00203 }
00204