Overhaul SLV2 API to return/take SLV2Value (instead of strings or primitives) wherever possible.

Make 'index' a fundemental property of ingen ports.


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

1 files changed, 127 insertions, 134 deletions

diff --git a/src/plugin.c b/src/plugin.c
index aee89ae..6ab21b4 100644
--- a/src/plugin.c
+++ b/src/plugin.c
@@ -32,15 +32,16 @@
 #include <slv2/pluginuis.h>
 
 
-/* private */
+/* private
+ * ownership of uri is taken */
 SLV2Plugin
-slv2_plugin_new(SLV2World world, librdf_uri* uri, librdf_uri* bundle_uri, librdf_uri* binary_uri)
+slv2_plugin_new(SLV2World world, SLV2Value uri, librdf_uri* bundle_uri, librdf_uri* binary_uri)
 {
 	struct _SLV2Plugin* plugin = malloc(sizeof(struct _SLV2Plugin));
 	plugin->world = world;
-	plugin->plugin_uri = librdf_new_uri_from_uri(uri);
-	plugin->bundle_uri = librdf_new_uri_from_uri(bundle_uri);
-	plugin->binary_uri = librdf_new_uri_from_uri(binary_uri);
+	plugin->plugin_uri = uri;
+	plugin->bundle_uri = slv2_value_new_librdf_uri(world, bundle_uri);
+	plugin->binary_uri = slv2_value_new_librdf_uri(world, binary_uri);
 	plugin->plugin_class = NULL;
 	plugin->data_uris = slv2_values_new();
 	plugin->ports = raptor_new_sequence((void (*)(void*))&slv2_port_free, NULL);
@@ -55,13 +56,13 @@ slv2_plugin_new(SLV2World world, librdf_uri* uri, librdf_uri* bundle_uri, librdf
 void
 slv2_plugin_free(SLV2Plugin p)
 {
-	librdf_free_uri(p->plugin_uri);
+	slv2_value_free(p->plugin_uri);
 	p->plugin_uri = NULL;
 	
-	librdf_free_uri(p->bundle_uri);
+	slv2_value_free(p->bundle_uri);
 	p->bundle_uri = NULL;
 	
-	librdf_free_uri(p->binary_uri);
+	slv2_value_free(p->binary_uri);
 	p->binary_uri = NULL;
 	
 	raptor_free_sequence(p->ports);
@@ -84,40 +85,6 @@ slv2_plugin_free(SLV2Plugin p)
 }
 
 
-// FIXME: ew
-librdf_query_results*
-slv2_plugin_query(SLV2Plugin plugin,
-                  const char* sparql_str);
-
-
-/*
-SLV2Plugin
-slv2_plugin_duplicate(SLV2Plugin p)
-{
-	assert(p);
-	struct _Plugin* result = malloc(sizeof(struct _Plugin));
-	result->world = p->world;
-	result->plugin_uri = librdf_new_uri_from_uri(p->plugin_uri);
-
-	//result->bundle_url = strdup(p->bundle_url);
-	result->binary_uri = strdup(p->binary_uri);
-	
-	result->data_uris = slv2_values_new();
-	for (unsigned i=0; i < slv2_values_size(p->data_uris); ++i)
-		raptor_sequence_push(result->data_uris, strdup(slv2_values_get_at(p->data_uris, i)));
-	
-	result->ports = raptor_new_sequence((void (*)(void*))&slv2_port_free, NULL);
-	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->storage = NULL;
-	result->rdf = NULL;
-
-	return result;
-}
-*/
-
-
 /** comparator for sorting */
 int
 slv2_port_compare_by_index(const void* a, const void* b)
@@ -161,29 +128,32 @@ slv2_plugin_load(SLV2Plugin p)
 		"SELECT DISTINCT ?class WHERE { <> a ?class }";
 	
 	librdf_query* q = librdf_new_query(p->world->world, "sparql",
-		NULL, query, p->plugin_uri);
+		NULL, query, slv2_value_as_librdf_uri(p->plugin_uri));
 	
 	librdf_query_results* results = librdf_query_execute(q, p->rdf);
 		
 	while (!librdf_query_results_finished(results)) {
 		librdf_node* class_node    = librdf_query_results_get_binding_value(results, 0);
 		librdf_uri*  class_uri     = librdf_node_get_uri(class_node);
-		assert(class_uri);
-		const char*  class_uri_str = (const char*)librdf_uri_as_string(class_uri);
+
+		SLV2Value class = slv2_value_new_librdf_uri(p->world, class_uri);
 		
-		if ( ! librdf_uri_equals(class_uri, p->world->lv2_plugin_class->uri) ) {
+		if ( ! slv2_value_equals(class, p->world->lv2_plugin_class->uri)) {
 
 			SLV2PluginClass plugin_class = slv2_plugin_classes_get_by_uri(
-					p->world->plugin_classes, class_uri_str);
+					p->world->plugin_classes, class);
 			
+
 			librdf_free_node(class_node);
 
 			if (plugin_class) {
 				p->plugin_class = plugin_class;
+				slv2_value_free(class);
 				break;
 			}
 		}
 
+		slv2_value_free(class);
 		librdf_query_results_next(results);
 	}
 	
@@ -204,7 +174,7 @@ slv2_plugin_load(SLV2Plugin p)
 		"} ORDER BY (?index)";
 	
 	q = librdf_new_query(p->world->world, "sparql",
-		NULL, query, p->plugin_uri);
+		NULL, query, slv2_value_as_librdf_uri(p->plugin_uri));
 	
 	results = librdf_query_execute(q, p->rdf);
 
@@ -231,7 +201,7 @@ slv2_plugin_load(SLV2Plugin p)
 		// Create a new SLV2Port, and add to template
 		if (this_index == num_ports) {
 			assert(this_index == last_index + 1);
-			this_port = slv2_port_new((unsigned)atoi(index), symbol);
+			this_port = slv2_port_new(p->world, (unsigned)atoi(index), symbol);
 			raptor_sequence_push(p->ports, this_port);
 			++num_ports;
 			++last_index;
@@ -258,30 +228,30 @@ slv2_plugin_load(SLV2Plugin p)
 }
 
 
-const char*
+SLV2Value
 slv2_plugin_get_uri(SLV2Plugin p)
 {
 	assert(p);
 	assert(p->plugin_uri);
-	return (const char*)librdf_uri_as_string(p->plugin_uri);
+	return p->plugin_uri;
 }
 
 
-const char*
+SLV2Value
 slv2_plugin_get_bundle_uri(SLV2Plugin p)
 {
 	assert(p);
 	assert(p->bundle_uri);
-	return (const char*)librdf_uri_as_string(p->bundle_uri);
+	return p->bundle_uri;
 }
 
 
-const char*
+SLV2Value
 slv2_plugin_get_library_uri(SLV2Plugin p)
 {
 	assert(p);
 	assert(p->binary_uri);
-	return (const char*)librdf_uri_as_string(p->binary_uri);
+	return p->binary_uri;
 }
 
 
@@ -352,7 +322,8 @@ slv2_plugin_verify(SLV2Plugin plugin)
 	librdf_free_query_results(results);
 
 	if ( ! (has_type && has_name && has_license && has_port) ) {
-		fprintf(stderr, "Invalid LV2 Plugin %s\n", slv2_plugin_get_uri(plugin));
+		fprintf(stderr, "Invalid LV2 Plugin %s\n",
+				slv2_value_as_uri(slv2_plugin_get_uri(plugin)));
 		return false;
 	} else {
 		return true;
@@ -360,49 +331,73 @@ slv2_plugin_verify(SLV2Plugin plugin)
 }
 
 
-char*
+SLV2Value
 slv2_plugin_get_name(SLV2Plugin plugin)
 {
-	char* result     = NULL;
-	SLV2Values prop = slv2_plugin_get_value(plugin, SLV2_QNAME, "doap:name");
+	SLV2Values results = slv2_plugin_get_value_by_qname(plugin, "doap:name");
+	SLV2Value  ret     = NULL;
 	
-	// FIXME: lang? guaranteed to be the untagged one?
-	if (prop && slv2_values_size(prop) > 0) {
-		SLV2Value val = slv2_values_get_at(prop, 0);
+	// FIXME: lang?
+	
+	if (results && slv2_values_size(results) > 0) {
+		SLV2Value val = slv2_values_get_at(results, 0);
 		if (slv2_value_is_string(val))
-			result = strdup(slv2_value_as_string(val));
+			ret = slv2_value_duplicate(val);
 	}
 
-	if (prop)
-		slv2_values_free(prop);
+	if (results)
+		slv2_values_free(results);
 
-	return result;
+	return ret;
 }
 
 
 SLV2Values
-slv2_plugin_get_value(SLV2Plugin  p,
-                      SLV2URIType predicate_type,
-                      const char* predicate)
+slv2_plugin_get_value(SLV2Plugin p,
+                      SLV2Value  predicate)
 {
 	char* query = NULL;
 	
 	/* Hack around broken RASQAL, full URI predicates don't work :/ */
 
-	if (predicate_type == SLV2_URI) {
+	if (predicate->type == SLV2_VALUE_URI) {
 		query = slv2_strjoin(
-			"PREFIX slv2predicate: <", predicate, ">",
+			"PREFIX slv2predicate: <", slv2_value_as_string(predicate), ">",
 			"SELECT DISTINCT ?value WHERE { \n"
 			"<> slv2predicate: ?value \n"
 			"}\n", NULL);
-	} else {
+	} else if (predicate->type == SLV2_VALUE_QNAME) {
     	query = slv2_strjoin(
 			"SELECT DISTINCT ?value WHERE { \n"
-			"<> ", predicate, " ?value \n"
+			"<> ", slv2_value_as_string(predicate), " ?value \n"
 			"}\n", NULL);
+	} else {
+		fprintf(stderr, "slv2_plugin_get_value error: "
+				"predicate is not a URI or QNAME\n");
+		return NULL;
 	}
 
-	SLV2Values result = slv2_plugin_simple_query(p, query, 0);
+	SLV2Values result = slv2_plugin_query_variable(p, query, 0);
+	
+	free(query);
+
+	return result;
+}
+
+
+/* internal */
+SLV2Values
+slv2_plugin_get_value_by_qname(SLV2Plugin  p,
+                               const char* predicate)
+{
+	char* query = NULL;
+	
+    query = slv2_strjoin(
+			"SELECT DISTINCT ?value WHERE { \n"
+			"<> ", predicate, " ?value \n"
+			"}\n", NULL);
+
+	SLV2Values result = slv2_plugin_query_variable(p, query, 0);
 	
 	free(query);
 
@@ -413,12 +408,11 @@ slv2_plugin_get_value(SLV2Plugin  p,
 SLV2Values
 slv2_plugin_get_value_for_subject(SLV2Plugin  p,
                                   SLV2Value   subject,
-                                  SLV2URIType predicate_type,
-                                  const char* predicate)
+                                  SLV2Value   predicate)
 {
 	if ( ! slv2_value_is_uri(subject)) {
 		fprintf(stderr, "slv2_plugin_get_value_for_subject error: "
-				"passed non-URI subject\n");
+				"subject is not a URI\n");
 		return NULL;
 	}
 
@@ -428,20 +422,25 @@ slv2_plugin_get_value_for_subject(SLV2Plugin  p,
 
 	char* subject_token = slv2_value_get_turtle_token(subject);
 
-	if (predicate_type == SLV2_URI) {
+	if (predicate->type == SLV2_VALUE_URI) {
 		query = slv2_strjoin(
 			"PREFIX slv2predicate: <", predicate, ">",
 			"SELECT DISTINCT ?value WHERE { \n",
 			subject_token, " slv2predicate: ?value \n"
 			"}\n", NULL);
-	} else {
+	} else if (predicate->type == SLV2_VALUE_URI) {
     	query = slv2_strjoin(
 			"SELECT DISTINCT ?value WHERE { \n",
 			subject_token, " ", predicate, " ?value \n"
 			"}\n", NULL);
+	} else {
+		fprintf(stderr, "slv2_plugin_get_value error: "
+				"predicate is not a URI or QNAME\n");
+		free(subject_token);
+		return NULL;
 	}
 
-	SLV2Values result = slv2_plugin_simple_query(p, query, 0);
+	SLV2Values result = slv2_plugin_query_variable(p, query, 0);
 	
 	free(query);
 	free(subject_token);
@@ -453,14 +452,14 @@ slv2_plugin_get_value_for_subject(SLV2Plugin  p,
 SLV2Values
 slv2_plugin_get_properties(SLV2Plugin p)
 {
-	return slv2_plugin_get_value(p, SLV2_QNAME, "lv2:pluginProperty");
+	return slv2_plugin_get_value_by_qname(p, "lv2:pluginProperty");
 }
 
 
 SLV2Values
 slv2_plugin_get_hints(SLV2Plugin p)
 {
-	return slv2_plugin_get_value(p, SLV2_QNAME, "lv2:pluginHint");
+	return slv2_plugin_get_value_by_qname(p, "lv2:pluginHint");
 }
 
 
@@ -478,13 +477,13 @@ bool
 slv2_plugin_has_latency(SLV2Plugin p)
 {
     const char* const query = 
-		"SELECT DISTINCT ?index WHERE {\n"
+		"SELECT ?index WHERE {\n"
 		"	<>      lv2:port         ?port .\n"
 		"	?port   lv2:portProperty lv2:reportsLatency ;\n"
 		"           lv2:index        ?index .\n"
 		"}\n";
 
-	SLV2Values results = slv2_plugin_simple_query(p, query, 0);
+	SLV2Values results = slv2_plugin_query_variable(p, query, 0);
 	const bool latent = (slv2_values_size(results) > 0);
 	slv2_values_free(results);
 	
@@ -493,16 +492,16 @@ slv2_plugin_has_latency(SLV2Plugin p)
 
 
 uint32_t
-slv2_plugin_get_latency_port(SLV2Plugin p)
+slv2_plugin_get_latency_port_index(SLV2Plugin p)
 {
     const char* const query = 
-		"SELECT DISTINCT ?index WHERE {\n"
+		"SELECT ?index WHERE {\n"
 		"	<>      lv2:port         ?port .\n"
 		"	?port   lv2:portProperty lv2:reportsLatency ;\n"
 		"           lv2:index        ?index .\n"
 		"}\n";
 
-	SLV2Values result = slv2_plugin_simple_query(p, query, 0);
+	SLV2Values result = slv2_plugin_query_variable(p, query, 0);
 	
 	// FIXME: need a sane error handling strategy
 	assert(slv2_values_size(result) > 0);
@@ -514,19 +513,14 @@ slv2_plugin_get_latency_port(SLV2Plugin p)
 
 	
 bool
-slv2_plugin_has_feature(SLV2Plugin  p,
-                        const char* feature)
+slv2_plugin_has_feature(SLV2Plugin p,
+                        SLV2Value  feature)
 {
-	assert(feature);
 	SLV2Values features = slv2_plugin_get_supported_features(p);
 	
-	SLV2Value val = slv2_value_new(p->world, SLV2_VALUE_URI, feature);
-
-	const bool ret = features && slv2_values_contains(features, val);
+	const bool ret = features && feature && slv2_values_contains(features, feature);
 
 	slv2_values_free(features);
-	slv2_value_free(val);
-
 	return ret;
 }
 
@@ -541,7 +535,7 @@ slv2_plugin_get_supported_features(SLV2Plugin p)
 		"	{ <>  lv2:requiredFeature ?feature }\n"
 		"}\n";
 
-	SLV2Values result = slv2_plugin_simple_query(p, query, 0);
+	SLV2Values result = slv2_plugin_query_variable(p, query, 0);
 	
 	return result;
 }
@@ -550,14 +544,14 @@ slv2_plugin_get_supported_features(SLV2Plugin p)
 SLV2Values
 slv2_plugin_get_optional_features(SLV2Plugin p)
 {
-	return slv2_plugin_get_value(p, SLV2_QNAME, "lv2:optionalFeature");
+	return slv2_plugin_get_value_by_qname(p, "lv2:optionalFeature");
 }
 
 
 SLV2Values
 slv2_plugin_get_required_features(SLV2Plugin p)
 {
-	return slv2_plugin_get_value(p, SLV2_QNAME, "lv2:requiredFeature");
+	return slv2_plugin_get_value_by_qname(p, "lv2:requiredFeature");
 }
 
 
@@ -573,16 +567,15 @@ slv2_plugin_get_port_by_index(SLV2Plugin p,
 
 
 SLV2Port
-slv2_plugin_get_port_by_symbol(SLV2Plugin  p,
-                               const char* symbol)
+slv2_plugin_get_port_by_symbol(SLV2Plugin p,
+                               SLV2Value  symbol)
 {
 	if (!p->rdf)
 		slv2_plugin_load(p);
 	
-	// FIXME: sort plugins and do a binary search
 	for (int i=0; i < raptor_sequence_size(p->ports); ++i) {
 		SLV2Port port = raptor_sequence_get_at(p->ports, i);
-		if (!strcmp(port->symbol, symbol))
+		if (slv2_value_equals(port->symbol, symbol))
 			return port;
 	}
 
@@ -590,79 +583,79 @@ slv2_plugin_get_port_by_symbol(SLV2Plugin  p,
 }
 
 
-char*
+SLV2Value
 slv2_plugin_get_author_name(SLV2Plugin plugin)
 {
-	char* ret = NULL;
+	SLV2Value ret = NULL;
 
     const char* const query = 
-		"SELECT DISTINCT ?name WHERE {\n"
+		"SELECT ?name WHERE {\n"
 		"	<>      doap:maintainer ?maint . \n"
 		"	?maint  foaf:name ?name . \n"
 		"}\n";
 
-	SLV2Values result = slv2_plugin_simple_query(plugin, query, 0);
+	SLV2Values results = slv2_plugin_query_variable(plugin, query, 0);
 	
-	if (result && slv2_values_size(result) > 0) {
-		SLV2Value val = slv2_values_get_at(result, 0);
+	if (results && slv2_values_size(results) > 0) {
+		SLV2Value val = slv2_values_get_at(results, 0);
 		if (slv2_value_is_string(val))
-			ret = strdup(slv2_value_as_string(val));
+			ret = slv2_value_duplicate(val);
 	}
 
-	if (result)
-		slv2_values_free(result);
+	if (results)
+		slv2_values_free(results);
 
 	return ret;
 }
 
 
-char*
+SLV2Value
 slv2_plugin_get_author_email(SLV2Plugin plugin)
 {
-	char* ret = NULL;
+	SLV2Value ret = NULL;
 
     const char* const query = 
-		"SELECT DISTINCT ?email WHERE {\n"
+		"SELECT ?email WHERE {\n"
 		"	<>      doap:maintainer ?maint . \n"
 		"	?maint  foaf:mbox ?email . \n"
 		"}\n";
-
-	SLV2Values result = slv2_plugin_simple_query(plugin, query, 0);
 	
-	if (result && slv2_values_size(result) > 0) {
-		SLV2Value val = slv2_values_get_at(result, 0);
-		if (slv2_value_is_string(val))
-			ret = strdup(slv2_value_as_string(val));
+	SLV2Values results = slv2_plugin_query_variable(plugin, query, 0);
+	
+	if (results && slv2_values_size(results) > 0) {
+		SLV2Value val = slv2_values_get_at(results, 0);
+		if (slv2_value_is_uri(val))
+			ret = slv2_value_duplicate(val);
 	}
 
-	if (result)
-		slv2_values_free(result);
+	if (results)
+		slv2_values_free(results);
 
 	return ret;
 }
 
 	
-char*
+SLV2Value
 slv2_plugin_get_author_homepage(SLV2Plugin plugin)
 {
-	char* ret = NULL;
+	SLV2Value ret = NULL;
 
     const char* const query = 
-		"SELECT DISTINCT ?email WHERE {\n"
+		"SELECT ?page WHERE {\n"
 		"	<>      doap:maintainer ?maint . \n"
-		"	?maint  foaf:homepage ?email . \n"
+		"	?maint  foaf:homepage ?page . \n"
 		"}\n";
-
-	SLV2Values result = slv2_plugin_simple_query(plugin, query, 0);
 	
-	if (result && slv2_values_size(result) > 0) {
-		SLV2Value val = slv2_values_get_at(result, 0);
-		if (slv2_value_is_string(val))
-			ret = strdup(slv2_value_as_string(val));
+	SLV2Values results = slv2_plugin_query_variable(plugin, query, 0);
+	
+	if (results && slv2_values_size(results) > 0) {
+		SLV2Value val = slv2_values_get_at(results, 0);
+		if (slv2_value_is_uri(val))
+			ret = slv2_value_duplicate(val);
 	}
 
-	if (result)
-		slv2_values_free(result);
+	if (results)
+		slv2_values_free(results);
 
 	return ret;
 }