summaryrefslogtreecommitdiffstats
path: root/src/serialisation
diff options
context:
space:
mode:
Diffstat (limited to 'src/serialisation')
-rw-r--r--src/serialisation/Parser.cpp596
-rw-r--r--src/serialisation/Parser.hpp16
-rw-r--r--src/serialisation/Serialiser.cpp335
-rw-r--r--src/serialisation/Serialiser.hpp16
4 files changed, 464 insertions, 499 deletions
diff --git a/src/serialisation/Parser.cpp b/src/serialisation/Parser.cpp
index a8938ca4..f64e96ab 100644
--- a/src/serialisation/Parser.cpp
+++ b/src/serialisation/Parser.cpp
@@ -42,8 +42,24 @@ namespace Serialisation {
static Glib::ustring
relative_uri(Glib::ustring base, const Glib::ustring uri, bool leading_slash)
{
- base = base.substr(0, base.find_last_of("/")+1);
Glib::ustring ret;
+ if (uri.substr(0, base.length()) == base) {
+ ret = (leading_slash ? "/" : "") + uri.substr(base.length());
+ while (ret[0] == '#' || ret[0] == '/')
+ ret = ret.substr(1);
+ if (leading_slash && ret[0] != '/')
+ ret = string("/") + ret;
+ return ret;
+ }
+
+ size_t last_slash = base.find_last_of("/");
+ if (last_slash != string::npos)
+ base = base.substr(0, last_slash + 1);
+
+ size_t last_hash = base.find_last_of("#");
+ if (last_hash != string::npos)
+ base = base.substr(0, last_hash + 1);
+
if (uri.length() >= base.length() && uri.substr(0, base.length()) == base)
ret = uri.substr(base.length());
else
@@ -58,6 +74,7 @@ relative_uri(Glib::ustring base, const Glib::ustring uri, bool leading_slash)
}
+#if 0
static Glib::ustring
chop_uri_scheme(const Glib::ustring in)
{
@@ -100,6 +117,7 @@ dequote_uri(const Glib::ustring in)
out = out.substr(1, out.length()-2);
return out;
}
+#endif
static void
@@ -116,13 +134,13 @@ normalise_uri(Glib::ustring& uri)
*/
bool
Parser::parse_document(
- Ingen::Shared::World* world,
- Ingen::Shared::CommonInterface* target,
- Glib::ustring document_uri,
- boost::optional<Raul::Path> data_path,
- boost::optional<Raul::Path> parent,
- boost::optional<Raul::Symbol> symbol,
- boost::optional<GraphObject::Variables> data)
+ Ingen::Shared::World* world,
+ Ingen::Shared::CommonInterface* target,
+ Glib::ustring document_uri,
+ boost::optional<Raul::Path> data_path,
+ boost::optional<Raul::Path> parent,
+ boost::optional<Raul::Symbol> symbol,
+ boost::optional<GraphObject::Properties> data)
{
normalise_uri(document_uri);
@@ -151,14 +169,14 @@ Parser::parse_document(
bool
Parser::parse_string(
- Ingen::Shared::World* world,
- Ingen::Shared::CommonInterface* target,
- const Glib::ustring& str,
- const Glib::ustring& base_uri,
- boost::optional<Raul::Path> data_path,
- boost::optional<Raul::Path> parent,
- boost::optional<Raul::Symbol> symbol,
- boost::optional<GraphObject::Variables> data)
+ Ingen::Shared::World* world,
+ Ingen::Shared::CommonInterface* target,
+ const Glib::ustring& str,
+ const Glib::ustring& base_uri,
+ boost::optional<Raul::Path> data_path,
+ boost::optional<Raul::Path> parent,
+ boost::optional<Raul::Symbol> symbol,
+ boost::optional<GraphObject::Properties> data)
{
Redland::Model model(*world->rdf_world, str.c_str(), str.length(), base_uri);
@@ -177,14 +195,14 @@ Parser::parse_string(
bool
Parser::parse_update(
- Ingen::Shared::World* world,
- Shared::CommonInterface* target,
- const Glib::ustring& str,
- const Glib::ustring& base_uri,
- boost::optional<Raul::Path> data_path,
- boost::optional<Raul::Path> parent,
- boost::optional<Raul::Symbol> symbol,
- boost::optional<GraphObject::Variables> data)
+ Ingen::Shared::World* world,
+ Shared::CommonInterface* target,
+ const Glib::ustring& str,
+ const Glib::ustring& base_uri,
+ boost::optional<Raul::Path> data_path,
+ boost::optional<Raul::Path> parent,
+ boost::optional<Raul::Symbol> symbol,
+ boost::optional<GraphObject::Properties> data)
{
Redland::Model model(*world->rdf_world, str.c_str(), str.length(), base_uri);
@@ -209,12 +227,11 @@ Parser::parse_update(
results = Redland::Query::Results(query.run(*world->rdf_world, model, base_uri));
for (Redland::Query::Results::iterator i = results.begin(); i != results.end(); ++i) {
- world->rdf_world->mutex().lock();
+ Glib::Mutex::Lock lock(world->rdf_world->mutex());
const string obj_path = (*i)["path"].to_string();
const string key = world->rdf_world->prefixes().qualify((*i)["varkey"].to_string());
const Redland::Node& val_node = (*i)["varval"];
const Atom a(AtomRDF::node_to_atom(val_node));
- world->rdf_world->mutex().unlock();
if (key != "")
target->set_variable(obj_path, key, a);
}
@@ -232,11 +249,10 @@ Parser::parse_update(
results = Redland::Query::Results(query.run(*world->rdf_world, model, base_uri));
for (Redland::Query::Results::iterator i = results.begin(); i != results.end(); ++i) {
- world->rdf_world->mutex().lock();
+ Glib::Mutex::Lock lock(world->rdf_world->mutex());
const string obj_path = (*i)["path"].to_string();
const Redland::Node& val_node = (*i)["value"];
const Atom a(AtomRDF::node_to_atom(val_node));
- world->rdf_world->mutex().unlock();
target->set_port_value(obj_path, a);
}
@@ -246,14 +262,14 @@ Parser::parse_update(
boost::optional<Path>
Parser::parse(
- Ingen::Shared::World* world,
- Ingen::Shared::CommonInterface* target,
- Redland::Model& model,
- Glib::ustring document_uri,
- boost::optional<Raul::Path> data_path,
- boost::optional<Raul::Path> parent,
- boost::optional<Raul::Symbol> symbol,
- boost::optional<GraphObject::Variables> data)
+ Ingen::Shared::World* world,
+ Ingen::Shared::CommonInterface* target,
+ Redland::Model& model,
+ Glib::ustring document_uri,
+ boost::optional<Raul::Path> data_path,
+ boost::optional<Raul::Path> parent,
+ boost::optional<Raul::Symbol> symbol,
+ boost::optional<GraphObject::Properties> data)
{
const Redland::Node::Type res = Redland::Node::RESOURCE;
@@ -284,9 +300,6 @@ Parser::parse(
const Redland::Node& subject = (data_path ? subject_node : (*i)["s"]);
const Redland::Node& rdf_class = (*i)["t"];
- //cout << "SUBJECT: " << subject.to_c_string() << endl;
- //cout << "CLASS: " << rdf_class.to_c_string() << endl;
-
if (!data_path)
path_str = relative_uri(document_uri, subject.to_c_string(), true);
else if (path_str == "" || path_str[0] != '/')
@@ -310,12 +323,9 @@ Parser::parse(
if (is_object) {
- string path;
- if (parent && symbol) {
- path = parent->base() + *symbol;
- } else {
- path = (parent ? parent->base() : "/") + path_str.substr(1);
- }
+ string path = (parent && symbol)
+ ? parent->base() + *symbol
+ : (parent ? parent->base() : "/") + path_str.substr(1);
if (!Path::is_valid(path)) {
cerr << "WARNING: Invalid path '" << path << "' transformed to /" << endl;
@@ -351,46 +361,48 @@ Parser::parse(
boost::optional<Path>
Parser::parse_patch(
- Ingen::Shared::World* world,
- Ingen::Shared::CommonInterface* target,
- Redland::Model& model,
- const Redland::Node& subject_node,
- boost::optional<Raul::Path> parent,
- boost::optional<Raul::Symbol> a_symbol,
- boost::optional<GraphObject::Variables> data)
+ Ingen::Shared::World* world,
+ Ingen::Shared::CommonInterface* target,
+ Redland::Model& model,
+ const Redland::Node& subject_node,
+ boost::optional<Raul::Path> parent,
+ boost::optional<Raul::Symbol> a_symbol,
+ boost::optional<GraphObject::Properties> data)
{
- std::set<Path> created;
- uint32_t patch_poly = 0;
+ uint32_t patch_poly = 0;
+
+ typedef Redland::Query::Results Results;
/* Use parameter overridden polyphony, if given */
if (data) {
- GraphObject::Variables::iterator poly_param = data.get().find("ingen:polyphony");
+ GraphObject::Properties::iterator poly_param = data.get().find("ingen:polyphony");
if (poly_param != data.get().end() && poly_param->second.type() == Atom::INT)
patch_poly = poly_param->second.get_int32();
}
const Glib::ustring subject = subject_node.to_turtle_token();
- //cout << "Parse patch " << subject << endl;
+ //cout << "**** Parse patch " << subject << endl;
- /* Get polyphony from file (mandatory if not specified in parameters) */
+ /* Load polyphony from file if necessary */
if (patch_poly == 0) {
Redland::Query query(*world->rdf_world, Glib::ustring(
"SELECT DISTINCT ?poly WHERE { ") + subject + " ingen:polyphony ?poly }");
- Redland::Query::Results results = query.run(*world->rdf_world, model);
-
- if (results.size() == 0) {
- cerr << "[Parser] ERROR: No polyphony found!" << endl;
- cerr << "Query was:" << endl << query.string() << endl;
- return boost::optional<Path>();
+ Results results = query.run(*world->rdf_world, model);
+ if (results.size() > 0) {
+ const Redland::Node& poly_node = (*results.begin())["poly"];
+ if (poly_node.is_int())
+ patch_poly = poly_node.to_int();
+ else
+ cerr << "WARNING: Patch has non-integer polyphony, assuming 1" << endl;
}
-
- const Redland::Node& poly_node = (*results.begin())["poly"];
- assert(poly_node.is_int());
- patch_poly = static_cast<uint32_t>(poly_node.to_int());
}
+ /* No polyphony value anywhere, 1 it is */
+ if (patch_poly == 0)
+ patch_poly = 1;
+
const Glib::ustring base_uri = model.base_uri().to_string();
string symbol;
@@ -402,183 +414,242 @@ Parser::parse_patch(
if (symbol != "")
symbol = Path::nameify(symbol);
}
-
- const Path patch_path(parent ? parent->base() + symbol : "/");
+
+ string patch_path_str = relative_uri(base_uri, subject_node.to_string(), true);
+ if (!Path::is_valid(patch_path_str)) {
+ cerr << "ERROR: Patch has invalid path: " << patch_path_str << endl;
+ return boost::optional<Raul::Path>();
+ }
+
+
+ /* Create patch */
+ Path patch_path(patch_path_str);
target->new_patch(patch_path, patch_poly);
- /* Plugin nodes */
+ /* Find patches in document */
Redland::Query query(*world->rdf_world, Glib::ustring(
- "SELECT DISTINCT ?name ?plugin ?varkey ?varval ?poly WHERE {\n") +
- subject + " ingen:node ?node .\n"
- "?node lv2:symbol ?name ;\n"
- " rdf:instanceOf ?plugin ;\n"
- " ingen:polyphonic ?poly .\n"
- "OPTIONAL { ?node lv2var:variable ?variable .\n"
- " ?variable rdf:predicate ?varkey ;\n"
- " rdf:value ?varval .\n"
- " }"
+ "SELECT DISTINCT ?patch WHERE {\n") +
+ "?patch a ingen:Patch .\n"
"}");
+ set<string> patches;
+ Results results = query.run(*world->rdf_world, model, base_uri);
+ for (Results::iterator i = results.begin(); i != results.end(); ++i) {
+ Glib::Mutex::Lock lock(world->rdf_world->mutex());
+ patches.insert((*i)["patch"].to_string());
+ }
+
+ typedef multimap<std::string, Redland::Node> Properties;
+ typedef map<string, Redland::Node> Resources;
+ typedef map<string, Properties> Objects;
+ typedef map<string, string> Types;
- Redland::Query::Results results = query.run(*world->rdf_world, model, base_uri);
-
- for (Redland::Query::Results::iterator i = results.begin(); i != results.end(); ++i) {
- world->rdf_world->mutex().lock();
- const string node_name = (*i)["name"].to_string();
- const Path node_path = patch_path.base() + node_name;
-
- if (created.find(node_path) == created.end()) {
- const string node_plugin = (*i)["plugin"].to_string();
- bool node_polyphonic = false;
- const Redland::Node& poly_node = (*i)["poly"];
- if (poly_node.is_bool() && poly_node.to_bool() == true)
- node_polyphonic = true;
-
- world->rdf_world->mutex().unlock();
-
- target->new_node(node_path, node_plugin);
- target->set_property(node_path, "ingen:polyphonic", node_polyphonic);
- created.insert(node_path);
-
- world->rdf_world->mutex().lock();
+ /* Find nodes on this patch */
+ query = Redland::Query(*world->rdf_world, Glib::ustring(
+ "SELECT DISTINCT ?node ?type WHERE {\n") +
+ subject + " ingen:node ?node .\n"
+ "?node rdf:instanceOf ?type .\n"
+ "}");
+ Objects patch_nodes;
+ Objects plugin_nodes;
+ Resources resources;
+ Types types;
+ results = query.run(*world->rdf_world, model, base_uri);
+ for (Results::iterator i = results.begin(); i != results.end(); ++i) {
+ Glib::Mutex::Lock lock(world->rdf_world->mutex());
+ Redland::Node& node = (*i)["node"];
+ Redland::Node& type = (*i)["type"];
+ if (node.type() == Redland::Node::RESOURCE && type.type() == Redland::Node::RESOURCE) {
+ types.insert(make_pair(node.to_string(), type.to_string()));
+ if (patches.find(type.to_string()) != patches.end()) {
+ patch_nodes.insert(make_pair(node.to_string(), Properties()));
+ resources.insert(make_pair(type.to_string(), type));
+ } else {
+ plugin_nodes.insert(make_pair(node.to_string(), Properties()));
+ }
}
-
- const string key = world->rdf_world->prefixes().qualify((*i)["varkey"].to_string());
- const Redland::Node& val_node = (*i)["varval"];
-
- world->rdf_world->mutex().unlock();
-
- if (key != "")
- target->set_variable(node_path, key, AtomRDF::node_to_atom(val_node));
}
- /* Load subpatches */
+ /* Load nodes on this patch */
query = Redland::Query(*world->rdf_world, Glib::ustring(
- "SELECT DISTINCT ?subpatch ?symbol WHERE {\n") +
- subject + " ingen:node ?subpatch .\n"
- "?subpatch a ingen:Patch ;\n"
- " lv2:symbol ?symbol .\n"
+ "SELECT DISTINCT ?node ?predicate ?object WHERE {\n") +
+ subject + " ingen:node ?node .\n"
+ "?node ?predicate ?object .\n"
"}");
-
results = query.run(*world->rdf_world, model, base_uri);
- for (Redland::Query::Results::iterator i = results.begin(); i != results.end(); ++i) {
- world->rdf_world->mutex().lock();
- const string symbol = (*i)["symbol"].to_string();
- const string subpatch = (*i)["subpatch"].to_string();
- world->rdf_world->mutex().unlock();
-
- const Path subpatch_path = patch_path.base() + symbol;
-
- if (created.find(subpatch_path) == created.end()) {
- /*const string subpatch_rel = relative_uri(base_uri, subpatch);
- string sub_base = engine_base;
- if (sub_base[sub_base.length()-1] == '/')
- sub_base = sub_base.substr(sub_base.length()-1);
- sub_base.append("/").append(symbol);*/
- created.insert(subpatch_path);
- parse_patch(world, target, model, (*i)["subpatch"], patch_path, Symbol(symbol));
+ for (Results::iterator i = results.begin(); i != results.end(); ++i) {
+ Glib::Mutex::Lock lock(world->rdf_world->mutex());
+ Redland::Node& node = (*i)["node"];
+ Redland::Node& predicate = (*i)["predicate"];
+ Redland::Node& object = (*i)["object"];
+ Objects::iterator patch_i = patch_nodes.find(node.to_string());
+ Objects::iterator plug_i = plugin_nodes.find(node.to_string());
+ Types::iterator type_i = types.find(node.to_string());
+ if (node.type() == Redland::Node::RESOURCE && type_i != types.end()) {
+ if (patch_i != patch_nodes.end()) {
+ patch_i->second.insert(make_pair(predicate.to_string(), object));
+ } else if (plug_i != plugin_nodes.end()) {
+ plug_i->second.insert(make_pair(predicate.to_string(), object));
+ } else {
+ cerr << "WARNING: Unrecognized node: " << node.to_string() << endl;
+ }
}
}
+ /* Create patch nodes */
+ for (Objects::iterator i = patch_nodes.begin(); i != patch_nodes.end(); ++i) {
+ const Path node_path = Path(relative_uri(base_uri, i->first, true));
+ Types::iterator type_i = types.find(i->first);
+ if (type_i == types.end())
+ continue;
+ Resources::iterator res_i = resources.find(type_i->second);
+ if (res_i == resources.end())
+ continue;
+ parse_patch(world, target, model, res_i->second, patch_path, Symbol(node_path.name()));
+ Glib::Mutex::Lock lock(world->rdf_world->mutex());
+ for (Properties::iterator j = i->second.begin(); j != i->second.end(); ++j) {
+ const string key = world->rdf_world->prefixes().qualify(j->first);
+ target->set_variable(node_path, key, AtomRDF::node_to_atom(j->second));
+ }
+ }
+
+ /* Create plugin nodes */
+ for (Objects::iterator i = plugin_nodes.begin(); i != plugin_nodes.end(); ++i) {
+ Types::iterator type_i = types.find(i->first);
+ if (type_i == types.end())
+ continue;
+ const Path node_path(relative_uri(base_uri, i->first, true));
+ target->new_node(node_path, type_i->second);
+ Glib::Mutex::Lock lock(world->rdf_world->mutex());
+ for (Properties::iterator j = i->second.begin(); j != i->second.end(); ++j) {
+ const string key = world->rdf_world->prefixes().qualify(j->first);
+ target->set_variable(node_path, key, AtomRDF::node_to_atom(j->second));
+ }
+ }
+
- /* Set node port control values */
+ /* Load node ports */
query = Redland::Query(*world->rdf_world, Glib::ustring(
- "SELECT DISTINCT ?nodename ?portname ?portval WHERE {\n") +
- subject + " ingen:node ?node .\n"
- "?node lv2:symbol ?nodename ;\n"
- " lv2:port ?port .\n"
- "?port lv2:symbol ?portname ;\n"
- " ingen:value ?portval .\n"
- "FILTER ( datatype(?portval) = xsd:decimal )\n"
+ "SELECT DISTINCT ?node ?port ?key ?val WHERE {\n") +
+ subject + " ingen:node ?node .\n"
+ "?node lv2:port ?port .\n"
+ "?port ?key ?val .\n"
"}");
-
results = query.run(*world->rdf_world, model, base_uri);
- for (Redland::Query::Results::iterator i = results.begin(); i != results.end(); ++i) {
- world->rdf_world->mutex().lock();
- const string node_name = (*i)["nodename"].to_string();
- const string port_name = (*i)["portname"].to_string();
- world->rdf_world->mutex().unlock();
-
- assert(Path::is_valid_name(node_name));
- assert(Path::is_valid_name(port_name));
- const Path port_path = patch_path.base() + node_name + "/" + port_name;
+ for (Results::iterator i = results.begin(); i != results.end(); ++i) {
+ Glib::Mutex::Lock lock(world->rdf_world->mutex());
+ const string node_uri = (*i)["node"].to_string();
+ const string port_uri = (*i)["port"].to_string();
+ if (port_uri.length() <= node_uri.length()) {
+ cerr << "WARNING: Port on " << node_uri << " has bad URI: " << port_uri << endl;
+ continue;
+ }
- target->set_port_value(port_path, AtomRDF::node_to_atom((*i)["portval"]));
+ const Path node_path(relative_uri(base_uri, node_uri, true));
+ const Symbol port_sym = port_uri.substr(node_uri.length() + 1);
+ const Path port_path = node_path.base() + port_sym;
+ const string key = world->rdf_world->prefixes().qualify((*i)["key"].to_string());
+ if (key == "ingen:value") {
+ target->set_port_value(port_path, AtomRDF::node_to_atom((*i)["val"]));
+ } else {
+ target->set_variable(port_path, key, AtomRDF::node_to_atom((*i)["val"]));
+ }
}
+
-
- /* Load this patch's ports */
+ /* Find ports on this patch */
query = Redland::Query(*world->rdf_world, Glib::ustring(
- "SELECT DISTINCT ?port ?type ?name ?datatype ?varkey ?varval ?portval WHERE {\n") +
- subject + " lv2:port ?port .\n"
- "?port a ?type ;\n"
- " a ?datatype ;\n"
- " lv2:symbol ?name .\n"
- " FILTER (?type != ?datatype && ((?type = lv2:InputPort) || (?type = lv2:OutputPort)))\n"
- "OPTIONAL { ?port ingen:value ?portval . \n"
- " FILTER ( datatype(?portval) = xsd:decimal ) }\n"
- "OPTIONAL { ?port lv2var:variable ?variable .\n"
- " ?variable rdf:predicate ?varkey ;\n"
- " rdf:value ?varval .\n"
- " }"
+ "SELECT DISTINCT ?port ?type WHERE {\n") +
+ subject + " lv2:port ?port .\n"
+ "?port rdf:instanceOf ?type .\n"
"}");
-
+ Objects patch_ports;
results = query.run(*world->rdf_world, model, base_uri);
-
- for (Redland::Query::Results::iterator i = results.begin(); i != results.end(); ++i) {
- world->rdf_world->mutex().lock();
- const string name = (*i)["name"].to_string();
- const string type = world->rdf_world->qualify((*i)["type"].to_string());
- const string datatype = world->rdf_world->qualify((*i)["datatype"].to_string());
- world->rdf_world->mutex().unlock();
-
- assert(Path::is_valid_name(name));
- const Path port_path = patch_path.base() + name;
-
- if (created.find(port_path) == created.end()) {
- // TODO: read index for plugin wrapper
- bool is_output = (type == "lv2:OutputPort");
- target->new_port(port_path, datatype, 0, is_output);
- created.insert(port_path);
+ for (Results::iterator i = results.begin(); i != results.end(); ++i) {
+ Glib::Mutex::Lock lock(world->rdf_world->mutex());
+ Redland::Node& port = (*i)["port"];
+ Redland::Node& type = (*i)["type"];
+ if (port.type() == Redland::Node::RESOURCE && type.type() == Redland::Node::RESOURCE) {
+ types.insert(make_pair(port.to_string(), type.to_string()));
+ patch_ports.insert(make_pair(port.to_string(), Properties()));
}
+ }
+
- world->rdf_world->mutex().lock();
- const Redland::Node& val_node = (*i)["portval"];
- world->rdf_world->mutex().unlock();
-
- target->set_port_value(patch_path.base() + name, AtomRDF::node_to_atom(val_node));
-
- world->rdf_world->mutex().lock();
- const string key = world->rdf_world->prefixes().qualify((*i)["varkey"].to_string());
- const Redland::Node& var_val_node = (*i)["varval"];
- world->rdf_world->mutex().unlock();
-
- if (key != "")
- target->set_variable(patch_path.base() + name, key, AtomRDF::node_to_atom(var_val_node));
+ /* Load patch ports */
+ query = Redland::Query(*world->rdf_world, Glib::ustring(
+ "SELECT DISTINCT ?port ?key ?val WHERE {\n") +
+ subject + " lv2:port ?port .\n"
+ "?port ?key ?val .\n"
+ "}");
+ results = query.run(*world->rdf_world, model, base_uri);
+ for (Results::iterator i = results.begin(); i != results.end(); ++i) {
+ Glib::Mutex::Lock lock(world->rdf_world->mutex());
+ const string port_uri = (*i)["port"].to_string();
+ const Path port_path(Path(relative_uri(base_uri, port_uri, true)));
+ const string key = world->rdf_world->prefixes().qualify((*i)["key"].to_string());
+ Objects::iterator ports_i = patch_ports.find(port_uri);
+ if (ports_i == patch_ports.end())
+ ports_i = patch_ports.insert(make_pair(port_uri, Properties())).first;
+ ports_i->second.insert(make_pair(key, (*i)["val"]));
}
+ for (Objects::iterator i = patch_ports.begin(); i != patch_ports.end(); ++i) {
+ Glib::Mutex::Lock lock(world->rdf_world->mutex());
+ const Path port_path(relative_uri(base_uri, i->first, true));
+ Properties::iterator types_begin = i->second.find("rdf:type");
+ if (types_begin == i->second.end()) {
+ cerr << "WARNING: Patch port has no types" << endl;
+ continue;
+ }
+ Properties::iterator types_end = i->second.upper_bound("rdf:type");
+ bool is_input = false;
+ bool is_output = false;
+ Redland::Node* type = 0;
+ for (Properties::iterator t = types_begin; t != types_end; ++t) {
+ if (t->second.to_string() == NS_LV2 "InputPort") {
+ is_input = true;
+ } else if (t->second.to_string() == NS_LV2 "OutputPort") {
+ is_output = true;
+ } else if (!type || type->to_string() == t->second.to_string()) {
+ type = &t->second;
+ } else {
+ cerr << "ERROR: Port has several data types" << endl;
+ continue;
+ }
+ }
+ if ((is_input && is_output) || !type) {
+ cerr << "ERROR: Corrupt patch port" << endl;
+ continue;
+ }
+ const string type_str = world->rdf_world->prefixes().qualify(type->to_string());
+ target->new_port(port_path, type_str, 0, is_output);
+ for (Properties::iterator j = i->second.begin(); j != i->second.end(); ++j) {
+ target->set_property(port_path, j->first, AtomRDF::node_to_atom(j->second));
+ }
+ }
- created.clear();
-
- parse_connections(world, target, model, subject, patch_path);
+ parse_connections(world, target, model, subject, "/");
parse_variables(world, target, model, subject_node, patch_path, data);
-
+
+
/* Enable */
query = Redland::Query(*world->rdf_world, Glib::ustring(
- "SELECT DISTINCT ?enabled WHERE { ") + subject + " ingen:enabled ?enabled }");
+ "SELECT DISTINCT ?enabled WHERE {\n")
+ + subject + " ingen:enabled ?enabled .\n"
+ "}");
results = query.run(*world->rdf_world, model, base_uri);
- for (Redland::Query::Results::iterator i = results.begin(); i != results.end(); ++i) {
- world->rdf_world->mutex().lock();
+ for (Results::iterator i = results.begin(); i != results.end(); ++i) {
+ Glib::Mutex::Lock lock(world->rdf_world->mutex());
const Redland::Node& enabled_node = (*i)["enabled"];
- world->rdf_world->mutex().unlock();
if (enabled_node.is_bool() && enabled_node) {
- target->set_property(patch_path, "ingen:enabled", (bool)true);
+ target->set_variable(patch_path, "ingen:enabled", (bool)true);
break;
} else {
- cerr << "WARNING: Unknown type for property ingen:enabled" << endl;
+ cerr << "WARNING: Unknown type for ingen:enabled" << endl;
}
}
@@ -588,17 +659,18 @@ Parser::parse_patch(
boost::optional<Path>
Parser::parse_node(
- Ingen::Shared::World* world,
- Ingen::Shared::CommonInterface* target,
- Redland::Model& model,
- const Redland::Node& subject,
- const Raul::Path& path,
- boost::optional<GraphObject::Variables> data)
+ Ingen::Shared::World* world,
+ Ingen::Shared::CommonInterface* target,
+ Redland::Model& model,
+ const Redland::Node& subject,
+ const Raul::Path& path,
+ boost::optional<GraphObject::Properties> data)
{
/* Get plugin */
Redland::Query query(*world->rdf_world, Glib::ustring(
- "SELECT DISTINCT ?plug WHERE { ") + subject.to_turtle_token()
- + " rdf:instanceOf ?plug }");
+ "SELECT DISTINCT ?plug WHERE {\n")
+ + subject.to_turtle_token() + " rdf:instanceOf ?plug .\n"
+ "}");
Redland::Query::Results results = query.run(*world->rdf_world, model);
@@ -621,12 +693,12 @@ Parser::parse_node(
boost::optional<Path>
Parser::parse_port(
- Ingen::Shared::World* world,
- Ingen::Shared::CommonInterface* target,
- Redland::Model& model,
- const Redland::Node& subject_node,
- const Raul::Path& path,
- boost::optional<GraphObject::Variables> data)
+ Ingen::Shared::World* world,
+ Ingen::Shared::CommonInterface* target,
+ Redland::Model& model,
+ const Redland::Node& subject_node,
+ const Raul::Path& path,
+ boost::optional<GraphObject::Properties> data)
{
const Glib::ustring subject = subject_node.to_turtle_token();
@@ -639,21 +711,20 @@ Parser::parse_port(
"}");
Redland::Query::Results results = query.run(*world->rdf_world, model);
- world->rdf_world->mutex().lock();
for (Redland::Query::Results::iterator i = results.begin(); i != results.end(); ++i) {
- const string type = world->rdf_world->qualify((*i)["type"].to_string());
- const string datatype = world->rdf_world->qualify((*i)["datatype"].to_string());
+ Glib::Mutex::Lock lock(world->rdf_world->mutex());
+ const string type = world->rdf_world->qualify((*i)["type"].to_string());
+ const string datatype = world->rdf_world->qualify((*i)["datatype"].to_string());
+ const Redland::Node& val_node = (*i)["value"];
// TODO: read index for plugin wrapper
bool is_output = (type == "lv2:OutputPort");
target->new_port(path, datatype, 0, is_output);
-
- const Redland::Node& val_node = (*i)["value"];
+
if (val_node.to_string() != "")
target->set_port_value(path, AtomRDF::node_to_atom(val_node));
}
- world->rdf_world->mutex().unlock();
parse_variables(world, target, model, subject_node, path, data);
return path;
@@ -670,36 +741,24 @@ Parser::parse_connections(
{
Redland::Query query(*world->rdf_world, Glib::ustring(
"SELECT DISTINCT ?src ?dst WHERE {\n")
- + subject + " ingen:connection ?connection .\n"
- "?connection ingen:source ?src ;\n"
- " ingen:destination ?dst .\n"
+ + subject + " ingen:connection ?connection .\n"
+ "?connection ingen:source ?src ;\n"
+ " ingen:destination ?dst .\n"
"}");
- const Glib::ustring& full_base_uri = model.base_uri().to_string();
- const Glib::ustring& base_uri = full_base_uri.substr(0, full_base_uri.find_last_of("/"));
- const Glib::ustring& subject_uri = dequote_uri(subject);
-
- const Glib::ustring& subject_base = (subject_uri == full_base_uri)
- ? ""
- : chop_uri_scheme(relative_uri(full_base_uri, subject_uri, false));
-
- const Glib::ustring& base = uri_child(base_uri, subject_base, true);
+ const Glib::ustring& base_uri = model.base_uri().to_string();
Redland::Query::Results results = query.run(*world->rdf_world, model);
for (Redland::Query::Results::iterator i = results.begin(); i != results.end(); ++i) {
- const string src_path = parent.base() + relative_uri(base, (*i)["src"].to_string(), false);
- if (!Path::is_valid(src_path)) {
- cerr << "ERROR: Invalid path in connection: " << src_path << endl;
- continue;
- }
-
- const string dst_path = parent.base() + relative_uri(base, (*i)["dst"].to_string(), false);
- if (!Path::is_valid(dst_path)) {
- cerr << "ERROR: Invalid path in connection: " << dst_path << endl;
- continue;
+ Glib::Mutex::Lock lock(world->rdf_world->mutex());
+ string src_path = parent.base() + relative_uri(base_uri, (*i)["src"].to_string(), false);
+ string dst_path = parent.base() + relative_uri(base_uri, (*i)["dst"].to_string(), false);
+ if (Path::is_valid(src_path) && Path::is_valid(dst_path)) {
+ target->connect(src_path, dst_path);
+ } else {
+ cerr << "ERROR: Invalid path in connection "
+ << src_path << " => " << dst_path << endl;
}
-
- target->connect(src_path, dst_path);
}
return true;
@@ -708,48 +767,33 @@ Parser::parse_connections(
bool
Parser::parse_variables(
- Ingen::Shared::World* world,
- Ingen::Shared::CommonInterface* target,
- Redland::Model& model,
- const Redland::Node& subject_node,
- const Raul::Path& path,
- boost::optional<GraphObject::Variables> data)
+ Ingen::Shared::World* world,
+ Ingen::Shared::CommonInterface* target,
+ Redland::Model& model,
+ const Redland::Node& subject_node,
+ const Raul::Path& path,
+ boost::optional<GraphObject::Properties> data)
{
const Glib::ustring& subject = subject_node.to_turtle_token();
Redland::Query query(*world->rdf_world, Glib::ustring(
- "SELECT DISTINCT ?varkey ?varval WHERE {\n") +
- subject + " lv2var:variable ?variable .\n"
- "?variable rdf:predicate ?varkey ;\n"
- " rdf:value ?varval .\n"
+ "SELECT DISTINCT ?key ?val WHERE {\n") +
+ subject + " ?key ?val .\n"
"}");
Redland::Query::Results results = query.run(*world->rdf_world, model);
for (Redland::Query::Results::iterator i = results.begin(); i != results.end(); ++i) {
- const string key = world->rdf_world->prefixes().qualify(string((*i)["varkey"]));
- const Redland::Node& val_node = (*i)["varval"];
+ Glib::Mutex::Lock lock(world->rdf_world->mutex());
+ const string key = world->rdf_world->prefixes().qualify(string((*i)["key"]));
+ const Redland::Node& val = (*i)["val"];
if (key != "")
- target->set_variable(path, key, AtomRDF::node_to_atom(val_node));
+ target->set_variable(path, key, AtomRDF::node_to_atom(val));
}
- query = Redland::Query(*world->rdf_world, Glib::ustring(
- "SELECT DISTINCT ?key ?val WHERE {\n") +
- subject + " ingen:property ?property .\n"
- "?property rdf:predicate ?key ;\n"
- " rdf:value ?val .\n"
- "}");
-
- results = query.run(*world->rdf_world, model);
- for (Redland::Query::Results::iterator i = results.begin(); i != results.end(); ++i) {
- const string key = world->rdf_world->prefixes().qualify(string((*i)["key"]));
- const Redland::Node& val_node = (*i)["val"];
- if (key != "")
- target->set_property(path, key, AtomRDF::node_to_atom(val_node));
- }
-
// Set passed variables last to override any loaded values
if (data)
- for (GraphObject::Variables::const_iterator i = data.get().begin(); i != data.get().end(); ++i)
+ for (GraphObject::Properties::const_iterator i = data.get().begin();
+ i != data.get().end(); ++i)
target->set_variable(path, i->first, i->second);
return true;
diff --git a/src/serialisation/Parser.hpp b/src/serialisation/Parser.hpp
index 7b5acede..6fbb8be6 100644
--- a/src/serialisation/Parser.hpp
+++ b/src/serialisation/Parser.hpp
@@ -46,7 +46,7 @@ public:
boost::optional<Raul::Path> data_path=boost::optional<Raul::Path>(),
boost::optional<Raul::Path> parent=boost::optional<Raul::Path>(),
boost::optional<Raul::Symbol> symbol=boost::optional<Raul::Symbol>(),
- boost::optional<GraphObject::Variables> data=boost::optional<GraphObject::Variables>());
+ boost::optional<GraphObject::Properties> data=boost::optional<GraphObject::Properties>());
virtual bool parse_string(
Ingen::Shared::World* world,
@@ -56,7 +56,7 @@ public:
boost::optional<Raul::Path> data_path=boost::optional<Raul::Path>(),
boost::optional<Raul::Path> parent=boost::optional<Raul::Path>(),
boost::optional<Raul::Symbol> symbol=boost::optional<Raul::Symbol>(),
- boost::optional<GraphObject::Variables> data=boost::optional<GraphObject::Variables>());
+ boost::optional<GraphObject::Properties> data=boost::optional<GraphObject::Properties>());
virtual bool parse_update(
Ingen::Shared::World* world,
@@ -66,7 +66,7 @@ public:
boost::optional<Raul::Path> data_path=boost::optional<Raul::Path>(),
boost::optional<Raul::Path> parent=boost::optional<Raul::Path>(),
boost::optional<Raul::Symbol> symbol=boost::optional<Raul::Symbol>(),
- boost::optional<GraphObject::Variables> data=boost::optional<GraphObject::Variables>());
+ boost::optional<GraphObject::Properties> data=boost::optional<GraphObject::Properties>());
private:
boost::optional<Raul::Path> parse(
@@ -77,7 +77,7 @@ private:
boost::optional<Raul::Path> data_path=boost::optional<Raul::Path>(),
boost::optional<Raul::Path> parent=boost::optional<Raul::Path>(),
boost::optional<Raul::Symbol> symbol=boost::optional<Raul::Symbol>(),
- boost::optional<GraphObject::Variables> data=boost::optional<GraphObject::Variables>());
+ boost::optional<GraphObject::Properties> data=boost::optional<GraphObject::Properties>());
boost::optional<Raul::Path> parse_patch(
Ingen::Shared::World* world,
@@ -86,7 +86,7 @@ private:
const Redland::Node& subject,
boost::optional<Raul::Path> parent=boost::optional<Raul::Path>(),
boost::optional<Raul::Symbol> symbol=boost::optional<Raul::Symbol>(),
- boost::optional<GraphObject::Variables> data=boost::optional<GraphObject::Variables>());
+ boost::optional<GraphObject::Properties> data=boost::optional<GraphObject::Properties>());
boost::optional<Raul::Path> parse_node(
Ingen::Shared::World* world,
@@ -94,7 +94,7 @@ private:
Redland::Model& model,
const Redland::Node& subject,
const Raul::Path& path,
- boost::optional<GraphObject::Variables> data=boost::optional<GraphObject::Variables>());
+ boost::optional<GraphObject::Properties> data=boost::optional<GraphObject::Properties>());
boost::optional<Raul::Path> parse_port(
Ingen::Shared::World* world,
@@ -102,7 +102,7 @@ private:
Redland::Model& model,
const Redland::Node& subject,
const Raul::Path& path,
- boost::optional<GraphObject::Variables> data=boost::optional<GraphObject::Variables>());
+ boost::optional<GraphObject::Properties> data=boost::optional<GraphObject::Properties>());
bool parse_variables(
Ingen::Shared::World* world,
@@ -110,7 +110,7 @@ private:
Redland::Model& model,
const Redland::Node& subject,
const Raul::Path& path,
- boost::optional<GraphObject::Variables> data=boost::optional<GraphObject::Variables>());
+ boost::optional<GraphObject::Properties> data=boost::optional<GraphObject::Properties>());
bool parse_connections(
Ingen::Shared::World* world,
diff --git a/src/serialisation/Serialiser.cpp b/src/serialisation/Serialiser.cpp
index 4bfa74db..a1f4f902 100644
--- a/src/serialisation/Serialiser.cpp
+++ b/src/serialisation/Serialiser.cpp
@@ -93,23 +93,19 @@ void
Serialiser::write_manifest(const std::string& bundle_uri,
const Records& records)
{
-
- cout << "WRITE MANIFEST BUNDLE URI: " << bundle_uri << endl;
const string filename = Glib::filename_from_uri(bundle_uri) + "manifest.ttl";
- cout << "FILENAME: " << filename << endl;
start_to_filename(filename);
_model->set_base_uri(bundle_uri);
for (Records::const_iterator i = records.begin(); i != records.end(); ++i) {
SharedPtr<Patch> patch = PtrCast<Patch>(i->object);
if (patch) {
- const Redland::Node subject(_model->world(), Redland::Node::RESOURCE,
- uri_to_symbol(i->uri));
+ const Redland::Resource subject(_model->world(), uri_to_symbol(i->uri));
_model->add_statement(subject, "rdf:type",
- Redland::Node(_model->world(), Redland::Node::RESOURCE, "ingen:Patch"));
+ Redland::Resource(_model->world(), "ingen:Patch"));
_model->add_statement(subject, "rdf:type",
- Redland::Node(_model->world(), Redland::Node::RESOURCE, "lv2:Plugin"));
+ Redland::Resource(_model->world(), "lv2:Plugin"));
_model->add_statement(subject, "rdfs:seeAlso",
- Redland::Node(_model->world(), Redland::Node::RESOURCE, i->uri));
+ Redland::Resource(_model->world(), i->uri));
}
}
finish();
@@ -139,15 +135,15 @@ Serialiser::write_bundle(const Record& record)
string
-Serialiser::to_string(SharedPtr<GraphObject> object,
- const string& base_uri,
- const GraphObject::Variables& extra_rdf)
+Serialiser::to_string(SharedPtr<GraphObject> object,
+ const string& base_uri,
+ const GraphObject::Properties& extra_rdf)
{
start_to_string(object->path(), base_uri);
serialise(object);
- Redland::Node base_rdf_node(_model->world(), Redland::Node::RESOURCE, base_uri);
- for (GraphObject::Variables::const_iterator v = extra_rdf.begin(); v != extra_rdf.end(); ++v) {
+ Redland::Resource 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, v->first,
AtomRDF::atom_to_node(_model->world(), v->second));
@@ -223,111 +219,37 @@ Serialiser::finish()
}
_base_uri = "";
-#ifdef USE_BLANK_NODES
- _node_map.clear();
-#endif
return ret;
}
-
-Redland::Node
-Serialiser::patch_path_to_rdf_node(const Path& path)
-{
-#ifdef USE_BLANK_NODES
- if (path == _root_path) {
- return Redland::Node(_model->world(), Redland::Node::RESOURCE, _base_uri);
- } else {
- assert(path.length() > _root_path.length());
- return Redland::Node(_model->world(), Redland::Node::RESOURCE,
- _base_uri + string("#") + path.substr(_root_path.length()));
- }
-#else
- return path_to_rdf_node(path);
-#endif
-}
-
-
-/** Convert a path to an RDF blank node ID for serializing.
- */
Redland::Node
-Serialiser::path_to_rdf_node(const Path& path)
+Serialiser::instance_rdf_node(const Path& path)
{
-#ifdef USE_BLANK_NODES
- NodeMap::iterator i = _node_map.find(path);
- if (i != _node_map.end()) {
- assert(i->second);
- assert(i->second.get_node());
- return i->second;
- } else {
- Redland::Node id = _world.blank_id(Path::nameify(path.substr(1)));
- assert(id);
- _node_map[path] = id;
- return id;
- }
-#else
assert(_model);
assert(path.substr(0, _root_path.length()) == _root_path);
if (path == _root_path)
- return Redland::Node(_model->world(), Redland::Node::RESOURCE, _base_uri);
+ return Redland::Resource(_model->world(), _base_uri);
else
- return Redland::Node(_model->world(), Redland::Node::RESOURCE,
+ return Redland::Resource(_model->world(),
path.substr(_root_path.base().length()));
-#endif
}
-#if 0
-/** Searches for the filename passed in the path, returning the full
- * path of the file, or the empty string if not found.
- *
- * This function tries to be as friendly a black box as possible - if the path
- * passed is an absolute path and the file is found there, it will return
- * that path, etc.
- *
- * additional_path is a list (colon delimeted as usual) of additional
- * directories to look in. ie the directory the parent patch resides in would
- * be a good idea to pass as additional_path, in the case of a subpatch.
- */
-string
-Serialiser::find_file(const string& filename, const string& additional_path)
+Redland::Node
+Serialiser::class_rdf_node(const Path& path)
{
- string search_path = additional_path + ":" + _patch_search_path;
-
- // Try to open the raw filename first
- std::ifstream is(filename.c_str(), std::ios::in);
- if (is.good()) {
- is.close();
- return filename;
- }
-
- string directory;
- string full_patch_path = "";
-
- while (search_path != "") {
- directory = search_path.substr(0, search_path.find(':'));
- if (search_path.find(':') != string::npos)
- search_path = search_path.substr(search_path.find(':')+1);
- else
- search_path = "";
-
- full_patch_path = directory +"/"+ filename;
-
- std::ifstream is;
- is.open(full_patch_path.c_str(), std::ios::in);
+ assert(_model);
+ assert(path.substr(0, _root_path.length()) == _root_path);
- if (is.good()) {
- is.close();
- return full_patch_path;
- } else {
- cerr << "[Serialiser] Could not find patch file " << full_patch_path << endl;
- }
- }
-
- return "";
+ if (path == _root_path)
+ return Redland::Resource(_model->world(), _base_uri);
+ else
+ return Redland::Resource(_model->world(),
+ string("#") + path.substr(_root_path.base().length()));
}
-#endif
+
void
Serialiser::serialise(SharedPtr<GraphObject> object) throw (std::logic_error)
@@ -337,19 +259,27 @@ Serialiser::serialise(SharedPtr<GraphObject> object) throw (std::logic_error)
SharedPtr<Shared::Patch> patch = PtrCast<Shared::Patch>(object);
if (patch) {
- serialise_patch(patch);
+ if (patch->path() == _root_path) {
+ const Redland::Resource patch_id(_model->world(), _base_uri);
+ serialise_patch(patch, patch_id);
+ } else {
+ const Redland::Resource patch_id(_model->world(), string("#") + patch->path().substr(1));
+ serialise_patch(patch, patch_id);
+ serialise_node(patch, patch_id, instance_rdf_node(patch->path()));
+ }
return;
}
SharedPtr<Shared::Node> node = PtrCast<Shared::Node>(object);
if (node) {
- serialise_node(node, path_to_rdf_node(node->path()));
+ const Redland::Resource plugin_id(_model->world(), node->plugin()->uri());
+ serialise_node(node, plugin_id, instance_rdf_node(node->path()));
return;
}
SharedPtr<Shared::Port> port = PtrCast<Shared::Port>(object);
if (port) {
- serialise_port(port.get(), path_to_rdf_node(port->path()));
+ serialise_port(port.get(), instance_rdf_node(port->path()));
return;
}
@@ -359,46 +289,30 @@ Serialiser::serialise(SharedPtr<GraphObject> object) throw (std::logic_error)
void
-Serialiser::serialise_patch(SharedPtr<Shared::Patch> patch)
+Serialiser::serialise_patch(SharedPtr<Shared::Patch> patch, const Redland::Node& patch_id)
{
assert(_model);
-
- const Redland::Node patch_id = patch_path_to_rdf_node(patch->path());
- _model->add_statement(
- patch_id,
- "rdf:type",
- Redland::Node(_model->world(), Redland::Node::RESOURCE, "http://drobilla.net/ns/ingen#Patch"));
+ _model->add_statement(patch_id, "rdf:type",
+ Redland::Resource(_model->world(), "ingen:Patch"));
- _model->add_statement(
- patch_id,
- "rdf:type",
- Redland::Node(_model->world(), Redland::Node::RESOURCE, "http://lv2plug.in/ns/lv2core#Plugin"));
-
- GraphObject::Variables::const_iterator s = patch->variables().find("lv2:symbol");
- // If symbol is stored as a variable, write that
- if (s != patch->variables().end()) {
+ _model->add_statement(patch_id, "rdf:type",
+ Redland::Resource(_model->world(), "lv2:Plugin"));
+
+ GraphObject::Properties::const_iterator s = patch->properties().find("lv2:symbol");
+ // If symbol is stored as a property, write that
+ if (s != patch->properties().end() && s->second.is_valid()) {
_model->add_statement(patch_id, "lv2:symbol",
- Redland::Node(_model->world(), Redland::Node::LITERAL, s->second.get_string()));
+ Redland::Literal(_model->world(), s->second.get_string()));
// Otherwise take the one from our path (if possible)
} else if (patch->path() != "/") {
- _model->add_statement(
- patch_id, "lv2:symbol",
- Redland::Node(_model->world(), Redland::Node::LITERAL, patch->path().name()));
+ _model->add_statement(patch_id, "lv2:symbol",
+ Redland::Literal(_model->world(), patch->path().name()));
+ } else {
+ cerr << "WARNING: Patch has no lv2:symbol" << endl;
}
- _model->add_statement(
- patch_id,
- "ingen:polyphony",
- AtomRDF::atom_to_node(_model->world(), Atom((int)patch->internal_polyphony())));
-
- _model->add_statement(
- patch_id,
- "ingen:enabled",
- AtomRDF::atom_to_node(_model->world(), Atom((bool)patch->enabled())));
-
serialise_properties(patch_id, patch->properties());
- serialise_variables(patch_id, patch->variables());
for (GraphObject::const_iterator n = _store->children_begin(patch);
n != _store->children_end(patch); ++n) {
@@ -409,25 +323,33 @@ Serialiser::serialise_patch(SharedPtr<Shared::Patch> patch)
SharedPtr<Shared::Patch> patch = PtrCast<Shared::Patch>(n->second);
SharedPtr<Shared::Node> node = PtrCast<Shared::Node>(n->second);
if (patch) {
- _model->add_statement(patch_id, "ingen:node", patch_path_to_rdf_node(patch->path()));
- serialise_patch(patch);
+ const Redland::Resource class_id(_model->world(),string("#") + patch->path().substr(1));
+ const Redland::Node node_id(instance_rdf_node(n->second->path()));
+ _model->add_statement(patch_id, "ingen:node", node_id);
+ serialise_patch(patch, class_id);
+ serialise_node(patch, class_id, node_id);
} else if (node) {
- const Redland::Node node_id = path_to_rdf_node(n->second->path());
+ const Redland::Resource class_id(_model->world(), node->plugin()->uri());
+ const Redland::Node node_id(instance_rdf_node(n->second->path()));
_model->add_statement(patch_id, "ingen:node", node_id);
- serialise_node(node, node_id);
+ serialise_node(node, class_id, node_id);
}
}
+
+ bool root = (patch->path() == _root_path);
for (uint32_t i=0; i < patch->num_ports(); ++i) {
Port* p = patch->port(i);
- const Redland::Node port_id = path_to_rdf_node(p->path());
+ const Redland::Node port_id = root
+ ? instance_rdf_node(p->path())
+ : class_rdf_node(p->path());
// Ensure lv2:name always exists so Patch is a valid LV2 plugin
if (p->properties().find("lv2:name") == p->properties().end())
- p->set_property("lv2:name", Atom(Atom::STRING, p->symbol())); // FIXME: use human name
+ p->set_property("lv2:name", Atom(Atom::STRING, p->symbol()));
_model->add_statement(patch_id, "lv2:port", port_id);
- serialise_port(p, port_id);
+ serialise_port_class(p, port_id);
}
for (Shared::Patch::Connections::const_iterator c = patch->connections().begin();
@@ -442,86 +364,90 @@ Serialiser::serialise_plugin(const Shared::Plugin& plugin)
{
assert(_model);
- const Redland::Node plugin_id = Redland::Node(_model->world(), Redland::Node::RESOURCE, plugin.uri());
+ const Redland::Node plugin_id = Redland::Resource(_model->world(), plugin.uri());
- _model->add_statement(
- plugin_id,
- "rdf:type",
- Redland::Node(_model->world(), Redland::Node::RESOURCE, plugin.type_uri()));
+ _model->add_statement(plugin_id, "rdf:type",
+ Redland::Resource(_model->world(), plugin.type_uri()));
}
void
-Serialiser::serialise_node(SharedPtr<Shared::Node> node, const Redland::Node& node_id)
+Serialiser::serialise_node(SharedPtr<Shared::Node> node,
+ const Redland::Node& class_id, const Redland::Node& node_id)
{
- const Redland::Node plugin_id
- = Redland::Node(_model->world(), Redland::Node::RESOURCE, node->plugin()->uri());
-
- _model->add_statement(
- node_id,
- "rdf:type",
- Redland::Node(_model->world(), Redland::Node::RESOURCE, "ingen:Node"));
-
- _model->add_statement(
- node_id,
- "lv2:symbol",
- Redland::Node(_model->world(), Redland::Node::LITERAL, node->path().name()));
-
- _model->add_statement(
- node_id,
- "rdf:instanceOf",
- plugin_id);
-
- _model->add_statement(
- node_id,
- "ingen:polyphonic",
- AtomRDF::atom_to_node(_model->world(), Atom(node->polyphonic())));
-
- //serialise_plugin(node->plugin());
+ _model->add_statement(node_id, "rdf:type",
+ Redland::Resource(_model->world(), "ingen:Node"));
+ _model->add_statement(node_id, "rdf:instanceOf",
+ class_id);
+ _model->add_statement(node_id, "lv2:symbol",
+ Redland::Literal(_model->world(), node->path().name()));
for (uint32_t i=0; i < node->num_ports(); ++i) {
Port* p = node->port(i);
- assert(p);
- const Redland::Node port_id = path_to_rdf_node(p->path());
+ const Redland::Node port_id = instance_rdf_node(p->path());
serialise_port(p, port_id);
_model->add_statement(node_id, "lv2:port", port_id);
}
- serialise_properties(node_id, node->properties());
serialise_variables(node_id, node->variables());
}
-/** Writes a port subject with various information only if there are some
- * predicate/object pairs to go with it (eg if the port has variable, or a value, or..).
- * Audio output ports with no variable will not be written, for example.
- */
+/** Serialise a port on a Node */
void
Serialiser::serialise_port(const Port* port, const Redland::Node& port_id)
{
if (port->is_input())
_model->add_statement(port_id, "rdf:type",
- Redland::Node(_model->world(), Redland::Node::RESOURCE, "lv2:InputPort"));
+ Redland::Resource(_model->world(), "lv2:InputPort"));
else
_model->add_statement(port_id, "rdf:type",
- Redland::Node(_model->world(), Redland::Node::RESOURCE, "lv2:OutputPort"));
+ Redland::Resource(_model->world(), "lv2:OutputPort"));
+
+ _model->add_statement(port_id, "rdf:type",
+ Redland::Resource(_model->world(), port->type().uri()));
if (dynamic_cast<Patch*>(port->graph_parent()))
- _model->add_statement(port_id, "lv2:index",
- AtomRDF::atom_to_node(_model->world(), Atom((int)port->index())));
+ _model->add_statement(port_id, "rdf:instanceOf",
+ class_rdf_node(port->path()));
+
+ if (port->is_input() && port->type() == DataType::CONTROL)
+ _model->add_statement(port_id, "ingen:value",
+ AtomRDF::atom_to_node(_model->world(), Atom(port->value())));
- _model->add_statement(port_id, "lv2:symbol",
- Redland::Node(_model->world(), Redland::Node::LITERAL, port->path().name()));
+ serialise_variables(port_id, port->variables());
+}
+
+
+/** Serialise a port on a Patch */
+void
+Serialiser::serialise_port_class(const Port* port, const Redland::Node& port_id)
+{
+ if (port->is_input())
+ _model->add_statement(port_id, "rdf:type",
+ Redland::Resource(_model->world(), "lv2:InputPort"));
+ else
+ _model->add_statement(port_id, "rdf:type",
+ Redland::Resource(_model->world(), "lv2:OutputPort"));
_model->add_statement(port_id, "rdf:type",
- Redland::Node(_model->world(), Redland::Node::RESOURCE, port->type().uri()));
+ Redland::Resource(_model->world(), port->type().uri()));
- if (port->type() == DataType::CONTROL && port->is_input())
- _model->add_statement(port_id, "ingen:value",
- AtomRDF::atom_to_node(_model->world(), Atom(port->value())));
+ _model->add_statement(port_id, "lv2:index",
+ AtomRDF::atom_to_node(_model->world(), Atom((int)port->index())));
+
+ if (!port->get_property("lv2:default").is_valid()) {
+ if (port->is_input()) {
+ if (port->value().is_valid()) {
+ _model->add_statement(port_id, "lv2:default",
+ AtomRDF::atom_to_node(_model->world(), Atom(port->value())));
+ } else if (port->type() == DataType::CONTROL) {
+ cerr << "WARNING: Port " << port->path() << " has no lv2:default" << endl;
+ }
+ }
+ }
serialise_properties(port_id, port->properties());
- serialise_variables(port_id, port->variables());
}
@@ -532,30 +458,26 @@ Serialiser::serialise_connection(SharedPtr<GraphObject> parent,
if (!_model)
throw std::logic_error("serialise_connection called without serialization in progress");
- const Redland::Node src_node = path_to_rdf_node(connection->src_port_path());
- const Redland::Node dst_node = path_to_rdf_node(connection->dst_port_path());
+ const Redland::Node src_node = class_rdf_node(connection->src_port_path());
+ const Redland::Node dst_node = class_rdf_node(connection->dst_port_path());
- /* This would allow associating data with the connection... */
const Redland::Node connection_node = _world.blank_id();
_model->add_statement(connection_node, "ingen:source", src_node);
_model->add_statement(connection_node, "ingen:destination", dst_node);
if (parent) {
- const Redland::Node parent_node = path_to_rdf_node(parent->path());
+ const Redland::Node parent_node = class_rdf_node(parent->path());
_model->add_statement(parent_node, "ingen:connection", connection_node);
} else {
_model->add_statement(connection_node, "rdf:type",
- Redland::Node(_model->world(), Redland::Node::RESOURCE, "ingen:Connection"));
+ Redland::Resource(_model->world(), "ingen:Connection"));
}
-
- /* ... but this is cleaner */
- //_model->add_statement(dst_node, "ingen:connectedTo", src_node);
}
void
-Serialiser::serialise_properties(Redland::Node subject, const GraphObject::Variables& properties)
+Serialiser::serialise_properties(Redland::Node subject, const GraphObject::Properties& properties)
{
- for (GraphObject::Variables::const_iterator v = properties.begin(); v != properties.end(); ++v) {
+ for (GraphObject::Properties::const_iterator v = properties.begin(); v != properties.end(); ++v) {
if (v->first.find(":") && v->second.is_valid()) {
const Redland::Node value = AtomRDF::atom_to_node(_model->world(), v->second);
_model->add_statement(subject, v->first, value);
@@ -567,24 +489,21 @@ Serialiser::serialise_properties(Redland::Node subject, const GraphObject::Varia
void
-Serialiser::serialise_variables(Redland::Node subject, const GraphObject::Variables& variables)
+Serialiser::serialise_variables(Redland::Node subject, const GraphObject::Properties& variables)
{
- for (GraphObject::Variables::const_iterator v = variables.begin(); v != variables.end(); ++v) {
+ for (GraphObject::Properties::const_iterator v = variables.begin(); v != variables.end(); ++v) {
if (v->first.find(":") && v->first != "ingen:document") {
if (v->second.is_valid()) {
- const Redland::Node var_id = _world.blank_id();
- const Redland::Node key(_model->world(), Redland::Node::RESOURCE, v->first);
+ const Redland::Resource key(_model->world(), v->first);
const Redland::Node value = AtomRDF::atom_to_node(_model->world(), v->second);
- if (value) {
- _model->add_statement(subject, "lv2var:variable", var_id);
- _model->add_statement(var_id, "rdf:predicate", key);
- _model->add_statement(var_id, "rdf:value", value);
+ if (value.is_valid()) {
+ _model->add_statement(subject, key, value);
} else {
- cerr << "Warning: can not serialise value: key '" << v->first << "', type "
+ cerr << "WARNING: can not serialise variable '" << v->first << "' :: "
<< (int)v->second.type() << endl;
}
} else {
- cerr << "Warning: variable with no value: key '" << v->first << "'" << endl;
+ cerr << "WARNING: variable '" << v->first << "' has no value" << endl;
}
} else {
cerr << "Not serialising special variable '" << v->first << "'" << endl;
diff --git a/src/serialisation/Serialiser.hpp b/src/serialisation/Serialiser.hpp
index 8126e350..a2863871 100644
--- a/src/serialisation/Serialiser.hpp
+++ b/src/serialisation/Serialiser.hpp
@@ -77,7 +77,7 @@ public:
std::string to_string(SharedPtr<GraphObject> object,
const std::string& base_uri,
- const GraphObject::Variables& extra_rdf);
+ const GraphObject::Properties& extra_rdf);
void start_to_string(const Raul::Path& root, const std::string& base_uri);
void serialise(SharedPtr<GraphObject> object) throw (std::logic_error);
@@ -94,15 +94,17 @@ private:
void setup_prefixes();
- void serialise_patch(SharedPtr<Shared::Patch> p);
- void serialise_node(SharedPtr<Shared::Node> n, const Redland::Node& id);
+ void serialise_patch(SharedPtr<Shared::Patch> p, const Redland::Node& id);
+ void serialise_node(SharedPtr<Shared::Node> n,
+ const Redland::Node& class_id, const Redland::Node& id);
void serialise_port(const Shared::Port* p, const Redland::Node& id);
+ void serialise_port_class(const Shared::Port* p, const Redland::Node& id);
- void serialise_properties(Redland::Node subject, const GraphObject::Variables& properties);
- void serialise_variables(Redland::Node subject, const GraphObject::Variables& variables);
+ void serialise_properties(Redland::Node subject, const GraphObject::Properties& properties);
+ void serialise_variables(Redland::Node subject, const GraphObject::Properties& variables);
- Redland::Node path_to_rdf_node(const Path& path);
- Redland::Node patch_path_to_rdf_node(const Path& path);
+ Redland::Node instance_rdf_node(const Path& path);
+ Redland::Node class_rdf_node(const Path& path);
Raul::Path _root_path;
SharedPtr<Shared::Store> _store;
generated by cgit v1.2.1 (git 2.18.0) at 2024-11-17 06:46:29 +0000