Renamed SLV2Model SLV2World.

Updated Ingen for SLV2 API changes.


git-svn-id: http://svn.drobilla.net/lad/slv2@459 a436a847-0d15-0410-975c-d299462d15a1

5 files changed, 63 insertions, 67 deletions

diff --git a/src/Makefile.am b/src/Makefile.am
index eb25597..8009ff8 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -6,7 +6,7 @@ libslv2_la_LIBADD = @REDLAND_LIBS@
 
 libslv2_la_SOURCES = \
 	private_types.h \
-	model.c \
+	world.c \
 	plugin.c \
 	query.c \
 	port.c \
diff --git a/src/plugin.c b/src/plugin.c
index ab36caf..b3577f2 100644
--- a/src/plugin.c
+++ b/src/plugin.c
@@ -31,10 +31,10 @@
 
 /* private */
 SLV2Plugin
-slv2_plugin_new(SLV2Model model, librdf_uri* uri, const char* binary_uri)
+slv2_plugin_new(SLV2World world, librdf_uri* uri, const char* binary_uri)
 {
 	struct _Plugin* plugin = malloc(sizeof(struct _Plugin));
-	plugin->model = model;
+	plugin->world = world;
 	plugin->plugin_uri = librdf_new_uri_from_uri(uri);
 	plugin->binary_uri = strdup(binary_uri);
 	plugin->data_uris = raptor_new_sequence((void (*)(void*))&raptor_free_uri, NULL);
@@ -84,11 +84,9 @@ slv2_plugin_query(SLV2Plugin plugin,
 SLV2Plugin
 slv2_plugin_duplicate(SLV2Plugin p)
 {
-	fprintf(stderr, "FIXME: duplicate\n");
-
 	assert(p);
 	struct _Plugin* result = malloc(sizeof(struct _Plugin));
-	result->model = p->model;
+	result->world = p->world;
 	result->plugin_uri = librdf_new_uri_from_uri(p->plugin_uri);
 
 	//result->bundle_url = strdup(p->bundle_url);
@@ -102,7 +100,6 @@ slv2_plugin_duplicate(SLV2Plugin p)
 	for (int i=0; i < raptor_sequence_size(p->ports); ++i)
 		raptor_sequence_push(result->ports, slv2_port_duplicate(raptor_sequence_get_at(p->ports, i)));
 
-	result->ports = NULL;
 	result->storage = NULL;
 	result->rdf = NULL;
 
@@ -133,15 +130,15 @@ slv2_plugin_load(SLV2Plugin p)
 
 	if (!p->storage) {
 		assert(!p->rdf);
-		p->storage = librdf_new_storage(p->model->world, "hashes", NULL,
+		p->storage = librdf_new_storage(p->world->world, "hashes", NULL,
 				"hash-type='memory'");
-		p->rdf = librdf_new_model(p->model->world, p->storage, NULL);
+		p->rdf = librdf_new_model(p->world->world, p->storage, NULL);
 	}
 
 	// Parse all the plugin's data files into RDF model
 	for (int i=0; i < raptor_sequence_size(p->data_uris); ++i) {
 		librdf_uri* data_uri = raptor_sequence_get_at(p->data_uris, i);
-		librdf_parser_parse_into_model(p->model->parser, data_uri, NULL, p->rdf);
+		librdf_parser_parse_into_model(p->world->parser, data_uri, NULL, p->rdf);
 	}
 
 	// Load ports
@@ -153,7 +150,7 @@ slv2_plugin_load(SLV2Plugin p)
 		"      :index  ?index .\n"
 		"}";
 	
-	librdf_query* q = librdf_new_query(p->model->world, "sparql",
+	librdf_query* q = librdf_new_query(p->world->world, "sparql",
 		NULL, query, p->plugin_uri);
 	
 	librdf_query_results* results = librdf_query_execute(q, p->rdf);
diff --git a/src/private_types.h b/src/private_types.h
index 12f74cb..8f2f89d 100644
--- a/src/private_types.h
+++ b/src/private_types.h
@@ -48,8 +48,7 @@ void     slv2_port_free(SLV2Port port);
  * paths of relevant files, the actual data therein isn't loaded into memory.
  */
 struct _Plugin {
-	int              deletable;
-	struct _Model*   model;
+	struct _World*   world;
 	librdf_uri*      plugin_uri;
 //	char*            bundle_url; // Bundle directory plugin was loaded from
 	char*            binary_uri; // lv2:binary
@@ -59,7 +58,7 @@ struct _Plugin {
 	librdf_model*    rdf;
 };
 
-SLV2Plugin slv2_plugin_new(SLV2Model model, librdf_uri* uri, const char* binary_uri);
+SLV2Plugin slv2_plugin_new(SLV2World world, librdf_uri* uri, const char* binary_uri);
 void       slv2_plugin_load(SLV2Plugin p);
 
 
@@ -77,7 +76,7 @@ struct _InstanceImpl {
 
 /** Model of LV2 (RDF) data loaded from bundles.
  */
-struct _Model {
+struct _World {
 	librdf_world*       world;
 	librdf_storage*     storage;
 	librdf_model*       model;
diff --git a/src/query.c b/src/query.c
index 7127a8d..968834c 100644
--- a/src/query.c
+++ b/src/query.c
@@ -124,7 +124,7 @@ slv2_plugin_query(SLV2Plugin  plugin,
 
 	//printf("******** Query \n%s********\n", query_str);
 	
-	librdf_query *rq = librdf_new_query(plugin->model->world, "sparql", NULL,
+	librdf_query *rq = librdf_new_query(plugin->world->world, "sparql", NULL,
 			(const unsigned char*)query_str, base_uri);
 	
 	if (!rq) {
@@ -200,7 +200,7 @@ slv2_query_count_results(SLV2Plugin  p,
 	assert(p);
 	assert(query_str);
 
-	librdf_query *rq = librdf_new_query(p->model->world, "sparql", NULL,
+	librdf_query *rq = librdf_new_query(p->world->world, "sparql", NULL,
 			(unsigned char*)query_str, NULL);
 
 	//printf("Query: \n%s\n\n", query_str);
@@ -209,7 +209,7 @@ slv2_query_count_results(SLV2Plugin  p,
 	//librdf_query_add_data_graph(rq, slv2_ontology_uri,
 	//	NULL, RASQAL_DATA_GRAPH_BACKGROUND);
 	
-	librdf_query_results* results = librdf_query_execute(rq, p->model->model);
+	librdf_query_results* results = librdf_query_execute(rq, p->world->model);
 	assert(results);
 	
 	size_t count = slv2_query_count_bindings(results);
diff --git a/src/model.c b/src/world.c
index 16a1962..afb71ad 100644
--- a/src/model.c
+++ b/src/world.c
@@ -22,65 +22,65 @@
 #include <dirent.h>
 #include <string.h>
 #include <librdf.h>
-#include <slv2/model.h>
+#include <slv2/world.h>
 #include <slv2/slv2.h>
 #include <slv2/util.h>
 #include "config.h"
 #include "private_types.h"
 
 
-SLV2Model
-slv2_model_new()
+SLV2World
+slv2_world_new()
 {
-	struct _Model* model = (struct _Model*)malloc(sizeof(struct _Model));
+	struct _World* world = (struct _World*)malloc(sizeof(struct _World));
 
-	model->world = librdf_new_world();
-	librdf_world_open(model->world);
+	world->world = librdf_new_world();
+	librdf_world_open(world->world);
 	
-	model->storage = librdf_new_storage(model->world, "hashes", NULL,
+	world->storage = librdf_new_storage(world->world, "hashes", NULL,
 			"hash-type='memory'");
 
-	model->model = librdf_new_model(model->world, model->storage, NULL);
+	world->model = librdf_new_model(world->world, world->storage, NULL);
 
-	model->parser = librdf_new_parser(model->world, "turtle", NULL, NULL);
+	world->parser = librdf_new_parser(world->world, "turtle", NULL, NULL);
 
-	model->plugins = slv2_plugins_new();
+	world->plugins = slv2_plugins_new();
 
 	/*slv2_ontology_uri = raptor_new_uri((const unsigned char*)
 		"file://" LV2_TTL_PATH);*/
 
-	return model;
+	return world;
 }
 
 
 void
-slv2_model_free(SLV2Model model)
+slv2_world_free(SLV2World world)
 {
 	/*raptor_free_uri(slv2_ontology_uri);
 	slv2_ontology_uri = NULL;*/
 
-	slv2_plugins_free(model->plugins);
-	model->plugins = NULL;
+	slv2_plugins_free(world->plugins);
+	world->plugins = NULL;
 	
-	librdf_free_parser(model->parser);
-	model->parser = NULL;
+	librdf_free_parser(world->parser);
+	world->parser = NULL;
 	
-	librdf_free_model(model->model);
-	model->model = NULL;
+	librdf_free_model(world->model);
+	world->model = NULL;
 	
-	librdf_free_storage(model->storage);
-	model->storage = NULL;
+	librdf_free_storage(world->storage);
+	world->storage = NULL;
 	
-	librdf_free_world(model->world);
-	model->world = NULL;
+	librdf_free_world(world->world);
+	world->world = NULL;
 
-	free(model);
+	free(world);
 }
 
 
 /* private */
 void
-slv2_model_load_directory(SLV2Model model, const char* dir)
+slv2_world_load_directory(SLV2World world, const char* dir)
 {
 	DIR* pdir = opendir(dir);
 	if (!pdir)
@@ -92,7 +92,7 @@ slv2_model_load_directory(SLV2Model model, const char* dir)
 			continue;
 
 		char* bundle_uri_str = slv2_strjoin("file://", dir, "/", pfile->d_name, "/", NULL);
-		librdf_uri* bundle_uri = librdf_new_uri(model->world, (unsigned char*)bundle_uri_str);
+		librdf_uri* bundle_uri = librdf_new_uri(world->world, (unsigned char*)bundle_uri_str);
 
 		DIR* bundle_dir = opendir(bundle_uri_str + 7);
 
@@ -102,7 +102,7 @@ slv2_model_load_directory(SLV2Model model, const char* dir)
 			librdf_uri* manifest_uri = librdf_new_uri_relative_to_base(
 					bundle_uri, (const unsigned char*)"manifest.ttl");
 
-			librdf_parser_parse_into_model(model->parser, manifest_uri, NULL, model->model);
+			librdf_parser_parse_into_model(world->parser, manifest_uri, NULL, world->model);
 			
 			librdf_free_uri(manifest_uri);
 		}
@@ -116,7 +116,7 @@ slv2_model_load_directory(SLV2Model model, const char* dir)
 
 
 void
-slv2_model_load_path(SLV2Model   model,
+slv2_world_load_path(SLV2World   world,
                      const char* lv2_path)
 {
 	char* path = slv2_strjoin(lv2_path, ":", NULL);
@@ -128,7 +128,7 @@ slv2_model_load_path(SLV2Model   model,
 		char* delim = strchr(path, ':');
 		*delim = '\0';
 		
-		slv2_model_load_directory(model, dir);
+		slv2_world_load_directory(world, dir);
 		
 		*delim = 'X';
 		dir = delim + 1;
@@ -151,13 +151,13 @@ slv2_plugin_compare_by_uri(const void* a, const void* b)
 */
 
 void
-slv2_model_load_all(SLV2Model model)
+slv2_world_load_all(SLV2World world)
 {
 	char* lv2_path = getenv("LV2_PATH");
 
 	// Read all manifest files
 	if (lv2_path) {
-		slv2_model_load_path(model, lv2_path);
+		slv2_world_load_path(world, lv2_path);
 	} else {
 		const char* const home = getenv("HOME");
 		const char* const suffix = "/.lv2:/usr/local/lib/lv2:usr/lib/lv2";
@@ -165,7 +165,7 @@ slv2_model_load_all(SLV2Model model)
 
 		//fprintf(stderr, "$LV2_PATH is unset.  Using default path %s\n", lv2_path);
 
-		slv2_model_load_path(model, lv2_path);
+		slv2_world_load_path(world, lv2_path);
 
 		free(lv2_path);
 	}
@@ -180,10 +180,10 @@ slv2_model_load_all(SLV2Model model)
 		"OPTIONAL { ?plugin :binary ?binary } }\n"
 		"ORDER BY ?plugin\n";
 	
-	librdf_query* q = librdf_new_query(model->world, "sparql",
+	librdf_query* q = librdf_new_query(world->world, "sparql",
 		NULL, query_string, NULL);
 	
-	librdf_query_results* results = librdf_query_execute(q, model->model);
+	librdf_query_results* results = librdf_query_execute(q, world->model);
 
 	while (!librdf_query_results_finished(results)) {
 	
@@ -194,20 +194,20 @@ slv2_model_load_all(SLV2Model model)
 		librdf_node* binary_node = librdf_query_results_get_binding_value(results, 2);
 		librdf_uri*  binary_uri  = librdf_node_get_uri(binary_node);
 		
-		SLV2Plugin plugin = slv2_plugins_get_by_uri(model->plugins,
+		SLV2Plugin plugin = slv2_plugins_get_by_uri(world->plugins,
 				(const char*)librdf_uri_as_string(plugin_uri));
 		
 		// Create a new SLV2Plugin
 		if (!plugin)
-			plugin = slv2_plugin_new(model, plugin_uri,
+			plugin = slv2_plugin_new(world, plugin_uri,
 					(const char*)librdf_uri_as_string(binary_uri));
 		
-		plugin->model = model;
+		plugin->world = world;
 
 		// FIXME: check for duplicates
 		raptor_sequence_push(plugin->data_uris, librdf_new_uri_from_uri(data_uri));
 		
-		raptor_sequence_push(model->plugins, plugin);
+		raptor_sequence_push(world->plugins, plugin);
 		
 		librdf_free_node(plugin_node);
 		librdf_free_node(data_node);
@@ -216,7 +216,7 @@ slv2_model_load_all(SLV2Model model)
 	}
 
 	// ORDER BY should (and appears to actually) guarantee this
-	//raptor_sequence_sort(model->plugins, slv2_plugin_compare_by_uri);
+	//raptor_sequence_sort(world->plugins, slv2_plugin_compare_by_uri);
 
 	if (results)
 		librdf_free_query_results(results);
@@ -227,7 +227,7 @@ slv2_model_load_all(SLV2Model model)
 
 #if 0
 void
-slv2_model_serialize(const char* filename)
+slv2_world_serialize(const char* filename)
 {
 	librdf_uri* lv2_uri = librdf_new_uri(slv2_rdf_world,
 			(unsigned char*)"http://lv2plug.in/ontology#");
@@ -240,14 +240,14 @@ slv2_model_serialize(const char* filename)
 			"turtle", NULL, NULL);
 	librdf_serializer_set_namespace(serializer, lv2_uri, "");
 	librdf_serializer_set_namespace(serializer, rdfs_uri, "rdfs");
-	librdf_serializer_serialize_model_to_file(serializer, filename, NULL, slv2_model);
+	librdf_serializer_serialize_world_to_file(serializer, filename, NULL, slv2_model);
 	librdf_free_serializer(serializer);
 }
 #endif
 
 
 SLV2Plugins
-slv2_model_get_all_plugins(SLV2Model model)
+slv2_world_get_all_plugins(SLV2World world)
 {
 	// FIXME: Slow..
 	
@@ -255,8 +255,8 @@ slv2_model_get_all_plugins(SLV2Model model)
 	// our locally stored plugins
 	raptor_sequence* result = raptor_new_sequence(NULL, NULL);
 
-	for (int i=0; i < raptor_sequence_size(model->plugins); ++i)
-		raptor_sequence_push(result, raptor_sequence_get_at(model->plugins, i));
+	for (int i=0; i < raptor_sequence_size(world->plugins); ++i)
+		raptor_sequence_push(result, raptor_sequence_get_at(world->plugins, i));
 
 	// sorted?
 	
@@ -265,9 +265,9 @@ slv2_model_get_all_plugins(SLV2Model model)
 
 
 SLV2Plugins
-slv2_model_get_plugins_by_filter(SLV2Model model, bool (*include)(SLV2Plugin))
+slv2_world_get_plugins_by_filter(SLV2World world, bool (*include)(SLV2Plugin))
 {
-	SLV2Plugins all = slv2_model_get_all_plugins(model);
+	SLV2Plugins all = slv2_world_get_all_plugins(world);
 	SLV2Plugins result = slv2_plugins_new();
 
 	for (int i=0; i < raptor_sequence_size(all); ++i) {
@@ -283,14 +283,14 @@ slv2_model_get_plugins_by_filter(SLV2Model model, bool (*include)(SLV2Plugin))
 
 #if 0
 SLV2Plugins
-slv2_model_get_plugins_by_query(SLV2Model model, const char* query)
+slv2_world_get_plugins_by_query(SLV2World world, const char* query)
 {
 	SLV2Plugins list = slv2_plugins_new();	
 
-	librdf_query* rq = librdf_new_query(model->world, "sparql",
+	librdf_query* rq = librdf_new_query(world->world, "sparql",
 		NULL, (const unsigned char*)query, NULL);
 	
-	librdf_query_results* results = librdf_query_execute(rq, model->model);
+	librdf_query_results* results = librdf_query_execute(rq, world->model);
 	
 	while (!librdf_query_results_finished(results)) {
 		librdf_node* plugin_node = librdf_query_results_get_binding_value(results, 0);
@@ -301,7 +301,7 @@ slv2_model_get_plugins_by_query(SLV2Model model, const char* query)
 
 		/* Create a new SLV2Plugin */
 		if (!plugin) {
-			SLV2Plugin new_plugin = slv2_plugin_new(model, plugin_uri);
+			SLV2Plugin new_plugin = slv2_plugin_new(world, plugin_uri);
 			raptor_sequence_push(list, new_plugin);
 		}