summaryrefslogtreecommitdiffstats
path: root/src/serialisation
diff options
context:
space:
mode:
Diffstat (limited to 'src/serialisation')
-rw-r--r--src/serialisation/Parser.cpp36
-rw-r--r--src/serialisation/Serialiser.cpp312
-rw-r--r--src/serialisation/Serialiser.hpp3
3 files changed, 159 insertions, 192 deletions
diff --git a/src/serialisation/Parser.cpp b/src/serialisation/Parser.cpp
index 2a7423b0..5b04a426 100644
--- a/src/serialisation/Parser.cpp
+++ b/src/serialisation/Parser.cpp
@@ -99,9 +99,9 @@ Parser::find_patches(Ingen::Shared::World* world,
Sord::Model model(*world->rdf_world(), manifest_uri);
model.load_file(manifest_uri);
- Sord::Resource rdf_type(*world->rdf_world(), NS_RDF "type");
- Sord::Resource rdfs_seeAlso(*world->rdf_world(), NS_RDFS "seeAlso");
- Sord::Resource ingen_Patch(*world->rdf_world(), NS_INGEN "Patch");
+ Sord::URI rdf_type(*world->rdf_world(), NS_RDF "type");
+ Sord::URI rdfs_seeAlso(*world->rdf_world(), NS_RDFS "seeAlso");
+ Sord::URI ingen_Patch(*world->rdf_world(), NS_INGEN "Patch");
RDFNodes patches;
for (Sord::Iter i = model.find(nil, rdf_type, ingen_Patch); !i.end(); ++i) {
@@ -196,7 +196,7 @@ Parser::parse_string(Ingen::Shared::World* world,
info << endl;
bool ret = parse(world, target, model, base_uri, data_path, parent, symbol, data);
- Sord::Resource subject(*world->rdf_world(), base_uri);
+ Sord::URI subject(*world->rdf_world(), base_uri);
parse_connections(world, target, model, subject, parent ? *parent : "/");
return ret;
@@ -246,7 +246,7 @@ Parser::parse_update(Ingen::Shared::World* world,
}
// Connections
- Sord::Resource subject(*world->rdf_world(), base_uri);
+ Sord::URI subject(*world->rdf_world(), base_uri);
parse_connections(world, target, model, subject, "/");
// Port values
@@ -279,9 +279,9 @@ Parser::parse(Ingen::Shared::World* world,
boost::optional<Raul::Symbol> symbol,
boost::optional<GraphObject::Properties> data)
{
- const Sord::Node::Type res = Sord::Node::RESOURCE;
+ const Sord::Node::Type res = Sord::Node::URI;
- const Sord::Resource rdf_type(*world->rdf_world(), NS_RDF "type");
+ const Sord::URI rdf_type(*world->rdf_world(), NS_RDF "type");
const Sord::Node patch_class (*world->rdf_world(), res, NS_INGEN "Patch");
const Sord::Node node_class (*world->rdf_world(), res, NS_INGEN "Node");
@@ -380,9 +380,9 @@ Parser::parse_patch(Ingen::Shared::World* world,
{
const LV2URIMap& uris = *world->uris().get();
- Sord::Resource ingen_polyphony(*world->rdf_world(), NS_INGEN "polyphony");
- Sord::Resource lv2_port(*world->rdf_world(), NS_LV2 "port");
- Sord::Resource lv2_symbol(*world->rdf_world(), NS_LV2 "symbol");
+ Sord::URI ingen_polyphony(*world->rdf_world(), NS_INGEN "polyphony");
+ Sord::URI lv2_port(*world->rdf_world(), NS_LV2 "port");
+ Sord::URI lv2_symbol(*world->rdf_world(), NS_LV2 "symbol");
const Sord::Node& patch = subject_node;
@@ -437,9 +437,9 @@ Parser::parse_patch(Ingen::Shared::World* world,
props.insert(make_pair(uris.ingen_polyphony, Raul::Atom(int32_t(patch_poly))));
target->put(patch_path, props);
- Sord::Resource rdf_type(*world->rdf_world(), NS_RDF "type");
- Sord::Resource ingen_Patch(*world->rdf_world(), NS_INGEN "Patch");
- Sord::Resource ingen_node(*world->rdf_world(), NS_INGEN "node");
+ Sord::URI rdf_type(*world->rdf_world(), NS_RDF "type");
+ Sord::URI ingen_Patch(*world->rdf_world(), NS_INGEN "Patch");
+ Sord::URI ingen_node(*world->rdf_world(), NS_INGEN "node");
typedef multimap<Raul::URI, Raul::Atom> Properties;
typedef map<string, Sord::Node> Resources;
@@ -569,7 +569,7 @@ Parser::parse_node(Ingen::Shared::World* world,
{
const LV2URIMap& uris = *world->uris().get();
- Sord::Resource rdf_instanceOf(*world->rdf_world(), NS_RDF "instanceOf");
+ Sord::URI rdf_instanceOf(*world->rdf_world(), NS_RDF "instanceOf");
/* Get plugin */
Sord::Iter i = model.find(subject, rdf_instanceOf, nil);
@@ -579,7 +579,7 @@ Parser::parse_node(Ingen::Shared::World* world,
}
const Sord::Node& plugin_node = i.get_object();
- if (plugin_node.type() != Sord::Node::RESOURCE) {
+ if (plugin_node.type() != Sord::Node::URI) {
LOG(error) << "Node's rdf:instanceOf property is not a resource" << endl;
return boost::optional<Path>();
}
@@ -602,9 +602,9 @@ Parser::parse_connections(Ingen::Shared::World* world,
const Sord::Node& subject,
const Raul::Path& parent)
{
- Sord::Resource ingen_connection(*world->rdf_world(), NS_INGEN "connection");
- Sord::Resource ingen_source(*world->rdf_world(), NS_INGEN "source");
- Sord::Resource ingen_destination(*world->rdf_world(), NS_INGEN "destination");
+ Sord::URI ingen_connection(*world->rdf_world(), NS_INGEN "connection");
+ Sord::URI ingen_source(*world->rdf_world(), NS_INGEN "source");
+ Sord::URI ingen_destination(*world->rdf_world(), NS_INGEN "destination");
const Glib::ustring& base_uri = model.base_uri().to_string();
diff --git a/src/serialisation/Serialiser.cpp b/src/serialisation/Serialiser.cpp
index a3952343..1ffe07c8 100644
--- a/src/serialisation/Serialiser.cpp
+++ b/src/serialisation/Serialiser.cpp
@@ -57,6 +57,8 @@
#define LOG(s) s << "[Serialiser] "
+#define NS_LV2 "http://lv2plug.in/ns/lv2core#"
+
using namespace std;
using namespace Raul;
using namespace Sord;
@@ -91,11 +93,7 @@ static
std::string
uri_to_symbol(const std::string& uri)
{
- string symbol = uri;
- symbol = symbol.substr(symbol.find_last_of("/") + 1);
- symbol = symbol.substr(0, symbol.find("."));
- symbol = Path::nameify(symbol);
- return symbol;
+ return Path::nameify(Glib::path_get_basename(Glib::filename_from_uri(uri)));
}
void
@@ -105,28 +103,25 @@ Serialiser::write_manifest(const std::string& bundle_uri,
const string bundle_path(Glib::filename_from_uri(bundle_uri));
const string filename(Glib::build_filename(bundle_path, "manifest.ttl"));
start_to_filename(filename);
+ Sord::World& world = _model->world();
for (Records::const_iterator i = records.begin(); i != records.end(); ++i) {
SharedPtr<Patch> patch = PtrCast<Patch>(i->object);
if (patch) {
const std::string filename = uri_to_symbol(i->uri) + INGEN_PATCH_FILE_EXT;
- const Sord::Resource subject(_model->world(), filename);
- _model->add_statement(
- subject,
- Sord::Curie(_model->world(), "rdf:type"),
- Sord::Curie(_model->world(), "ingen:Patch"));
- _model->add_statement(
- subject,
- Sord::Curie(_model->world(), "rdf:type"),
- Sord::Curie(_model->world(), "lv2:Plugin"));
- _model->add_statement(
- subject,
- Sord::Curie(_model->world(), "rdfs:seeAlso"),
- Sord::Resource(_model->world(), filename));
+ const Sord::URI subject(world, filename);
+ _model->add_statement(subject,
+ Sord::Curie(world, "rdf:type"),
+ Sord::Curie(world, "ingen:Patch"));
+ _model->add_statement(subject,
+ Sord::Curie(world, "rdf:type"),
+ Sord::Curie(world, "lv2:Plugin"));
+ _model->add_statement(subject,
+ Sord::Curie(world, "rdfs:seeAlso"),
+ Sord::URI(world, filename));
_model->add_statement(
subject,
- Sord::Curie(_model->world(), "lv2:binary"),
- Sord::Resource(_model->world(),
- Glib::Module::build_path("", "ingen_lv2")));
+ Sord::Curie(world, "lv2:binary"),
+ Sord::URI(world, Glib::Module::build_path("", "ingen_lv2")));
symlink(Glib::Module::build_path(INGEN_MODULE_DIR, "ingen_lv2").c_str(),
Glib::Module::build_path(bundle_path, "ingen_lv2").c_str());
}
@@ -163,13 +158,13 @@ Serialiser::to_string(SharedPtr<GraphObject> object,
start_to_string(object->path(), base_uri);
serialise(object);
- Sord::Resource base_rdf_node(_model->world(), base_uri);
- for (GraphObject::Properties::const_iterator v = extra_rdf.begin(); v != extra_rdf.end(); ++v) {
+ Sord::URI base_rdf_node(_model->world(), base_uri);
+ for (GraphObject::Properties::const_iterator v = extra_rdf.begin();
+ v != extra_rdf.end(); ++v) {
if (v->first.find(":") != string::npos) {
- _model->add_statement(
- base_rdf_node,
- AtomRDF::atom_to_node(*_model, v->first),
- AtomRDF::atom_to_node(*_model, v->second));
+ _model->add_statement(base_rdf_node,
+ AtomRDF::atom_to_node(*_model, v->first),
+ AtomRDF::atom_to_node(*_model, v->second));
} else {
LOG(warn) << "Not serialising extra RDF with key '" << v->first << "'" << endl;
}
@@ -243,19 +238,11 @@ Serialiser::finish()
}
Sord::Node
-Serialiser::instance_rdf_node(const Path& path)
+Serialiser::path_rdf_node(const Path& path)
{
assert(_model);
assert(path.is_child_of(_root_path));
- return Sord::Resource(_model->world(), path.chop_scheme().substr(1));
-}
-
-Sord::Node
-Serialiser::class_rdf_node(const Path& path)
-{
- assert(_model);
- assert(path.is_child_of(_root_path));
- return Sord::Resource(_model->world(), path.chop_scheme().substr(1));
+ return Sord::URI(_model->world(), path.chop_scheme().substr(1));
}
void
@@ -267,27 +254,27 @@ Serialiser::serialise(SharedPtr<GraphObject> object) throw (std::logic_error)
SharedPtr<Shared::Patch> patch = PtrCast<Shared::Patch>(object);
if (patch) {
if (patch->path() == _root_path) {
- const Sord::Resource patch_id(_model->world(), "");
+ const Sord::URI patch_id(_model->world(), "");
serialise_patch(patch, patch_id);
} else {
- const Sord::Resource patch_id(_model->world(),
- string(META_PREFIX) + patch->path().chop_start("/"));
+ const Sord::URI patch_id(_model->world(),
+ string(META_PREFIX) + patch->path().chop_start("/"));
serialise_patch(patch, patch_id);
- serialise_node(patch, patch_id, instance_rdf_node(patch->path()));
+ serialise_node(patch, patch_id, path_rdf_node(patch->path()));
}
return;
}
SharedPtr<Shared::Node> node = PtrCast<Shared::Node>(object);
if (node) {
- const Sord::Resource plugin_id(_model->world(), node->plugin()->uri().str());
- serialise_node(node, plugin_id, instance_rdf_node(node->path()));
+ const Sord::URI plugin_id(_model->world(), node->plugin()->uri().str());
+ serialise_node(node, plugin_id, path_rdf_node(node->path()));
return;
}
SharedPtr<Shared::Port> port = PtrCast<Shared::Port>(object);
if (port) {
- serialise_port(port.get(), instance_rdf_node(port->path()));
+ serialise_port(port.get(), path_rdf_node(port->path()));
return;
}
@@ -299,16 +286,15 @@ void
Serialiser::serialise_patch(SharedPtr<Shared::Patch> patch, const Sord::Node& patch_id)
{
assert(_model);
+ Sord::World& world = _model->world();
- _model->add_statement(
- patch_id,
- Sord::Curie(_model->world(), "rdf:type"),
- Sord::Curie(_model->world(), "ingen:Patch"));
+ _model->add_statement(patch_id,
+ Sord::Curie(world, "rdf:type"),
+ Sord::Curie(world, "ingen:Patch"));
- _model->add_statement(
- patch_id,
- Sord::Curie(_model->world(), "rdf:type"),
- Sord::Curie(_model->world(), "lv2:Plugin"));
+ _model->add_statement(patch_id,
+ Sord::Curie(world, "rdf:type"),
+ Sord::Curie(world, "lv2:Plugin"));
const LV2URIMap& uris = *_world.uris().get();
@@ -323,17 +309,16 @@ Serialiser::serialise_patch(SharedPtr<Shared::Patch> patch, const Sord::Node& pa
_model->add_statement(
patch_id,
AtomRDF::atom_to_node(*_model, uris.lv2_symbol.c_str()),
- Sord::Literal(_model->world(), symbol));
+ Sord::Literal(world, symbol));
} else {
symbol = s->second.get_string();
}
// If the patch has no doap:name (required by LV2), use the symbol
if (patch->meta().properties().find(uris.doap_name) == patch->meta().properties().end())
- _model->add_statement(
- patch_id,
- AtomRDF::atom_to_node(*_model, uris.doap_name),
- Sord::Literal(_model->world(), symbol));
+ _model->add_statement(patch_id,
+ AtomRDF::atom_to_node(*_model, uris.doap_name),
+ Sord::Literal(world, symbol));
serialise_properties(patch_id, NULL, patch->meta().properties());
@@ -346,22 +331,20 @@ Serialiser::serialise_patch(SharedPtr<Shared::Patch> patch, const Sord::Node& pa
SharedPtr<Shared::Patch> subpatch = PtrCast<Shared::Patch>(n->second);
SharedPtr<Shared::Node> node = PtrCast<Shared::Node>(n->second);
if (subpatch) {
- const Sord::Resource class_id(_model->world(),
- string(META_PREFIX) + subpatch->path().chop_start("/"));
- const Sord::Node node_id(instance_rdf_node(n->second->path()));
- _model->add_statement(
- patch_id,
- Sord::Curie(_model->world(), "ingen:node"),
- node_id);
+ const Sord::URI class_id(world,
+ string(META_PREFIX) + subpatch->path().chop_start("/"));
+ const Sord::Node node_id(path_rdf_node(n->second->path()));
+ _model->add_statement(patch_id,
+ Sord::Curie(world, "ingen:node"),
+ node_id);
serialise_patch(subpatch, class_id);
serialise_node(subpatch, class_id, node_id);
} else if (node) {
- const Sord::Resource class_id(_model->world(), node->plugin()->uri().str());
- const Sord::Node node_id(instance_rdf_node(n->second->path()));
- _model->add_statement(
- patch_id,
- Sord::Curie(_model->world(), "ingen:node"),
- node_id);
+ const Sord::URI class_id(world, node->plugin()->uri().str());
+ const Sord::Node node_id(path_rdf_node(n->second->path()));
+ _model->add_statement(patch_id,
+ Sord::Curie(world, "ingen:node"),
+ node_id);
serialise_node(node, class_id, node_id);
}
}
@@ -370,18 +353,15 @@ Serialiser::serialise_patch(SharedPtr<Shared::Patch> patch, const Sord::Node& pa
for (uint32_t i=0; i < patch->num_ports(); ++i) {
Port* p = patch->port(i);
- const Sord::Node port_id = root
- ? instance_rdf_node(p->path())
- : class_rdf_node(p->path());
+ const Sord::Node port_id = path_rdf_node(p->path());
// Ensure lv2:name always exists so Patch is a valid LV2 plugin
- if (p->properties().find("http://lv2plug.in/ns/lv2core#name") == p->properties().end())
- p->set_property("http://lv2plug.in/ns/lv2core#name", Atom(p->symbol().c_str()));
+ if (p->properties().find(NS_LV2 "name") == p->properties().end())
+ p->set_property(NS_LV2 "name", Atom(p->symbol().c_str()));
- _model->add_statement(
- patch_id,
- Sord::Resource(_model->world(), "http://lv2plug.in/ns/lv2core#port"),
- port_id);
+ _model->add_statement(patch_id,
+ Sord::URI(world, NS_LV2 "port"),
+ port_id);
serialise_port_meta(p, port_id);
if (root)
serialise_properties(port_id, &p->meta(), p->properties());
@@ -398,12 +378,11 @@ Serialiser::serialise_plugin(const Shared::Plugin& plugin)
{
assert(_model);
- const Sord::Node plugin_id = Sord::Resource(_model->world(), plugin.uri().str());
+ const Sord::Node plugin_id = Sord::URI(_model->world(), plugin.uri().str());
- _model->add_statement(
- plugin_id,
- Sord::Curie(_model->world(), "rdf:type"),
- Sord::Resource(_model->world(), plugin.type_uri().str()));
+ _model->add_statement(plugin_id,
+ Sord::Curie(_model->world(), "rdf:type"),
+ Sord::URI(_model->world(), plugin.type_uri().str()));
}
void
@@ -411,29 +390,25 @@ Serialiser::serialise_node(SharedPtr<Shared::Node> node,
const Sord::Node& class_id,
const Sord::Node& node_id)
{
- _model->add_statement(
- node_id,
- Sord::Curie(_model->world(), "rdf:type"),
- Sord::Curie(_model->world(), "ingen:Node"));
- _model->add_statement(
- node_id,
- Sord::Curie(_model->world(), "rdf:instanceOf"),
- class_id);
- _model->add_statement(
- node_id,
- Sord::Curie(_model->world(), "lv2:symbol"),
- Sord::Literal(_model->world(), node->path().symbol()));
+ _model->add_statement(node_id,
+ Sord::Curie(_model->world(), "rdf:type"),
+ Sord::Curie(_model->world(), "ingen:Node"));
+ _model->add_statement(node_id,
+ Sord::Curie(_model->world(), "rdf:instanceOf"),
+ class_id);
+ _model->add_statement(node_id,
+ Sord::Curie(_model->world(), "lv2:symbol"),
+ Sord::Literal(_model->world(), node->path().symbol()));
serialise_properties(node_id, &node->meta(), node->properties());
- for (uint32_t i=0; i < node->num_ports(); ++i) {
- Port* p = node->port(i);
- const Sord::Node port_id = instance_rdf_node(p->path());
+ for (uint32_t i = 0; i < node->num_ports(); ++i) {
+ Port* const p = node->port(i);
+ const Sord::Node port_id = path_rdf_node(p->path());
serialise_port(p, port_id);
- _model->add_statement(
- node_id,
- Sord::Curie(_model->world(), "lv2:port"),
- port_id);
+ _model->add_statement(node_id,
+ Sord::Curie(_model->world(), "lv2:port"),
+ port_id);
}
}
@@ -441,34 +416,33 @@ Serialiser::serialise_node(SharedPtr<Shared::Node> node,
void
Serialiser::serialise_port(const Port* port, const Sord::Node& port_id)
{
+ Sord::World& world = _model->world();
+
if (port->is_input())
- _model->add_statement(
- port_id,
- Sord::Curie(_model->world(), "rdf:type"),
- Sord::Curie(_model->world(), "lv2:InputPort"));
+ _model->add_statement(port_id,
+ Sord::Curie(world, "rdf:type"),
+ Sord::Curie(world, "lv2:InputPort"));
else
- _model->add_statement(
- port_id,
- Sord::Curie(_model->world(), "rdf:type"),
- Sord::Curie(_model->world(), "lv2:OutputPort"));
+ _model->add_statement(port_id,
+ Sord::Curie(world, "rdf:type"),
+ Sord::Curie(world, "lv2:OutputPort"));
for (Port::PortTypes::const_iterator i = port->types().begin();
i != port->types().end(); ++i)
- _model->add_statement(
- port_id,
- Sord::Curie(_model->world(), "rdf:type"),
- Sord::Resource(_model->world(), i->uri().str()));
+ _model->add_statement(port_id,
+ Sord::Curie(world, "rdf:type"),
+ Sord::URI(world, i->uri().str()));
+ /*
if (dynamic_cast<Patch*>(port->graph_parent()))
- _model->add_statement(
- port_id,
- Sord::Curie(_model->world(), "rdf:instanceOf"),
- class_rdf_node(port->path()));
+ _model->add_statement(port_id,
+ Sord::Curie(world, "rdf:instanceOf"),
+ class_rdf_node(port->path()));
+ */
- _model->add_statement(
- port_id,
- Sord::Curie(_model->world(), "lv2:symbol"),
- Sord::Literal(_model->world(), port->path().symbol()));
+ _model->add_statement(port_id,
+ Sord::Curie(world, "lv2:symbol"),
+ Sord::Literal(world, port->path().symbol()));
serialise_properties(port_id, &port->meta(), port->properties());
}
@@ -477,41 +451,40 @@ Serialiser::serialise_port(const Port* port, const Sord::Node& port_id)
void
Serialiser::serialise_port_meta(const Port* port, const Sord::Node& port_id)
{
+ Sord::World& world = _model->world();
+
if (port->is_input())
- _model->add_statement(
- port_id,
- Sord::Curie(_model->world(), "rdf:type"),
- Sord::Curie(_model->world(), "lv2:InputPort"));
+ _model->add_statement(port_id,
+ Sord::Curie(world, "rdf:type"),
+ Sord::Curie(world, "lv2:InputPort"));
else
- _model->add_statement(
- port_id,
- Sord::Curie(_model->world(), "rdf:type"),
- Sord::Curie(_model->world(), "lv2:OutputPort"));
+ _model->add_statement(port_id,
+ Sord::Curie(world, "rdf:type"),
+ Sord::Curie(world, "lv2:OutputPort"));
for (Port::PortTypes::const_iterator i = port->types().begin();
i != port->types().end(); ++i)
- _model->add_statement(
- port_id,
- Sord::Curie(_model->world(), "rdf:type"),
- Sord::Resource(_model->world(), i->uri().str()));
+ _model->add_statement(port_id,
+ Sord::Curie(world, "rdf:type"),
+ Sord::URI(world, i->uri().str()));
_model->add_statement(
port_id,
- Sord::Curie(_model->world(), "lv2:index"),
+ Sord::Curie(world, "lv2:index"),
AtomRDF::atom_to_node(*_model, Atom((int)port->index())));
_model->add_statement(
port_id,
- Sord::Curie(_model->world(), "lv2:symbol"),
- Sord::Literal(_model->world(), port->path().symbol()));
+ Sord::Curie(world, "lv2:symbol"),
+ Sord::Literal(world, port->path().symbol()));
- if (!port->get_property("http://lv2plug.in/ns/lv2core#default").is_valid()) {
+ if (!port->get_property(NS_LV2 "default").is_valid()) {
if (port->is_input()) {
if (port->value().is_valid()) {
_model->add_statement(
port_id,
- Sord::Curie(_model->world(), "lv2:default"),
- AtomRDF::atom_to_node(*_model, Atom(port->value())));
+ Sord::Curie(world, "lv2:default"),
+ AtomRDF::atom_to_node(*_model, port->value()));
} else if (port->is_a(PortType::CONTROL)) {
LOG(warn) << "Port " << port->path() << " has no lv2:default" << endl;
}
@@ -525,38 +498,33 @@ void
Serialiser::serialise_connection(SharedPtr<GraphObject> parent,
SharedPtr<Connection> connection) throw (std::logic_error)
{
- if (!_model)
- throw std::logic_error("serialise_connection called without serialization in progress");
-
- bool top = (parent->path() == _root_path);
- const Sord::Node src_node = top
- ? instance_rdf_node(connection->src_port_path())
- : class_rdf_node(connection->src_port_path());
- const Sord::Node dst_node = top
- ? instance_rdf_node(connection->dst_port_path())
- : class_rdf_node(connection->dst_port_path());
+ Sord::World& world = _model->world();
- const Sord::Node connection_node = Sord::Node::blank_id(*_world.rdf_world());
- _model->add_statement(
- connection_node,
- Sord::Curie(_model->world(), "ingen:source"),
- src_node);
- _model->add_statement(
- connection_node,
- Sord::Curie(_model->world(), "ingen:destination"),
- dst_node);
+ if (!_model)
+ throw std::logic_error(
+ "serialise_connection called without serialization in progress");
+
+ const Sord::Node src = path_rdf_node(connection->src_port_path());
+ const Sord::Node dst = path_rdf_node(connection->dst_port_path());
+ const Sord::Node connection_id = Sord::Node::blank_id(*_world.rdf_world());
+ _model->add_statement(connection_id,
+ Sord::Curie(world, "ingen:source"),
+ src);
+ _model->add_statement(connection_id,
+ Sord::Curie(world, "ingen:destination"),
+ dst);
+ /*
if (parent) {
- const Sord::Node parent_node = class_rdf_node(parent->path());
- _model->add_statement(
- parent_node,
- Sord::Curie(_model->world(), "ingen:connection"),
- connection_node);
+ const Sord::Node parent_id = class_rdf_node(parent->path());
+ _model->add_statement(parent_id,
+ Sord::Curie(world, "ingen:connection"),
+ connection_id);
} else {
- _model->add_statement(
- connection_node,
- Sord::Curie(_model->world(), "rdf:type"),
- Sord::Curie(_model->world(), "ingen:Connection"));
- }
+ */
+ _model->add_statement(connection_id,
+ Sord::Curie(world, "rdf:type"),
+ Sord::Curie(world, "ingen:Connection"));
+ //}
}
void
@@ -568,8 +536,8 @@ Serialiser::serialise_properties(Sord::Node subject,
v != properties.end(); ++v) {
if (v->second.is_valid()) {
if (!meta || !meta->has_property(v->first.str(), v->second)) {
- const Sord::Resource key(_model->world(), v->first.str());
- const Sord::Node value(AtomRDF::atom_to_node(*_model, v->second));
+ const Sord::URI key(_model->world(), v->first.str());
+ const Sord::Node value(AtomRDF::atom_to_node(*_model, v->second));
if (value.is_valid()) {
_model->add_statement(subject, key, value);
} else {
diff --git a/src/serialisation/Serialiser.hpp b/src/serialisation/Serialiser.hpp
index 650e48e7..7fc641f6 100644
--- a/src/serialisation/Serialiser.hpp
+++ b/src/serialisation/Serialiser.hpp
@@ -105,8 +105,7 @@ private:
const Shared::Resource* meta,
const Properties& properties);
- Sord::Node instance_rdf_node(const Raul::Path& path);
- Sord::Node class_rdf_node(const Raul::Path& path);
+ Sord::Node path_rdf_node(const Raul::Path& path);
Raul::Path _root_path;
SharedPtr<Shared::Store> _store;
generated by cgit v1.2.1 (git 2.18.0) at 2024-11-04 21:14:24 +0000