summaryrefslogtreecommitdiffstats
path: root/sord
diff options
context:
space:
mode:
Diffstat (limited to 'sord')
-rw-r--r--sord/sord.h27
-rw-r--r--sord/sordmm.hpp504
2 files changed, 531 insertions, 0 deletions
diff --git a/sord/sord.h b/sord/sord.h
index 6b00268..f1169f9 100644
--- a/sord/sord.h
+++ b/sord/sord.h
@@ -22,9 +22,15 @@
#ifndef SORD_SORD_H
#define SORD_SORD_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
#include <stdbool.h>
#include <stdint.h>
+#include "serd/serd.h"
+
#if defined _WIN32 || defined __CYGWIN__
#define SORD_LIB_IMPORT __declspec(dllimport)
#define SORD_LIB_EXPORT __declspec(dllexport)
@@ -330,8 +336,29 @@ sord_read_file_handle(SordModel model,
const SordNode graph,
const uint8_t* blank_prefix);
+SORD_API
+bool
+sord_write_file(SordModel model,
+ SerdEnv env,
+ const uint8_t* uri,
+ const SordNode graph,
+ const uint8_t* blank_prefix);
+
+SORD_API
+bool
+sord_write_file_handle(SordModel model,
+ SerdEnv env,
+ FILE* fd,
+ const uint8_t* base_uri,
+ const SordNode graph,
+ const uint8_t* blank_prefix);
+
/** @} */
/** @} */
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
#endif // SORD_SORD_H
diff --git a/sord/sordmm.hpp b/sord/sordmm.hpp
new file mode 100644
index 0000000..4661458
--- /dev/null
+++ b/sord/sordmm.hpp
@@ -0,0 +1,504 @@
+/* Sord, a lightweight RDF model library.
+ * Copyright 2010-2011 David Robillard <d@drobilla.net>
+ *
+ * Sord is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Sord is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/** @file sordmm.hpp
+ * Public Sord C++ API.
+ */
+
+#ifndef SORD_SORDMM_HPP
+#define SORD_SORDMM_HPP
+
+#include <cassert>
+#include <cstring>
+#include <iostream>
+#include <set>
+#include <string>
+
+#include <boost/utility.hpp>
+#include <glibmm/ustring.h>
+
+#include "serd/serd.h"
+#include "sord/sord.h"
+
+#define SORD_NS_XSD "http://www.w3.org/2001/XMLSchema#"
+
+namespace Sord {
+
+/** C++ wrapper for a Sord object. */
+template <typename T>
+class Wrapper {
+public:
+ inline Wrapper(T c_obj = NULL) : _c_obj(c_obj) {}
+
+ inline T c_obj() { return _c_obj; }
+ inline const T c_obj() const { return _c_obj; }
+
+protected:
+ T _c_obj;
+};
+
+/** Collection of RDF namespaces with prefixes. */
+class Namespaces : public Wrapper<SerdEnv> {
+public:
+ Namespaces() : Wrapper<SerdEnv>(serd_env_new()) {}
+
+ static inline SerdNode string_to_node(SerdType type, const std::string& s) {
+ SerdNode ret = {
+ type, s.length() + 1, s.length(), (const uint8_t*)s.c_str() };
+ return ret;
+ }
+
+ inline void add(const std::string& name,
+ const std::string& uri) {
+ const SerdNode name_node = string_to_node(SERD_LITERAL, name);
+ const SerdNode uri_node = string_to_node(SERD_URI, uri);
+ serd_env_add(_c_obj, &name_node, &uri_node);
+ }
+
+ inline std::string qualify(std::string uri) const {
+ const SerdNode uri_node = string_to_node(SERD_URI, uri);
+ SerdNode prefix;
+ SerdChunk suffix;
+ if (serd_env_qualify(_c_obj, &uri_node, &prefix, &suffix)) {
+ std::string ret((const char*)prefix.buf, prefix.n_bytes - 1);
+ ret.append((const char*)suffix.buf, suffix.len);
+ return ret;
+ }
+ return uri;
+ }
+
+ inline std::string expand(const std::string& curie) const {
+ assert(curie.find(":") != std::string::npos);
+ SerdNode curie_node = string_to_node(SERD_CURIE, curie);
+ SerdChunk uri_prefix;
+ SerdChunk uri_suffix;
+ if (serd_env_expand(_c_obj, &curie_node, &uri_prefix, &uri_suffix)) {
+ std::string ret((const char*)uri_prefix.buf, uri_prefix.len);
+ ret.append((const char*)uri_suffix.buf, uri_suffix.len);
+ return ret;
+ }
+ std::cerr << "CURIE `" << curie << "' has unknown prefix." << std::endl;
+ return curie;
+ }
+};
+
+/** Sord library state. */
+class World : public boost::noncopyable, public Wrapper<SordWorld> {
+public:
+ inline World()
+ : _next_blank_id(0)
+ {
+ _c_obj = sord_world_new();
+ add_prefix("rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#");
+ }
+
+ inline ~World() {
+ sord_world_free(_c_obj);
+ }
+
+ inline uint64_t blank_id() { return _next_blank_id++; }
+
+ inline void add_prefix(const std::string& prefix, const std::string& uri) {
+ _prefixes.add(prefix, uri);
+ }
+
+ inline const Namespaces& prefixes() const { return _prefixes; }
+ inline SordWorld world() { return _c_obj; }
+
+private:
+ Namespaces _prefixes;
+ std::set<std::string> _blank_ids;
+ uint64_t _next_blank_id;
+};
+
+/** An RDF Node (resource, literal, etc)
+ */
+class Node : public Wrapper<SordNode> {
+public:
+ enum Type {
+ UNKNOWN = 0,
+ RESOURCE = SORD_URI,
+ BLANK = SORD_BLANK,
+ LITERAL = SORD_LITERAL
+ };
+
+ inline Node() : Wrapper<SordNode>(NULL), _world(NULL) {}
+
+ inline Node(World& world, Type t, const std::string& s);
+ inline Node(World& world);
+ inline Node(World& world, SordNode node);
+ inline Node(const Node& other);
+ inline ~Node();
+
+ inline Type type() const {
+ return _c_obj ? (Type)sord_node_get_type(_c_obj) : UNKNOWN;
+ }
+
+ inline SordNode get_node() const { return _c_obj; }
+
+ inline bool is_valid() const { return type() != UNKNOWN; }
+
+ inline bool operator<(const Node& other) const {
+ if (type() != other.type()) {
+ return type() < other.type();
+ } else {
+ return to_string() < other.to_string();
+ }
+ }
+
+ const Node& operator=(const Node& other) {
+ if (_c_obj)
+ sord_node_free(_c_obj);
+ _world = other._world;
+ _c_obj = other._c_obj ? sord_node_copy(other._c_obj) : NULL;
+ return *this;
+ }
+
+ inline bool operator==(const Node& other) const {
+ return sord_node_equals(_c_obj, other._c_obj);
+ }
+
+ inline const uint8_t* to_u_string() const;
+ inline const char* to_c_string() const;
+ inline std::string to_string() const;
+
+ inline bool is_literal_type(const char* type_uri) const;
+
+ inline bool is_resource() const { return _c_obj && type() == RESOURCE; }
+ inline bool is_blank() const { return _c_obj && type() == BLANK; }
+ inline bool is_int() const { return is_literal_type(SORD_NS_XSD "integer"); }
+ inline bool is_float() const { return is_literal_type(SORD_NS_XSD "decimal"); }
+ inline bool is_bool() const { return is_literal_type(SORD_NS_XSD "boolean"); }
+
+ inline int to_int() const;
+ inline float to_float() const;
+ inline bool to_bool() const;
+
+ inline static Node blank_id(World& world, const std::string base="b") {
+ const uint64_t num = world.blank_id();
+ std::ostringstream ss;
+ ss << base << num;
+ return Node(world, Node::BLANK, ss.str());
+ }
+
+private:
+ World* _world;
+};
+
+inline std::ostream&
+operator<<(std::ostream& os, const Node& node)
+{
+ return os << node.to_string() << std::endl;
+}
+
+class Resource : public Node {
+public:
+ inline Resource(World& world, const std::string& s) : Node(world, Node::RESOURCE, s) {}
+};
+
+class Curie : public Node {
+public:
+ inline Curie(World& world, const std::string& s)
+ : Node(world, Node::RESOURCE, world.prefixes().expand(s)) {}
+};
+
+class Literal : public Node {
+public:
+ inline Literal(World& world, const std::string& s) : Node(world, Node::LITERAL, s) {}
+};
+
+inline
+Node::Node(World& world, Type type, const std::string& s)
+ : _world(&world)
+{
+ switch (type) {
+ case RESOURCE:
+ assert(s.find(":") == std::string::npos
+ || s.substr(0, 5) == "http:"
+ || s.substr(0, 5) == "file:"
+ || s.substr(0, 4) == "urn:");
+ _c_obj = sord_new_uri(
+ world.world(), (const unsigned char*)s.c_str());
+ break;
+ case LITERAL:
+ _c_obj = sord_new_literal(
+ world.world(), NULL, (const unsigned char*)s.c_str(), NULL);
+ break;
+ case BLANK:
+ _c_obj = sord_new_blank(
+ world.world(), (const unsigned char*)s.c_str());
+ break;
+ default:
+ _c_obj = NULL;
+ }
+
+ assert(this->type() == type);
+}
+
+inline
+Node::Node(World& world)
+ : _world(&world)
+{
+ Node me = blank_id(world);
+ *this = me;
+}
+
+inline
+Node::Node(World& world, SordNode node)
+ : _world(&world)
+{
+ _c_obj = node ? sord_node_copy(node) : NULL;
+}
+
+inline
+Node::Node(const Node& other)
+ : Wrapper<SordNode>()
+ , _world(other._world)
+{
+ if (_world) {
+ _c_obj = other._c_obj ? sord_node_copy(other._c_obj) : NULL;
+ }
+
+ assert((!_c_obj && !other._c_obj) || to_string() == other.to_string());
+}
+
+inline
+Node::~Node()
+{
+ if (_world) {
+ sord_node_free(_c_obj);
+ }
+}
+
+
+inline std::string
+Node::to_string() const
+{
+ return std::string(to_c_string());
+}
+
+
+inline const char*
+Node::to_c_string() const
+{
+ return (const char*)sord_node_get_string(_c_obj);
+}
+
+inline const uint8_t*
+Node::to_u_string() const
+{
+ return sord_node_get_string(_c_obj);
+}
+
+inline bool
+Node::is_literal_type(const char* type_uri) const
+{
+ if (_c_obj && sord_node_get_type(_c_obj) == SORD_LITERAL) {
+ SordNode datatype = sord_node_get_datatype(_c_obj);
+ if (datatype && !strcmp((const char*)sord_node_get_string(datatype),
+ type_uri))
+ return true;
+ }
+ return false;
+}
+
+inline int
+Node::to_int() const
+{
+ assert(is_int());
+ std::locale c_locale("C");
+ std::stringstream ss((const char*)sord_node_get_string(_c_obj));
+ ss.imbue(c_locale);
+ int i = 0;
+ ss >> i;
+ return i;
+}
+
+inline float
+Node::to_float() const
+{
+ assert(is_float());
+ std::locale c_locale("C");
+ std::stringstream ss((const char*)sord_node_get_string(_c_obj));
+ ss.imbue(c_locale);
+ float f = 0.0f;
+ ss >> f;
+ return f;
+}
+
+inline bool
+Node::to_bool() const
+{
+ assert(is_bool());
+ return !strcmp((const char*)sord_node_get_string(_c_obj), "true");
+}
+
+struct Iter : public Wrapper<SordIter> {
+ inline Iter(World& world, SordIter c_obj)
+ : Wrapper<SordIter>(c_obj), _world(world) {}
+ inline ~Iter() { sord_iter_free(_c_obj); }
+ inline bool end() const { return sord_iter_end(_c_obj); }
+ inline bool next() const { return sord_iter_next(_c_obj); }
+ inline Iter& operator++() { assert(!end()); next(); return *this; }
+ inline Node get_subject() const {
+ SordQuad quad;
+ sord_iter_get(_c_obj, quad);
+ return Node(_world, quad[SORD_SUBJECT]);
+ }
+ inline Node get_predicate() const {
+ SordQuad quad;
+ sord_iter_get(_c_obj, quad);
+ return Node(_world, quad[SORD_PREDICATE]);
+ }
+ inline Node get_object() const {
+ SordQuad quad;
+ sord_iter_get(_c_obj, quad);
+ return Node(_world, quad[SORD_OBJECT]);
+ }
+ World& _world;
+};
+
+
+/** An RDF Model (collection of triples).
+ */
+class Model : public boost::noncopyable, public Wrapper<SordModel> {
+public:
+ inline Model(World& world, const Glib::ustring& base_uri=".");
+ inline ~Model();
+
+ inline const Node& base_uri() const { return _base; }
+
+ inline void load_file(const Glib::ustring& uri);
+
+ inline void load_string(const char* str,
+ size_t len,
+ const Glib::ustring& base_uri,
+ const std::string lang = "turtle");
+
+ inline void write_to_file_handle(FILE* fd, const char* lang);
+ inline void write_to_file(const Glib::ustring& uri, const char* lang);
+ inline char* write_to_string(const char* lang);
+
+ inline void add_statement(const Node& subject,
+ const Node& predicate,
+ const Node& object);
+
+ inline Iter find(const Node& subject,
+ const Node& predicate,
+ const Node& object);
+
+ inline World& world() const { return _world; }
+
+private:
+ World& _world;
+ Node _base;
+ SerdWriter _writer;
+ size_t _next_blank_id;
+};
+
+/** Create an empty in-memory RDF model.
+ */
+inline
+Model::Model(World& world, const Glib::ustring& base_uri)
+ : _world(world)
+ , _base(world, Node::RESOURCE, base_uri)
+ , _writer(NULL)
+{
+ // FIXME: parameters
+ _c_obj = sord_new(_world.world(), SORD_SPO|SORD_OPS, true);
+}
+
+inline void
+Model::load_string(const char* str,
+ size_t len,
+ const Glib::ustring& base_uri,
+ const std::string lang)
+{
+ // TODO
+}
+
+inline Model::~Model()
+{
+ sord_free(_c_obj);
+}
+
+inline void
+Model::load_file(const Glib::ustring& data_uri)
+{
+ // FIXME: blank prefix
+ sord_read_file(_c_obj, (const uint8_t*)data_uri.c_str(), NULL,
+ (const uint8_t*)"b");
+}
+
+inline void
+Model::write_to_file_handle(FILE* fd, const char* lang)
+{
+ sord_write_file_handle(_c_obj,
+ _world.prefixes().c_obj(),
+ fd,
+ _base.to_u_string(),
+ NULL,
+ NULL);
+}
+
+inline void
+Model::write_to_file(const Glib::ustring& uri, const char* lang)
+{
+ sord_write_file(_c_obj,
+ _world.prefixes().c_obj(),
+ (const uint8_t*)uri.c_str(),
+ NULL,
+ NULL);
+}
+
+inline char*
+Model::write_to_string(const char* lang)
+{
+ std::cerr << "TODO: serialise" << std::endl;
+ return NULL;
+}
+
+inline void
+Model::add_statement(const Node& subject,
+ const Node& predicate,
+ const Node& object)
+{
+ SordQuad quad = { subject.c_obj(),
+ predicate.c_obj(),
+ object.c_obj(),
+ NULL };
+
+ sord_add(_c_obj, quad);
+}
+
+inline Iter
+Model::find(const Node& subject,
+ const Node& predicate,
+ const Node& object)
+{
+ SordQuad quad = { subject.c_obj(),
+ predicate.c_obj(),
+ object.c_obj(),
+ NULL };
+
+ return Iter(_world, sord_find(_c_obj, quad));
+}
+
+} // namespace Sord
+
+#endif // SORD_SORDMM_HPP
+