session: Add kustore_t class

klish/Makefile.am

@@ -28,17 +28,20 @@ nobase_include_HEADERS += \
 
 # Session
 nobase_include_HEADERS += \
-	klish/kudata.h
+	klish/kudata.h \
+	klish/kustore.h
 
 #noinst_HEADERS += \
 #	klish/khelper.h
 
 EXTRA_DIST += \
 	klish/ktp/Makefile.am \
-	klish/kscheme/Makefile.am
+	klish/kscheme/Makefile.am \
+	klish/ksession/Makefile.am
 
 include $(top_srcdir)/klish/ktp/Makefile.am
 include $(top_srcdir)/klish/kscheme/Makefile.am
+include $(top_srcdir)/klish/ksession/Makefile.am
 
 #if TESTC
 #include $(top_srcdir)/klish/testc_module/Makefile.am

klish/ksession/Makefile.am

@@ -0,0 +1,3 @@
+libklish_la_SOURCES += \
+	klish/ksession/kudata.c \
+	klish/ksession/kustore.c

klish/session/kudata.c → klish/ksession/kudata.c

@@ -7,11 +7,12 @@
 
 #include <faux/str.h>
 #include <klish/khelper.h>
+#include <klish/kudata.h>
 
 struct kudata_s {
 	char *name;
 	void *data;
-	kudata_free_fn free_fn;
+	kudata_data_free_fn free_fn;
 };
 
 // Name
@@ -22,8 +23,8 @@ KGET(udata, void *, data);
 KSET(udata, void *, data);
 
 // Data
-KGET(udata, kudata_free_fn, free_fn);
-KSET(udata, kudata_free_fn, free_fn);
+KGET(udata, kudata_data_free_fn, free_fn);
+KSET(udata, kudata_data_free_fn, free_fn);
 
 
 kudata_t *kudata_new(const char *name)
@@ -47,18 +48,14 @@ kudata_t *kudata_new(const char *name)
 }
 
 
-bool_t kudata_free(kudata_t *udata)
+void kudata_free(kudata_t *udata)
 {
-	void *data;
-
 	if (!udata)
-		return BOOL_FALSE;
+		return;
 
 	faux_str_free(udata->name);
 	if (udata->free_fn)
 		udata->free_fn(udata->data);
 
 	faux_free(udata);
-
-	return BOOL_TRUE;
 }

klish/ksession/kustore.c

@@ -0,0 +1,94 @@
+/** @file kustore.c
+ */
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <faux/list.h>
+#include <klish/khelper.h>
+#include <klish/kudata.h>
+#include <klish/kustore.h>
+
+struct kustore_s {
+	faux_list_t *udatas;
+};
+
+
+// User data blobs list
+KCMP_NESTED(ustore, udata, name);
+KCMP_NESTED_BY_KEY(ustore, udata, name);
+KADD_NESTED(ustore, udata);
+KFIND_NESTED(ustore, udata);
+
+
+kustore_t *kustore_new()
+{
+	kustore_t *ustore = NULL;
+
+	ustore = faux_zmalloc(sizeof(*ustore));
+	assert(ustore);
+	if (!ustore)
+		return NULL;
+
+	// User data blobs list
+	ustore->udatas = faux_list_new(FAUX_LIST_SORTED, FAUX_LIST_UNIQUE,
+		kustore_udata_compare, kustore_udata_kcompare,
+		(void (*)(void *))kudata_free);
+	assert(ustore->udatas);
+
+	return ustore;
+}
+
+
+void kustore_free(kustore_t *ustore)
+{
+	if (!ustore)
+		return;
+
+	faux_list_free(ustore->udatas);
+
+	free(ustore);
+}
+
+
+kudata_t *kustore_slot_new(kustore_t *ustore,
+	const char *name, void *data, kudata_data_free_fn free_fn)
+{
+	kudata_t *udata = NULL;
+
+	assert(ustore);
+	if (!ustore)
+		return NULL;
+
+	if (!name)
+		return NULL;
+
+	udata = kudata_new(name);
+	if (!udata)
+		return NULL;
+
+	kudata_set_data(udata, data);
+	kudata_set_free_fn(udata, free_fn);
+
+	return udata;
+}
+
+
+void *kustore_slot_data(kustore_t *ustore, const char *udata_name)
+{
+	kudata_t *udata = NULL;
+
+	assert(ustore);
+	if (!ustore)
+		return NULL;
+
+	if (!udata_name)
+		return NULL;
+
+	udata = kustore_find_udata(ustore, udata_name);
+	if (!udata)
+		return NULL;
+
+	return kudata_data(udata);
+}

klish/kudata.h

@@ -8,7 +8,7 @@
 
 typedef struct kudata_s kudata_t;
 
-typedef bool_t (*kudata_free_fn)(void *data);
+typedef bool_t (*kudata_data_free_fn)(void *data);
 
 C_DECL_BEGIN
 
@@ -19,8 +19,8 @@ void kudata_free(kudata_t *udata);
 const char *kudata_name(const kudata_t *udata);
 void *kudata_data(const kudata_t *udata);
 bool_t kudata_set_data(kudata_t *udata, void *data);
-kudata_free_fn kudata_free_fn(const kudata_t *udata);
-bool_t kudata_set_free_fn(kudata_t *udata, kudata_free_fn free_fn);
+kudata_data_free_fn kudata_free_fn(const kudata_t *udata);
+bool_t kudata_set_free_fn(kudata_t *udata, kudata_data_free_fn free_fn);
 
 C_DECL_END
 

klish/kustore.h

@@ -0,0 +1,29 @@
+/** @file kustore.h
+ *
+ * @brief Klish ustore
+ */
+
+#ifndef _klish_kustore_h
+#define _klish_kustore_h
+
+#include <klish/kudata.h>
+
+
+typedef struct kustore_s kustore_t;
+
+C_DECL_BEGIN
+
+kustore_t *kustore_new();
+void kustore_free(kustore_t *ustore);
+
+bool_t kustore_add_udata(kustore_t *ustore, kudata_t *udata);
+kudata_t *kustore_find_udata(const kustore_t *ustore, const char *name);
+
+// Helper functions for easy access to udata entries
+kudata_t *kustore_slot_new(kustore_t *ustore,
+	const char *name, void *data, kudata_data_free_fn free_fn);
+void *kustore_slot_data(kustore_t *ustore, const char *udata_name);
+
+C_DECL_END
+
+#endif // _klish_kustore_h

klish/session/Makefile.am

@@ -1,2 +0,0 @@
-libklish_la_SOURCES += \
-	klish/session/kudata.c

klish/session/kustore.c

@@ -1,115 +0,0 @@
-/** @file kudata.c
- */
-#include <assert.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-
-struct kudata_s {
-	char *name;
-	void *data;
-};
-
-
-// User data blobs list
-KCMP_NESTED(udata, plugin, name);
-KCMP_NESTED_BY_KEY(udata, plugin, name);
-KADD_NESTED(udata, plugin);
-KFIND_NESTED(udata, plugin);
-
-// PTYPE list
-KCMP_NESTED(udata, ptype, name);
-KCMP_NESTED_BY_KEY(udata, ptype, name);
-KADD_NESTED(udata, ptype);
-KFIND_NESTED(udata, ptype);
-
-// VIEW list
-KCMP_NESTED(udata, view, name);
-KCMP_NESTED_BY_KEY(udata, view, name);
-KADD_NESTED(udata, view);
-KFIND_NESTED(udata, view);
-
-
-kudata_t *kudata_new(kudata_error_e *error)
-{
-	kudata_t *udata = NULL;
-
-	udata = faux_zmalloc(sizeof(*udata));
-	assert(udata);
-	if (!udata) {
-		if (error)
-			*error = KSCHEME_ERROR_ALLOC;
-		return NULL;
-	}
-
-	// PLUGIN list
-	udata->plugins = faux_list_new(FAUX_LIST_SORTED, FAUX_LIST_UNIQUE,
-		kudata_plugin_compare, kudata_plugin_kcompare,
-		(void (*)(void *))kplugin_free);
-	assert(udata->plugins);
-
-	// PTYPE list
-	udata->ptypes = faux_list_new(FAUX_LIST_SORTED, FAUX_LIST_UNIQUE,
-		kudata_ptype_compare, kudata_ptype_kcompare,
-		(void (*)(void *))kptype_free);
-	assert(udata->ptypes);
-
-	// VIEW list
-	udata->views = faux_list_new(FAUX_LIST_SORTED, FAUX_LIST_UNIQUE,
-		kudata_view_compare, kudata_view_kcompare,
-		(void (*)(void *))kview_free);
-	assert(udata->views);
-
-	return udata;
-}
-
-
-
-/*--------------------------------------------------------- */
-int kudata_compare(const void *first, const void *second)
-{
-	const kudata_t *f = (const kudata_t *)first;
-	const kudata_t *s = (const kudata_t *)second;
-
-	return strcmp(f->name, s->name);
-}
-
-/*--------------------------------------------------------- */
-kudata_t *kudata_new(const char *name, void *data)
-{
-	kudata_t *pdata =
-		(kudata_t *)malloc(sizeof(kudata_t));
-
-	if (!name) {
-		free(pdata);
-		return NULL;
-	}
-	memset(pdata, 0, sizeof(*pdata));
-	pdata->name = lub_string_dup(name);
-	pdata->data = data;
-
-	return pdata;
-}
-
-/*--------------------------------------------------------- */
-void *kudata_free(kudata_t *this)
-{
-	void *data;
-
-	if (!this)
-		return NULL;
-	if (this->name)
-		lub_string_free(this->name);
-	data = this->data;
-	free(this);
-
-	return data;
-}
-
-/*--------------------------------------------------------- */
-void kudata_delete(void *data)
-{
-	kudata_t *this = (kudata_t *)data;
-	kudata_free(this);
-}