diff options
| author | David Robillard <d@drobilla.net> | 2019-03-09 17:44:36 +0100 |
|---|---|---|
| committer | David Robillard <d@drobilla.net> | 2019-12-12 19:42:09 +0100 |
| commit | 3c0ed6b66b6e99c68fc01c86b5796a55d74a5977 (patch) | |
| tree | 7be3252c13ef123b956424169c1bfbf55359564a /src | |
| parent | e32f32a360f2bf8f017ea347b6d1e568c0beaf68 (diff) | |
| download | ingen-serd1.tar.gz ingen-serd1.tar.bz2 ingen-serd1.zip | |
WIP: Port to serd1serd1
Diffstat (limited to 'src')
41 files changed, 697 insertions, 889 deletions
diff --git a/src/AtomWriter.cpp b/src/AtomWriter.cpp index 27f224fc..e2c0f252 100644 --- a/src/AtomWriter.cpp +++ b/src/AtomWriter.cpp @@ -74,11 +74,14 @@ namespace ingen { -AtomWriter::AtomWriter(URIMap& map, URIs& uris, AtomSink& sink) - : _map(map) - , _uris(uris) - , _sink(sink) - , _forge(map.urid_map_feature()->urid_map) +AtomWriter::AtomWriter(serd::World& world, + URIMap& map, + URIs& uris, + AtomSink& sink) + : _map(map) + , _uris(uris) + , _sink(sink) + , _forge(world, map.urid_map_feature()->urid_map) { } @@ -135,7 +138,7 @@ AtomWriter::operator()(const BundleEnd& message) void AtomWriter::forge_uri(const URI& uri) { - if (serd_uri_string_has_scheme((const uint8_t*)uri.c_str())) { + if (serd_uri_string_has_scheme(uri.c_str())) { lv2_atom_forge_urid(&_forge, _map.map_uri(uri.c_str())); } else { lv2_atom_forge_uri(&_forge, uri.c_str(), uri.length()); diff --git a/src/Configuration.cpp b/src/Configuration.cpp index 5178e97a..611d949b 100644 --- a/src/Configuration.cpp +++ b/src/Configuration.cpp @@ -22,10 +22,8 @@ #include "ingen/ingen.h" #include "ingen/runtime_paths.hpp" #include "lv2/urid/urid.h" -#include "serd/serd.h" -#include "sord/sord.h" -#include "sord/sordmm.hpp" -#include "sratom/sratom.h" +#include "serd/serd.hpp" +#include "sratom/sratom.hpp" #include <algorithm> #include <cassert> @@ -33,6 +31,7 @@ #include <cstdint> #include <cstdlib> #include <cstring> +#include <fstream> #include <memory> #include <thread> #include <utility> @@ -226,43 +225,40 @@ Configuration::parse(int argc, char** argv) } bool -Configuration::load(const FilePath& path) +Configuration::load(serd::World& world, const FilePath& path) { if (!filesystem::exists(path)) { return false; } - SerdNode node = serd_node_new_file_uri( - (const uint8_t*)path.c_str(), nullptr, nullptr, true); - const std::string uri((const char*)node.buf); - - Sord::World world; - Sord::Model model(world, uri, SORD_SPO, false); - SerdEnv* env = serd_env_new(&node); - model.load_file(env, SERD_TURTLE, uri, uri); - - Sord::Node nodemm(world, Sord::Node::URI, (const char*)node.buf); - Sord::Node nil; - for (Sord::Iter i = model.find(nodemm, nil, nil); !i.end(); ++i) { - const Sord::Node& pred = i.get_predicate(); - const Sord::Node& obj = i.get_object(); - if (pred.to_string().substr(0, sizeof(INGEN_NS) - 1) == INGEN_NS) { - const std::string key = pred.to_string().substr(sizeof(INGEN_NS) - 1); - const Keys::iterator k = _keys.find(key); - if (k != _keys.end() && obj.type() == Sord::Node::LITERAL) { + const serd::Node uri(serd::make_file_uri(path.c_str(), nullptr)); + serd::Env env(uri); + serd::Model model(world, serd::ModelFlag::index_SPO); + serd::Inserter inserter(model, env); + serd::Reader reader(world, serd::Syntax::Turtle, {}, inserter.sink(), 4096); + reader.start_file(uri); + reader.read_document(); + reader.finish(); + + for (const auto& s : model.range(uri, {}, {})) { + const auto& pred = s.predicate(); + const auto& obj = s.object(); + if (pred.str().substr(0, sizeof(INGEN_NS) - 1) == INGEN_NS) { + const auto key = pred.str().substr(sizeof(INGEN_NS) - 1); + const Keys::iterator k = _keys.find(key.str()); + if (k != _keys.end() && obj.type() == serd::NodeType::literal) { set_value_from_string(_options.find(k->second)->second, - obj.to_string()); + std::string(obj)); } } } - serd_node_free(&node); - serd_env_free(env); return true; } FilePath -Configuration::save(URIMap& uri_map, +Configuration::save(serd::World& world, + URIMap& uri_map, const std::string& app, const FilePath& filename, unsigned scopes) @@ -281,41 +277,33 @@ Configuration::save(URIMap& uri_map, } // Attempt to open file for writing - std::unique_ptr<FILE, decltype(&fclose)> file{fopen(path.c_str(), "w"), - &fclose}; - if (!file) { + std::ofstream file(path); + if (!file.good()) { throw FileError(fmt("Failed to open file %1% (%2%)", path, strerror(errno))); } // Use the file's URI as the base URI - SerdURI base_uri; - SerdNode base = serd_node_new_file_uri( - (const uint8_t*)path.c_str(), nullptr, &base_uri, true); + serd::Node base = serd::make_file_uri(path.c_str()); // Create environment with ingen prefix - SerdEnv* env = serd_env_new(&base); - serd_env_set_prefix_from_strings( - env, (const uint8_t*)"ingen", (const uint8_t*)INGEN_NS); + serd::Env env(base); + env.set_prefix("ingen", INGEN_NS); // Create Turtle writer - SerdWriter* writer = serd_writer_new( - SERD_TURTLE, - (SerdStyle)(SERD_STYLE_RESOLVED|SERD_STYLE_ABBREVIATED), - env, - &base_uri, - serd_file_sink, - file.get()); + serd::Writer writer(world, + serd::Syntax::Turtle, + {}, + env, + file); // Write a prefix directive for each prefix in the environment - serd_env_foreach(env, (SerdPrefixSink)serd_writer_set_prefix, writer); + env.write_prefixes(writer.sink()); // Create an atom serialiser and connect it to the Turtle writer - Sratom* sratom = sratom_new(&uri_map.urid_map_feature()->urid_map); - sratom_set_pretty_numbers(sratom, true); - sratom_set_sink(sratom, (const char*)base.buf, - (SerdStatementSink)serd_writer_write_statement, nullptr, - writer); + sratom::Streamer streamer{world, + uri_map.urid_map_feature()->urid_map, + uri_map.urid_unmap_feature()->urid_unmap}; // Write a statement for each valid option for (const auto& o : _options) { @@ -327,35 +315,31 @@ Configuration::save(URIMap& uri_map, } const std::string key(std::string("ingen:") + o.second.key); - SerdNode pred = serd_node_from_string( - SERD_CURIE, (const uint8_t*)key.c_str()); - sratom_write(sratom, &uri_map.urid_unmap_feature()->urid_unmap, 0, - &base, &pred, value.type(), value.size(), value.get_body()); + const serd::Node pred = serd::make_curie(key); + streamer.write( + writer.sink(), base, pred, *value.atom(), sratom::Flag::pretty_numbers); } - sratom_free(sratom); - serd_writer_free(writer); - serd_env_free(env); - serd_node_free(&base); - return path; } std::list<FilePath> -Configuration::load_default(const std::string& app, const FilePath& filename) +Configuration::load_default(serd::World& world, + const std::string& app, + const FilePath& filename) { std::list<FilePath> loaded; const std::vector<FilePath> dirs = system_config_dirs(); for (const auto& d : dirs) { const FilePath path = d / app / filename; - if (load(path)) { + if (load(world, path)) { loaded.push_back(path); } } const FilePath path = user_config_dir() / app / filename; - if (load(path)) { + if (load(world, path)) { loaded.push_back(path); } diff --git a/src/FilePath.cpp b/src/FilePath.cpp index d16c133c..33b1b937 100644 --- a/src/FilePath.cpp +++ b/src/FilePath.cpp @@ -89,7 +89,7 @@ FilePath::operator+=(value_type chr) } FilePath& -FilePath::operator+=(boost::basic_string_view<value_type> sv) +FilePath::operator+=(serd::StringView sv) { _str.append(sv.data(), sv.size()); return *this; diff --git a/src/Forge.cpp b/src/Forge.cpp index cc1b12c8..d9390e08 100644 --- a/src/Forge.cpp +++ b/src/Forge.cpp @@ -35,7 +35,7 @@ Forge::Forge(URIMap& map) Atom Forge::make_urid(const ingen::URI& u) { - const LV2_URID urid = _map.map_uri(u.string()); + const LV2_URID urid = _map.map_uri(u.c_str()); return Atom(sizeof(int32_t), URID, &urid); } diff --git a/src/Parser.cpp b/src/Parser.cpp index 5cc1dedd..936f1b9f 100644 --- a/src/Parser.cpp +++ b/src/Parser.cpp @@ -16,6 +16,9 @@ #include "ingen/Parser.hpp" +#include <boost/optional/optional.hpp> +#include <boost/optional/optional_io.hpp> + #include "ingen/Atom.hpp" #include "ingen/AtomForge.hpp" #include "ingen/Forge.hpp" @@ -35,9 +38,7 @@ #include "lv2/urid/urid.h" #include "raul/Path.hpp" #include "raul/Symbol.hpp" -#include "serd/serd.h" -#include "sord/sord.h" -#include "sord/sordmm.hpp" +#include "serd/serd.hpp" #include <cassert> #include <cstdint> @@ -52,36 +53,43 @@ namespace ingen { +static void +load_file(serd::World& world, + serd::Model& model, + serd::Env& env, + const URI& file_uri) +{ + serd::Inserter inserter(model, env); + serd::Reader reader(world, serd::Syntax::Turtle, {}, inserter.sink(), 4096); + + reader.start_file(file_uri.str()); + reader.read_document(); + reader.finish(); +} + std::set<Parser::ResourceRecord> -Parser::find_resources(Sord::World& world, - const URI& manifest_uri, - const URI& type_uri) +Parser::find_resources(const URI& manifest_uri, const URI& type_uri) { - const Sord::URI base (world, manifest_uri.string()); - const Sord::URI type (world, type_uri.string()); - const Sord::URI rdf_type (world, NS_RDF "type"); - const Sord::URI rdfs_seeAlso(world, NS_RDFS "seeAlso"); - const Sord::Node nil; + const auto rdf_type = serd::make_uri(NS_RDF "type"); + const auto rdfs_seeAlso = serd::make_uri(NS_RDFS "seeAlso"); + + serd::World world; + serd::Env env{serd::Node(manifest_uri)}; + serd::Model model{world, + serd::ModelFlag::index_SPO | serd::ModelFlag::index_OPS}; - SerdEnv* env = serd_env_new(sord_node_to_serd_node(base.c_obj())); - Sord::Model model(world, manifest_uri.string()); - model.load_file(env, SERD_TURTLE, manifest_uri.string()); + load_file(world, model, env, manifest_uri); std::set<ResourceRecord> resources; - for (Sord::Iter i = model.find(nil, rdf_type, type); !i.end(); ++i) { - const Sord::Node resource = i.get_subject(); - const std::string resource_uri = resource.to_c_string(); - Sord::Iter f = model.find(resource, rdfs_seeAlso, nil); - std::string file_path; - if (!f.end()) { - uint8_t* p = serd_file_uri_parse(f.get_object().to_u_string(), nullptr); - file_path = (const char*)p; - serd_free(p); - } + for (const auto& s : model.range({}, rdf_type, type_uri)) { + const auto& resource = s.subject(); + const auto f = model.find(resource, rdfs_seeAlso, {}); + const FilePath file_path = + ((f != model.end() ? serd::file_uri_parse((*f).object().str()) + : "")); resources.insert(ResourceRecord(resource, file_path)); } - serd_env_free(env); return resources; } @@ -89,13 +97,14 @@ static boost::optional<Raul::Path> get_path(const URI& base, const URI& uri) { const URI relative = uri.make_relative(base); - const std::string uri_str = "/" + relative.string(); + const std::string uri_str = relative.string(); + // assert(Raul::Path::is_valid(uri_str)); return Raul::Path::is_valid(uri_str) ? Raul::Path(uri_str) : boost::optional<Raul::Path>(); } static bool -skip_property(ingen::URIs& uris, const Sord::Node& predicate) +skip_property(ingen::URIs& uris, const serd::Node& predicate) { return (predicate == INGEN__file || predicate == uris.ingen_arc || @@ -105,25 +114,20 @@ skip_property(ingen::URIs& uris, const Sord::Node& predicate) static Properties get_properties(ingen::World& world, - Sord::Model& model, - const Sord::Node& subject, + serd::Model& model, + const serd::Node& subject, Resource::Graph ctx, const boost::optional<Properties>& data = {}) { - AtomForge forge(world.uri_map().urid_map_feature()->urid_map); - - const Sord::Node nil; - Properties props; - for (Sord::Iter i = model.find(subject, nil, nil); !i.end(); ++i) { - if (!skip_property(world.uris(), i.get_predicate())) { - forge.clear(); - forge.read( - *world.rdf_world(), model.c_obj(), i.get_object().c_obj()); - const LV2_Atom* atom = forge.atom(); - Atom atomm; - atomm = world.forge().alloc( - atom->size, atom->type, LV2_ATOM_BODY_CONST(atom)); - props.emplace(i.get_predicate(), Property(atomm, ctx)); + AtomForge forge(world.rdf_world(), + world.uri_map().urid_map_feature()->urid_map); + + Properties props; + for (const auto& s : model.range(subject, {}, {})) { + if (!skip_property(world.uris(), s.predicate())) { + auto atom = forge.read(model, s.object()); + props.emplace(s.predicate(), + Property(world.forge().alloc(atom), ctx)); } } @@ -151,8 +155,8 @@ using PortRecord = std::pair<Raul::Path, Properties>; static boost::optional<PortRecord> get_port(ingen::World& world, - Sord::Model& model, - const Sord::Node& subject, + serd::Model& model, + const serd::Node& subject, Resource::Graph ctx, const Raul::Path& parent, uint32_t* index) @@ -180,8 +184,8 @@ get_port(ingen::World& world, if (s != props.end() && s->second.type() == world.forge().String) { sym = s->second.ptr<char>(); } else { - const std::string subject_str = subject.to_string(); - const size_t last_slash = subject_str.find_last_of('/'); + const std::string subject_str{subject.str()}; + const size_t last_slash{subject_str.find_last_of('/')}; sym = ((last_slash == std::string::npos) ? subject_str @@ -204,9 +208,8 @@ static boost::optional<Raul::Path> parse( World& world, Interface& target, - Sord::Model& model, + serd::Model& model, const URI& base_uri, - Sord::Node& subject, const boost::optional<Raul::Path>& parent = boost::optional<Raul::Path>(), const boost::optional<Raul::Symbol>& symbol = boost::optional<Raul::Symbol>(), const boost::optional<Properties>& data = boost::optional<Properties>()); @@ -215,9 +218,9 @@ static boost::optional<Raul::Path> parse_graph( World& world, Interface& target, - Sord::Model& model, + serd::Model& model, const URI& base_uri, - const Sord::Node& subject, + const serd::Node& subject, Resource::Graph ctx, const boost::optional<Raul::Path>& parent = boost::optional<Raul::Path>(), const boost::optional<Raul::Symbol>& symbol = boost::optional<Raul::Symbol>(), @@ -227,9 +230,9 @@ static boost::optional<Raul::Path> parse_block( World& world, Interface& target, - Sord::Model& model, + serd::Model& model, const URI& base_uri, - const Sord::Node& subject, + const serd::Node& subject, const Raul::Path& path, const boost::optional<Properties>& data = boost::optional<Properties>()); @@ -237,70 +240,58 @@ static bool parse_arcs( World& world, Interface& target, - Sord::Model& model, + serd::Model& model, const URI& base_uri, - const Sord::Node& subject, + const serd::Node& subject, const Raul::Path& graph); static boost::optional<Raul::Path> parse_block(ingen::World& world, ingen::Interface& target, - Sord::Model& model, + serd::Model& model, const URI& base_uri, - const Sord::Node& subject, + const serd::Node& subject, const Raul::Path& path, const boost::optional<Properties>& data) { const URIs& uris = world.uris(); // Try lv2:prototype and old ingen:prototype for backwards compatibility - const Sord::URI prototype_predicates[] = { - Sord::URI(*world.rdf_world(), uris.lv2_prototype), - Sord::URI(*world.rdf_world(), uris.ingen_prototype) - }; + const serd::Node prototype_predicates[] = {uris.lv2_prototype, + uris.ingen_prototype}; // Get prototype - Sord::Node prototype; - for (const Sord::URI& pred : prototype_predicates) { - prototype = model.get(subject, pred, Sord::Node()); - if (prototype.is_valid()) { + serd::Optional<serd::NodeView> prototype; + for (const auto& pred : prototype_predicates) { + prototype = model.get(subject, pred, {}); + if (prototype) { break; } } - if (!prototype.is_valid()) { - world.log().error("Block %1% (%2%) missing mandatory lv2:prototype\n", - subject, path); + if (!prototype) { + world.log().error( + fmt("Block %1% (%2%) missing mandatory lv2:prototype\n", + subject, path)); return boost::optional<Raul::Path>(); } - const auto* type_uri = (const uint8_t*)prototype.to_c_string(); - if (!serd_uri_string_has_scheme(type_uri) || - !strncmp((const char*)type_uri, "file:", 5)) { + const char* type_uri = prototype->c_str(); + if (!serd_uri_string_has_scheme(type_uri) || !strncmp(type_uri, "file:", 5)) { // Prototype is a file, subgraph - SerdURI base_uri_parts; - serd_uri_parse((const uint8_t*)base_uri.c_str(), &base_uri_parts); - - SerdURI ignored; - SerdNode sub_uri = serd_node_new_uri_from_string( - type_uri, - &base_uri_parts, - &ignored); - - const std::string sub_uri_str = (const char*)sub_uri.buf; - const std::string sub_file = sub_uri_str + "/main.ttl"; + serd::Node sub_uri = serd::make_relative_uri(type_uri, base_uri); - const SerdNode sub_base = serd_node_from_string( - SERD_URI, (const uint8_t*)sub_file.c_str()); + const URI sub_file{sub_uri.str().str() + "/main.ttl"}; + const serd::Node sub_base = serd::make_uri(sub_file.c_str()); - Sord::Model sub_model(*world.rdf_world(), sub_file); - SerdEnv* env = serd_env_new(&sub_base); - sub_model.load_file(env, SERD_TURTLE, sub_file); - serd_env_free(env); + serd::Model sub_model(world.rdf_world(), + serd::ModelFlag::index_SPO | + serd::ModelFlag::index_OPS); + serd::Env env(sub_base); + load_file(world.rdf_world(), sub_model, env, sub_file); - Sord::URI sub_node(*world.rdf_world(), sub_file); parse_graph(world, target, sub_model, sub_base, - sub_node, Resource::Graph::INTERNAL, + sub_uri, Resource::Graph::INTERNAL, path.parent(), Raul::Symbol(path.symbol()), data); parse_graph(world, target, model, base_uri, @@ -319,9 +310,9 @@ parse_block(ingen::World& world, static boost::optional<Raul::Path> parse_graph(ingen::World& world, ingen::Interface& target, - Sord::Model& model, + serd::Model& model, const URI& base_uri, - const Sord::Node& subject, + const serd::Node& subject, Resource::Graph ctx, const boost::optional<Raul::Path>& parent, const boost::optional<Raul::Symbol>& symbol, @@ -329,11 +320,9 @@ parse_graph(ingen::World& world, { const URIs& uris = world.uris(); - const Sord::URI ingen_block(*world.rdf_world(), uris.ingen_block); - const Sord::URI lv2_port(*world.rdf_world(), LV2_CORE__port); + const serd::Node lv2_port = serd::make_uri(LV2_CORE__port); - const Sord::Node& graph = subject; - const Sord::Node nil; + const serd::Node& graph = subject; // Build graph path and symbol Raul::Path graph_path; @@ -352,8 +341,8 @@ parse_graph(ingen::World& world, // For each port on this graph using PortRecords = std::map<uint32_t, PortRecord>; PortRecords ports; - for (Sord::Iter p = model.find(graph, lv2_port, nil); !p.end(); ++p) { - Sord::Node port = p.get_object(); + for (const auto& s : model.range(graph, lv2_port, {})) { + const auto& port = s.object(); // Get all properties uint32_t index = 0; @@ -385,9 +374,9 @@ parse_graph(ingen::World& world, } // For each block in this graph - for (Sord::Iter n = model.find(subject, ingen_block, nil); !n.end(); ++n) { - Sord::Node node = n.get_object(); - URI node_uri = node; + for (const auto& b : model.range(subject, uris.ingen_block, {})) { + const auto& node = b.object(); + URI node_uri = node; assert(!node_uri.path().empty() && node_uri.path() != "/"); const Raul::Path block_path = graph_path.child( Raul::Symbol(FilePath(node_uri.path()).stem().string())); @@ -397,13 +386,12 @@ parse_graph(ingen::World& world, boost::optional<Properties>()); // For each port on this block - for (Sord::Iter p = model.find(node, lv2_port, nil); !p.end(); ++p) { - Sord::Node port = p.get_object(); + for (const auto& p : model.range(node, lv2_port, {})) { + const auto& port = p.object(); Resource::Graph subctx = Resource::Graph::DEFAULT; - if (!model.find(node, - Sord::URI(*world.rdf_world(), uris.rdf_type), - Sord::URI(*world.rdf_world(), uris.ingen_Graph)).end()) { + if (model.find(node, uris.rdf_type, uris.ingen_Graph) == + model.end()) { subctx = Resource::Graph::EXTERNAL; } @@ -431,50 +419,38 @@ parse_graph(ingen::World& world, static bool parse_arc(ingen::World& world, ingen::Interface& target, - Sord::Model& model, + serd::Model& model, const URI& base_uri, - const Sord::Node& subject, + const serd::Node& subject, const Raul::Path& graph) { const URIs& uris = world.uris(); - const Sord::URI ingen_tail(*world.rdf_world(), uris.ingen_tail); - const Sord::URI ingen_head(*world.rdf_world(), uris.ingen_head); - const Sord::Node nil; + const auto& tail = model.get(subject, uris.ingen_tail, {}); + const auto& head = model.get(subject, uris.ingen_head, {}); - Sord::Iter t = model.find(subject, ingen_tail, nil); - Sord::Iter h = model.find(subject, ingen_head, nil); - - if (t.end()) { + if (!tail) { world.log().error("Arc has no tail\n"); return false; - } else if (h.end()) { + } else if (!head) { world.log().error("Arc has no head\n"); return false; } const boost::optional<Raul::Path> tail_path = get_path( - base_uri, t.get_object()); + base_uri, *tail); if (!tail_path) { world.log().error("Arc tail has invalid URI\n"); return false; } const boost::optional<Raul::Path> head_path = get_path( - base_uri, h.get_object()); + base_uri, *head); if (!head_path) { world.log().error("Arc head has invalid URI\n"); return false; } - if (!(++t).end()) { - world.log().error("Arc has multiple tails\n"); - return false; - } else if (!(++h).end()) { - world.log().error("Arc has multiple heads\n"); - return false; - } - target.connect(graph.child(*tail_path), graph.child(*head_path)); return true; @@ -483,16 +459,13 @@ parse_arc(ingen::World& world, static bool parse_arcs(ingen::World& world, ingen::Interface& target, - Sord::Model& model, + serd::Model& model, const URI& base_uri, - const Sord::Node& subject, + const serd::Node& subject, const Raul::Path& graph) { - const Sord::URI ingen_arc(*world.rdf_world(), world.uris().ingen_arc); - const Sord::Node nil; - - for (Sord::Iter i = model.find(subject, ingen_arc, nil); !i.end(); ++i) { - parse_arc(world, target, model, base_uri, i.get_object(), graph); + for (const auto& s : model.range(subject, world.uris().ingen_arc, {})) { + parse_arc(world, target, model, base_uri, s.object(), graph); } return true; @@ -501,72 +474,56 @@ parse_arcs(ingen::World& world, static boost::optional<Raul::Path> parse(ingen::World& world, ingen::Interface& target, - Sord::Model& model, + serd::Model& model, const URI& base_uri, - Sord::Node& subject, const boost::optional<Raul::Path>& parent, const boost::optional<Raul::Symbol>& symbol, const boost::optional<Properties>& data) { - const URIs& uris = world.uris(); + using Subjects = std::map<serd::Node, std::set<serd::Node>>; - const Sord::URI graph_class (*world.rdf_world(), uris.ingen_Graph); - const Sord::URI block_class (*world.rdf_world(), uris.ingen_Block); - const Sord::URI arc_class (*world.rdf_world(), uris.ingen_Arc); - const Sord::URI internal_class(*world.rdf_world(), uris.ingen_Internal); - const Sord::URI in_port_class (*world.rdf_world(), LV2_CORE__InputPort); - const Sord::URI out_port_class(*world.rdf_world(), LV2_CORE__OutputPort); - const Sord::URI lv2_class (*world.rdf_world(), LV2_CORE__Plugin); - const Sord::URI rdf_type (*world.rdf_world(), uris.rdf_type); - const Sord::Node nil; - - // Parse explicit subject graph - if (subject.is_valid()) { - return parse_graph(world, target, model, base_uri, - subject, Resource::Graph::INTERNAL, - parent, symbol, data); - } + const URIs& uris = world.uris(); // Get all subjects and their types (?subject a ?type) - using Subjects = std::map< Sord::Node, std::set<Sord::Node> >; Subjects subjects; - for (Sord::Iter i = model.find(subject, rdf_type, nil); !i.end(); ++i) { - const Sord::Node& subject = i.get_subject(); - const Sord::Node& rdf_class = i.get_object(); - - assert(rdf_class.is_uri()); - auto s = subjects.find(subject); - if (s == subjects.end()) { - std::set<Sord::Node> types; + for (const auto& s : model.range({}, uris.rdf_type, {})) { + const auto& subject = s.subject(); + const auto& rdf_class = s.object(); + + assert(rdf_class.type() == serd::NodeType::URI); + auto t = subjects.find(subject); + if (t == subjects.end()) { + std::set<serd::Node> types; types.insert(rdf_class); subjects.emplace(subject, types); } else { - s->second.insert(rdf_class); + t->second.insert(rdf_class); } } // Parse and create each subject for (const auto& i : subjects) { - const Sord::Node& s = i.first; - const std::set<Sord::Node>& types = i.second; + const auto& s = i.first; + const auto& types = i.second; + boost::optional<Raul::Path> ret; - if (types.find(graph_class) != types.end()) { + if (types.find(uris.ingen_Graph) != types.end()) { ret = parse_graph(world, target, model, base_uri, s, Resource::Graph::INTERNAL, parent, symbol, data); - } else if (types.find(block_class) != types.end()) { + } else if (types.find(uris.ingen_Block) != types.end()) { const Raul::Path rel_path(*get_path(base_uri, s)); const Raul::Path path = parent ? parent->child(rel_path) : rel_path; ret = parse_block(world, target, model, base_uri, s, path, data); - } else if (types.find(in_port_class) != types.end() || - types.find(out_port_class) != types.end()) { + } else if (types.find(uris.lv2_InputPort) != types.end() || + types.find(uris.lv2_OutputPort) != types.end()) { const Raul::Path rel_path(*get_path(base_uri, s)); const Raul::Path path = parent ? parent->child(rel_path) : rel_path; const Properties properties = get_properties( world, model, s, Resource::Graph::DEFAULT, data); target.put(path_to_uri(path), properties); ret = path; - } else if (types.find(arc_class) != types.end()) { + } else if (types.find(uris.ingen_Arc) != types.end()) { Raul::Path parent_path(parent ? parent.get() : Raul::Path("/")); parse_arc(world, target, model, base_uri, s, parent_path); } else { @@ -599,8 +556,8 @@ Parser::parse_file(ingen::World& world, URI manifest_uri(manifest_path); // Find graphs in manifest - const std::set<ResourceRecord> resources = find_resources( - *world.rdf_world(), manifest_uri, URI(INGEN__Graph)); + const std::set<ResourceRecord> resources = + find_resources(manifest_uri, URI(INGEN__Graph)); if (resources.empty()) { world.log().error("No graphs found in %1%\n", path); @@ -610,7 +567,7 @@ Parser::parse_file(ingen::World& world, /* Choose the graph to load. If this is a manifest, then there should only be one, but if this is a graph file, subgraphs will be returned as well. In this case, choose the one with the file URI. */ - URI uri; + boost::optional<URI> uri; for (const ResourceRecord& r : resources) { if (r.uri == URI(manifest_path)) { uri = r.uri; @@ -619,7 +576,7 @@ Parser::parse_file(ingen::World& world, } } - if (uri.empty()) { + if (!uri) { // Didn't find a graph with the same URI as the file, use the first uri = (*resources.begin()).uri; file_path = (*resources.begin()).filename; @@ -631,15 +588,13 @@ Parser::parse_file(ingen::World& world, } // Initialise parsing environment - const URI file_uri = URI(file_path); - const auto* uri_c_str = (const uint8_t*)uri.c_str(); - SerdNode base_node = serd_node_from_string(SERD_URI, uri_c_str); - SerdEnv* env = serd_env_new(&base_node); + const URI file_uri(file_path); + serd::Env env(*uri); // Load graph into model - Sord::Model model(*world.rdf_world(), uri.string(), SORD_SPO|SORD_PSO, false); - model.load_file(env, SERD_TURTLE, file_uri); - serd_env_free(env); + serd::Model model(world.rdf_world(), + serd::ModelFlag::index_SPO | serd::ModelFlag::index_OPS); + load_file(world.rdf_world(), model, env, file_uri); world.log().info("Loading %1% from %2%\n", uri, file_path); if (parent) { @@ -649,15 +604,21 @@ Parser::parse_file(ingen::World& world, world.log().info("Symbol: %1%\n", symbol->c_str()); } - Sord::Node subject(*world.rdf_world(), Sord::Node::URI, uri.string()); - boost::optional<Raul::Path> parsed_path - = parse(world, target, model, model.base_uri(), - subject, parent, symbol, data); + boost::optional<Raul::Path> parsed_path = + parse_graph(world, + target, + model, + *uri, + *uri, + Resource::Graph::INTERNAL, + parent, + symbol, + data); if (parsed_path) { target.set_property(path_to_uri(*parsed_path), URI(INGEN__file), - world.forge().alloc_uri(uri.string())); + world.forge().alloc_uri(uri->string())); return true; } else { world.log().warn("Document URI lost\n"); @@ -675,23 +636,27 @@ Parser::parse_string(ingen::World& world, const boost::optional<Properties>& data) { // Load string into model - Sord::Model model(*world.rdf_world(), base_uri, SORD_SPO|SORD_PSO, false); + serd::Model model(world.rdf_world(), + serd::ModelFlag::index_SPO | serd::ModelFlag::index_OPS); - SerdEnv* env = serd_env_new(nullptr); + serd::Env env; if (!base_uri.empty()) { - const SerdNode base = serd_node_from_string( - SERD_URI, (const uint8_t*)base_uri.c_str()); - serd_env_set_base_uri(env, &base); + env.set_base_uri(base_uri); } - model.load_string(env, SERD_TURTLE, str.c_str(), str.length(), base_uri); - URI actual_base((const char*)serd_env_get_base_uri(env, nullptr)->buf); - serd_env_free(env); + serd::Inserter inserter(model, env); + serd::Reader reader( + world.rdf_world(), serd::Syntax::Turtle, {}, inserter.sink(), 4096); + + reader.start_string(str); + reader.read_document(); + reader.finish(); + + URI actual_base(env.base_uri()); world.log().info("Parsing string (base %1%)\n", base_uri); - Sord::Node subject; - parse(world, target, model, actual_base, subject, parent, symbol, data); + parse(world, target, model, actual_base, parent, symbol, data); return actual_base; } diff --git a/src/Serialiser.cpp b/src/Serialiser.cpp index f0b5009e..3ac18fe2 100644 --- a/src/Serialiser.cpp +++ b/src/Serialiser.cpp @@ -38,15 +38,16 @@ #include "raul/Path.hpp" #include "raul/Symbol.hpp" #include "serd/serd.h" -#include "sord/sord.h" -#include "sord/sordmm.hpp" -#include "sratom/sratom.h" +#include "serd/serd.hpp" +#include "sratom/sratom.hpp" #include <cassert> #include <cstdint> #include <cstring> +#include <fstream> #include <map> #include <set> +#include <sstream> #include <stdexcept> #include <string> #include <utility> @@ -55,15 +56,14 @@ namespace ingen { struct Serialiser::Impl { explicit Impl(World& world) - : _root_path("/") - , _mode(Mode::TO_FILE) - , _world(world) - , _model(nullptr) - , _sratom(sratom_new(&_world.uri_map().urid_map_feature()->urid_map)) - {} - - ~Impl() { - sratom_free(_sratom); + : _root_path("/") + , _mode(Mode::TO_STRING) + , _base_uri("ingen:") + , _world(world) + , _streamer(_world.rdf_world(), + _world.uri_map().urid_map_feature()->urid_map, + _world.uri_map().urid_unmap_feature()->urid_unmap) + { } Impl(const Impl&) = delete; @@ -77,22 +77,22 @@ struct Serialiser::Impl { const FilePath& filename); std::set<const Resource*> serialise_graph(const SPtr<const Node>& graph, - const Sord::Node& graph_id); + const serd::Node& graph_id); void serialise_block(const SPtr<const Node>& block, - const Sord::Node& class_id, - const Sord::Node& block_id); + const serd::Node& class_id, + const serd::Node& block_id); void serialise_port(const Node* port, Resource::Graph context, - const Sord::Node& port_id); + const serd::Node& port_id); - void serialise_properties(Sord::Node id, + void serialise_properties(serd::Node id, const Properties& props); void write_bundle(const SPtr<const Node>& graph, const URI& uri); - Sord::Node path_rdf_node(const Raul::Path& path); + serd::Node path_rdf_node(const Raul::Path& path); void write_manifest(const FilePath& bundle_path, const SPtr<const Node>& graph); @@ -100,18 +100,18 @@ struct Serialiser::Impl { void write_plugins(const FilePath& bundle_path, const std::set<const Resource*>& plugins); - void serialise_arc(const Sord::Node& parent, - const SPtr<const Arc>& arc); + void serialise_arc(const serd::Optional<serd::Node>& parent, + const SPtr<const Arc>& arc); std::string finish(); - Raul::Path _root_path; - Mode _mode; - URI _base_uri; - FilePath _basename; - World& _world; - Sord::Model* _model; - Sratom* _sratom; + Raul::Path _root_path; + Mode _mode; + URI _base_uri; + FilePath _basename; + World& _world; + UPtr<serd::Model> _model; + sratom::Streamer _streamer; }; Serialiser::Serialiser(World& world) @@ -129,24 +129,17 @@ Serialiser::Impl::write_manifest(const FilePath& bundle_path, start_to_file(Raul::Path("/"), manifest_path); - Sord::World& world = _model->world(); - const URIs& uris = _world.uris(); + const URIs& uris = _world.uris(); const std::string filename("main.ttl"); - const Sord::URI subject(world, filename, _base_uri); - - _model->add_statement(subject, - Sord::URI(world, uris.rdf_type), - Sord::URI(world, uris.ingen_Graph)); - _model->add_statement(subject, - Sord::URI(world, uris.rdf_type), - Sord::URI(world, uris.lv2_Plugin)); - _model->add_statement(subject, - Sord::URI(world, uris.rdfs_seeAlso), - Sord::URI(world, filename, _base_uri)); - _model->add_statement(subject, - Sord::URI(world, uris.lv2_prototype), - Sord::URI(world, uris.ingen_GraphPrototype)); + const serd::Node subject = serd::make_resolved_uri(filename, _base_uri); + + _model->insert(subject, uris.rdf_type, uris.ingen_Graph); + _model->insert(subject, uris.rdf_type, uris.lv2_Plugin); + _model->insert(subject, uris.lv2_prototype, uris.ingen_GraphPrototype); + _model->insert(subject, + uris.rdfs_seeAlso, + serd::make_resolved_uri(filename, _base_uri)); finish(); } @@ -159,24 +152,21 @@ Serialiser::Impl::write_plugins(const FilePath& bundle_path, start_to_file(Raul::Path("/"), plugins_path); - Sord::World& world = _model->world(); - const URIs& uris = _world.uris(); + const URIs& uris = _world.uris(); for (const auto& p : plugins) { const Atom& minor = p->get_property(uris.lv2_minorVersion); const Atom& micro = p->get_property(uris.lv2_microVersion); - _model->add_statement(Sord::URI(world, p->uri()), - Sord::URI(world, uris.rdf_type), - Sord::URI(world, uris.lv2_Plugin)); + _model->insert(p->uri(), uris.rdf_type, uris.lv2_Plugin); if (minor.is_valid() && micro.is_valid()) { - _model->add_statement(Sord::URI(world, p->uri()), - Sord::URI(world, uris.lv2_minorVersion), - Sord::Literal::integer(world, minor.get<int32_t>())); - _model->add_statement(Sord::URI(world, p->uri()), - Sord::URI(world, uris.lv2_microVersion), - Sord::Literal::integer(world, micro.get<int32_t>())); + _model->insert(p->uri(), + uris.lv2_minorVersion, + serd::make_integer(minor.get<int32_t>())); + _model->insert(p->uri(), + uris.lv2_microVersion, + serd::make_integer(micro.get<int32_t>())); } } @@ -207,7 +197,7 @@ Serialiser::Impl::write_bundle(const SPtr<const Node>& graph, const URI& uri) std::set<const Resource*> plugins = serialise_graph( graph, - Sord::URI(_model->world(), main_file, _base_uri)); + serd::make_resolved_uri(main_file.c_str(), _base_uri)); finish(); write_manifest(path, graph); @@ -230,9 +220,11 @@ Serialiser::Impl::start_to_file(const Raul::Path& root, _basename = filename.parent_path().stem(); } - _model = new Sord::Model(*_world.rdf_world(), _base_uri); - _mode = Mode::TO_FILE; _root_path = root; + _mode = Mode::TO_FILE; + _model = make_unique<serd::Model>(_world.rdf_world(), + serd::ModelFlag::index_SPO | + serd::ModelFlag::index_OPS); } void @@ -240,8 +232,10 @@ Serialiser::start_to_string(const Raul::Path& root, const URI& base_uri) { me->_root_path = root; me->_base_uri = base_uri; - me->_model = new Sord::Model(*me->_world.rdf_world(), base_uri); me->_mode = Impl::Mode::TO_STRING; + me->_model = make_unique<serd::Model>(me->_world.rdf_world(), + serd::ModelFlag::index_SPO | + serd::ModelFlag::index_OPS); } void @@ -259,32 +253,54 @@ Serialiser::finish() std::string Serialiser::Impl::finish() { - std::string ret; + std::string ret{}; + serd::Env env{_world.env()}; + + env.set_base_uri(_base_uri); + if (_mode == Mode::TO_FILE) { - SerdStatus st = _model->write_to_file(_base_uri, SERD_TURTLE); - if (st) { - _world.log().error("Error writing file %1% (%2%)\n", - _base_uri, serd_strerror(st)); + const std::string path = serd::file_uri_parse(_base_uri.string()); + std::ofstream file(path); + serd::Writer writer( + _world.rdf_world(), serd::Syntax::Turtle, {}, env, file); + + env.write_prefixes(writer.sink()); + const serd::Status st = _model->all().serialise(writer.sink()); + + if (st != serd::Status::success) { + _world.log().error(fmt("Error writing file %1% (%2%)\n", + _base_uri, serd::strerror(st))); } } else { - ret = _model->write_to_string(_base_uri, SERD_TURTLE); + std::stringstream ss; + serd::Writer writer( + _world.rdf_world(), serd::Syntax::Turtle, {}, env, ss); + + env.write_prefixes(writer.sink()); + const serd::Status st = _model->all().serialise(writer.sink()); + + writer.finish(); + ret = ss.str(); + + if (st != serd::Status::success) { + _world.log().error(fmt("Error writing string (%2%)\n", + serd::strerror(st))); + } } - delete _model; - _model = nullptr; - _base_uri = URI(); + _model.reset(); + _base_uri = URI("ingen:"); return ret; } -Sord::Node +serd::Node Serialiser::Impl::path_rdf_node(const Raul::Path& path) { assert(_model); assert(path == _root_path || path.is_child_of(_root_path)); - return Sord::URI(_model->world(), - path.substr(_root_path.base().length()), - _base_uri); + return serd::make_resolved_uri(path.substr(_root_path.base().length()), + _base_uri); } void @@ -297,8 +313,9 @@ Serialiser::serialise(const SPtr<const Node>& object, Resource::Graph context) if (object->graph_type() == Node::GraphType::GRAPH) { me->serialise_graph(object, me->path_rdf_node(object->path())); } else if (object->graph_type() == Node::GraphType::BLOCK) { - const Sord::URI plugin_id(me->_model->world(), object->plugin()->uri()); - me->serialise_block(object, plugin_id, me->path_rdf_node(object->path())); + me->serialise_block(object, + object->plugin()->uri(), + me->path_rdf_node(object->path())); } else if (object->graph_type() == Node::GraphType::PORT) { me->serialise_port( object.get(), context, me->path_rdf_node(object->path())); @@ -310,32 +327,27 @@ Serialiser::serialise(const SPtr<const Node>& object, Resource::Graph context) std::set<const Resource*> Serialiser::Impl::serialise_graph(const SPtr<const Node>& graph, - const Sord::Node& graph_id) + const serd::Node& graph_id) { - Sord::World& world = _model->world(); - const URIs& uris = _world.uris(); + const URIs& uris = _world.uris(); - _model->add_statement(graph_id, - Sord::URI(world, uris.rdf_type), - Sord::URI(world, uris.ingen_Graph)); + _model->insert(graph_id, uris.rdf_type, uris.ingen_Graph); - _model->add_statement(graph_id, - Sord::URI(world, uris.rdf_type), - Sord::URI(world, uris.lv2_Plugin)); + _model->insert(graph_id, uris.rdf_type, uris.lv2_Plugin); - _model->add_statement(graph_id, - Sord::URI(world, uris.lv2_extensionData), - Sord::URI(world, LV2_STATE__interface)); + _model->insert(graph_id, + uris.lv2_extensionData, + serd::make_uri(LV2_STATE__interface)); - _model->add_statement(graph_id, - Sord::URI(world, LV2_UI__ui), - Sord::URI(world, "http://drobilla.net/ns/ingen#GraphUIGtk2")); + _model->insert(graph_id, + serd::make_uri(LV2_UI__ui), + serd::make_uri("http://drobilla.net/ns/ingen#GraphUIGtk2")); // If the graph has no doap:name (required by LV2), use the basename if (graph->properties().find(uris.doap_name) == graph->properties().end()) { - _model->add_statement(graph_id, - Sord::URI(world, uris.doap_name), - Sord::Literal(world, _basename)); + _model->insert(graph_id, + uris.doap_name, + serd::make_string((std::string)_basename)); } const Properties props = graph->properties(Resource::Graph::INTERNAL); @@ -352,45 +364,33 @@ Serialiser::Impl::serialise_graph(const SPtr<const Node>& graph, if (n->second->graph_type() == Node::GraphType::GRAPH) { SPtr<Node> subgraph = n->second; - SerdURI base_uri; - serd_uri_parse((const uint8_t*)_base_uri.c_str(), &base_uri); - const std::string sub_bundle_path = subgraph->path().substr(1) + ".ingen"; - SerdURI subgraph_uri; - SerdNode subgraph_node = serd_node_new_uri_from_string( - (const uint8_t*)sub_bundle_path.c_str(), - &base_uri, - &subgraph_uri); - - const Sord::URI subgraph_id(world, (const char*)subgraph_node.buf); + serd::Node subgraph_node = serd::make_resolved_uri( + sub_bundle_path, + _base_uri); // Save our state - URI my_base_uri = _base_uri; - Sord::Model* my_model = _model; + URI my_base_uri = _base_uri; + auto my_model = std::move(_model); // Write child bundle within this bundle - write_bundle(subgraph, subgraph_id); + write_bundle(subgraph, subgraph_node); // Restore our state _base_uri = my_base_uri; - _model = my_model; + _model = std::move(my_model); // Serialise reference to graph block - const Sord::Node block_id(path_rdf_node(subgraph->path())); - _model->add_statement(graph_id, - Sord::URI(world, uris.ingen_block), - block_id); - serialise_block(subgraph, subgraph_id, block_id); + const serd::Node block_id(path_rdf_node(subgraph->path())); + _model->insert(graph_id, uris.ingen_block, block_id); + serialise_block(subgraph, subgraph_node, block_id); } else if (n->second->graph_type() == Node::GraphType::BLOCK) { SPtr<const Node> block = n->second; - const Sord::URI class_id(world, block->plugin()->uri()); - const Sord::Node block_id(path_rdf_node(n->second->path())); - _model->add_statement(graph_id, - Sord::URI(world, uris.ingen_block), - block_id); - serialise_block(block, class_id, block_id); + const serd::Node block_id(path_rdf_node(n->second->path())); + _model->insert(graph_id, uris.ingen_block, block_id); + serialise_block(block, block->plugin()->uri(), block_id); plugins.insert(block->plugin()); } @@ -398,7 +398,7 @@ Serialiser::Impl::serialise_graph(const SPtr<const Node>& graph, for (uint32_t i = 0; i < graph->num_ports(); ++i) { Node* p = graph->port(i); - const Sord::Node port_id = path_rdf_node(p->path()); + const serd::Node port_id = path_rdf_node(p->path()); // Ensure lv2:name always exists so Graph is a valid LV2 plugin if (p->properties().find(uris.lv2_name) == p->properties().end()) { @@ -406,9 +406,7 @@ Serialiser::Impl::serialise_graph(const SPtr<const Node>& graph, _world.forge().alloc(p->symbol().c_str())); } - _model->add_statement(graph_id, - Sord::URI(world, LV2_CORE__port), - port_id); + _model->insert(graph_id, serd::make_uri(LV2_CORE__port), port_id); serialise_port(p, Resource::Graph::DEFAULT, port_id); serialise_port(p, Resource::Graph::INTERNAL, port_id); } @@ -422,17 +420,13 @@ Serialiser::Impl::serialise_graph(const SPtr<const Node>& graph, void Serialiser::Impl::serialise_block(const SPtr<const Node>& block, - const Sord::Node& class_id, - const Sord::Node& block_id) + const serd::Node& class_id, + const serd::Node& block_id) { const URIs& uris = _world.uris(); - _model->add_statement(block_id, - Sord::URI(_model->world(), uris.rdf_type), - Sord::URI(_model->world(), uris.ingen_Block)); - _model->add_statement(block_id, - Sord::URI(_model->world(), uris.lv2_prototype), - class_id); + _model->insert(block_id, uris.rdf_type, uris.ingen_Block); + _model->insert(block_id, uris.lv2_prototype, class_id); // Serialise properties, but remove possibly stale state:state (set again below) Properties props = block->properties(); @@ -445,36 +439,33 @@ Serialiser::Impl::serialise_block(const SPtr<const Node>& block, const FilePath state_dir = graph_dir / block->symbol(); const FilePath state_file = state_dir / "state.ttl"; if (block->save_state(state_dir)) { - _model->add_statement(block_id, - Sord::URI(_model->world(), uris.state_state), - Sord::URI(_model->world(), URI(state_file))); + _model->insert(block_id, + uris.state_state, + serd::make_uri((std::string)state_file)); } } for (uint32_t i = 0; i < block->num_ports(); ++i) { Node* const p = block->port(i); - const Sord::Node port_id = path_rdf_node(p->path()); + const serd::Node port_id = path_rdf_node(p->path()); serialise_port(p, Resource::Graph::DEFAULT, port_id); - _model->add_statement(block_id, - Sord::URI(_model->world(), uris.lv2_port), - port_id); + _model->insert(block_id, uris.lv2_port, port_id); } } void Serialiser::Impl::serialise_port(const Node* port, Resource::Graph context, - const Sord::Node& port_id) + const serd::Node& port_id) { - URIs& uris = _world.uris(); - Sord::World& world = _model->world(); + URIs& uris = _world.uris(); Properties props = port->properties(context); if (context == Resource::Graph::INTERNAL) { // Always write lv2:symbol for Graph ports (required for lv2:Plugin) - _model->add_statement(port_id, - Sord::URI(world, uris.lv2_symbol), - Sord::Literal(world, port->path().symbol())); + _model->insert(port_id, + uris.lv2_symbol, + serd::make_string(port->path().symbol())); } else if (context == Resource::Graph::EXTERNAL) { // Never write lv2:index for plugin instances (not persistent/stable) props.erase(uris.lv2_index); @@ -500,47 +491,38 @@ Serialiser::Impl::serialise_port(const Node* port, } void -Serialiser::serialise_arc(const Sord::Node& parent, - const SPtr<const Arc>& arc) +Serialiser::serialise_arc(const serd::Optional<serd::Node>& parent, + const SPtr<const Arc>& arc) { return me->serialise_arc(parent, arc); } void -Serialiser::Impl::serialise_arc(const Sord::Node& parent, - const SPtr<const Arc>& arc) +Serialiser::Impl::serialise_arc(const serd::Optional<serd::Node>& parent, + const SPtr<const Arc>& arc) { if (!_model) { throw std::logic_error( "serialise_arc called without serialisation in progress"); } - Sord::World& world = _model->world(); - const URIs& uris = _world.uris(); - - const Sord::Node src = path_rdf_node(arc->tail_path()); - const Sord::Node dst = path_rdf_node(arc->head_path()); - const Sord::Node arc_id = Sord::Node::blank_id(*_world.rdf_world()); - _model->add_statement(arc_id, - Sord::URI(world, uris.ingen_tail), - src); - _model->add_statement(arc_id, - Sord::URI(world, uris.ingen_head), - dst); - - if (parent.is_valid()) { - _model->add_statement(parent, - Sord::URI(world, uris.ingen_arc), - arc_id); + const URIs& uris = _world.uris(); + + const serd::Node src = path_rdf_node(arc->tail_path()); + const serd::Node dst = path_rdf_node(arc->head_path()); + const serd::Node arc_id = _world.rdf_world().get_blank(); + _model->insert(arc_id, uris.ingen_tail, src); + _model->insert(arc_id, uris.ingen_head, dst); + + if (parent) { + _model->insert(*parent, uris.ingen_arc, arc_id); } else { - _model->add_statement(arc_id, - Sord::URI(world, uris.rdf_type), - Sord::URI(world, uris.ingen_Arc)); + _model->insert(arc_id, uris.rdf_type, uris.ingen_Arc); } } static bool -skip_property(ingen::URIs& uris, const Sord::Node& predicate) +skip_property(ingen::URIs& uris, const serd::Node& predicate) { return (predicate == INGEN__file || predicate == uris.ingen_arc || @@ -549,45 +531,37 @@ skip_property(ingen::URIs& uris, const Sord::Node& predicate) } void -Serialiser::Impl::serialise_properties(Sord::Node id, +Serialiser::Impl::serialise_properties(serd::Node id, const Properties& props) { - LV2_URID_Unmap* unmap = &_world.uri_map().urid_unmap_feature()->urid_unmap; - SerdNode base = serd_node_from_string(SERD_URI, - (const uint8_t*)_base_uri.c_str()); - SerdEnv* env = serd_env_new(&base); - SordInserter* inserter = sord_inserter_new(_model->c_obj(), env); - - sratom_set_sink(_sratom, _base_uri.c_str(), - (SerdStatementSink)sord_inserter_write_statement, nullptr, - inserter); - - sratom_set_pretty_numbers(_sratom, true); + serd::Env env{_base_uri}; + serd::Inserter inserter{*_model, env, {}}; for (const auto& p : props) { - const Sord::URI key(_model->world(), p.first); + const serd::Node key = serd::make_uri(p.first.c_str()); if (!skip_property(_world.uris(), key)) { if (p.second.type() == _world.uris().atom_URI && - !strncmp((const char*)p.second.get_body(), "ingen:/main/", 13)) { + !strncmp( + (const char*)p.second.get_body(), "ingen:/main/", 13)) { /* Value is a graph URI relative to the running engine. Chop the prefix and save the path relative to the graph file. This allows saving references to bundle resources. */ - sratom_write(_sratom, unmap, 0, - sord_node_to_serd_node(id.c_obj()), - sord_node_to_serd_node(key.c_obj()), - p.second.type(), p.second.size(), - (const char*)p.second.get_body() + 13); + _streamer.write(inserter.sink(), + id, + key, + p.second.type(), + p.second.size(), + (const char*)p.second.get_body() + 13, + sratom::Flag::pretty_numbers); } else { - sratom_write(_sratom, unmap, 0, - sord_node_to_serd_node(id.c_obj()), - sord_node_to_serd_node(key.c_obj()), - p.second.type(), p.second.size(), p.second.get_body()); + _streamer.write(inserter.sink(), + id, + key, + *p.second.atom(), + sratom::Flag::pretty_numbers); } } } - - sord_inserter_free(inserter); - serd_env_free(env); } } // namespace ingen diff --git a/src/SocketReader.cpp b/src/SocketReader.cpp index 443c418f..273c9e49 100644 --- a/src/SocketReader.cpp +++ b/src/SocketReader.cpp @@ -21,10 +21,11 @@ #include "ingen/Log.hpp" #include "ingen/URIMap.hpp" #include "ingen/World.hpp" +#include "ingen/types.hpp" #include "lv2/atom/forge.h" #include "lv2/urid/urid.h" #include "raul/Socket.hpp" -#include "sord/sordmm.hpp" +#include "serd/serd.hpp" #include <cerrno> #include <cstdint> @@ -42,9 +43,6 @@ SocketReader::SocketReader(ingen::World& world, SPtr<Raul::Socket> sock) : _world(world) , _iface(iface) - , _env() - , _inserter(nullptr) - , _msg_node(nullptr) , _socket(std::move(sock)) , _exit_flag(false) , _thread(&SocketReader::run, this) @@ -57,46 +55,10 @@ SocketReader::~SocketReader() _thread.join(); } -SerdStatus -SocketReader::set_base_uri(SocketReader* iface, - const SerdNode* uri_node) -{ - return sord_inserter_set_base_uri(iface->_inserter, uri_node); -} - -SerdStatus -SocketReader::set_prefix(SocketReader* iface, - const SerdNode* name, - const SerdNode* uri_node) -{ - return sord_inserter_set_prefix(iface->_inserter, name, uri_node); -} - -SerdStatus -SocketReader::write_statement(SocketReader* iface, - SerdStatementFlags flags, - const SerdNode* graph, - const SerdNode* subject, - const SerdNode* predicate, - const SerdNode* object, - const SerdNode* object_datatype, - const SerdNode* object_lang) -{ - if (!iface->_msg_node) { - iface->_msg_node = sord_node_from_serd_node( - iface->_world.rdf_world()->c_obj(), iface->_env, subject, nullptr, nullptr); - } - - return sord_inserter_write_statement( - iface->_inserter, flags, graph, - subject, predicate, object, - object_datatype, object_lang); -} - void SocketReader::run() { - Sord::World* world = _world.rdf_world(); + serd::World& world = _world.rdf_world(); LV2_URID_Map& map = _world.uri_map().urid_map_feature()->urid_map; // Open socket as a FILE for reading directly with serd @@ -111,33 +73,51 @@ SocketReader::run() } // Set up a forge to build LV2 atoms from model - SordNode* base_uri = nullptr; - SordModel* model = nullptr; - AtomForge forge(map); + AtomForge forge(world, map); + serd::Optional<serd::Node> base_uri; + serd::Optional<serd::Model> model; + serd::Env env; + UPtr<serd::Inserter> inserter; + serd::Optional<serd::Node> msg_node; { // Lock RDF world std::lock_guard<std::mutex> lock(_world.rdf_mutex()); // Use <ingen:/> as base URI, so relative URIs are like bundle paths - base_uri = sord_new_uri(world->c_obj(), (const uint8_t*)"ingen:/"); + base_uri = serd::make_uri("ingen:/"); // Make a model and reader to parse the next Turtle message - _env = world->prefixes().c_obj(); - model = sord_new(world->c_obj(), SORD_SPO, false); + env = _world.env(); + model = serd::Model(world, serd::ModelFlag::index_SPO); // Create an inserter for writing incoming triples to model - _inserter = sord_inserter_new(model, _env); + inserter = UPtr<serd::Inserter>{new serd::Inserter(*model, env)}; } - SerdReader* reader = serd_reader_new( - SERD_TURTLE, this, nullptr, - (SerdBaseSink)set_base_uri, - (SerdPrefixSink)set_prefix, - (SerdStatementSink)write_statement, - nullptr); + serd::Sink sink; + + sink.set_base_func([&](const serd::Node& uri) { + return inserter->sink().base(uri); + }); + + sink.set_prefix_func([&](const serd::Node& name, const serd::Node& uri) { + return inserter->sink().prefix(name, uri); + }); + + sink.set_statement_func([&](const serd::StatementFlags flags, + const serd::Statement& statement) { + if (!msg_node) { + msg_node = statement.subject(); + } + + return inserter->sink().statement(flags, statement); + }); + + serd::Reader reader(world, serd::Syntax::Turtle, {}, sink, 4096); - serd_env_set_base_uri(_env, sord_node_to_serd_node(base_uri)); - serd_reader_start_stream(reader, f.get(), (const uint8_t*)"(socket)", false); + serd::Node name = serd::make_string("(socket)"); + env.set_base_uri(*base_uri); + reader.start_stream(f.get(), name, 1); // Make an AtomReader to call Ingen Interface methods based on Atom AtomReader ar(_world.uri_map(), _world.uris(), _world.log(), _iface); @@ -165,24 +145,22 @@ SocketReader::run() std::lock_guard<std::mutex> lock(_world.rdf_mutex()); // Read until the next '.' - SerdStatus st = serd_reader_read_chunk(reader); - if (st == SERD_FAILURE || !_msg_node) { - continue; // Read nothing, e.g. just whitespace - } else if (st) { - _world.log().error("Read error: %1%\n", serd_strerror(st)); + auto st = reader.read_chunk(); + if (st == serd::Status::failure || !msg_node) { + continue; // Read no node (e.g. a directive) + } else if (st != serd::Status::success) { + _world.log().error("Read error: %1%\n", serd::strerror(st)); continue; } - // Build an LV2_Atom at chunk.buf from the message - forge.read(*world, model, _msg_node); + // Build an LV2_Atom from the message + auto atom = forge.read(*model, *msg_node); - // Call _iface methods based on atom content - ar.write(forge.atom()); + // Call _iface methods with forged atom + ar.write(atom); // Reset everything for the next iteration - forge.clear(); - sord_node_free(world->c_obj(), _msg_node); - _msg_node = nullptr; + msg_node.reset(); } // Lock RDF world @@ -190,10 +168,7 @@ SocketReader::run() // Destroy everything f.reset(); - sord_inserter_free(_inserter); - serd_reader_end_stream(reader); - serd_reader_free(reader); - sord_free(model); + reader.finish(); _socket.reset(); } diff --git a/src/SocketWriter.cpp b/src/SocketWriter.cpp index 910f67f3..41254ef3 100644 --- a/src/SocketWriter.cpp +++ b/src/SocketWriter.cpp @@ -31,12 +31,13 @@ namespace ingen { -SocketWriter::SocketWriter(URIMap& map, +SocketWriter::SocketWriter(serd::World& world, + URIMap& map, URIs& uris, const URI& uri, SPtr<Raul::Socket> sock) - : TurtleWriter(map, uris, uri) - , _socket(std::move(sock)) + : TurtleWriter(world, map, uris, uri) + , _socket(std::move(sock)) {} void diff --git a/src/StreamWriter.cpp b/src/StreamWriter.cpp index d8a93a0b..32831601 100644 --- a/src/StreamWriter.cpp +++ b/src/StreamWriter.cpp @@ -21,14 +21,15 @@ namespace ingen { -StreamWriter::StreamWriter(URIMap& map, +StreamWriter::StreamWriter(serd::World& world, + URIMap& map, URIs& uris, const URI& uri, FILE* stream, ColorContext::Color color) - : TurtleWriter(map, uris, uri) - , _stream(stream) - , _color(color) + : TurtleWriter(world, map, uris, uri) + , _stream(stream) + , _color(color) {} size_t diff --git a/src/TurtleWriter.cpp b/src/TurtleWriter.cpp index 1deb2e13..e8a38561 100644 --- a/src/TurtleWriter.cpp +++ b/src/TurtleWriter.cpp @@ -19,72 +19,43 @@ #include "ingen/URIMap.hpp" #include "lv2/atom/atom.h" -#define USTR(s) ((const uint8_t*)(s)) - namespace ingen { -static size_t -c_text_sink(const void* buf, size_t len, void* stream) -{ - auto* writer = static_cast<TurtleWriter*>(stream); - return writer->text_sink(buf, len); -} - -static SerdStatus -write_prefix(void* handle, const SerdNode* name, const SerdNode* uri) -{ - serd_writer_set_prefix((SerdWriter*)handle, name, uri); - return SERD_SUCCESS; -} - -TurtleWriter::TurtleWriter(URIMap& map, URIs& uris, URI uri) - : AtomWriter(map, uris, *this) +TurtleWriter::TurtleWriter(serd::World& world, + URIMap& map, + URIs& uris, + const URI& uri) + : AtomWriter(world, map, uris, *this) , _map(map) - , _sratom(sratom_new(&map.urid_map_feature()->urid_map)) - , _base(SERD_NODE_NULL) - , _base_uri(SERD_URI_NULL) - , _uri(std::move(uri)) + , _streamer(world, + map.urid_map_feature()->urid_map, + map.urid_unmap_feature()->urid_unmap) + , _base(serd::make_uri("ingen:/")) // Make relative URIs like bundle paths + , _env(_base) + , _writer(world, + serd::Syntax::Turtle, + {}, + _env, + [&](const char* str, size_t len) { return text_sink(str, len); }) + , _uri(uri) , _wrote_prefixes(false) { - // Use <ingen:/> as base URI, so relative URIs are like bundle paths - _base = serd_node_from_string(SERD_URI, (const uint8_t*)"ingen:/"); - serd_uri_parse(_base.buf, &_base_uri); - - // Set up serialisation environment - _env = serd_env_new(&_base); - serd_env_set_prefix_from_strings(_env, USTR("atom"), USTR("http://lv2plug.in/ns/ext/atom#")); - serd_env_set_prefix_from_strings(_env, USTR("doap"), USTR("http://usefulinc.com/ns/doap#")); - serd_env_set_prefix_from_strings(_env, USTR("ingen"), USTR(INGEN_NS)); - serd_env_set_prefix_from_strings(_env, USTR("lv2"), USTR("http://lv2plug.in/ns/lv2core#")); - serd_env_set_prefix_from_strings(_env, USTR("midi"), USTR("http://lv2plug.in/ns/ext/midi#")); - serd_env_set_prefix_from_strings(_env, USTR("owl"), USTR("http://www.w3.org/2002/07/owl#")); - serd_env_set_prefix_from_strings(_env, USTR("patch"), USTR("http://lv2plug.in/ns/ext/patch#")); - serd_env_set_prefix_from_strings(_env, USTR("rdf"), USTR("http://www.w3.org/1999/02/22-rdf-syntax-ns#")); - serd_env_set_prefix_from_strings(_env, USTR("rdfs"), USTR("http://www.w3.org/2000/01/rdf-schema#")); - serd_env_set_prefix_from_strings(_env, USTR("xsd"), USTR("http://www.w3.org/2001/XMLSchema#")); - - // Make a Turtle writer that writes to text_sink - _writer = serd_writer_new( - SERD_TURTLE, - (SerdStyle)(SERD_STYLE_RESOLVED|SERD_STYLE_ABBREVIATED|SERD_STYLE_CURIED), - _env, - &_base_uri, - c_text_sink, - this); - - // Configure sratom to write directly to the writer (and thus text_sink) - sratom_set_sink(_sratom, - (const char*)_base.buf, - (SerdStatementSink)serd_writer_write_statement, - (SerdEndSink)serd_writer_end_anon, - _writer); + // Set namespace prefixes + _env.set_prefix("atom", "http://lv2plug.in/ns/ext/atom#"); + _env.set_prefix("doap", "http://usefulinc.com/ns/doap#"); + _env.set_prefix("ingen", INGEN_NS); + _env.set_prefix("lv2", "http://lv2plug.in/ns/lv2core#"); + _env.set_prefix("midi", "http://lv2plug.in/ns/ext/midi#"); + _env.set_prefix("owl", "http://www.w3.org/2002/07/owl#"); + _env.set_prefix("patch", "http://lv2plug.in/ns/ext/patch#"); + _env.set_prefix("rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#"); + _env.set_prefix("rdfs", "http://www.w3.org/2000/01/rdf-schema#"); + _env.set_prefix("xsd", "http://www.w3.org/2001/XMLSchema#"); } TurtleWriter::~TurtleWriter() { - sratom_free(_sratom); - serd_writer_free(_writer); - serd_env_free(_env); + _writer.finish(); } bool @@ -92,13 +63,13 @@ TurtleWriter::write(const LV2_Atom* msg, int32_t) { if (!_wrote_prefixes) { // Write namespace prefixes once to reduce traffic - serd_env_foreach(_env, write_prefix, _writer); + _env.write_prefixes(_writer.sink()); + _writer.finish(); _wrote_prefixes = true; } - sratom_write(_sratom, &_map.urid_unmap_feature()->urid_unmap, 0, - nullptr, nullptr, msg->type, msg->size, LV2_ATOM_BODY_CONST(msg)); - serd_writer_finish(_writer); + _streamer.write(_writer.sink(), *msg); + _writer.finish(); return true; } diff --git a/src/URI.cpp b/src/URI.cpp index f7b64209..fd649393 100644 --- a/src/URI.cpp +++ b/src/URI.cpp @@ -22,102 +22,39 @@ namespace ingen { -URI::URI() - : _uri(SERD_URI_NULL) - , _node(SERD_NODE_NULL) -{} - URI::URI(const std::string& str) - : _uri(SERD_URI_NULL) - , _node(serd_node_new_uri_from_string((const uint8_t*)str.c_str(), - nullptr, - &_uri)) -{} - -URI::URI(const char* str) - : _uri(SERD_URI_NULL) - , _node(serd_node_new_uri_from_string((const uint8_t*)str, nullptr, &_uri)) -{} - -URI::URI(const std::string& str, const URI& base) - : _uri(SERD_URI_NULL) - , _node(serd_node_new_uri_from_string((const uint8_t*)str.c_str(), - &base._uri, - &_uri)) -{} - -URI::URI(SerdNode node) - : _uri(SERD_URI_NULL) - , _node(serd_node_new_uri_from_node(&node, nullptr, &_uri)) + : serd::Node{serd::make_uri(str)} { - assert(node.type == SERD_URI); } -URI::URI(SerdNode node, SerdURI uri) - : _uri(uri) - , _node(node) -{ - assert(node.type == SERD_URI); -} - -URI::URI(const Sord::Node& node) - : URI(*node.to_serd_node()) -{ -} - -URI::URI(const FilePath& path) - : _uri(SERD_URI_NULL) - , _node(serd_node_new_file_uri((const uint8_t*)path.c_str(), - nullptr, - &_uri, - true)) -{} - -URI::URI(const URI& uri) - : _uri(SERD_URI_NULL) - , _node(serd_node_new_uri(&uri._uri, nullptr, &_uri)) -{} - -URI& -URI::operator=(const URI& uri) +URI::URI(const char* str) + : serd::Node{serd::make_uri(str)} { - if (&uri != this) { - serd_node_free(&_node); - _node = serd_node_new_uri(&uri._uri, nullptr, &_uri); - } - - return *this; } -URI::URI(URI&& uri) noexcept - : _uri(uri._uri) - , _node(uri._node) +URI::URI(const serd::NodeView& node) + : serd::Node{node} { - uri._node = SERD_NODE_NULL; - uri._uri = SERD_URI_NULL; + assert(cobj()); + assert(node.type() == serd::NodeType::URI); } -URI& -URI::operator=(URI&& uri) noexcept +URI::URI(const serd::Node& node) + : serd::Node{node} { - _node = uri._node; - _uri = uri._uri; - uri._node = SERD_NODE_NULL; - uri._uri = SERD_URI_NULL; - return *this; + assert(cobj()); + assert(node.type() == serd::NodeType::URI); } -URI::~URI() +URI::URI(const FilePath& path) + : serd::Node{serd::make_file_uri(path.string())} { - serd_node_free(&_node); } URI URI::make_relative(const URI& base) const { - SerdURI uri; - SerdNode node = serd_node_new_relative_uri(&_uri, &base._uri, nullptr, &uri); - return URI(node, uri); + return URI(serd::make_relative_uri(std::string(*this), base)); } } // namespace ingen diff --git a/src/URIs.cpp b/src/URIs.cpp index dfe6b867..9c83a637 100644 --- a/src/URIs.cpp +++ b/src/URIs.cpp @@ -43,21 +43,8 @@ URIs::Quark::Quark(Forge& forge, : URI(str) , urid(forge.make_urid(URI(str))) , uri(forge.alloc_uri(str)) - , lnode(lilv_new_uri(lworld, str)) {} -URIs::Quark::Quark(const Quark& copy) - : URI(copy) - , urid(copy.urid) - , uri(copy.uri) - , lnode(lilv_node_duplicate(copy.lnode)) -{} - -URIs::Quark::~Quark() -{ - lilv_node_free(lnode); -} - #define NS_RDF "http://www.w3.org/1999/02/22-rdf-syntax-ns#" #define NS_RDFS "http://www.w3.org/2000/01/rdf-schema#" diff --git a/src/World.cpp b/src/World.cpp index 41e69826..12d10bb2 100644 --- a/src/World.cpp +++ b/src/World.cpp @@ -37,7 +37,7 @@ #include "lilv/lilv.h" #include "lv2/log/log.h" #include "lv2/urid/urid.h" -#include "sord/sordmm.hpp" +#include "serd/serd.hpp" #include <cstdint> #include <list> @@ -90,7 +90,6 @@ public: : argc(nullptr) , argv(nullptr) , lv2_features(nullptr) - , rdf_world(new Sord::World()) , lilv_world(lilv_world_new(), lilv_world_free) , uri_map(log, map, unmap) , forge(uri_map) @@ -108,16 +107,16 @@ public: lilv_world_load_all(lilv_world.get()); // Set up RDF namespaces - rdf_world->add_prefix("atom", "http://lv2plug.in/ns/ext/atom#"); - rdf_world->add_prefix("doap", "http://usefulinc.com/ns/doap#"); - rdf_world->add_prefix("ingen", INGEN_NS); - rdf_world->add_prefix("lv2", "http://lv2plug.in/ns/lv2core#"); - rdf_world->add_prefix("midi", "http://lv2plug.in/ns/ext/midi#"); - rdf_world->add_prefix("owl", "http://www.w3.org/2002/07/owl#"); - rdf_world->add_prefix("patch", "http://lv2plug.in/ns/ext/patch#"); - rdf_world->add_prefix("rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#"); - rdf_world->add_prefix("rdfs", "http://www.w3.org/2000/01/rdf-schema#"); - rdf_world->add_prefix("xsd", "http://www.w3.org/2001/XMLSchema#"); + env.set_prefix("atom", "http://lv2plug.in/ns/ext/atom#"); + env.set_prefix("doap", "http://usefulinc.com/ns/doap#"); + env.set_prefix("ingen", INGEN_NS); + env.set_prefix("lv2", "http://lv2plug.in/ns/lv2core#"); + env.set_prefix("midi", "http://lv2plug.in/ns/ext/midi#"); + env.set_prefix("owl", "http://www.w3.org/2002/07/owl#"); + env.set_prefix("patch", "http://lv2plug.in/ns/ext/patch#"); + env.set_prefix("rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#"); + env.set_prefix("rdfs", "http://www.w3.org/2000/01/rdf-schema#"); + env.set_prefix("xsd", "http://www.w3.org/2001/XMLSchema#"); // Load internal 'plugin' information into lilv world LilvNode* rdf_type = lilv_new_uri( @@ -183,7 +182,8 @@ public: int* argc; char*** argv; LV2Features* lv2_features; - UPtr<Sord::World> rdf_world; + serd::World rdf_world; + serd::Env env; LilvWorldUPtr lilv_world; URIMap uri_map; Forge forge; @@ -219,7 +219,8 @@ World::load_configuration(int& argc, char**& argv) _impl->argv = &argv; // Parse default configuration files - const auto files = _impl->conf.load_default("ingen", "options.ttl"); + const auto files = + _impl->conf.load_default(rdf_world(), "ingen", "options.ttl"); for (const auto& f : files) { _impl->log.info("Loaded configuration %1%\n", f); } @@ -247,7 +248,8 @@ Log& World::log() { return _impl->log; } std::mutex& World::rdf_mutex() { return _impl->rdf_mutex; } -Sord::World* World::rdf_world() { return _impl->rdf_world.get(); } +serd::World& World::rdf_world() { return _impl->rdf_world; } +serd::Env& World::env() { return _impl->env; } LilvWorld* World::lilv_world() { return _impl->lilv_world.get(); } LV2Features& World::lv2_features() { return *_impl->lv2_features; } diff --git a/src/client/ClientStore.cpp b/src/client/ClientStore.cpp index a42efd16..2fdfa4a7 100644 --- a/src/client/ClientStore.cpp +++ b/src/client/ClientStore.cpp @@ -59,6 +59,7 @@ ClientStore::clear() void ClientStore::add_object(SPtr<ObjectModel> object) { + _log.info("Add object %1%\n", object->path()); // If we already have "this" object, merge the existing one into the new // one (with precedence to the new values). auto existing = find(object->path()); diff --git a/src/client/PluginModel.cpp b/src/client/PluginModel.cpp index f0e3c3a0..b0a2c5cb 100644 --- a/src/client/PluginModel.cpp +++ b/src/client/PluginModel.cpp @@ -38,8 +38,6 @@ namespace client { LilvWorld* PluginModel::_lilv_world = nullptr; const LilvPlugins* PluginModel::_lilv_plugins = nullptr; -Sord::World* PluginModel::_rdf_world = nullptr; - PluginModel::PluginModel(URIs& uris, const URI& uri, const Atom& type, @@ -65,7 +63,7 @@ PluginModel::PluginModel(URIs& uris, if (uris.ingen_Internal == _type) { set_property(uris.doap_name, - uris.forge.alloc(std::string(uri.fragment().substr(1)))); + uris.forge.alloc(uri.fragment().substr(1))); } } @@ -103,7 +101,7 @@ PluginModel::get_property(const URI& key) const // No lv2:symbol from data or engine, invent one if (key == _uris.lv2_symbol) { - string str = this->uri(); + string str = this->uri().str(); size_t last_delim = last_uri_delim(str); while (last_delim != string::npos && !contains_alpha_after(str, last_delim)) { @@ -264,12 +262,13 @@ heading(const std::string& text, bool html, unsigned level) } static std::string -link(const std::string& addr, bool html) +link(const URI& addr, bool html) { if (html) { - return std::string("<a href=\"") + addr + "\">" + addr + "</a>"; + return std::string("<a href=\"") + addr.str() + "\">" + addr.str() + + "</a>"; } else { - return addr; + return addr.str(); } } diff --git a/src/client/PluginUI.cpp b/src/client/PluginUI.cpp index a997d716..72a1fba0 100644 --- a/src/client/PluginUI.cpp +++ b/src/client/PluginUI.cpp @@ -224,9 +224,9 @@ PluginUI::create(ingen::World& world, bool PluginUI::instantiate() { - const URIs& uris = _world.uris(); - const std::string plugin_uri = _block->plugin()->uri(); - LilvWorld* lworld = _world.lilv_world(); + const URIs& uris = _world.uris(); + const URI& plugin_uri = _block->plugin()->uri(); + LilvWorld* lworld = _world.lilv_world(); // Load seeAlso files to access data like portNotification descriptions lilv_world_load_resource(lworld, lilv_ui_get_uri(_ui)); diff --git a/src/client/wscript b/src/client/wscript index 394c9e4d..c42046e1 100644 --- a/src/client/wscript +++ b/src/client/wscript @@ -10,7 +10,7 @@ def build(bld): target = 'ingen_client', install_path = '${LIBDIR}', use = 'libingen', - uselib = 'GLIBMM LV2 LILV SUIL RAUL SERD SORD SIGCPP') + uselib = 'GLIBMM LV2 LILV SUIL RAUL SERD SIGCPP') obj.source = ''' BlockModel.cpp diff --git a/src/gui/App.cpp b/src/gui/App.cpp index dfa34998..0e2292eb 100644 --- a/src/gui/App.cpp +++ b/src/gui/App.cpp @@ -87,7 +87,7 @@ App::App(ingen::World& world) , _requested_plugins(false) , _is_plugin(false) { - _world.conf().load_default("ingen", "gui.ttl"); + _world.conf().load_default(_world.rdf_world(), "ingen", "gui.ttl"); WidgetFactory::get_widget_derived("connect_win", _connect_window); WidgetFactory::get_widget_derived("messages_win", _messages_window); @@ -99,7 +99,6 @@ App::App(ingen::World& world) _about_dialog->property_program_name() = "Ingen"; _about_dialog->property_logo_icon_name() = "ingen"; - PluginModel::set_rdf_world(*world.rdf_world()); PluginModel::set_lilv_world(world.lilv_world()); using namespace std::placeholders; @@ -178,7 +177,8 @@ App::attach(SPtr<ingen::Interface> client) } if (_world.conf().option("dump").get<int32_t>()) { - _dumper = SPtr<StreamWriter>(new StreamWriter(_world.uri_map(), + _dumper = SPtr<StreamWriter>(new StreamWriter(_world.rdf_world(), + _world.uri_map(), _world.uris(), URI("ingen:/client"), stderr, @@ -469,8 +469,11 @@ App::quit(Gtk::Window* dialog_parent) Gtk::Main::quit(); try { - const std::string path = _world.conf().save( - _world.uri_map(), "ingen", "gui.ttl", Configuration::GUI); + const std::string path = _world.conf().save(_world.rdf_world(), + _world.uri_map(), + "ingen", + "gui.ttl", + Configuration::GUI); std::cout << fmt("Saved GUI settings to %1%\n", path); } catch (const std::exception& e) { std::cerr << fmt("Error saving GUI settings (%1%)\n", e.what()); diff --git a/src/gui/ConnectWindow.cpp b/src/gui/ConnectWindow.cpp index 209475e0..a7b2cbf7 100644 --- a/src/gui/ConnectWindow.cpp +++ b/src/gui/ConnectWindow.cpp @@ -228,7 +228,7 @@ ConnectWindow::connect(bool existing) if (_mode == Mode::CONNECT_REMOTE) { std::string uri_str = world.conf().option("connect").ptr<char>(); if (existing) { - uri_str = world.interface()->uri(); + uri_str = world.interface()->uri().str(); _connect_stage = 1; SPtr<client::SocketClient> client = dynamic_ptr_cast<client::SocketClient>( world.interface()); diff --git a/src/gui/GraphCanvas.cpp b/src/gui/GraphCanvas.cpp index 13b17bdf..40373a1a 100644 --- a/src/gui/GraphCanvas.cpp +++ b/src/gui/GraphCanvas.cpp @@ -636,7 +636,7 @@ serialise_arc(GanvEdge* arc, void* data) gui::Arc* garc = dynamic_cast<gui::Arc*>(Glib::wrap(GANV_EDGE(arc))); if (garc) { - serialiser->serialise_arc(Sord::Node(), garc->model()); + serialiser->serialise_arc({}, garc->model()); } } @@ -690,7 +690,7 @@ GraphCanvas::paste() // Figure out the copy graph base path Raul::Path copy_root("/"); if (base_uri) { - std::string base = *base_uri; + std::string base = base_uri->str(); if (base[base.size() - 1] == '/') { base = base.substr(0, base.size() - 1); } diff --git a/src/gui/LoadPluginWindow.cpp b/src/gui/LoadPluginWindow.cpp index bb84f96f..32a35c65 100644 --- a/src/gui/LoadPluginWindow.cpp +++ b/src/gui/LoadPluginWindow.cpp @@ -459,7 +459,7 @@ LoadPluginWindow::filter_changed() field = get_author_name(plugin); break; case CriteriaColumns::Criteria::URI: - field = plugin->uri(); + field = plugin->uri().str(); break; } diff --git a/src/gui/NodeMenu.cpp b/src/gui/NodeMenu.cpp index e2478592..ef0e80dc 100644 --- a/src/gui/NodeMenu.cpp +++ b/src/gui/NodeMenu.cpp @@ -235,11 +235,11 @@ NodeMenu::on_save_preset_activated() } void -NodeMenu::on_preset_activated(const std::string& uri) +NodeMenu::on_preset_activated(const URI& uri) { _app->set_property(block()->uri(), _app->uris().pset_preset, - _app->forge().make_urid(URI(uri))); + _app->forge().make_urid(uri)); } bool diff --git a/src/gui/NodeMenu.hpp b/src/gui/NodeMenu.hpp index 2a3268b4..799abef3 100644 --- a/src/gui/NodeMenu.hpp +++ b/src/gui/NodeMenu.hpp @@ -60,7 +60,7 @@ protected: void on_menu_enabled(); void on_menu_randomize(); void on_save_preset_activated(); - void on_preset_activated(const std::string& uri); + void on_preset_activated(const URI& uri); Gtk::MenuItem* _popup_gui_menuitem; Gtk::CheckMenuItem* _embed_gui_menuitem; diff --git a/src/gui/Port.cpp b/src/gui/Port.cpp index 14f87fc1..63e90bdd 100644 --- a/src/gui/Port.cpp +++ b/src/gui/Port.cpp @@ -289,8 +289,8 @@ Port::build_uri_menu() // Add a menu item for each such class for (const auto& v : values) { if (!v.first.empty()) { - const std::string qname = world.rdf_world()->prefixes().qualify(v.second); - const std::string label = qname + " - " + v.first; + const auto qname = world.env().qualify(v.second); + const std::string label = std::string(*qname) + " - " + v.first; menu->items().push_back(Gtk::Menu_Helpers::MenuElem(label)); Gtk::MenuItem* menu_item = &(menu->items().back()); menu_item->signal_activate().connect( diff --git a/src/gui/PropertiesWindow.cpp b/src/gui/PropertiesWindow.cpp index 9912f73a..32ed24e5 100644 --- a/src/gui/PropertiesWindow.cpp +++ b/src/gui/PropertiesWindow.cpp @@ -114,7 +114,8 @@ PropertiesWindow::add_property(const URI& key, const Atom& value) LilvNode* prop = lilv_new_uri(world.lilv_world(), key.c_str()); std::string name = rdfs::label(world, prop); if (name.empty()) { - name = world.rdf_world()->prefixes().qualify(key); + const auto qname = world.env().qualify(key); + name = qname ? std::string(*qname) : key.str(); } Gtk::Label* label = new Gtk::Label( std::string("<a href=\"") + key.string() + "\">" + name + "</a>", diff --git a/src/gui/ingen_gui_lv2.cpp b/src/gui/ingen_gui_lv2.cpp index 4817e9ae..4107d5c0 100644 --- a/src/gui/ingen_gui_lv2.cpp +++ b/src/gui/ingen_gui_lv2.cpp @@ -143,6 +143,7 @@ instantiate(const LV2UI_Descriptor* descriptor, // Set up an engine interface that writes LV2 atoms ui->engine = SPtr<ingen::Interface>( new ingen::AtomWriter( + ui->world->rdf_world(), ui->world->uri_map(), ui->world->uris(), *ui->sink)); ui->world->set_interface(ui->engine); diff --git a/src/gui/wscript b/src/gui/wscript index b33bd31e..2a52849e 100644 --- a/src/gui/wscript +++ b/src/gui/wscript @@ -57,11 +57,10 @@ def build(bld): LILV LV2 RAUL - SIGCPP SERD - SORD - SRATOM + SIGCPP SOUP + SRATOM SUIL WEBKIT ''') @@ -124,4 +123,4 @@ def build(bld): target = 'ingen_gui_lv2', install_path = '${LV2DIR}/ingen.lv2/', use = 'libingen libingen_gui', - uselib = 'LV2 SERD SORD SRATOM LILV RAUL GLIBMM GTKMM') + uselib = 'LV2 SERD SRATOM LILV RAUL GLIBMM GTKMM') diff --git a/src/ingen/ingen.cpp b/src/ingen/ingen.cpp index 15544c10..214e9e01 100644 --- a/src/ingen/ingen.cpp +++ b/src/ingen/ingen.cpp @@ -200,31 +200,26 @@ main(int argc, char** argv) *world, *engine_interface, graph, parent, symbol); } else if (conf.option("server-load").is_valid()) { const char* path = conf.option("server-load").ptr<char>(); - if (serd_uri_string_has_scheme((const uint8_t*)path)) { + if (serd_uri_string_has_scheme(path)) { std::cout << "Loading " << path << " (server side)" << std::endl; engine_interface->copy(URI(path), main_uri()); } else { - SerdNode uri = serd_node_new_file_uri( - (const uint8_t*)path, nullptr, nullptr, true); - std::cout << "Loading " << (const char*)uri.buf - << " (server side)" << std::endl; - engine_interface->copy(URI((const char*)uri.buf), main_uri()); - serd_node_free(&uri); + serd::Node uri = serd::make_file_uri(path); + std::cout << "Loading " << uri << " (server side)" << std::endl; + engine_interface->copy(URI(uri), main_uri()); } } // Save the currently loaded graph if (conf.option("save").is_valid()) { const char* path = conf.option("save").ptr<char>(); - if (serd_uri_string_has_scheme((const uint8_t*)path)) { + if (serd_uri_string_has_scheme(path)) { std::cout << "Saving to " << path << std::endl; engine_interface->copy(main_uri(), URI(path)); } else { - SerdNode uri = serd_node_new_file_uri( - (const uint8_t*)path, nullptr, nullptr, true); - std::cout << "Saving to " << (const char*)uri.buf << std::endl; - engine_interface->copy(main_uri(), URI((const char*)uri.buf)); - serd_node_free(&uri); + serd::Node uri = serd::make_file_uri(path); + std::cout << "Saving to " << uri << std::endl; + engine_interface->copy(main_uri(), URI(uri)); } } @@ -256,8 +251,12 @@ main(int argc, char** argv) } // Save configuration to restore preferences on next run - const std::string path = conf.save( - world->uri_map(), "ingen", "options.ttl", Configuration::GLOBAL); + const std::string path = conf.save(world->rdf_world(), + world->uri_map(), + "ingen", + "options.ttl", + Configuration::GLOBAL); + std::cout << fmt("Saved configuration to %1%\n", path); engine_interface.reset(); diff --git a/src/server/Engine.cpp b/src/server/Engine.cpp index 8256981b..f1a86792 100644 --- a/src/server/Engine.cpp +++ b/src/server/Engine.cpp @@ -68,31 +68,37 @@ INGEN_THREAD_LOCAL unsigned ThreadManager::flags(0); bool ThreadManager::single_threaded(true); Engine::Engine(ingen::World& world) - : _world(world) - , _options(new LV2Options(world.uris())) - , _buffer_factory(new BufferFactory(*this, world.uris())) - , _maid(new Raul::Maid) - , _worker(new Worker(world.log(), event_queue_size())) - , _sync_worker(new Worker(world.log(), event_queue_size(), true)) - , _broadcaster(new Broadcaster()) - , _control_bindings(new ControlBindings(*this)) - , _block_factory(new BlockFactory(world)) - , _undo_stack(new UndoStack(world.uris(), world.uri_map())) - , _redo_stack(new UndoStack(world.uris(), world.uri_map())) - , _post_processor(new PostProcessor(*this)) - , _pre_processor(new PreProcessor(*this)) - , _event_writer(new EventWriter(*this)) - , _interface(_event_writer) - , _atom_interface( - new AtomReader(world.uri_map(), world.uris(), world.log(), *_interface)) - , _root_graph(nullptr) - , _cycle_start_time(0) - , _rand_engine(reinterpret_cast<uintptr_t>(this)) - , _uniform_dist(0.0f, 1.0f) - , _quit_flag(false) - , _reset_load_flag(false) - , _atomic_bundles(world.conf().option("atomic-bundles").get<int32_t>()) - , _activated(false) + : _world(world) + , _options(new LV2Options(world.uris())) + , _buffer_factory(new BufferFactory(*this, world.uris())) + , _maid(new Raul::Maid) + , _worker(new Worker(world.log(), event_queue_size())) + , _sync_worker(new Worker(world.log(), event_queue_size(), true)) + , _broadcaster(new Broadcaster()) + , _control_bindings(new ControlBindings(*this)) + , _block_factory(new BlockFactory(world)) + , _undo_stack(new UndoStack(world.rdf_world(), + world.uris(), + world.uri_map())) + , _redo_stack(new UndoStack(world.rdf_world(), + world.uris(), + world.uri_map())) + , _post_processor(new PostProcessor(*this)) + , _pre_processor(new PreProcessor(*this)) + , _event_writer(new EventWriter(*this)) + , _interface(_event_writer) + , _atom_interface(new AtomReader(world.uri_map(), + world.uris(), + world.log(), + *_interface)) + , _root_graph(nullptr) + , _cycle_start_time(0) + , _rand_engine(reinterpret_cast<uintptr_t>(this)) + , _uniform_dist(0.0f, 1.0f) + , _quit_flag(false) + , _reset_load_flag(false) + , _atomic_bundles(world.conf().option("atomic-bundles").get<int32_t>()) + , _activated(false) { if (!world.store()) { world.set_store(std::make_shared<ingen::Store>()); @@ -125,7 +131,8 @@ Engine::Engine(ingen::World& world) _interface = std::make_shared<Tee>( Tee::Sinks{ _event_writer, - std::make_shared<StreamWriter>(world.uri_map(), + std::make_shared<StreamWriter>(world.rdf_world(), + world.uri_map(), world.uris(), URI("ingen:/engine"), stderr, diff --git a/src/server/Event.hpp b/src/server/Event.hpp index 7da4b955..f5c826b4 100644 --- a/src/server/Event.hpp +++ b/src/server/Event.hpp @@ -133,7 +133,7 @@ protected: } inline bool pre_process_done(Status st, const URI& subject) { - _err_subject = subject; + _err_subject = std::string{subject}; return pre_process_done(st); } diff --git a/src/server/LV2Plugin.cpp b/src/server/LV2Plugin.cpp index 01357d8d..40ba34e7 100644 --- a/src/server/LV2Plugin.cpp +++ b/src/server/LV2Plugin.cpp @@ -68,7 +68,7 @@ LV2Plugin::update_properties() Raul::Symbol LV2Plugin::symbol() const { - std::string working = uri(); + std::string working(uri()); if (working.back() == '/') { working = working.substr(0, working.length() - 1); } diff --git a/src/server/PreProcessor.cpp b/src/server/PreProcessor.cpp index 872302c0..76e0ac73 100644 --- a/src/server/PreProcessor.cpp +++ b/src/server/PreProcessor.cpp @@ -176,8 +176,10 @@ PreProcessor::run() UndoStack& undo_stack = *_engine.undo_stack(); UndoStack& redo_stack = *_engine.redo_stack(); AtomWriter undo_writer( + _engine.world().rdf_world(), _engine.world().uri_map(), _engine.world().uris(), undo_stack); AtomWriter redo_writer( + _engine.world().rdf_world(), _engine.world().uri_map(), _engine.world().uris(), redo_stack); ThreadManager::set_flag(THREAD_PRE_PROCESS); diff --git a/src/server/SocketListener.cpp b/src/server/SocketListener.cpp index b4b50a14..51e07b2b 100644 --- a/src/server/SocketListener.cpp +++ b/src/server/SocketListener.cpp @@ -92,7 +92,7 @@ ingen_listen(Engine* engine, Raul::Socket* unix_sock, Raul::Socket* net_sock) // Bind UNIX socket and create PID-less symbolic link const URI unix_uri(unix_scheme + unix_path); bool make_link = true; - if (!unix_sock->bind(unix_uri) || !unix_sock->listen()) { + if (!unix_sock->bind(unix_uri.str()) || !unix_sock->listen()) { world.log().error("Failed to create UNIX socket\n"); unix_sock->close(); make_link = false; @@ -130,7 +130,7 @@ ingen_listen(Engine* engine, Raul::Socket* unix_sock, Raul::Socket* net_sock) const int port = world.conf().option("engine-port").get<int32_t>(); std::ostringstream ss; ss << "tcp://*:" << port; - if (!net_sock->bind(URI(ss.str())) || !net_sock->listen()) { + if (!net_sock->bind(ss.str()) || !net_sock->listen()) { world.log().error("Failed to create TCP socket\n"); net_sock->close(); } else { diff --git a/src/server/SocketServer.hpp b/src/server/SocketServer.hpp index f3f02a26..86f81d65 100644 --- a/src/server/SocketServer.hpp +++ b/src/server/SocketServer.hpp @@ -43,14 +43,16 @@ public: , _sink(world.conf().option("dump").get<int32_t>() ? SPtr<Interface>( new Tee({SPtr<Interface>(new EventWriter(engine)), - SPtr<Interface>(new StreamWriter(world.uri_map(), + SPtr<Interface>(new StreamWriter(world.rdf_world(), + world.uri_map(), world.uris(), URI("ingen:/engine"), stderr, ColorContext::Color::CYAN))})) : SPtr<Interface>(new EventWriter(engine))) , _reader(new SocketReader(world, *_sink.get(), sock)) - , _writer(new SocketWriter(world.uri_map(), + , _writer(new SocketWriter(world.rdf_world(), + world.uri_map(), world.uris(), URI(sock->uri()), sock)) diff --git a/src/server/UndoStack.cpp b/src/server/UndoStack.cpp index a94617a5..d6829200 100644 --- a/src/server/UndoStack.cpp +++ b/src/server/UndoStack.cpp @@ -23,15 +23,14 @@ #include "lv2/patch/patch.h" #include "lv2/urid/urid.h" #include "serd/serd.h" -#include "sratom/sratom.h" +#include "sratom/sratom.hpp" #include <ctime> +#include <fstream> #include <iterator> #include <memory> -#define NS_RDF (const uint8_t*)"http://www.w3.org/1999/02/22-rdf-syntax-ns#" - -#define USTR(s) ((const uint8_t*)(s)) +#define NS_RDF "http://www.w3.org/1999/02/22-rdf-syntax-ns#" namespace ingen { namespace server { @@ -120,9 +119,9 @@ UndoStack::pop() struct BlankIDs { explicit BlankIDs(char c='b') : c(c) {} - SerdNode get() { + serd::Node get() { snprintf(buf, sizeof(buf), "%c%u", c, n++); - return serd_node_from_string(SERD_BLANK, USTR(buf)); + return serd::make_blank(buf); } char buf[16]{}; @@ -131,126 +130,120 @@ struct BlankIDs { }; struct ListContext { - explicit ListContext(BlankIDs& ids, unsigned flags, const SerdNode* s, const SerdNode* p) - : ids(ids) - , s(*s) - , p(*p) - , flags(flags | SERD_LIST_O_BEGIN) + explicit ListContext(BlankIDs& ids, + serd::StatementFlags flags, + const serd::Node& s, + const serd::Node& p) + : ids(ids) + , s(s) + , p(p) + , flags(flags | serd::StatementFlag::list_O) {} - SerdNode start_node(SerdWriter* writer) { - const SerdNode node = ids.get(); - serd_writer_write_statement(writer, flags, nullptr, &s, &p, &node, nullptr, nullptr); + serd::Node start_node(serd::Writer& writer) { + const serd::Node node = ids.get(); + writer.sink().write(flags, s, p, node); return node; } - void append(SerdWriter* writer, unsigned oflags, const SerdNode* value) { + void append(serd::Writer& writer, + serd::StatementFlags oflags, + const serd::Node& value) + { // s p node - const SerdNode node = start_node(writer); + const serd::Node node = start_node(writer); // node rdf:first value - p = serd_node_from_string(SERD_URI, NS_RDF "first"); - flags = SERD_LIST_CONT; - serd_writer_write_statement(writer, flags|oflags, nullptr, &node, &p, value, nullptr, nullptr); + p = serd::make_uri(NS_RDF "first"); + flags = {}; + writer.sink().write(flags | oflags, node, p, value); - end_node(writer, &node); + end_node(writer, node); } - void end_node(SerdWriter*, const SerdNode* node) { + void end_node(serd::Writer&, const serd::Node& node) { // Prepare for next call: node rdf:rest ... - s = *node; - p = serd_node_from_string(SERD_URI, NS_RDF "rest"); + s = node; + p = serd::make_uri(NS_RDF "rest"); } - void end(SerdWriter* writer) { - const SerdNode nil = serd_node_from_string(SERD_URI, NS_RDF "nil"); - serd_writer_write_statement(writer, flags, nullptr, &s, &p, &nil, nullptr, nullptr); + void end(serd::Writer& writer) { + const serd::Node nil = serd::make_uri(NS_RDF "nil"); + writer.sink().write(flags, s, p, nil); } - BlankIDs& ids; - SerdNode s; - SerdNode p; - unsigned flags; + BlankIDs& ids; + serd::Node s; + serd::Node p; + serd::StatementFlags flags; }; void -UndoStack::write_entry(Sratom* sratom, - SerdWriter* writer, - const SerdNode* const subject, +UndoStack::write_entry(sratom::Streamer& streamer, + serd::Writer& writer, + const serd::Node& subject, const UndoStack::Entry& entry) { char time_str[24]; strftime(time_str, sizeof(time_str), "%FT%T", gmtime(&entry.time)); - // entry rdf:type ingen:UndoEntry - SerdNode p = serd_node_from_string(SERD_URI, USTR(INGEN_NS "time")); - SerdNode o = serd_node_from_string(SERD_LITERAL, USTR(time_str)); - serd_writer_write_statement(writer, SERD_ANON_CONT, nullptr, subject, &p, &o, nullptr, nullptr); + writer.sink().write({}, + subject, + serd::make_uri(INGEN_NS "time"), + serd::make_string(time_str)); - p = serd_node_from_string(SERD_URI, USTR(INGEN_NS "events")); + serd::Node p = serd::make_uri(INGEN_NS "events"); BlankIDs ids('e'); - ListContext ctx(ids, SERD_ANON_CONT, subject, &p); + ListContext ctx(ids, {}, subject, p); for (const LV2_Atom* atom : entry.events) { - const SerdNode node = ctx.start_node(writer); - - p = serd_node_from_string(SERD_URI, NS_RDF "first"); - ctx.flags = SERD_LIST_CONT; - sratom_write(sratom, &_map.urid_unmap_feature()->urid_unmap, SERD_LIST_CONT, - &node, &p, - atom->type, atom->size, LV2_ATOM_BODY_CONST(atom)); + const serd::Node node = ctx.start_node(writer); - ctx.end_node(writer, &node); + p = serd::make_uri(NS_RDF "first"); + ctx.flags = {}; + streamer.write(writer.sink(), node, p, *atom); + ctx.end_node(writer, node); } ctx.end(writer); } void -UndoStack::save(FILE* stream, const char* name) +UndoStack::save(std::ofstream& stream, const char* name) { - SerdEnv* env = serd_env_new(nullptr); - serd_env_set_prefix_from_strings(env, USTR("atom"), USTR(LV2_ATOM_PREFIX)); - serd_env_set_prefix_from_strings(env, USTR("ingen"), USTR(INGEN_NS)); - serd_env_set_prefix_from_strings(env, USTR("patch"), USTR(LV2_PATCH_PREFIX)); - - const SerdNode base = serd_node_from_string(SERD_URI, USTR("ingen:/")); - SerdURI base_uri; - serd_uri_parse(base.buf, &base_uri); - - SerdWriter* writer = serd_writer_new( - SERD_TURTLE, - (SerdStyle)(SERD_STYLE_RESOLVED|SERD_STYLE_ABBREVIATED|SERD_STYLE_CURIED), - env, - &base_uri, - serd_file_sink, - stream); + serd::Env env; + env.set_prefix("atom", LV2_ATOM_PREFIX); + env.set_prefix("ingen", INGEN_NS); + env.set_prefix("patch", LV2_PATCH_PREFIX); + + const serd::Node base = serd::make_uri("ingen:/"); + + serd::Writer writer(_world, + serd::Syntax::Turtle, + {}, + env, + stream); // Configure sratom to write directly to the writer (and thus the socket) - Sratom* sratom = sratom_new(&_map.urid_map_feature()->urid_map); - sratom_set_sink(sratom, - (const char*)base.buf, - (SerdStatementSink)serd_writer_write_statement, - (SerdEndSink)serd_writer_end_anon, - writer); + sratom::Streamer streamer{_world, + _map.urid_map_feature()->urid_map, + _map.urid_unmap_feature()->urid_unmap}; - SerdNode s = serd_node_from_string(SERD_BLANK, (const uint8_t*)name); - SerdNode p = serd_node_from_string(SERD_URI, USTR(INGEN_NS "entries")); + serd::Node s = serd::make_blank(name); + serd::Node p = serd::make_uri(INGEN_NS "entries"); BlankIDs ids('u'); - ListContext ctx(ids, 0, &s, &p); + ListContext ctx(ids, {}, s, p); for (const Entry& e : _stack) { - const SerdNode entry = ids.get(); - ctx.append(writer, SERD_ANON_O_BEGIN, &entry); - write_entry(sratom, writer, &entry, e); - serd_writer_end_anon(writer, &entry); + const serd::Node entry = ids.get(); + ctx.append(writer, serd::StatementFlag::anon_O, entry); + write_entry(streamer, writer, entry, e); + writer.sink().end(entry); } ctx.end(writer); - sratom_free(sratom); - serd_writer_finish(writer); - serd_writer_free(writer); + writer.finish(); } } // namespace server diff --git a/src/server/UndoStack.hpp b/src/server/UndoStack.hpp index 04021b99..7d79e7fc 100644 --- a/src/server/UndoStack.hpp +++ b/src/server/UndoStack.hpp @@ -21,8 +21,7 @@ #include "ingen/ingen.h" #include "lv2/atom/atom.h" #include "lv2/atom/util.h" -#include "serd/serd.h" -#include "sratom/sratom.h" +#include "serd/serd.hpp" #include <cstdint> #include <cstdio> @@ -30,6 +29,9 @@ #include <cstring> #include <ctime> #include <deque> +#include <iosfwd> + +namespace sratom { class Streamer; } namespace ingen { @@ -80,7 +82,10 @@ public: std::deque<LV2_Atom*> events; }; - UndoStack(URIs& uris, URIMap& map) : _uris(uris), _map(map), _depth(0) {} + UndoStack(serd::World& world, URIs& uris, URIMap& map) + : _world(world), _uris(uris), _map(map), _depth(0) + { + } int start_entry(); bool write(const LV2_Atom* msg, int32_t default_id=0) override; @@ -89,17 +94,18 @@ public: bool empty() const { return _stack.empty(); } Entry pop(); - void save(FILE* stream, const char* name="undo"); + void save(std::ofstream& stream, const char* name="undo"); private: bool ignore_later_event(const LV2_Atom* first, const LV2_Atom* second) const; - void write_entry(Sratom* sratom, - SerdWriter* writer, - const SerdNode* subject, - const Entry& entry); + void write_entry(sratom::Streamer& streamer, + serd::Writer& writer, + const serd::Node& subject, + const Entry& entry); + serd::World& _world; URIs& _uris; URIMap& _map; std::deque<Entry> _stack; diff --git a/src/server/events/Copy.cpp b/src/server/events/Copy.cpp index 5418af4b..5ac31f55 100644 --- a/src/server/events/Copy.cpp +++ b/src/server/events/Copy.cpp @@ -131,9 +131,10 @@ Copy::engine_to_engine(PreProcessContext& ctx) } static bool -ends_with(const std::string& str, const std::string& end) +ends_with(const URI& uri, const std::string& end) { - if (str.length() >= end.length()) { + const auto& str = uri.str(); + if (str.length() >= end.length()) { return !str.compare(str.length() - end.length(), end.length(), end); } return false; diff --git a/src/server/events/Delta.cpp b/src/server/events/Delta.cpp index 0a7b05ea..ab751b76 100644 --- a/src/server/events/Delta.cpp +++ b/src/server/events/Delta.cpp @@ -35,6 +35,8 @@ #include "ingen/World.hpp" #include "raul/Maid.hpp" +#include <boost/optional/optional_io.hpp> + #include <mutex> #include <set> #include <string> @@ -364,7 +366,7 @@ Delta::pre_process(PreProcessContext& ctx) _status = Status::BAD_VALUE_TYPE; } } else if (key == uris.pset_preset) { - URI uri; + boost::optional<URI> uri; if (uris.forge.is_uri(value)) { const std::string uri_str = uris.forge.str(value, false); if (URI::is_valid(uri_str)) { @@ -374,9 +376,9 @@ Delta::pre_process(PreProcessContext& ctx) uri = URI(FilePath(value.ptr<char>())); } - if (!uri.empty()) { + if (uri) { op = SpecialType::PRESET; - if ((_state = block->load_preset(uri))) { + if ((_state = block->load_preset(*uri))) { lilv_state_emit_port_values( _state, s_add_set_event, this); } else { diff --git a/src/server/ingen_lv2.cpp b/src/server/ingen_lv2.cpp index 57663344..8a639765 100644 --- a/src/server/ingen_lv2.cpp +++ b/src/server/ingen_lv2.cpp @@ -60,8 +60,7 @@ #include "raul/RingBuffer.hpp" #include "raul/Semaphore.hpp" #include "raul/Symbol.hpp" -#include "serd/serd.h" -#include "sord/sordmm.hpp" +#include "serd/serd.hpp" #include <algorithm> #include <cstdint> @@ -123,7 +122,8 @@ public: engine.world().uris(), engine.world().log(), *engine.world().interface().get()) - , _writer(engine.world().uri_map(), + , _writer(engine.world().rdf_world(), + engine.world().uri_map(), engine.world().uris(), *this) , _from_ui(ui_ring_size(block_length)) @@ -460,11 +460,10 @@ struct IngenPlugin { static Lib::Graphs find_graphs(const URI& manifest_uri) { - Sord::World world; + serd::World world; Parser parser; const std::set<Parser::ResourceRecord> resources = parser.find_resources( - world, manifest_uri, URI(INGEN__Graph)); @@ -512,11 +511,8 @@ ingen_instantiate(const LV2_Descriptor* descriptor, set_bundle_path(bundle_path); const std::string manifest_path = ingen::bundle_file_path("manifest.ttl"); - SerdNode manifest_node = serd_node_new_file_uri( - (const uint8_t*)manifest_path.c_str(), nullptr, nullptr, true); - - Lib::Graphs graphs = find_graphs(URI((const char*)manifest_node.buf)); - serd_node_free(&manifest_node); + serd::Node manifest_node = serd::make_file_uri(manifest_path); + Lib::Graphs graphs = find_graphs(URI(manifest_node)); const LV2Graph* graph = nullptr; for (const auto& g : graphs) { @@ -823,13 +819,9 @@ LV2Graph::LV2Graph(Parser::ResourceRecord record) Lib::Lib(const char* bundle_path) { ingen::set_bundle_path(bundle_path); - const std::string manifest_path = ingen::bundle_file_path("manifest.ttl"); - SerdNode manifest_node = serd_node_new_file_uri( - (const uint8_t*)manifest_path.c_str(), nullptr, nullptr, true); - - graphs = find_graphs(URI((const char*)manifest_node.buf)); - serd_node_free(&manifest_node); + const auto manifest_path = ingen::bundle_file_path("manifest.ttl"); + graphs = find_graphs(serd::make_file_uri(manifest_path.string())); } static void diff --git a/src/server/wscript b/src/server/wscript index 00588915..137b85c9 100644 --- a/src/server/wscript +++ b/src/server/wscript @@ -53,7 +53,7 @@ def build(bld): mix.cpp ''' - core_libs = 'LV2 LILV RAUL SERD SORD SRATOM' + core_libs = 'LV2 LILV RAUL SERD SRATOM' bld(features = 'cxx cxxshlib', source = core_source, diff --git a/src/wscript b/src/wscript index 72c7d48c..39789778 100644 --- a/src/wscript +++ b/src/wscript @@ -41,7 +41,7 @@ def build(bld): vnum = bld.env.INGEN_VERSION, install_path = '${LIBDIR}', lib = lib, - uselib = 'LV2 LILV RAUL SERD SORD SRATOM', + uselib = 'LV2 LILV RAUL SERD SRATOM', cxxflags = (['-fvisibility=hidden'] + bld.env.PTHREAD_CFLAGS + bld.env.INGEN_TEST_CXXFLAGS), linkflags = bld.env.PTHREAD_LINKFLAGS + bld.env.INGEN_TEST_LINKFLAGS) |