[Pdatabase-cvs] pdb/api_src pdb.c,1.1,1.2

[Michael L. <par...@us...>]

Update of /cvsroot/pdatabase/pdb/api_src
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv5663/api_src

Modified Files:
	pdb.c 
Log Message:
pdb_del() now uses pdb_free_node(). Updated api_src/pdb.c

Index: pdb.c
===================================================================
RCS file: /cvsroot/pdatabase/pdb/api_src/pdb.c,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- pdb.c	8 Feb 2005 15:10:18 -0000	1.1
+++ pdb.c	18 Feb 2005 21:25:29 -0000	1.2
@@ -74,6 +74,8 @@
 int unload_pdb_lib() {
 	int r;
 	
+	if (!_pdb_obj)	return 0;
+	
 	#ifdef _PDB_VERBOSE
 	printf("INFO: pdb.c: Unloading pdb library... ");
 	#endif
@@ -96,6 +98,8 @@
  *	(Re)cache the pdb shared object function pointers.
  */
 void recache_pdb_lib() {
+	if (!_pdb_obj)	return;
+
 	#ifdef _PDB_VERBOSE
 	printf("INFO: pdb.c: Caching pdb function pointers...\n");
 	#endif
@@ -122,6 +126,15 @@
 		dlsym(_pdb_obj, "pdb_set_free_method");
 	_pdb_funcs._pdb_count_children_fptr = dlsym(_pdb_obj, "pdb_count_children");
 	
+	_pdb_funcs._pdb_free_node_fptr = dlsym(_pdb_obj, "pdb_free_node");
+	_pdb_funcs._pdb_create_tree_fptr = dlsym(_pdb_obj, "pdb_create_tree");
+	_pdb_funcs._pdb_create_list_fptr = dlsym(_pdb_obj, "pdb_create_list");
+	_pdb_funcs._pdb_create_hash_fptr = dlsym(_pdb_obj, "pdb_create_hash");
+	_pdb_funcs._pdb_create_abstract_fptr = dlsym(_pdb_obj,
+		"pdb_create_abstract");
+	_pdb_funcs._pdb_set_int_fptr = dlsym(_pdb_obj, "pdb_set_int");
+
+
 	#ifdef _PDB_VERBOSE
 	printf("INFO: pdb.c: Cached pdb_load(): %s\n",
 		(_pdb_funcs._pdb_load_fptr ? "success" : "failed"));
@@ -157,6 +170,20 @@
 		(_pdb_funcs._pdb_set_free_method_fptr ? "success" : "failed"));
 	printf("INFO: pdb.c: Cached pdb_count_children(): %s\n",
 		(_pdb_funcs._pdb_count_children_fptr ? "success" : "failed"));
+		
+	printf("INFO: pdb.c: Cached pdb_free_node(): %s\n",
+		(_pdb_funcs._pdb_free_node_fptr ? "success" : "failed"));
+
+	printf("INFO: pdb.c: Cached pdb_create_tree(): %s\n",
+		(_pdb_funcs._pdb_create_tree_fptr ? "success" : "failed"));
+	printf("INFO: pdb.c: Cached pdb_create_list(): %s\n",
+		(_pdb_funcs._pdb_create_list_fptr ? "success" : "failed"));
+	printf("INFO: pdb.c: Cached pdb_create_hash(): %s\n",
+		(_pdb_funcs._pdb_create_hash_fptr ? "success" : "failed"));
+	printf("INFO: pdb.c: Cached pdb_create_abstract(): %s\n",
+		(_pdb_funcs._pdb_create_abstract_fptr ? "success" : "failed"));
+	printf("INFO: pdb.c: Cached pdb_set_int(): %s\n",
+		(_pdb_funcs._pdb_set_int_fptr ? "success" : "failed"));
 	#endif
 }
 
@@ -165,73 +192,127 @@
  *	Function wrappers from library.
  */
 struct pdb* pdb_load(char* file) {
+	if (!_pdb_obj)	return NULL;
 	return _pdb_funcs._pdb_load_fptr(file);
 }
 
 int pdb_unload(struct pdb* dbptr) {
+	if (!_pdb_obj)	return 0;
 	return _pdb_funcs._pdb_unload_fptr(dbptr);
 }
 
 void pdb_enable(struct pdb* dbptr, int settings) {
+	if (!_pdb_obj)	return;
 	_pdb_funcs._pdb_enable_fptr(dbptr, settings);
 }
 
 void pdb_disable(struct pdb* dbptr, int settings) {
+	if (!_pdb_obj)	return;
 	_pdb_funcs._pdb_disable_fptr(dbptr, settings);
 }
 
 int pdb_is_set(struct pdb* dbptr, int setting) {
+	if (!_pdb_obj)	return 0;
 	return _pdb_funcs._pdb_is_set_fptr(dbptr, setting);
 }
 
 int pdb_create_link(struct pdb* dbptr, char* path, char* key,
 	struct pdb_node_t* tnptr) {
+	if (!_pdb_obj)	return 0;
 	return _pdb_funcs._pdb_create_link_fptr(dbptr, path, key, tnptr);
 }
 
 struct pdb_node_t* pdb_query_node(struct pdb* dbptr, char* path) {
-	return _pdb_funcs._pdb_query_fptr(dbptr, path);
+	if (!_pdb_obj)	return NULL;
+	return _pdb_funcs._pdb_query_node_fptr(dbptr, path);
 }
 
 void* pdb_query(struct pdb* dbptr, char* path) {
+	if (!_pdb_obj)	return NULL;
 	return _pdb_funcs._pdb_query_fptr(dbptr, path);
 }
 
 struct pdb_node_t* pdb_set(struct pdb* dbptr, char* path, char* key,
 	void* data) {
+	if (!_pdb_obj)	return NULL;
 	return _pdb_funcs._pdb_set_fptr(dbptr, path, key, data);
 }
 
 struct pdb_node_t* pdb_set_node(struct pdb* dbptr, char* path, char* key,
 	void* data, int type) {
+	if (!_pdb_obj)	return NULL;
 	return _pdb_funcs._pdb_set_node_fptr(dbptr, path, key, data, type);
 }
 
 int pdb_del(struct pdb* dbptr, char* path) {
+	if (!_pdb_obj)	return 0;
 	return _pdb_funcs._pdb_del_fptr(dbptr, path);
 }
 
 char* pdb_trace(struct pdb_node_t* nptr) {
+	if (!_pdb_obj)	return NULL;
 	return _pdb_funcs._pdb_trace_fptr(nptr);
 }
 
 void pdb_set_write_interval(struct pdb* dbptr, int seconds) {
+	if (!_pdb_obj)	return;
 	_pdb_funcs._pdb_set_write_interval_fptr(dbptr, seconds);
 }
 
 int pdb_need_write(struct pdb* dbptr) {
+	if (!_pdb_obj)	return 0;
 	return _pdb_funcs._pdb_need_write_fptr(dbptr);
 }
 
 int pdb_write(struct pdb* dbptr, char* file) {
+	if (!_pdb_obj)	return 0;
 	return _pdb_funcs._pdb_write_fptr(dbptr, file);
 }
 
 void pdb_set_free_method(struct pdb* dbptr, struct pdb_node_t* nptr,
 	void* free_cb) {
+	if (!_pdb_obj)	return;
 	_pdb_funcs._pdb_set_free_method_fptr(dbptr, nptr, free_cb);
 }
 
 int pdb_count_children(struct pdb* dbptr, char* path) {
+	if (!_pdb_obj)	return 0;
 	return _pdb_funcs._pdb_count_children_fptr(dbptr, path);
 }
+
+int pdb_free_node(struct pdb_node_t* nptr) {
+	if (!_pdb_obj)	return 0;
+	return _pdb_funcs._pdb_free_node_fptr(nptr);
+}
+
+/*
+ *	Extra wrappers for pdb_set_node -- provided by the lib.
+ */
+struct pdb_node_t* pdb_create_tree(struct pdb* dbptr, char* path, char* key) {
+	if (!_pdb_obj)	return NULL;
+	return _pdb_funcs._pdb_create_tree_fptr(dbptr, path, key);
+}
+
+struct pdb_node_t* pdb_create_list(struct pdb* dbptr, char* path, char* key) {
+	if (!_pdb_obj)	return NULL;
+	return _pdb_funcs._pdb_create_list_fptr(dbptr, path, key);
+}
+
+struct pdb_node_t* pdb_create_hash(struct pdb* dbptr, char* path, char* key,
+	int size) {
+	if (!_pdb_obj)	return NULL;
+	return _pdb_funcs._pdb_create_hash_fptr(dbptr, path, key, size);
+}
+
+struct pdb_node_t* pdb_create_abstract(struct pdb* dbptr, char* path,
+	char* key, void* data, void* free_cb) {
+	if (!_pdb_obj)	return NULL;
+	return _pdb_funcs._pdb_create_abstract_fptr(dbptr, path, key, data,
+		free_cb);
+}
+
+struct pdb_node_t* pdb_set_int(struct pdb* dbptr, char* path, char* key,
+	int data) {
+	if (!_pdb_obj)	return NULL;
+	return _pdb_funcs._pdb_set_int_fptr(dbptr, path, key, data);
+}