Renamed SLV2Model SLV2World.

Updated Ingen for SLV2 API changes.


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

15 files changed, 115 insertions, 119 deletions

diff --git a/hosts/lv2_jack_host.c b/hosts/lv2_jack_host.c
index 2e7a23f..a0bca74 100644
--- a/hosts/lv2_jack_host.c
+++ b/hosts/lv2_jack_host.c
@@ -63,9 +63,9 @@ main(int argc, char** argv)
 	host.ports       = NULL;
 	
 	/* Find all installed plugins */
-	SLV2Model model = slv2_model_new();
-	slv2_model_load_all(model);
-	SLV2Plugins plugins = slv2_model_get_all_plugins(model);
+	SLV2World world = slv2_world_new();
+	slv2_world_load_all(world);
+	SLV2Plugins plugins = slv2_world_get_all_plugins(world);
 
 	/* Find the plugin to run */
 	const char* plugin_uri = (argc == 2) ? argv[1] : NULL;
@@ -140,7 +140,7 @@ main(int argc, char** argv)
 	}
 	jack_client_close(host.jack_client);
 	
-	slv2_model_free(model);
+	slv2_world_free(world);
 
 	return 0;
 }
diff --git a/hosts/lv2_simple_jack_host.c b/hosts/lv2_simple_jack_host.c
index 260605c..0b938e3 100644
--- a/hosts/lv2_simple_jack_host.c
+++ b/hosts/lv2_simple_jack_host.c
@@ -24,8 +24,8 @@
 int
 main(/*int argc, char** argv*/)
 {
-	SLV2Model model = slv2_model_new();
-	slv2_model_load_all(model);
+	SLV2World world = slv2_world_new();
+	slv2_world_load_all(world);
 	
 
 	/*printf("********** All plugins **********\n");
@@ -62,7 +62,7 @@ main(/*int argc, char** argv*/)
 	slv2_plugins_free(plugins);
 	*/
 
-	slv2_model_free(model);
+	slv2_world_free(world);
 	
 	return 0;
 }
diff --git a/slv2/Makefile.am b/slv2/Makefile.am
index 2c69aef..e20cde8 100644
--- a/slv2/Makefile.am
+++ b/slv2/Makefile.am
@@ -4,7 +4,7 @@ slv2include_HEADERS = \
 	lv2.h \
 	types.h \
 	slv2.h \
-	model.h \
+	world.h \
 	plugin.h \
 	port.h \
 	pluginlist.h \
diff --git a/slv2/plugin.h b/slv2/plugin.h
index 7b8d62b..47cb9ee 100644
--- a/slv2/plugin.h
+++ b/slv2/plugin.h
@@ -31,12 +31,12 @@ extern "C" {
 
 /** \defgroup data Plugin data access
  *
- * These functions work exclusively with the plugin's RDF data file.
+ * These functions work exclusively with the plugin's RDF data.
  * They do not load or access the plugin dynamic library in any way.
  *
- * An SLV2Plugin is a weak reference (ie URIs) to an LV2 plugin in the
- * Model.  Most functions which operate on an SLV2Plugin actually query
- * the data in the model.
+ * An SLV2Plugin contains an in-memory cache of the plugin data, loaded
+ * on demand.  Duplicating plugins should be avoided when possible for
+ * performance reasons.
  *
  * @{
  */
diff --git a/slv2/pluginlist.h b/slv2/pluginlist.h
index c0c1b4d..cd1bbf8 100644
--- a/slv2/pluginlist.h
+++ b/slv2/pluginlist.h
@@ -32,7 +32,7 @@ typedef void* SLV2Plugins;
 /** \defgroup plugins Plugin lists
  * 
  * These functions work with lists of plugins which come from an
- * SLV2Model.  These lists contain only a weak reference to an LV2 plugin
+ * SLV2World.  These lists contain only a weak reference to an LV2 plugin
  * in the Model.
  *
  * @{
diff --git a/slv2/slv2.h b/slv2/slv2.h
index 8691e28..431bd17 100644
--- a/slv2/slv2.h
+++ b/slv2/slv2.h
@@ -24,7 +24,7 @@ extern "C" {
 #endif
 
 #include <slv2/types.h>
-#include <slv2/model.h>
+#include <slv2/world.h>
 #include <slv2/plugin.h>
 #include <slv2/port.h>
 #include <slv2/pluginlist.h>
diff --git a/slv2/types.h b/slv2/types.h
index da53069..f0f9b7f 100644
--- a/slv2/types.h
+++ b/slv2/types.h
@@ -47,7 +47,7 @@ typedef struct _Port* SLV2Port;
 
 typedef struct _Plugin* SLV2Plugin;
 
-typedef struct _Model* SLV2Model;
+typedef struct _World* SLV2World;
 
 #ifdef __cplusplus
 }
diff --git a/slv2/model.h b/slv2/world.h
index 4db1b2f..4f5b252 100644
--- a/slv2/model.h
+++ b/slv2/world.h
@@ -16,8 +16,8 @@
  * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  */
 
-#ifndef __SLV2_MODEL_H__
-#define __SLV2_MODEL_H__
+#ifndef __SLV2_WORLD_H__
+#define __SLV2_WORLD_H__
 
 #include <slv2/pluginlist.h>
 
@@ -26,15 +26,15 @@ extern "C" {
 #endif
 
 
-/** \defgroup model Data model loading
+/** \defgroup world Library context, data loading, etc.
  * 
  * These functions deal with the data model which other SLV2 methods
- * operate with.  The data model is LV2 data loaded from bundles, from
- * which you can query plugins, etc.
+ * operate with.  The world contains an in-memory cache of all bundles
+ * manifest.ttl files, from which you can quickly query plugins, etc.
  *
  * Normal hosts which just want to easily load plugins by URI are strongly
  * recommended to simply find all installed data in the recommended way with
- * \ref slv2_model_load_all rather than find and load bundles manually.
+ * \ref slv2_world_load_all rather than find and load bundles manually.
  * 
  * Functions are provided for hosts that wish to access bundles explicitly and
  * individually for some reason, this is intended for hosts which are tied to
@@ -44,20 +44,20 @@ extern "C" {
  */
 
 
-/** Create a new, empty model.
+/** Initialize a new, empty world.
  */
-SLV2Model
-slv2_model_new();
+SLV2World
+slv2_world_new();
 
 
-/** Destroy a model.
+/** Destroy the world, mwahaha.
  *
- * NB: Destroying a model will leave dangling references in any plugin lists,
- * plugins, etc.  Do not destroy a model until you are finished with all
+ * NB: Destroying the world will leave dangling references in any plugin lists,
+ * plugins, etc.  Do not destroy the world until you are finished with all
  * objects that came from it.
  */
 void
-slv2_model_free(SLV2Model model);
+slv2_world_free(SLV2World world);
 
 
 /** Load all installed LV2 bundles on the system
@@ -72,7 +72,7 @@ slv2_model_free(SLV2Model model);
  * without a special reason to do so - use this one.
  */
 void
-slv2_model_load_all(SLV2Model model);
+slv2_world_load_all(SLV2World world);
 
 
 /** Load all bundles found in \a search_path.
@@ -81,15 +81,15 @@ slv2_model_load_all(SLV2Model model);
  * should contain LV2 bundle directories (ie the search path is a list of
  * parent directories of bundles, not a list of bundle directories).
  *
- * If \a search_path is NULL, \a model will be unmodified.
- * Use of this function is \b not recommended.  Use \ref slv2_model_load_all.
+ * If \a search_path is NULL, \a world will be unmodified.
+ * Use of this function is \b not recommended.  Use \ref slv2_world_load_all.
  */
 void
-slv2_model_load_path(SLV2Model   model,
+slv2_world_load_path(SLV2World   world,
                      const char* search_path);
 
 
-/** Load a specific bundle into \a model.
+/** Load a specific bundle into \a world.
  *
  * \arg bundle_base_uri is a fully qualified URI to the bundle directory,
  * with the trailing slash, eg. file:///usr/lib/lv2/someBundle/
@@ -103,37 +103,37 @@ slv2_model_load_path(SLV2Model   model,
  * the same package).
  */
 void
-slv2_model_load_bundle(SLV2Model   model,
+slv2_world_load_bundle(SLV2World   world,
                        const char* bundle_base_uri);
 
 
-/** Add all plugins present in \a model to \a list.
+/** Add all plugins present in \a world to \a list.
  *
- * Returned plugins contain a reference to this model, model must not be
+ * Returned plugins contain a reference to this world, world must not be
  * destroyed until plugins are finished with.
  */
 SLV2Plugins
-slv2_model_get_all_plugins(SLV2Model model);
+slv2_world_get_all_plugins(SLV2World world);
 
 
 /** Get plugins filtered by a user-defined filter function.
  *
- * All plugins in \a model that return true when passed to \a include
+ * All plugins in \a world that return true when passed to \a include
  * (a pointer to a function that takes an SLV2Plugin and returns a bool)
  * will be added to \a list.
  *
- * Returned plugins contain a reference to this model, model must not be
+ * Returned plugins contain a reference to this world, world must not be
  * destroyed until plugins are finished with.
  */
 SLV2Plugins
-slv2_model_get_plugins_by_filter(SLV2Model   model,
+slv2_world_get_plugins_by_filter(SLV2World world,
                                  bool (*include)(SLV2Plugin));
 
 
 #if 0
 /** Get plugins filtered by a user-defined SPARQL query.
  *
- * This is much faster than using slv2_model_get_plugins_by_filter with a
+ * This is much faster than using slv2_world_get_plugins_by_filter with a
  * filter function which calls the various slv2_plugin_* functions.
  *
  * \param query A valid SPARQL query which SELECTs a single variable, which
@@ -148,11 +148,11 @@ SELECT DISTINCT ?plugin WHERE {
 }
 \endverbatim </tt>
  *
- * Returned plugins contain a reference to this model, model must not be
+ * Returned plugins contain a reference to this world, world must not be
  * destroyed until plugins are finished with.
  */
 SLV2Plugins
-slv2_model_get_plugins_by_query(SLV2Model   model,
+slv2_world_get_plugins_by_query(SLV2World   world,
                                 const char* query);
 #endif
 
@@ -162,5 +162,5 @@ slv2_model_get_plugins_by_query(SLV2Model   model,
 }
 #endif
 
-#endif /* __SLV2_MODEL_H__ */
+#endif /* __SLV2_WORLD_H__ */
 
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);
 		}
 		
diff --git a/utils/lv2_inspect.c b/utils/lv2_inspect.c
index 593cc00..a6a949d 100644
--- a/utils/lv2_inspect.c
+++ b/utils/lv2_inspect.c
@@ -138,15 +138,15 @@ print_plugin(SLV2Plugin p)
 int
 main(int argc, char** argv)
 {
-	SLV2Model model = slv2_model_new();
-	slv2_model_load_all(model);
+	SLV2World world = slv2_world_new();
+	slv2_world_load_all(world);
 
 	if (argc != 2) {
 		fprintf(stderr, "Usage: %s PLUGIN_URI\n", argv[0]);
 		return -1;
 	}
 
-	SLV2Plugins plugins = slv2_model_get_all_plugins(model);
+	SLV2Plugins plugins = slv2_world_get_all_plugins(world);
 
 	SLV2Plugin p = slv2_plugins_get_by_uri(plugins, argv[1]);
 
@@ -158,7 +158,7 @@ main(int argc, char** argv)
 	}
 
 	slv2_plugins_free(plugins);
-	slv2_model_free(model);
+	slv2_world_free(world);
 
 	return (p != NULL ? 0 : -1);
 }
diff --git a/utils/lv2_list.c b/utils/lv2_list.c
index 5c2a1dd..56afe4a 100644
--- a/utils/lv2_list.c
+++ b/utils/lv2_list.c
@@ -33,15 +33,15 @@ list_plugins(SLV2Plugins list)
 int
 main()//int argc, char** argv)
 {
-	SLV2Model model = slv2_model_new();
-	slv2_model_load_all(model);
+	SLV2World world = slv2_world_new();
+	slv2_world_load_all(world);
 
-	SLV2Plugins plugins = slv2_model_get_all_plugins(model);
+	SLV2Plugins plugins = slv2_world_get_all_plugins(world);
 
 	list_plugins(plugins);
 	
 	slv2_plugins_free(plugins);
-	slv2_model_free(model);
+	slv2_world_free(world);
 
 	return 0;
 }