From 3e5fef2e59776923f175a4260adf18c559ab861f Mon Sep 17 00:00:00 2001 From: David Robillard Date: Tue, 1 May 2007 04:01:04 +0000 Subject: 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/ingen@486 a436a847-0d15-0410-975c-d299462d15a1 --- src/libs/client/Serializer.cpp | 184 +++++++++++++++++++++++------------------ 1 file changed, 102 insertions(+), 82 deletions(-) (limited to 'src/libs/client/Serializer.cpp') diff --git a/src/libs/client/Serializer.cpp b/src/libs/client/Serializer.cpp index 762cd061..85a13331 100644 --- a/src/libs/client/Serializer.cpp +++ b/src/libs/client/Serializer.cpp @@ -27,7 +27,12 @@ #include // atof #include #include -#include +#include +#include +#include +#include +#include +#include #include "Serializer.h" #include "PatchModel.h" #include "NodeModel.h" @@ -36,25 +41,19 @@ #include "PresetModel.h" #include "ModelEngineInterface.h" #include "PluginModel.h" -#include "raul/Path.h" -#include "raul/Atom.h" -#include "raul/AtomRaptor.h" -using std::string; using std::vector; using std::pair; -using std::cerr; using std::cout; using std::endl; -using boost::optional; +using namespace std; using namespace Raul; +using namespace Raul::RDF; +using boost::optional; namespace Ingen { namespace Client { -Serializer::Serializer() +Serializer::Serializer(Raul::RDF::World& world) + : _world(world) { - _writer.add_prefix("ingen", "http://drobilla.net/ns/ingen#"); - _writer.add_prefix("ingenuity", "http://drobilla.net/ns/ingenuity#"); - _writer.add_prefix("lv2", "http://lv2plug.in/ontology#"); - _writer.add_prefix("doap", "http://usefulinc.com/ns/doap#"); } @@ -63,10 +62,12 @@ Serializer::Serializer() * This must be called before any serializing methods. */ void -Serializer::start_to_filename(const string& filename) throw (std::logic_error) +Serializer::start_to_filename(const string& filename) { _base_uri = "file://" + filename; - _writer.start_to_filename(filename); + _model = new RDF::Model(_world); + _mode = TO_FILE; + _filename = filename; } @@ -78,10 +79,12 @@ Serializer::start_to_filename(const string& filename) throw (std::logic_error) * the desired objects have been serialized. */ void -Serializer::start_to_string() throw (std::logic_error) +Serializer::start_to_string() { _base_uri = ""; - _writer.start_to_string(); + _model = new RDF::Model(_world); + _mode = TO_STRING; + _filename = ""; } @@ -91,18 +94,28 @@ Serializer::start_to_string() throw (std::logic_error) * will be returned, otherwise the empty string is returned. */ string -Serializer::finish() throw(std::logic_error) +Serializer::finish() { - return _writer.finish(); - _id_map.clear(); + string ret = ""; + + if (_mode == TO_FILE) + _model->serialize_to_file(_filename); + else + ret = _model->serialize_to_string(); + + _filename = ""; + _node_map.clear(); + + return ret; } /** Convert a path to an RDF blank node ID for serializing. */ -RdfId +Node Serializer::path_to_node_id(const Path& path) { + assert(_model); /*string ret = path.substr(1); for (size_t i=0; i < ret.length(); ++i) { @@ -110,15 +123,15 @@ Serializer::path_to_node_id(const Path& path) ret[i] = '_'; } - return RdfId(RdfId::ANONYMOUS, ret); + return Node(Node::BLANK, ret); */ - IDMap::iterator i = _id_map.find(path); - if (i != _id_map.end()) { + NodeMap::iterator i = _node_map.find(path); + if (i != _node_map.end()) { return i->second; } else { - const RdfId id = _writer.blank_id(); - _id_map[path] = id; + Node id = _world.blank_id(); + _node_map[path] = id; return id; } } @@ -178,12 +191,12 @@ Serializer::find_file(const string& filename, const string& additional_path) void Serializer::serialize(SharedPtr object) throw (std::logic_error) { - if (!_writer.serialization_in_progress()) + if (!_model) throw std::logic_error("serialize called without serialization in progress"); SharedPtr patch = PtrCast(object); if (patch) { - serialize_patch(patch, RdfId(RdfId::RESOURCE, _base_uri)); + serialize_patch(patch, Node(_model->world(), Node::RESOURCE, _base_uri)); return; } @@ -205,29 +218,31 @@ Serializer::serialize(SharedPtr object) throw (std::logic_error) void -Serializer::serialize_patch(SharedPtr patch, const RdfId& patch_id) +Serializer::serialize_patch(SharedPtr patch, const Node& patch_id) { - _writer.write( + assert(_model); + + _model->add_statement( patch_id, - NS_RDF("type"), - NS_INGEN("Patch")); + "rdf:type", + "ingen:Patch"); if (patch->path().name().length() > 0) { - _writer.write( - patch_id, NS_INGEN("name"), + _model->add_statement( + patch_id, "ingen:name", Atom(patch->path().name().c_str())); } - _writer.write( + _model->add_statement( patch_id, - NS_INGEN("polyphony"), + "ingen:polyphony", Atom((int)patch->poly())); for (MetadataMap::const_iterator m = patch->metadata().begin(); m != patch->metadata().end(); ++m) { - if (_writer.expand_uri(m->first) != "") { - _writer.write( + if (m->first.find(":") != string::npos) { + _model->add_statement( patch_id, - RdfId(RdfId::RESOURCE, _writer.expand_uri(m->first.c_str()).c_str()), + m->first.c_str(), m->second); } } @@ -235,20 +250,20 @@ Serializer::serialize_patch(SharedPtr patch, const RdfId& patch_id) for (NodeModelMap::const_iterator n = patch->nodes().begin(); n != patch->nodes().end(); ++n) { SharedPtr patch = PtrCast(n->second); if (patch) { - const RdfId subpatch_id = RdfId(RdfId::RESOURCE, + const Node subpatch_id = Node(_model->world(), Node::RESOURCE, patch_id.to_string() + "#" + patch->path().substr(1)); - _writer.write(patch_id, NS_INGEN("node"), subpatch_id); + _model->add_statement(patch_id, "ingen:node", subpatch_id); serialize_patch(patch, subpatch_id); } else { - const RdfId node_id = path_to_node_id(n->second->path()); - _writer.write(patch_id, NS_INGEN("node"), node_id); + const Node node_id = path_to_node_id(n->second->path()); + _model->add_statement(patch_id, "ingen:node", node_id); serialize_node(n->second, node_id); } } for (PortModelList::const_iterator p = patch->ports().begin(); p != patch->ports().end(); ++p) { - const RdfId port_id = path_to_node_id((*p)->path()); - _writer.write(patch_id, NS_INGEN("port"), port_id); + const Node port_id = path_to_node_id((*p)->path()); + _model->add_statement(patch_id, "ingen:port", port_id); serialize_port(*p, port_id); } @@ -261,53 +276,55 @@ Serializer::serialize_patch(SharedPtr patch, const RdfId& patch_id) void Serializer::serialize_plugin(SharedPtr plugin) { - const RdfId plugin_id = RdfId(RdfId::RESOURCE, plugin->uri()); + assert(_model); + + const Node plugin_id = Node(_model->world(), Node::RESOURCE, plugin->uri()); - _writer.write( + _model->add_statement( plugin_id, - NS_RDF("type"), - RdfId(RdfId::RESOURCE, plugin->type_uri())); -} + "rdf:type", + Node(_model->world(), Node::RESOURCE, plugin->type_uri())); +} void -Serializer::serialize_node(SharedPtr node, const RdfId& node_id) +Serializer::serialize_node(SharedPtr node, const Node& node_id) { - const RdfId plugin_id = RdfId(RdfId::RESOURCE, node->plugin()->uri()); + const Node plugin_id = Node(_model->world(), Node::RESOURCE, node->plugin()->uri()); - _writer.write( + _model->add_statement( node_id, - NS_RDF("type"), - NS_INGEN("Node")); + "rdf:type", + "ingen:Node"); - _writer.write( + _model->add_statement( node_id, - NS_INGEN("name"), + "ingen:name", node->path().name()); - _writer.write( + _model->add_statement( node_id, - NS_INGEN("plugin"), + "ingen:plugin", plugin_id); //serialize_plugin(node->plugin()); - /*_writer.write(_serializer, + /*_model->add_statement(_serializer, node_uri_ref.c_str(), - NS_INGEN("name"), + "ingen:name", Atom(node->path().name()));*/ for (PortModelList::const_iterator p = node->ports().begin(); p != node->ports().end(); ++p) { - const RdfId port_id = path_to_node_id((*p)->path()); + const Node port_id = path_to_node_id((*p)->path()); serialize_port(*p, port_id); - _writer.write(node_id, NS_INGEN("port"), port_id); + _model->add_statement(node_id, "ingen:port", port_id); } for (MetadataMap::const_iterator m = node->metadata().begin(); m != node->metadata().end(); ++m) { - if (_writer.expand_uri(m->first) != "") { - _writer.write( + if (m->first.find(":") != string::npos) { + _model->add_statement( node_id, - RdfId(RdfId::RESOURCE, _writer.expand_uri(m->first.c_str()).c_str()), + m->first, m->second); } } @@ -318,26 +335,26 @@ Serializer::serialize_node(SharedPtr node, const RdfId& node_id) * Audio output ports with no metadata will not be written, for example. */ void -Serializer::serialize_port(SharedPtr port, const RdfId& port_id) +Serializer::serialize_port(SharedPtr port, const Node& port_id) { if (port->is_input()) - _writer.write(port_id, NS_RDF("type"), NS_INGEN("InputPort")); + _model->add_statement(port_id, "rdf:type", "ingen:InputPort"); else - _writer.write(port_id, NS_RDF("type"), NS_INGEN("OutputPort")); + _model->add_statement(port_id, "rdf:type", "ingen:OutputPort"); - _writer.write(port_id, NS_INGEN("name"), Atom(port->path().name().c_str())); + _model->add_statement(port_id, "ingen:name", Atom(port->path().name().c_str())); - _writer.write(port_id, NS_INGEN("dataType"), Atom(port->type())); + _model->add_statement(port_id, "ingen:dataType", Atom(port->type())); if (port->is_control() && port->is_input()) - _writer.write(port_id, NS_INGEN("value"), Atom(port->value())); + _model->add_statement(port_id, "ingen:value", Atom(port->value())); if (port->metadata().size() > 0) { for (MetadataMap::const_iterator m = port->metadata().begin(); m != port->metadata().end(); ++m) { - if (_writer.expand_uri(m->first) != "") { - _writer.write( + if (m->first.find(":") != string::npos) { + _model->add_statement( port_id, - RdfId(RdfId::RESOURCE, _writer.expand_uri(m->first).c_str()), + m->first, m->second); } } @@ -348,22 +365,25 @@ Serializer::serialize_port(SharedPtr port, const RdfId& port_id) void Serializer::serialize_connection(SharedPtr connection) throw (std::logic_error) { - const RdfId connection_id = RdfId(RdfId::ANONYMOUS, + if (!_model) + throw std::logic_error("serialize_connection called without serialization in progress"); + + const Node connection_id = Node(_model->world(), Node::BLANK, path_to_node_id(connection->src_port_path()).to_string() + "-" + path_to_node_id(connection->dst_port_path()).to_string()); - _writer.write(path_to_node_id(connection->dst_port_path()), - NS_INGEN("connectedTo"), + _model->add_statement(path_to_node_id(connection->dst_port_path()), + "ingen:connectedTo", path_to_node_id(connection->src_port_path())); - /*_writer.write(connection_id, NS_RDF("type"), NS_INGEN("Connection")); + /*_model->add_statement(connection_id, "rdf:type", "ingen:Connection"; - _writer.write(connection_id, - NS_INGEN("source"), + _model->add_statement(connection_id, + "ingen:source", path_to_node_id(connection->src_port_path())); - _writer.write(connection_id, - NS_INGEN("destination"), + _model->add_statement(connection_id, + "ingen:destination", path_to_node_id(connection->dst_port_path())); */ } -- cgit v1.2.1