comin_keyval.cpp

Go to the documentation of this file.

// @file comin_keyval.cpp
// @brief Key value storage backend based on std::unordered_map and std::variant
//
// @authors 08/2024 :: ICON Community Interface  <comin@icon-model.org>
//
// SPDX-License-Identifier: BSD-3-Clause
//
// See LICENSES for license information.
// Where software is supplied by third parties, it is indicated in the
// headers of the routines.
 
#include <cstdint>
#include <iostream>
#include <memory>
#include <string>
#include <string_view>
#include <unordered_map>
#include <variant>
 
#include "comin_hash.hpp"
#include "comin_keyval.hpp"
#include "comin_state.hpp"
#include "comin_variable.hpp"
 
namespace {
using MapType = comin::keyval::Map;
 
t_comin_var_descriptor to_var_descriptor(const char* name, size_t len, int id) {
  t_comin_var_descriptor descr;
  strncpy(descr.name, name, len);
  descr.name[len] = '\0';
  descr.id        = id;
 
  return descr;
}
} // namespace
 
extern "C" {
  void comin_keyval_set_int_c(const char* ckey, int val, MapType* map) {
    (*map)[ckey] = val;
  }
 
  void comin_keyval_get_int_c(const char* ckey, int* val, MapType* map) {
    *val = std::get<int>(map->at(ckey));
  }
 
  void comin_keyval_set_double_c(const char* ckey, double val, MapType* map) {
    (*map)[ckey] = val;
  }
 
  void comin_keyval_get_double_c(const char* ckey, double* val, MapType* map) {
    *val = std::get<double>(map->at(ckey));
  }
 
  void comin_keyval_set_char_c(const char* ckey, char* val, MapType* map) {
    (*map)[ckey] = std::string(val);
  }
 
  void comin_keyval_get_char_c(const char* ckey, const char** val,
                               MapType* map) {
    *val = std::get<std::string>(map->at(ckey)).data();
  }
 
  void comin_keyval_set_bool_c(const char* ckey, bool val, MapType* map) {
    (*map)[ckey] = val;
  }
 
  void comin_keyval_get_bool_c(const char* ckey, bool* val, MapType* map) {
    *val = std::get<bool>(map->at(ckey));
  }
 
  void comin_keyval_create_c(MapType** map) { *map = new MapType(); }
 
  void comin_keyval_delete_c(MapType* map) { delete map; }
 
  void comin_keyval_query_c(const char* ckey, int* idx, MapType* map) {
    auto it = map->find(ckey);
    if (it == map->end())
      *idx = -1;
    else
      *idx = it->second.index();
  }
 
  void comin_keyval_iterator_begin_c(MapType* map, MapType::iterator** it) {
    *it = new MapType::iterator(map->begin());
  }
 
  void comin_keyval_iterator_end_c(MapType* map, MapType::iterator** it) {
    *it = new MapType::iterator(map->end());
  }
 
  const char* comin_keyval_iterator_get_key_c(MapType::iterator* it) {
    return ((*it)->first).c_str();
  }
 
  bool comin_keyval_iterator_compare_c(MapType::iterator* it1,
                                       MapType::iterator* it2) {
    return (*it1 == *it2);
  }
 
  void comin_keyval_iterator_next_c(MapType::iterator* it) { (*it)++; }
 
  void comin_keyval_iterator_delete_c(MapType::iterator* it) { delete it; }
 
  void comin_varmap_new_c(t_comin_var_map** map) {
    *map = new t_comin_var_map();
  }
  void comin_varmap_delete_c(t_comin_var_map* map) { delete map; }
  void comin_varmap_clear_c(t_comin_var_map* map) { map->clear(); }
  const t_comin_var_item* comin_varmap_get_c(const t_comin_var_map* map,
                                             const char* name, size_t len,
                                             int id) {
    auto it = map->find(to_var_descriptor(name, len, id));
    if (it == map->end())
      return nullptr;
 
    return it->second.get();
  }
 
  void comin_varmap_put_c(t_comin_var_map* map, const char* name, size_t len,
                          int id, const t_comin_var_item* ptr) {
    // store a copy of the item in the map
    map->emplace(to_var_descriptor(name, len, id),
                 std::make_unique<t_comin_var_item>(*ptr));
  }
 
  void comin_varmap_iterator_begin_c(t_comin_var_map* map,
                                     t_comin_var_map::iterator** it) {
    *it = new t_comin_var_map::iterator(map->begin());
  }
 
  void comin_varmap_iterator_delete_c(t_comin_var_map::iterator* it) {
    delete it;
  }
 
  void comin_varmap_iterator_next_c(t_comin_var_map::iterator* it) { ++*it; }
 
  void comin_varmap_iterator_value_c(const t_comin_var_map::iterator* it,
                                     t_comin_var_item const** ptr) {
    *ptr = (*it)->second.get();
  }
 
  bool comin_varmap_iterator_is_end_c(const t_comin_var_map* map,
                                      const t_comin_var_map::iterator* it) {
    return *it == map->end();
  }
}