diff options
Diffstat (limited to 'serd/serd.hpp')
| -rw-r--r-- | serd/serd.hpp | 1029 |
1 files changed, 1029 insertions, 0 deletions
diff --git a/serd/serd.hpp b/serd/serd.hpp new file mode 100644 index 00000000..bb2d48a1 --- /dev/null +++ b/serd/serd.hpp @@ -0,0 +1,1029 @@ +/* + Copyright 2018 David Robillard <http://drobilla.net> + + Permission to use, copy, modify, and/or distribute this software for any + purpose with or without fee is hereby granted, provided that the above + copyright notice and this permission notice appear in all copies. + + THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +/** + @file serd.hpp C++ API for Serd, a lightweight RDF syntax library. +*/ + +#ifndef SERD_SERD_HPP +#define SERD_SERD_HPP + +#include <serd/serd.h> + +#include <cassert> +#include <memory> +#include <ostream> +#include <type_traits> +#include <utility> + +/** + @defgroup serdxx Serdxx + C++ bindings for Serd, a lightweight RDF syntax library. + @{ +*/ + +namespace serd { + +class Node; + +/** + Return status code. +*/ +enum class Status { + Success = SERD_SUCCESS, /**< No error */ + Failure = SERD_FAILURE, /**< Non-fatal failure */ + ErrUnknown = SERD_ERR_UNKNOWN, /**< Unknown error */ + ErrBadSyntax = SERD_ERR_BAD_SYNTAX, /**< Invalid syntax */ + ErrBadArg = SERD_ERR_BAD_ARG, /**< Invalid argument */ + ErrNotFound = SERD_ERR_NOT_FOUND, /**< Not found */ + ErrIdClash = SERD_ERR_ID_CLASH, /**< Clashing blank node IDs */ + ErrBadCurie = SERD_ERR_BAD_CURIE, /**< Invalid CURIE */ + ErrInternal = SERD_ERR_INTERNAL /**< Unexpected internal error */ +}; + +namespace detail { + +template <typename T> +using FreeFunc = void (*)(T*); + +template <typename T> +using CopyFunc = T* (*)(const T*); + +template <typename T> +void +no_free(T*) +{ +} + +template <typename T> +struct Deleter +{ + Deleter(FreeFunc<T> free_func) : _free_func(free_func) {} + + void operator()(T* ptr) + { + if (_free_func) { + _free_func(ptr); + } + } + + FreeFunc<T> _free_func; +}; + +/** C++ wrapper for a C object. */ +template <typename T, void FreeFunc(T*)> +class Wrapper +{ +public: + using CType = T; + + Wrapper(T* ptr) : _ptr(ptr, Deleter<T>(FreeFunc)) {} + + Wrapper(const T* ptr) : _ptr(const_cast<T*>(ptr), nullptr) {} + + Wrapper(Wrapper&& wrapper) = default; + Wrapper& operator=(Wrapper&& wrapper) = default; + + Wrapper(const Wrapper&) = delete; + Wrapper& operator=(const Wrapper&) = delete; + + bool operator==(const Wrapper&) = delete; + bool operator!=(const Wrapper&) = delete; + + operator const T*() const { return _ptr.get(); } + + inline T* c_obj() { return _ptr.get(); } + inline const T* c_obj() const { return _ptr.get(); } + +protected: + Wrapper(std::nullptr_t) : _ptr(nullptr, nullptr) {} + + std::unique_ptr<T, Deleter<T>> _ptr; +}; + +template <typename T, T* CopyFunc(const T*), void FreeFunc(T*)> +class Copyable : public Wrapper<T, FreeFunc> +{ +public: + Copyable(T* ptr) : Wrapper<T, FreeFunc>(ptr) {} + + Copyable(const T* ptr) : Wrapper<T, FreeFunc>(ptr) {} + + Copyable(const Copyable& wrapper) + : Wrapper<T, FreeFunc>(CopyFunc(wrapper.c_obj())) + { + } + + Copyable(Copyable&&) = default; + Copyable& operator=(Copyable&&) = default; + + Copyable& operator=(const Copyable& wrapper) + { + this->_ptr = std::unique_ptr<T, Deleter<T>>(CopyFunc(wrapper.c_obj()), + FreeFunc); + return *this; + } + +protected: + Copyable(std::nullptr_t) : Wrapper<T, FreeFunc>(nullptr) {} +}; + +template <typename Traits> +size_t +stream_sink(const void* buf, size_t size, size_t nmemb, void* stream) +{ + using Stream = std::basic_ostream<char, Traits>; + + try { + Stream* const s = static_cast<Stream*>(stream); + s->write(static_cast<const char*>(buf), std::streamsize(size * nmemb)); + if (s->good()) { + return nmemb; + } + } catch (...) { + } + return 0; +} + +} // namespace detail + +/** + A simple optional wrapper around a wrapped type with a pointer-like API. + + This works like a typical optional type, but only works with Wrapper types. + The fact that these are interally just pointers is used to avoid adding + space overhead for an "is_set" flag, like a generic optional class would. +*/ +template <typename T> +class Optional +{ +public: + using CType = typename T::CType; + + Optional() : _value() {} + Optional(std::nullptr_t) : _value() {} + Optional(const T& value) : _value(value) {} + Optional(T&& value) : _value(std::move(value)) {} + + Optional(const Optional&) = default; + Optional(Optional&&) = default; + Optional& operator=(const Optional&) = default; + Optional& operator=(Optional&&) = default; + + void reset() { *this = nullptr; } + + const T& operator*() const + { + assert(_value.c_obj()); + return _value; + } + + T& operator*() + { + assert(_value.c_obj()); + return _value; + } + + const T* operator->() const + { + assert(_value.c_obj()); + return &_value; + } + + T* operator->() + { + assert(_value.c_obj()); + return &_value; + } + + bool operator==(const Optional& optional) + { + return (!*this && !optional) || + (*this && optional && _value == optional._value); + } + + bool operator!=(const Optional& optional) { return !operator==(optional); } + + explicit operator bool() const { return _value.c_obj(); } + + bool operator!() const { return !_value.c_obj(); } + + inline CType* ptr() { return _value.c_obj(); } + inline const CType* ptr() const { return _value.c_obj(); } + +private: + T _value; +}; + +/** + A temporary reference to a string. + + This is used as a function parameter type to allow passing either + `std::string` or `const char*` without requiring multiple wrapper + definitions or the copying overhead of `std::string`. +*/ +struct StringRef +{ + StringRef(const char* str) : _ptr(str) {} + StringRef(const std::string& str) : _ptr(str.c_str()) {} + + StringRef(const StringRef&) = delete; + StringRef& operator=(const StringRef&) = delete; + + operator const char*() const { return _ptr; } + +private: + const char* const _ptr; +}; + +using Type = SerdType; +using NodeFlags = SerdNodeFlags; +using StyleFlags = SerdStyleFlags; +using IndexOptions = SerdIndexOptions; +using Field = SerdField; +using StatementFlags = SerdStatementFlags; + +class Statement; + +/** + RDF syntax. +*/ +enum class Syntax { + /** + Turtle - Terse RDF Triple Language (UTF-8). + @see <a href="http://www.w3.org/TeamSubmission/turtle/">Turtle</a> + */ + Turtle = SERD_TURTLE, + + /** + NTriples - Line-based RDF triples (ASCII). + @see <a href="http://www.w3.org/TR/rdf-testcases#ntriples">NTriples</a> + */ + NTriples = SERD_NTRIPLES, + + /** + NQuads - Line-based RDF quads (UTF-8). + @see <a href="https://www.w3.org/TR/n-quads/">NQuads</a> + */ + NQuads = SERD_NQUADS, + + /** + TriG - Terse RDF quads (UTF-8). + @see <a href="https://www.w3.org/TR/trig/">Trig</a> + */ + TriG = SERD_TRIG +}; + +/** + Syntax style options. + + The style of the writer output can be controlled by ORing together + values from this enumeration. Note that some options are only supported + for some syntaxes (e.g. NTriples does not support abbreviation and is + always ASCII). +*/ +enum class Style { + ascii = SERD_STYLE_ASCII, /**< Escape all non-ASCII characters. */ +}; + +inline StyleFlags +operator|(const Style a, const Style b) +{ + return (StyleFlags)(int(a) | int(b)); +} + +inline StyleFlags +operator|(const StyleFlags a, const Style b) +{ + return (StyleFlags)(int(a) | int(b)); +} + +/** + Indexing option. +*/ +enum class IndexOption { + SPO = SERD_SPO, /**< Subject, Predicate, Object */ + SOP = SERD_SOP, /**< Subject, Object, Predicate */ + OPS = SERD_OPS, /**< Object, Predicate, Subject */ + OSP = SERD_OSP, /**< Object, Subject, Predicate */ + PSO = SERD_PSO, /**< Predicate, Subject, Object */ + POS = SERD_POS /**< Predicate, Object, Subject */ +}; + +inline IndexOptions +operator|(const IndexOption a, const IndexOption b) +{ + return (IndexOptions)(int(a) | int(b)); +} + +inline IndexOptions +operator|(const IndexOptions a, const IndexOption b) +{ + return (IndexOptions)(int(a) | int(b)); +} + +/** + @name String Utilities + @{ +*/ + +inline const char* +strerror(const Status status) +{ + return serd_strerror((SerdStatus)status); +} + +/** + @} + @name URI + @{ +*/ + +inline std::string +file_uri_parse(const StringRef& uri, std::string* hostname = nullptr) +{ + char* c_hostname = nullptr; + char* c_path = serd_file_uri_parse(uri, &c_hostname); + if (hostname && c_hostname) { + *hostname = c_hostname; + } + const std::string path(c_path); + free(c_hostname); + free(c_path); + return path; +} + +/** + @} + @name Node + @{ +*/ + +class Node : public detail::Copyable<SerdNode, serd_node_copy, serd_node_free> +{ +public: + explicit Node(SerdNode* ptr) : Copyable(ptr) {} + explicit Node(const SerdNode* ptr) : Copyable(ptr) {} + + Type type() const { return serd_node_get_type(c_obj()); } + const char* c_str() const { return serd_node_get_string(c_obj()); } + std::string str() const { return c_str(); } + size_t size() const { return serd_node_get_length(c_obj()); } + size_t length() const { return serd_node_get_length(c_obj()); } + NodeFlags flags() const { return serd_node_get_flags(c_obj()); } + + Optional<Node> datatype() const + { + return Node(serd_node_get_datatype(c_obj())); + } + + Optional<Node> language() const + { + return Node(serd_node_get_language(c_obj())); + } + + bool operator==(const Node& node) const + { + return serd_node_equals(c_obj(), node.c_obj()); + } + + bool operator!=(const Node& node) const + { + return !serd_node_equals(c_obj(), node.c_obj()); + } + + bool operator<(const Node& node) const + { + return serd_node_compare(c_obj(), node.c_obj()) < 0; + } + + operator std::string() const + { + return std::string(serd_node_get_string(c_obj()), + serd_node_get_length(c_obj())); + } + +private: + friend class Optional<Node>; + Node() : Copyable(nullptr) {} +}; + +inline std::ostream& +operator<<(std::ostream& os, const Node& node) +{ + return os << node.c_str(); +} + +inline Node +make_string(const StringRef& str) +{ + return Node(serd_new_string(str)); +} + +inline Node +make_plain_literal(const StringRef& str, const StringRef& lang) +{ + return Node(serd_new_plain_literal(str, lang)); +} + +inline Node +make_typed_literal(const StringRef& str, const Node& datatype) +{ + return Node(serd_new_typed_literal(str, datatype.c_obj())); +} + +inline Node +make_blank(const StringRef& str) +{ + return Node(serd_new_blank(str)); +} + +inline Node +make_curie(const StringRef& str) +{ + return Node(serd_new_curie(str)); +} + +inline Node +make_uri(const StringRef& str) +{ + return Node(serd_new_uri(str)); +} + +inline Node +make_resolved_uri(const StringRef& str, const Node& base) +{ + return Node(serd_new_resolved_uri(str, base.c_obj())); +} + +// TODO: serd_node_resolve? + +inline Node +make_file_uri(const StringRef& path) +{ + return Node(serd_new_file_uri(path, nullptr)); +} + +inline Node +make_file_uri(const StringRef& path, const StringRef& hostname) +{ + return Node(serd_new_file_uri(path, hostname)); +} + +inline Node +make_relative_uri(const StringRef& str, + const Node& base, + const Optional<Node>& root = {}) +{ + return Node(serd_new_relative_uri(str, base.c_obj(), root.ptr())); +} + +inline Node +make_decimal(double d, + unsigned frac_digits, + const Optional<Node>& datatype = {}) +{ + return Node(serd_new_decimal(d, frac_digits, datatype.ptr())); +} + +inline Node +make_integer(int64_t i, const Optional<Node>& datatype = {}) +{ + return Node(serd_new_integer(i, datatype.ptr())); +} + +inline Node +make_blob(const void* buf, + size_t size, + bool wrap_lines, + const Optional<Node>& datatype = {}) +{ + return Node(serd_new_blob(buf, size, wrap_lines, datatype.ptr())); +} + +/** + @} + @name World + @{ +*/ + +class World : public detail::Wrapper<SerdWorld, serd_world_free> +{ +public: + World() : Wrapper(serd_world_new()) {} + + explicit World(SerdWorld* ptr) : Wrapper(ptr) {} + + Node get_blank() { return Node(serd_world_get_blank(c_obj())); } + + void set_error_sink(SerdErrorSink error_sink, void* handle) + { + serd_world_set_error_sink(c_obj(), error_sink, handle); + } + + // operator SerdWorld*() { return c_obj(); } +}; + +/** + @} + @name Statement + @{ +*/ + +class Statement : public detail::Wrapper<SerdStatement, detail::no_free> +{ +public: + Statement(const SerdStatement* statement) : Wrapper(statement) {} + + Node node(Field field) + { + return Node(serd_statement_get_node(c_obj(), field)); + } + + Node subject() const { return Node(serd_statement_get_subject(c_obj())); } + + Node predicate() const + { + return Node(serd_statement_get_predicate(c_obj())); + } + + Node object() const { return Node(serd_statement_get_object(c_obj())); } + + Node graph() const { return Node(serd_statement_get_graph(c_obj())); } +}; + +/** + @} + @name Sink + @{ +*/ + +class Sink +{ +public: + Sink() + : _sink(serd_sink_new(this), detail::Deleter<SerdSink>(serd_sink_free)) + , _is_user(true) + { + serd_sink_set_base_func(_sink.get(), s_base); + serd_sink_set_prefix_func(_sink.get(), s_prefix); + serd_sink_set_statement_func(_sink.get(), s_statement); + serd_sink_set_end_func(_sink.get(), s_end); + } + + explicit Sink(const SerdSink* ptr) + : _sink(const_cast<SerdSink*>(ptr), detail::Deleter<SerdSink>(nullptr)) + , _is_user(false) + { + } + + virtual ~Sink() = default; + + virtual Status base(const Node& uri) + { + return _is_user ? Status::Success + : Status(serd_sink_set_base(_sink.get(), uri.c_obj())); + } + + virtual Status prefix(const Node& name, const Node& uri) + { + return _is_user ? Status::Success + : Status(serd_sink_set_prefix( + _sink.get(), name.c_obj(), uri.c_obj())); + } + + virtual Status statement(StatementFlags flags, const Statement& statement) + { + return _is_user ? Status::Success + : Status(serd_sink_write_statement( + _sink.get(), flags, statement.c_obj())); + } + + virtual Status nodes(StatementFlags flags, + const Node& subject, + const Node& predicate, + const Node& object, + const Optional<Node>& graph = {}) + { + return _is_user ? Status::Success + : Status(serd_sink_write_nodes(_sink.get(), + flags, + subject.c_obj(), + predicate.c_obj(), + object.c_obj(), + graph.ptr())); + } + + virtual Status end(const Node& node) + { + return _is_user ? Status::Success + : Status(serd_sink_end(_sink.get(), node.c_obj())); + } + + // operator const SerdSink*() const { return _sink.get(); } + // operator SerdSink*() { return _sink.get(); } + + const SerdSink* c_sink() const { return _sink.get(); } + SerdSink* c_sink() { return _sink.get(); } + +private: + static SerdStatus s_base(void* handle, const SerdNode* uri) + { + return (SerdStatus)((Sink*)handle)->base(Node(uri)); + } + + static SerdStatus + s_prefix(void* handle, const SerdNode* name, const SerdNode* uri) + { + return (SerdStatus)((Sink*)handle)->prefix(Node(name), Node(uri)); + } + + static SerdStatus s_statement(void* handle, + SerdStatementFlags flags, + const SerdStatement* statement) + { + return (SerdStatus)((Sink*)handle)->statement(flags, statement); + } + + static SerdStatus s_end(void* handle, const SerdNode* node) + { + return (SerdStatus)((Sink*)handle)->end(Node(node)); + } + + std::unique_ptr<SerdSink, detail::Deleter<SerdSink>> _sink; + bool _is_user; +}; + +/** + @} + @name Environment + @{ +*/ + +class Env : public detail::Copyable<SerdEnv, serd_env_copy, serd_env_free> +{ +public: + explicit Env(const Optional<Node>& base = {}) + : Copyable(serd_env_new(base.ptr())) + { + } + + /// Return the base URI + Node base_uri() const { return Node(serd_env_get_base_uri(c_obj())); } + + /// Set the base URI + Status set_base_uri(const Node& uri) + { + return Status(serd_env_set_base_uri(c_obj(), uri.c_obj())); + } + + /// Set a namespace prefix + Status set_prefix(const Node& name, const Node& uri) + { + return Status(serd_env_set_prefix(c_obj(), name.c_obj(), uri.c_obj())); + } + + /// Set a namespace prefix + Status set_prefix(const StringRef& name, const StringRef& uri) + { + return Status(serd_env_set_prefix_from_strings(c_obj(), name, uri)); + } + + /// Qualify `uri` into a CURIE if possible + Optional<Node> qualify(const Node& uri) const + { + return Node(serd_env_qualify(c_obj(), uri.c_obj())); + } + + /// Expand `node` into an absolute URI if possible + Optional<Node> expand(const Node& node) const + { + return Node(serd_env_expand(c_obj(), node.c_obj())); + } + + /// Send all prefixes to `sink` + void send_prefixes(Sink& sink) + { + serd_env_send_prefixes(c_obj(), sink.c_sink()); + } + + bool operator==(const Env& env) + { + return serd_env_equals(c_obj(), env.c_obj()); + } + + bool operator!=(const Env& env) { return !operator==(env); } + + // operator SerdEnv*() { return c_obj(); } +}; + +/** + @} + @name Reader + @{ +*/ + +class Reader : public detail::Wrapper<SerdReader, serd_reader_free>, public Sink +{ +public: + Reader(World& world, Syntax syntax, const Sink& sink, size_t stack_size) + : Wrapper(serd_reader_new(world.c_obj(), + SerdSyntax(syntax), + sink.c_sink(), + stack_size)) + { + } + + void set_strict(bool strict) { serd_reader_set_strict(c_obj(), strict); } + + void add_blank_prefix(const StringRef& prefix) + { + serd_reader_add_blank_prefix(c_obj(), prefix); + } + + SerdStatus start_file(const StringRef& uri, bool bulk = true) + { + return serd_reader_start_file(c_obj(), uri, bulk); + } + + SerdStatus start_stream(SerdReadFunc read_func, + SerdStreamErrorFunc error_func, + void* stream, + const Node& name, + size_t page_size) + { + return serd_reader_start_stream(c_obj(), + read_func, + error_func, + stream, + name.c_obj(), + page_size); + } + + SerdStatus + start_string(const StringRef& utf8, const Optional<Node>& name = {}) + { + return serd_reader_start_string(c_obj(), utf8, name.ptr()); + } + + SerdStatus read_chunk() { return serd_reader_read_chunk(c_obj()); } + + SerdStatus read_document() { return serd_reader_read_document(c_obj()); } + + SerdStatus finish() { return serd_reader_finish(c_obj()); } +}; + +/** + @} + @name Writer + @{ +*/ + +class ByteSink : public detail::Wrapper<SerdByteSink, serd_byte_sink_free> +{ +public: + ByteSink(SerdWriteFunc sink, void* stream, size_t block_size) + : Wrapper(serd_byte_sink_new(sink, stream, block_size)) + { + } + + template <typename Traits> + ByteSink(std::basic_ostream<char, Traits>& stream) + : Wrapper(serd_byte_sink_new(detail::stream_sink<Traits>, &stream, 1)) + { + } + + // operator SerdByteSink*() { return c_obj(); } +}; + +class Writer : public detail::Wrapper<SerdWriter, serd_writer_free>, public Sink +{ +public: + Writer(World& world, + const Syntax syntax, + const StyleFlags style, + Env& env, + ByteSink& sink) + : Wrapper(serd_writer_new(world.c_obj(), + SerdSyntax(syntax), + style, + env.c_obj(), + (SerdWriteFunc)serd_byte_sink_write, + sink.c_obj())) + , Sink(serd_writer_get_sink(c_obj())) + { + } + + Writer(World& world, + const Syntax syntax, + const StyleFlags style, + Env& env, + SerdWriteFunc write_func, + void* stream) + : Wrapper(serd_writer_new(world.c_obj(), + SerdSyntax(syntax), + style, + env.c_obj(), + write_func, + stream)) + , Sink(serd_writer_get_sink(c_obj())) + { + } + + // FIXME: test + template <typename Traits> + Writer(World& world, + const Syntax syntax, + const StyleFlags style, + Env& env, + std::basic_ostream<char, Traits>& stream) + : Wrapper(serd_writer_new(world.c_obj(), + SerdSyntax(syntax), + style, + env.c_obj(), + detail::stream_sink<Traits>, + &stream)) + , Sink(serd_writer_get_sink(c_obj())) + { + } + + Status set_root_uri(const Node& uri) + { + return Status(serd_writer_set_root_uri(c_obj(), uri.c_obj())); + } + + SerdStatus finish() { return serd_writer_finish(c_obj()); } +}; + +/** + @} +*/ + +class Iter : public detail::Copyable<SerdIter, serd_iter_copy, serd_iter_free> +{ +public: + Iter(SerdIter* i) : Copyable(i) {} + Iter(const SerdIter* i) : Copyable(i) {} + + Iter& operator++() + { + serd_iter_next(c_obj()); + return *this; + } + + Statement operator*() const { return Statement(serd_iter_get(c_obj())); } + + bool operator==(const Iter& i) + { + return serd_iter_equals(c_obj(), i.c_obj()); + } + bool operator!=(const Iter& i) + { + return !serd_iter_equals(c_obj(), i.c_obj()); + } +}; + +class Range + : public detail::Copyable<SerdRange, serd_range_copy, serd_range_free> +{ +public: + Range(SerdRange* r) : Copyable(r) {} + Range(const SerdRange* r) : Copyable(r) {} + + Iter begin() const { return Iter(serd_range_begin(c_obj())); } + Iter end() const { return Iter(serd_range_end(c_obj())); } + + bool operator==(const Range& i) + { + return serd_range_equals(c_obj(), i.c_obj()); + } + bool operator!=(const Range& i) + { + return !serd_range_equals(c_obj(), i.c_obj()); + } +}; + +class Model + : public detail::Copyable<SerdModel, serd_model_copy, serd_model_free> +{ +public: + using value_type = Statement; + using iterator = Iter; + using const_iterator = Iter; + + Model(World& world, SerdIndexOptions indices, SerdModelFlags flags) + : Copyable(serd_model_new(world.c_obj(), indices, flags)) + { + } + + Model(World& world, IndexOption indices, SerdModelFlags flags) + : Copyable(serd_model_new(world.c_obj(), + (SerdIndexOptions)indices, + flags)) + { + } + + size_t size() const { return serd_model_size(c_obj()); } + + bool empty() const { return serd_model_empty(c_obj()); } + + void insert(const Statement& s) + { + serd_model_insert(c_obj(), s.c_obj()); + } + + void insert(const Node& s, + const Node& p, + const Node& o, + const Optional<Node>& g = {}) + { + serd_model_add(c_obj(), s.c_obj(), p.c_obj(), o.c_obj(), g.ptr()); + } + + Iter find(const Optional<Node>& s, + const Optional<Node>& p, + const Optional<Node>& o, + const Optional<Node>& g = {}) + { + return Iter( + serd_model_find(c_obj(), s.ptr(), p.ptr(), o.ptr(), g.ptr())); + } + + Range range(const Optional<Node>& s, + const Optional<Node>& p, + const Optional<Node>& o, + const Optional<Node>& g = {}) + { + return Range( + serd_model_range(c_obj(), s.ptr(), p.ptr(), o.ptr(), g.ptr())); + } + + Optional<Node> get(const Optional<Node>& s, + const Optional<Node>& p, + const Optional<Node>& o, + const Optional<Node>& g = {}) + { + return Node( + serd_model_get(c_obj(), s.ptr(), p.ptr(), o.ptr(), g.ptr())); + } + + bool ask(const Optional<Node>& s, + const Optional<Node>& p, + const Optional<Node>& o, + const Optional<Node>& g = {}) const + { + return serd_model_ask(c_obj(), s.ptr(), p.ptr(), o.ptr(), g.ptr()); + } + + bool operator==(const Model& model) const + { + return serd_model_equals(c_obj(), model.c_obj()); + } + + bool operator!=(const Model& model) const + { + return !serd_model_equals(c_obj(), model.c_obj()); + } + + Range all() const { return Range(serd_model_all(c_obj())); } + + iterator begin() const { return iterator(serd_model_begin(c_obj())); } + + iterator end() const { return iterator(serd_model_end(c_obj())); } + + // operator SerdModel*() { return c_obj(); } +}; + +class Inserter : public detail::Wrapper<SerdInserter, serd_inserter_free>, + public Sink +{ +public: + Inserter(Model& model, Env& env, const Optional<Node>& default_graph = {}) + : Wrapper(serd_inserter_new(model.c_obj(), + env.c_obj(), + default_graph.ptr())) + , Sink(serd_inserter_get_sink(c_obj())) + { + } +}; + +} // namespace serd + +/** + @} +*/ + +#endif /* SERD_SERD_HPP */ |