Converted Raul (and thus Ingen and Machina) to use Redland over Raptor/Rasqal independently.

Fixed patch loading for Ingen (local only, still something wrong with remote...).


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

14 files changed, 117 insertions, 111 deletions

diff --git a/src/engine/Action.cpp b/src/engine/Action.cpp
index a8a7db1..a9de1ee 100644
--- a/src/engine/Action.cpp
+++ b/src/engine/Action.cpp
@@ -15,22 +15,23 @@
  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
  */
 
-#include <raul/RDFWriter.h>
+#include <raul/RDFWorld.h>
+#include <raul/RDFModel.h>
 #include "machina/Action.hpp"
 
 namespace Machina {
 
 void
-Action::write_state(Raul::RDFWriter& writer)
+Action::write_state(Raul::RDF::Model& model)
 {
-	using Raul::RdfId;
+	using namespace Raul;
 	
 	if (!_id)
-		set_id(writer.blank_id());
+		set_id(model.world().blank_id());
 
-	writer.write(_id,
-			RdfId(RdfId::RESOURCE, "rdf:type"),
-			RdfId(RdfId::RESOURCE, "machina:Action"));
+	model.add_statement(_id,
+			RDF::Node(model.world(), RDF::Node::RESOURCE, "rdf:type"),
+			RDF::Node(model.world(), RDF::Node::RESOURCE, "machina:Action"));
 }
 
 
diff --git a/src/engine/Edge.cpp b/src/engine/Edge.cpp
index 3ad1bfc..710629c 100644
--- a/src/engine/Edge.cpp
+++ b/src/engine/Edge.cpp
@@ -15,7 +15,8 @@
  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
  */
 
-#include <raul/RDFWriter.h>
+#include <raul/RDFWorld.h>
+#include <raul/RDFModel.h>
 #include "machina/Node.hpp"
 #include "machina/Edge.hpp"
 
@@ -23,16 +24,16 @@ namespace Machina {
 
 
 void
-Edge::write_state(Raul::RDFWriter& writer)
+Edge::write_state(Raul::RDF::Model& model)
 {
-	using Raul::RdfId;
+	using namespace Raul;
 
 	if (!_id)
-		set_id(writer.blank_id());
+		set_id(model.world().blank_id());
 
-	writer.write(_id,
-			RdfId(RdfId::RESOURCE, "rdf:type"),
-			RdfId(RdfId::RESOURCE, "machina:Edge"));
+	model.add_statement(_id,
+			"rdf:type",
+			RDF::Node(model.world(), RDF::Node::RESOURCE, "machina:Edge"));
 
 	SharedPtr<Node> tail = _tail.lock();
 	SharedPtr<Node> head = _head;
@@ -42,16 +43,16 @@ Edge::write_state(Raul::RDFWriter& writer)
 
 	assert(tail->id() && head->id());
 
-	writer.write(_id,
-			RdfId(RdfId::RESOURCE, "machina:tail"),
+	model.add_statement(_id,
+			"machina:tail",
 			tail->id());
 
-	writer.write(_id,
-			RdfId(RdfId::RESOURCE, "machina:head"),
+	model.add_statement(_id,
+			"machina:head",
 			head->id());
 	
-	writer.write(_id,
-			RdfId(RdfId::RESOURCE, "machina:probability"),
+	model.add_statement(_id,
+			"machina:probability",
 			_probability.get());
 }
 
diff --git a/src/engine/Engine.cpp b/src/engine/Engine.cpp
index 9135d43..1417e6e 100644
--- a/src/engine/Engine.cpp
+++ b/src/engine/Engine.cpp
@@ -32,7 +32,7 @@ Engine::load_machine(const Glib::ustring& uri)
 {
 	SharedPtr<Machine> old_machine = _driver->machine(); // Hold a reference to current machine..
 
-	SharedPtr<Machine> m = Loader().load(uri);
+	SharedPtr<Machine> m = _loader.load(uri);
 	if (m) {
 		m->activate();
 		_driver->set_machine(m);
@@ -50,7 +50,7 @@ Engine::load_machine(const Glib::ustring& uri)
 SharedPtr<Machine>
 Engine::import_machine(const Glib::ustring& uri)
 {
-	SharedPtr<Machine> m = Loader().load(uri);
+	SharedPtr<Machine> m = _loader.load(uri);
 	if (m) {
 		m->activate();
 		_driver->machine()->nodes().append(m->nodes());
diff --git a/src/engine/Loader.cpp b/src/engine/Loader.cpp
index 7085ec1..34f29d2 100644
--- a/src/engine/Loader.cpp
+++ b/src/engine/Loader.cpp
@@ -18,8 +18,6 @@
 #include <iostream>
 #include <map>
 #include <cmath>
-#include <raptor.h>
-#include <rasqal.h>
 #include <glibmm/ustring.h>
 #include <raul/RDFQuery.h>
 #include "machina/Loader.hpp"
@@ -34,14 +32,11 @@ using std::cerr; using std::cout; using std::endl;
 namespace Machina {
 
 
-Loader::Loader(SharedPtr<Namespaces>  namespaces)
-	: _namespaces(namespaces)
+Loader::Loader(Raul::RDF::World& rdf_world)
+	: _rdf_world(rdf_world)
 {
-	if (!_namespaces)
-		_namespaces = SharedPtr<Namespaces>(new Namespaces());
-
-	(*_namespaces)[""] = "http://drobilla.net/ns/machina#";
-	(*_namespaces)["xsd"] = "http://www.w3.org/2001/XMLSchema#";
+	_rdf_world.add_prefix("xsd", "http://www.w3.org/2001/XMLSchema#");
+	_rdf_world.add_prefix("", "http://drobilla.net/ns/machina#");
 }
 
 
@@ -53,11 +48,9 @@ Loader::Loader(SharedPtr<Namespaces>  namespaces)
 SharedPtr<Machine>
 Loader::load(const Glib::ustring& uri)
 {
-	using Raul::RDFQuery;
+	using Raul::RDF::Query;
 	SharedPtr<Machine> machine;
 
-	rasqal_init();
-
 	Glib::ustring document_uri = uri;
 
 	// If "URI" doesn't contain a colon, try to resolve as a filename
@@ -84,23 +77,24 @@ Loader::load(const Glib::ustring& uri)
 	typedef std::map<string, SharedPtr<Node> > Created;
 	Created created;
 
+	Raul::RDF::Model model(_rdf_world, document_uri);
 
 	/* Get initial nodes */
 
-	Raul::RDFQuery query = Raul::RDFQuery(*_namespaces, Glib::ustring(
+	Query query = Query(_rdf_world, Glib::ustring(
 			"SELECT DISTINCT ?initialNode ?duration FROM <")
 			+ document_uri + "> WHERE {\n" +
 			machine_uri + " :initialNode ?initialNode .\n"
 			"?initialNode   :duration    ?duration .\n"
 			"}\n");
 
-	RDFQuery::Results results = query.run(document_uri);
+	Query::Results results = query.run(_rdf_world, model);
 
-	for (RDFQuery::Results::iterator i = results.begin(); i != results.end(); ++i) {
-		const Glib::ustring& node_id  = (*i)["initialNode"];
-		const Glib::ustring& duration = (*i)["duration"];
+	for (Query::Results::iterator i = results.begin(); i != results.end(); ++i) {
+		Glib::ustring node_id  = (*i)["initialNode"].to_string();
+		float         duration = (*i)["duration"].to_float();
 
-		SharedPtr<Node> node(new Node(strtod(duration.c_str(), NULL), true));
+		SharedPtr<Node> node(new Node(duration, true));
 		machine->add_node(node);
 		created.insert(std::make_pair(node_id.collate_key(), node));
 	}
@@ -108,21 +102,21 @@ Loader::load(const Glib::ustring& uri)
 
 	/* Get remaining (non-initial) nodes */
 
-	query = Raul::RDFQuery(*_namespaces, Glib::ustring(
+	query = Query(_rdf_world, Glib::ustring(
 			"SELECT DISTINCT ?node ?duration FROM <")
 			+ document_uri + "> WHERE {\n" +
 			machine_uri + " :node     ?node .\n"
 			"?node          :duration ?duration .\n"
 			"}\n");
 
-	results = query.run(document_uri);
+	results = query.run(_rdf_world, model);
 
-	for (RDFQuery::Results::iterator i = results.begin(); i != results.end(); ++i) {
-		const Glib::ustring& node_id  = (*i)["node"];
-		const Glib::ustring& duration = (*i)["duration"];
+	for (Query::Results::iterator i = results.begin(); i != results.end(); ++i) {
+		Glib::ustring node_id  = (*i)["initialNode"].to_string();
+		float         duration = (*i)["duration"].to_float();
 
 		if (created.find(node_id.collate_key()) == created.end()) {
-			SharedPtr<Node> node(new Node(strtod(duration.c_str(), NULL), false));
+			SharedPtr<Node> node(new Node(duration, false));
 			machine->add_node(node); 
 			created.insert(std::make_pair(node_id.collate_key(), node));
 		} else {
@@ -133,18 +127,18 @@ Loader::load(const Glib::ustring& uri)
 
 	/* Get note actions */
 
-	query = Raul::RDFQuery(*_namespaces, Glib::ustring(
+	query = Query(_rdf_world, Glib::ustring(
 			"SELECT DISTINCT ?node ?note FROM <")
 			+ document_uri + "> WHERE {\n" +
 			"?node :enterAction [ a :MidiAction; :midiNote ?note ] ;\n"
 			"      :exitAction  [ a :MidiAction; :midiNote ?note ] .\n"
 			"}\n");
 
-	results = query.run(document_uri);
+	results = query.run(_rdf_world, model);
 
-	for (RDFQuery::Results::iterator i = results.begin(); i != results.end(); ++i) {
-		const Glib::ustring& node_id = (*i)["node"];
-		const Glib::ustring& note    = (*i)["note"];
+	for (Query::Results::iterator i = results.begin(); i != results.end(); ++i) {
+		Glib::ustring node_id  = (*i)["initialNode"].to_string();
+		Glib::ustring note     = (*i)["note"].to_string();
 
 		Created::iterator node_i = created.find(node_id);
 		if (node_i != created.end()) {
@@ -164,7 +158,7 @@ Loader::load(const Glib::ustring& uri)
 
 	/* Get edges */
 
-	query = Raul::RDFQuery(*_namespaces, Glib::ustring(
+	query = Query(_rdf_world, Glib::ustring(
 			"SELECT DISTINCT ?edge ?src ?dst ?prob FROM <")
 			+ document_uri + "> WHERE {\n" +
 			machine_uri + " :edge ?edge .\n"
@@ -172,12 +166,12 @@ Loader::load(const Glib::ustring& uri)
 			"      :head        ?dst ;\n"
 			"      :probability ?prob .\n }");
 
-	results = query.run(document_uri);
+	results = query.run(_rdf_world, model);
 
-	for (RDFQuery::Results::iterator i = results.begin(); i != results.end(); ++i) {
-		const Glib::ustring& src_uri = (*i)["src"];
-		const Glib::ustring& dst_uri = (*i)["dst"]; 
-		double               prob    = strtod((*i)["prob"].c_str(), NULL);
+	for (Query::Results::iterator i = results.begin(); i != results.end(); ++i) {
+		Glib::ustring src_uri = (*i)["src"].to_string();
+		Glib::ustring dst_uri = (*i)["dst"].to_string(); 
+		float         prob    = (*i)["prob"].to_float();
 
 		Created::iterator src_i = created.find(src_uri.collate_key());
 		Created::iterator dst_i = created.find(dst_uri.collate_key());
diff --git a/src/engine/Machine.cpp b/src/engine/Machine.cpp
index d4a3425..815ba5b 100644
--- a/src/engine/Machine.cpp
+++ b/src/engine/Machine.cpp
@@ -16,7 +16,9 @@
  */
 
 #include <cstdlib>
-#include "raul/SharedPtr.h"
+#include <raul/RDFWorld.h>
+#include <raul/RDFModel.h>
+#include <raul/SharedPtr.h>
 #include "machina/Machine.hpp"
 #include "machina/Node.hpp"
 #include "machina/Edge.hpp"
@@ -292,29 +294,29 @@ Machine::learn(SharedPtr<LearnRequest> learn)
 
 
 void
-Machine::write_state(Raul::RDFWriter& writer)
+Machine::write_state(Raul::RDF::Model& model)
 {
-	using Raul::RdfId;
+	using namespace Raul;
 
-	writer.add_prefix("machina", "http://drobilla.net/ns/machina#");
+	model.world().add_prefix("machina", "http://drobilla.net/ns/machina#");
 
-	writer.write(RdfId(RdfId::RESOURCE, ""),
-			RdfId(RdfId::RESOURCE, "rdf:type"),
-			RdfId(RdfId::RESOURCE, "machina:Machine"));
+	model.add_statement(RDF::Node(model.world(), RDF::Node::RESOURCE, ""),
+			RDF::Node(model.world(), RDF::Node::RESOURCE, "rdf:type"),
+			RDF::Node(model.world(), RDF::Node::RESOURCE, "machina:Machine"));
 
 	size_t count = 0;
 
 	for (Nodes::const_iterator n = _nodes.begin(); n != _nodes.end(); ++n) {
 	
-		(*n)->write_state(writer);
+		(*n)->write_state(model);
 
 		if ((*n)->is_initial()) {
-			writer.write(RdfId(RdfId::RESOURCE, ""),
-					RdfId(RdfId::RESOURCE, "machina:initialNode"),
+			model.add_statement(RDF::Node(model.world(), RDF::Node::RESOURCE, ""),
+					RDF::Node(model.world(), RDF::Node::RESOURCE, "machina:initialNode"),
 					(*n)->id());
 		} else {
-			writer.write(RdfId(RdfId::RESOURCE, ""),
-					RdfId(RdfId::RESOURCE, "machina:node"),
+			model.add_statement(RDF::Node(model.world(), RDF::Node::RESOURCE, ""),
+					RDF::Node(model.world(), RDF::Node::RESOURCE, "machina:node"),
 					(*n)->id());
 		}
 	}
@@ -326,10 +328,10 @@ Machine::write_state(Raul::RDFWriter& writer)
 		for (Node::Edges::const_iterator e = (*n)->outgoing_edges().begin();
 			e != (*n)->outgoing_edges().end(); ++e) {
 			
-			(*e)->write_state(writer);
+			(*e)->write_state(model);
 		
-			writer.write(RdfId(RdfId::RESOURCE, ""),
-				RdfId(RdfId::RESOURCE, "machina:edge"),
+			model.add_statement(RDF::Node(model.world(), RDF::Node::RESOURCE, ""),
+				RDF::Node(model.world(), RDF::Node::RESOURCE, "machina:edge"),
 				(*e)->id());
 		}
 
diff --git a/src/engine/MidiAction.cpp b/src/engine/MidiAction.cpp
index 969e53a..38a5d6f 100644
--- a/src/engine/MidiAction.cpp
+++ b/src/engine/MidiAction.cpp
@@ -91,19 +91,19 @@ MidiAction::execute(SharedPtr<Raul::MIDISink> sink, Raul::BeatTime time)
 
 
 void
-MidiAction::write_state(Raul::RDFWriter& writer)
+MidiAction::write_state(Raul::RDF::Model& model)
 {
-	using Raul::RdfId;
+	using namespace Raul;
 
-	Action::write_state(writer);
+	Action::write_state(model);
 
-	writer.write(_id,
-			RdfId(RdfId::RESOURCE, "rdf:type"),
-			RdfId(RdfId::RESOURCE, "machina:MidiAction"));
+	model.add_statement(_id,
+			RDF::Node(model.world(), RDF::Node::RESOURCE, "rdf:type"),
+			RDF::Node(model.world(), RDF::Node::RESOURCE, "machina:MidiAction"));
 	
 	// FIXME: Assumes note on/note off
-	writer.write(_id,
-			RdfId(RdfId::RESOURCE, "machina:midiNote"),
+	model.add_statement(_id,
+			RDF::Node(model.world(), RDF::Node::RESOURCE, "machina:midiNote"),
 			(int)(_event.get()[1]));
 }
 
diff --git a/src/engine/Node.cpp b/src/engine/Node.cpp
index dfbfb4b..73a2059 100644
--- a/src/engine/Node.cpp
+++ b/src/engine/Node.cpp
@@ -16,7 +16,8 @@
  */
 
 #include <cassert>
-#include <raul/RDFWriter.h>
+#include <raul/RDFWorld.h>
+#include <raul/RDFModel.h>
 #include <machina/Node.hpp>
 #include <machina/Edge.hpp>
 
@@ -134,39 +135,39 @@ Node::remove_outgoing_edges_to(SharedPtr<Node> node)
 
 
 void
-Node::write_state(Raul::RDFWriter& writer)
+Node::write_state(Raul::RDF::Model& model)
 {
-	using Raul::RdfId;
+	using namespace Raul;
 	
 	if (!_id)
-		set_id(writer.blank_id());
+		set_id(model.world().blank_id());
 
 	if (_is_selector)
-		writer.write(_id,
-				RdfId(RdfId::RESOURCE, "rdf:type"),
-				RdfId(RdfId::RESOURCE, "machina:SelectorNode"));
+		model.add_statement(_id,
+				"rdf:type",
+				RDF::Node(model.world(), RDF::Node::RESOURCE, "machina:SelectorNode"));
 	else
-		writer.write(_id,
-				RdfId(RdfId::RESOURCE, "rdf:type"),
-				RdfId(RdfId::RESOURCE, "machina:Node"));
+		model.add_statement(_id,
+				"rdf:type",
+				RDF::Node(model.world(), RDF::Node::RESOURCE, "machina:Node"));
 
-	writer.write(_id,
-			RdfId(RdfId::RESOURCE, "machina:duration"),
+	model.add_statement(_id,
+			"machina:duration",
 			Raul::Atom((float)_duration));
 
 	if (_enter_action) {
-		_enter_action->write_state(writer);
+		_enter_action->write_state(model);
 		
-		writer.write(_id,
-				RdfId(RdfId::RESOURCE, "machina:enterAction"),
+		model.add_statement(_id,
+				"machina:enterAction",
 				_enter_action->id());
 	}
 
 	if (_exit_action) {
-		_exit_action->write_state(writer);
+		_exit_action->write_state(model);
 
-		writer.write(_id,
-				RdfId(RdfId::RESOURCE, "machina:exitAction"),
+		model.add_statement(_id,
+				"machina:exitAction",
 				_exit_action->id());
 	}
 }
diff --git a/src/engine/machina/Action.hpp b/src/engine/machina/Action.hpp
index 888f639..d3c47cb 100644
--- a/src/engine/machina/Action.hpp
+++ b/src/engine/machina/Action.hpp
@@ -34,7 +34,7 @@ namespace Machina {
 struct Action : public Raul::Deletable, public Raul::Stateful {
 	virtual void execute(SharedPtr<Raul::MIDISink> sink, Raul::BeatTime time) = 0;
 
-	virtual void write_state(Raul::RDFWriter& writer);
+	virtual void write_state(Raul::RDF::Model& model);
 };
 
 
diff --git a/src/engine/machina/Edge.hpp b/src/engine/machina/Edge.hpp
index 51314c4..4681b38 100644
--- a/src/engine/machina/Edge.hpp
+++ b/src/engine/machina/Edge.hpp
@@ -40,7 +40,7 @@ public:
 		, _head(head)
 	{}
 
-	void write_state(Raul::RDFWriter& writer);
+	void write_state(Raul::RDF::Model& model);
 
 	WeakPtr<Node>   tail() { return _tail; }
 	SharedPtr<Node> head() { return _head; }
diff --git a/src/engine/machina/Engine.hpp b/src/engine/machina/Engine.hpp
index 4263ef3..2cae36d 100644
--- a/src/engine/machina/Engine.hpp
+++ b/src/engine/machina/Engine.hpp
@@ -21,7 +21,8 @@
 #include <glibmm/ustring.h>
 #include <raul/SharedPtr.h>
 #include <raul/types.h>
-#include "machina/Driver.hpp" 
+#include "machina/Driver.hpp"
+#include "machina/Loader.hpp"
 
 namespace Machina {
 
@@ -30,10 +31,14 @@ class Machine;
 
 class Engine {
 public:
-	Engine(SharedPtr<Driver> driver)
+	Engine(SharedPtr<Driver> driver, Raul::RDF::World& rdf_world)
 		: _driver(driver)
+		, _rdf_world(rdf_world)
+		, _loader(_rdf_world)
 	{ }
 	
+	Raul::RDF::World& rdf_world() { return _rdf_world; }
+
 	SharedPtr<Driver>  driver()  { return _driver; }
 	SharedPtr<Machine> machine() { return _driver->machine(); }
 
@@ -46,6 +51,8 @@ public:
 
 private:
 	SharedPtr<Driver> _driver;
+	Raul::RDF::World& _rdf_world;
+	Loader            _loader;
 };
 
 
diff --git a/src/engine/machina/Loader.hpp b/src/engine/machina/Loader.hpp
index af35c56..eb7deac 100644
--- a/src/engine/machina/Loader.hpp
+++ b/src/engine/machina/Loader.hpp
@@ -19,9 +19,9 @@
 #define MACHINA_LOADER_HPP
 
 #include <glibmm/ustring.h>
-#include "raul/SharedPtr.h"
-#include "raul/Path.h"
-#include "raul/Namespaces.h"
+#include <raul/SharedPtr.h>
+#include <raul/Path.h>
+#include <raul/RDFWorld.h>
 
 using Raul::Namespaces;
 
@@ -32,12 +32,12 @@ class Machine;
 
 class Loader {
 public:
-	Loader(SharedPtr<Namespaces> = SharedPtr<Namespaces>());
+	Loader(Raul::RDF::World& rdf_world);
 
 	SharedPtr<Machine> load(const Glib::ustring& filename);
 
 private:
-	SharedPtr<Namespaces>  _namespaces;
+	Raul::RDF::World& _rdf_world;
 };
 
 
diff --git a/src/engine/machina/Machine.hpp b/src/engine/machina/Machine.hpp
index c2f081d..ff32930 100644
--- a/src/engine/machina/Machine.hpp
+++ b/src/engine/machina/Machine.hpp
@@ -21,7 +21,7 @@
 #include <boost/utility.hpp>
 #include <raul/SharedPtr.h>
 #include <raul/List.h>
-#include <raul/RDFWriter.h> 
+#include <raul/RDFModel.h> 
 #include <raul/TimeSlice.h>
 #include "types.hpp"
 #include "LearnRequest.hpp"
@@ -47,7 +47,7 @@ public:
 	void remove_node(SharedPtr<Node> node);
 	void learn(SharedPtr<LearnRequest> learn);
 
-	void write_state(Raul::RDFWriter& writer);
+	void write_state(Raul::RDF::Model& model);
 
 	// Audio context
 	void      reset();
diff --git a/src/engine/machina/MidiAction.hpp b/src/engine/machina/MidiAction.hpp
index 510c0d0..c019ca9 100644
--- a/src/engine/machina/MidiAction.hpp
+++ b/src/engine/machina/MidiAction.hpp
@@ -53,7 +53,7 @@ public:
 
 	void execute(SharedPtr<Raul::MIDISink> driver, Raul::BeatTime time);
 	
-	virtual void write_state(Raul::RDFWriter& writer);
+	virtual void write_state(Raul::RDF::Model& model);
 
 private:
 
diff --git a/src/engine/machina/Node.hpp b/src/engine/machina/Node.hpp
index 23fb4ec..6c275a8 100644
--- a/src/engine/machina/Node.hpp
+++ b/src/engine/machina/Node.hpp
@@ -62,7 +62,7 @@ public:
 	void remove_outgoing_edge(SharedPtr<Edge> edge);
 	void remove_outgoing_edges_to(SharedPtr<Node> node);
 
-	void write_state(Raul::RDFWriter& writer);
+	void write_state(Raul::RDF::Model& model);
 
 	bool      is_initial() const        { return _is_initial; }
 	void      set_initial(bool i)       { _is_initial = i; }