use librtti for worker/queue/resource

src/lib/kvmgr.c

@@ -1,9 +1,12 @@
 #include <errno.h>
+#include <rtti.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 #include "htab.h"
+#include "kv.h"
 #include "kvmgr.h"
+#include "mylock.h"
 #include "objmgr.h"
 #include "utils.h"
 #include "xce/types.h"
@@ -393,3 +396,211 @@ int jobmgr_iter(jobmgr_t* mgr, xlist_t* l, void* arg)
     return kvmgr_iter(&(mgr->jobs), NULL, l, arg);
 }
 
+typedef struct {
+    my_rwlock_t lock;
+} xkvmgr_private_t;
+
+typedef struct {
+    kvmgr_key_type_t key_type;
+    unsigned int     dynamic : 1;
+    uint32_t         nslots;
+    var              kvtab;
+    var              data;
+} xkvmgr_t;
+
+static size_t xkvmgr_datasize(va_list ap)
+{
+    size_t sz = sizeof(xkvmgr_t);
+
+    return sz;
+}
+
+static int xkvmgr_init(meta_obj_t* obj, va_list ap)
+{
+    xkvmgr_t*        kvm    = RTTI_OBJ_TO_DATA(xkvmgr_t, obj);
+    kvmgr_params_t*  params = va_arg(ap, kvmgr_params_t*);
+    kv_params_t      kv_params;
+    xzarray_params_t data_params;
+
+    if ((params == NULL)
+        || ((params->key_type != KVMGR_KEY_INT)
+            && (params->key_type != KVMGR_KEY_STRING))
+        || (params->nslots <= 1) || (params->delta < 1)) {
+        return -EINVAL;
+    }
+
+    kv_params.nslots     = params->nslots;
+    kv_params.datakiller = params->datakiller;
+
+    switch (params->key_type) {
+    case KVMGR_KEY_INT:
+        kv_params.keyops = &int_key_ops;
+        break;
+    case KVMGR_KEY_STRING:
+        kv_params.keyops = &string_key_ops;
+        break;
+    default:
+        return -EINVAL;
+    }
+
+    kvm->kvtab = makeInstance(&kvtab_type, &kv_params);
+    if (kvm->kvtab == NULL) {
+        return -errno;
+    }
+
+    data_params.delta      = params->delta;
+    data_params.datakiller = params->datakiller;
+    kvm->data              = makeInstance(&xzarray_type, &data_params);
+    if (kvm->data == NULL) {
+        destroy(kvm->kvtab);
+
+        return -errno;
+    }
+
+    kvm->nslots   = params->nslots;
+    kvm->key_type = params->key_type;
+
+    if (params->dynamic) {
+        xkvmgr_private_t* priv = RTTI_OBJ_TO_PRIV(obj);
+
+        my_rwlock_init(&(priv->lock));
+    }
+
+    return 1;
+}
+
+static void xkvmgr_destroy(meta_obj_t* obj)
+{
+    xkvmgr_t* kvm = RTTI_OBJ_TO_DATA(xkvmgr_t, obj);
+
+    if (kvm->data != NULL) {
+        destroy(kvm->data);
+    }
+
+    if (kvm->kvtab != NULL) {
+        destroy(kvm->kvtab);
+    }
+
+    if (kvm->dynamic) {
+        xkvmgr_private_t* priv = RTTI_OBJ_TO_PRIV(obj);
+
+        my_rwlock_fini(&(priv->lock));
+    }
+    memset(kvm, 0x0, sizeof(*kvm));
+
+    return;
+}
+
+static int xkvmgr_add(meta_obj_t* obj, void* key, void* value)
+{
+    xkvmgr_t*         kvm = RTTI_OBJ_TO_DATA(xkvmgr_t, obj);
+    int               rc;
+    xkvmgr_private_t* priv = RTTI_OBJ_TO_PRIV(obj);
+
+    if (kvm->dynamic) {
+        my_rwlock_wlock(&(priv->lock));
+    }
+
+    rc = key_add(kvm->kvtab, key, value);
+
+    if (kvm->dynamic) {
+        my_rwlock_unlock(&(priv->lock));
+    }
+
+    return rc;
+}
+
+static int xkvmgr_find(meta_obj_t* obj, void* key, void** value)
+{
+    xkvmgr_t*         kvm = RTTI_OBJ_TO_DATA(xkvmgr_t, obj);
+    int               rc;
+    xkvmgr_private_t* priv = RTTI_OBJ_TO_PRIV(obj);
+
+    if (kvm->dynamic) {
+        my_rwlock_rlock(&(priv->lock));
+    }
+
+    rc = key_find(kvm->kvtab, key, value);
+
+    if (kvm->dynamic) {
+        my_rwlock_unlock(&(priv->lock));
+    }
+
+    return rc;
+}
+
+static int xkvmgr_make_iter(iterator_t* iter, va_list ap)
+{
+    meta_obj_t*       obj  = iter->obj;
+    xkvmgr_t*         kvm  = RTTI_OBJ_TO_DATA(xkvmgr_t, obj);
+    xkvmgr_private_t* priv = RTTI_OBJ_TO_PRIV(obj);
+    iterator_t*       it   = calloc(1, sizeof(*it));
+    int               rc   = 0;
+
+    if (it == NULL) {
+        return -ENOMEM;
+    }
+
+    if (kvm->dynamic) {
+        my_rwlock_rlock(&(priv->lock));
+    }
+    rc = iter_make(it, kvm->data);
+    if (rc < 0) {
+        FREEUP(it);
+        if (kvm->dynamic) {
+            my_rwlock_unlock(&(priv->lock));
+        }
+        return rc;
+    }
+
+    iter->data = it;
+
+    return RTTI_ITER_OK;
+}
+
+static int xkvmgr_iter_next(iterator_t* iter, void** data)
+{
+    iterator_t* it = (iterator_t*)iter->data;
+
+    return iter_next(it, data);
+}
+
+static void xkvmgr_iter_destroy(iterator_t* iter)
+{
+    iterator_t*       it   = iter->data;
+    meta_obj_t*       obj  = iter->obj;
+    xkvmgr_t*         kvm  = RTTI_OBJ_TO_DATA(xkvmgr_t, obj);
+    xkvmgr_private_t* priv = RTTI_OBJ_TO_PRIV(obj);
+
+    if (it != NULL) {
+        iter_destroy(it);
+
+        FREEUP(it);
+    }
+
+    iter->data = NULL;
+
+    if (kvm->dynamic) {
+        my_rwlock_unlock(&(priv->lock));
+    }
+
+    return;
+}
+
+typeinfo_t xkvmgr_type = {
+    .name        = "xkvmgr",
+    .privateSize = sizeof(xkvmgr_private_t),
+    .dataSize    = (datasize_fn_t)xkvmgr_datasize,
+    .init        = (obj_init_fn_t)xkvmgr_init,
+    .destroy     = (obj_destroy_fn_t)xkvmgr_destroy,
+    .interfaces
+    = { .kv = &(intf_kv_t) { .add_key  = (key_add_fn_t)xkvmgr_add,
+                             .del_key  = (key_del_fn_t)NULL,
+                             .find_key = (key_find_fn_t)xkvmgr_find },
+       .iter
+        = &(intf_iterator_t) { .make  = (iter_make_fn_t)xkvmgr_make_iter,
+                               .next  = (iter_next_fn_t)xkvmgr_iter_next,
+                               .reset = (iter_reset_fn_t)NULL,
+                               .destroy
+                               = (iter_destroy_fn_t)xkvmgr_iter_destroy } }
+};