diff --git a/Modules/RDF/mitkRdfNode.cpp b/Modules/RDF/mitkRdfNode.cpp index 4652a77682..a4478381ad 100644 --- a/Modules/RDF/mitkRdfNode.cpp +++ b/Modules/RDF/mitkRdfNode.cpp @@ -1,118 +1,119 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #include "mitkRdfNode.h" #include +#include #include #include #include namespace mitk { RdfNode::RdfNode() : m_Type(NOTHING) { } RdfNode::RdfNode(RdfUri uri) : m_Type(URI), m_Value(uri.ToString()) { } RdfNode::RdfNode(std::string text) : m_Type(LITERAL), m_Value(text) { } RdfNode::RdfNode(std::string text, RdfUri dataType) : m_Type(LITERAL), m_Value(text), m_Datatype(dataType) { } RdfNode::~RdfNode() { } void RdfNode::SetType(RdfNode::Type type) { m_Type = type; } void RdfNode::SetDatatype(RdfUri dataType) { m_Datatype = dataType; } void RdfNode::SetValue(std::string value) { m_Value = value; } RdfNode::Type RdfNode::GetType() const { return m_Type; } RdfUri RdfNode::GetDatatype() const { return m_Datatype; } std::string RdfNode::GetValue() const { return m_Value; } bool RdfNode::operator==(const RdfNode &u) const { if (this->m_Type != u.m_Type) return false; if (this->m_Value.compare(u.m_Value) != 0) return false; if (this->m_Datatype != u.m_Datatype) return false; return true; } bool RdfNode::operator!=(const RdfNode &u) const { return !operator==(u); } // Define outstream of a Node std::ostream & operator<<(std::ostream &out, const RdfNode &n) { switch (n.GetType()) { case RdfNode::NOTHING: out << "[]"; break; case RdfNode::URI: if (n.GetValue() == "") { out << "[empty-uri]"; } else { out << "<" << n.GetValue() << ">"; } break; case RdfNode::LITERAL: out << "\"" << n.GetValue() << "\""; if (n.GetDatatype() != RdfUri()) out << "^^" << n.GetDatatype(); break; case RdfNode::BLANK: out << "[blank " << n.GetValue() << "]"; break; } return out; } } diff --git a/Modules/RDF/mitkRdfNode.h b/Modules/RDF/mitkRdfNode.h index b3ebbbdb6c..04f26381c7 100644 --- a/Modules/RDF/mitkRdfNode.h +++ b/Modules/RDF/mitkRdfNode.h @@ -1,114 +1,114 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #ifndef MITKRDFNODE_H #define MITKRDFNODE_H #include #include "mitkRdfUri.h" #include #include namespace mitk { /** * \ingroup MitkRDFModule */ class MITKRDF_EXPORT RdfNode { public: /** * Enumeration for node types. */ enum Type { NOTHING, URI, LITERAL, BLANK }; /** * Construct a empty invalid node. */ RdfNode(); /** * Construct a node from type URI which represents a object of the real world. * @param uri An RdfUri which represents a URI. */ RdfNode(RdfUri uri); /** * Construct a node from type LITERAL. * @param text A std::string which represents a literal. */ RdfNode(std::string text); /** * Construct a node from type LITERAL with a specific data type. * @param text A std::string which represents a literal. * @param dataType An RdfUri which represents a specific data type. */ RdfNode(std::string text, RdfUri dataType); virtual ~RdfNode(); /** * Set the type of a Node. * @param type An RdfNode::Type which represents a type of a node. */ void SetType(Type type); /** * Set the data type of a LITERAL Node. * @param dataType An RdfUri which represents an URI of a specific data type. */ void SetDatatype(RdfUri dataType); /** * Set the internal represantation of an URI or a text. * @param value A std::string which represents an URI or a text. */ void SetValue(std::string value); /** * Get the type of a node. * @return The type of a node. */ Type GetType() const; /** * Get the data type of the internal value of a node. * @return The data type of the internal value of a node. */ RdfUri GetDatatype() const; /** * Get the internal value of a node. * @return The internal value of a node. */ std::string GetValue() const; bool operator==(const RdfNode &u) const; bool operator!=(const RdfNode &u) const; private: Type m_Type; - RdfUri m_Datatype; std::string m_Value; + RdfUri m_Datatype; }; MITKRDF_EXPORT std::ostream & operator<<(std::ostream &out, const mitk::RdfNode &n); } #endif diff --git a/Modules/RDF/mitkRdfStore.cpp b/Modules/RDF/mitkRdfStore.cpp index 4350f363db..8939419e98 100644 --- a/Modules/RDF/mitkRdfStore.cpp +++ b/Modules/RDF/mitkRdfStore.cpp @@ -1,536 +1,536 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #include "mitkRdfStore.h" #include #include #include namespace mitk { class RdfStorePrivate { public: typedef std::map > ResultMap; typedef std::map PrefixMap; RdfStorePrivate(); ~RdfStorePrivate(); void SetBaseUri(RdfUri uri); RdfUri GetBaseUri() const; void AddPrefix(std::string prefix, RdfUri uri); PrefixMap GetPrefixes() const; void CleanUp(); bool Add(RdfTriple triple); bool Remove(RdfTriple triple); bool Contains(RdfTriple triple); ResultMap Query(std::string query) const; void Save(std::string filename, std::string format = ""); void Import(std::string url, std::string format = ""); RdfUri m_BaseUri; PrefixMap m_Prefixes; - librdf_model* m_Model; - librdf_storage* m_Storage; librdf_world* m_World; + librdf_storage* m_Storage; + librdf_model* m_Model; librdf_statement* RdfTripleToStatement(RdfTriple triple) const; librdf_node* RdfNodeToLibRdfNode(RdfNode node) const; librdf_uri* RdfUriToLibRdfUri(RdfUri uri) const; RdfTriple StatementToRdfTriple(librdf_statement* statement) const; RdfNode LibRdfNodeToRdfNode(librdf_node* node) const; RdfUri LibRdfUriToRdfUri(librdf_uri* uri) const; bool CheckComplete(librdf_statement* statement); }; /**************************************************************************** **************************** mitkRdfStorePrivate **************************** ****************************************************************************/ RdfStorePrivate::RdfStorePrivate() : m_World(0), m_Storage(0), m_Model(0) { // SetUp base prefixes m_Prefixes["rdf"] = RdfUri("http://www.w3.org/1999/02/22-rdf-syntax-ns#"); m_Prefixes["rdfs"] = RdfUri("http://www.w3.org/2000/01/rdf-schema#"); m_Prefixes["xsd"] = RdfUri("http://www.w3.org/2001/XMLSchema#"); m_Prefixes["owl"] = RdfUri("http://www.w3.org/2002/07/owl#"); // SetUp new store CleanUp(); } RdfStorePrivate::~RdfStorePrivate() { if(m_Model) librdf_free_model(m_Model); if(m_Storage) librdf_free_storage(m_Storage); if(m_World) librdf_free_world(m_World); } void RdfStorePrivate::SetBaseUri(RdfUri uri) { m_BaseUri = uri; m_Prefixes[""] = RdfUri(m_BaseUri.ToString()); } RdfUri RdfStorePrivate::GetBaseUri() const { return m_BaseUri; } void RdfStorePrivate::AddPrefix(std::string prefix, RdfUri uri) { m_Prefixes[prefix] = uri; } RdfStorePrivate::PrefixMap RdfStorePrivate::GetPrefixes() const { return m_Prefixes; } void RdfStorePrivate::CleanUp() { // CleanUp old Store if there is one if(m_Model) librdf_free_model(m_Model); if(m_Storage) librdf_free_storage(m_Storage); if(m_World) librdf_free_world(m_World); // SetUp new Store m_World = librdf_new_world(); librdf_world_open(m_World); m_Storage = librdf_new_storage(m_World, "memory", 0, 0); if(!m_Storage) { mitkThrow() << "RDF Library Error"; } m_Model = librdf_new_model(m_World, m_Storage, 0); if(!m_Model) { mitkThrow() << "RDF Library Error"; } } bool RdfStorePrivate::Add(RdfTriple triple) { librdf_statement* statement = RdfTripleToStatement(triple); if (!CheckComplete(statement)) { librdf_free_statement(statement); return false; } // Store already contains statement if (Contains(triple)) return true; if (librdf_model_add_statement(m_Model, statement) != 0) { librdf_free_statement(statement); return false; } else { librdf_free_statement(statement); return true; } } bool RdfStorePrivate::Remove(RdfTriple triple) { librdf_statement* statement = RdfTripleToStatement(triple); if (!CheckComplete(statement)) { librdf_free_statement(statement); return false; } // Store does not contain statement if (!Contains(triple)) return true; if (librdf_model_remove_statement(m_Model, statement) != 0) { librdf_free_statement(statement); return false; } else { librdf_free_statement(statement); return true; } return false; } bool RdfStorePrivate::Contains(RdfTriple triple) { librdf_statement* statement = RdfTripleToStatement(triple); // if 0 there is no triple if (librdf_model_contains_statement(m_Model, statement) == 0) { librdf_free_statement(statement); return false; } else { librdf_free_statement(statement); return true; } return false; } RdfStorePrivate::ResultMap RdfStorePrivate::Query(std::string sparqlQuery) const { RdfStorePrivate::ResultMap resultMap; std::string completeQuery; for (PrefixMap::const_iterator i = m_Prefixes.begin(); i != m_Prefixes.end(); i++) { completeQuery += "PREFIX " + i->first + ": " + "<" + i->second.ToString() + "> "; } completeQuery += sparqlQuery; librdf_query* rdfQuery = librdf_new_query(m_World, "sparql", 0, (const unsigned char*) completeQuery.c_str(), 0); if (!rdfQuery) return resultMap; librdf_query_results* results = librdf_query_execute(rdfQuery, m_Model); if (!results) { librdf_free_query(rdfQuery); return resultMap; } if (!librdf_query_results_is_bindings(results)) { librdf_free_query_results(results); librdf_free_query(rdfQuery); return resultMap; } while (!librdf_query_results_finished(results)) { int count = librdf_query_results_get_bindings_count(results); for (int i = 0; i < count; ++i) { const char *name = librdf_query_results_get_binding_name(results, i); if (!name) continue; std::string key = name; std::list list; if(!resultMap[key].empty()) { list = resultMap[key]; } librdf_node *node = librdf_query_results_get_binding_value(results, i); list.push_front(LibRdfNodeToRdfNode(node)); resultMap[key] = list; } librdf_query_results_next(results); } librdf_free_query_results(results); librdf_free_query(rdfQuery); return resultMap; } void RdfStorePrivate::Save(std::string filename, std::string format) { if (format == "") format = "turtle"; librdf_uri* baseUri = RdfUriToLibRdfUri(m_BaseUri); librdf_serializer* s = librdf_new_serializer(m_World, format.c_str(), 0, 0); if(!s) { mitkThrow() << "RDF Library Error"; } for (PrefixMap::const_iterator i = m_Prefixes.begin(); i != m_Prefixes.end(); i++) { librdf_serializer_set_namespace(s, RdfUriToLibRdfUri(i->second), i->first.c_str()); } FILE* f = fopen(filename.c_str(), "w+"); librdf_serializer_serialize_model_to_file_handle(s, f, baseUri, m_Model); librdf_free_serializer(s); librdf_free_uri(baseUri); fclose(f); } void RdfStorePrivate::Import(std::string url, std::string format) { std::string baseUri = m_BaseUri.ToString(); if (baseUri.empty()) { baseUri = url; SetBaseUri(RdfUri(baseUri)); } if (format == "") format= "turtle"; // Redland uses file paths like file:YOURPATH ( Example: file:D:/home/readme.txt ) librdf_uri* uri = librdf_new_uri(m_World, (const unsigned char*) url.c_str()); librdf_uri* libRdfBaseUri = librdf_new_uri(m_World, (const unsigned char*) baseUri.c_str()); librdf_parser* p = librdf_new_parser(m_World, format.c_str(), 0, 0); if(!p) { mitkThrow() << "RDF Library Error"; } if (librdf_parser_parse_into_model(p, uri, libRdfBaseUri, m_Model) != 0 ) { librdf_free_parser(p); MITK_ERROR << "Parsing into Model failed."; return; } int namespaces = librdf_parser_get_namespaces_seen_count(p); for (int i = 0; i < namespaces; i++) { const char* prefixChar = librdf_parser_get_namespaces_seen_prefix(p, i); if ( !prefixChar ) continue; std::string prefix = prefixChar; RdfUri uri = LibRdfUriToRdfUri(librdf_parser_get_namespaces_seen_uri(p, i)); if (uri == RdfUri()) return; RdfStorePrivate::PrefixMap::iterator it = m_Prefixes.find(prefix); // map iterator is equal to iterator-end so it is not already added if (it == m_Prefixes.end()) { AddPrefix(prefix, uri); } } librdf_free_parser(p); } bool RdfStorePrivate::CheckComplete(librdf_statement* statement) { if (librdf_statement_is_complete(statement) != 0) return true; else return false; } librdf_statement* RdfStorePrivate::RdfTripleToStatement(RdfTriple triple) const { librdf_node* subject = RdfNodeToLibRdfNode(triple.GetTripleSubject()); librdf_node* predicate = RdfNodeToLibRdfNode(triple.GetTriplePredicate()); librdf_node* object = RdfNodeToLibRdfNode(triple.GetTripleObject()); librdf_statement* statement = librdf_new_statement_from_nodes(m_World, subject, predicate, object); if(!statement) return 0; return statement; } librdf_node* RdfStorePrivate::RdfNodeToLibRdfNode(RdfNode node) const { librdf_node* newNode = 0; switch (node.GetType()) { case RdfNode::NOTHING: break; case RdfNode::BLANK: newNode = librdf_new_node_from_blank_identifier(m_World, (const unsigned char*) node.GetValue().c_str()); break; case RdfNode::LITERAL: { if (node.GetDatatype() != RdfUri()) { librdf_uri* typeUri = RdfUriToLibRdfUri(node.GetDatatype()); newNode = librdf_new_node_from_typed_literal(m_World, (const unsigned char*) node.GetValue().c_str(), 0, typeUri); } else { newNode = librdf_new_node_from_literal(m_World, (const unsigned char*) node.GetValue().c_str(), 0, 0); } } break; case RdfNode::URI: newNode = librdf_new_node_from_uri( m_World, librdf_new_uri(m_World, (const unsigned char*) node.GetValue().c_str()) ); break; default: break; } return newNode; } librdf_uri* RdfStorePrivate::RdfUriToLibRdfUri(RdfUri uri) const { librdf_uri* libUri = librdf_new_uri(m_World, (const unsigned char*) uri.ToString().c_str()); if (!libUri) return 0; return libUri; } RdfTriple RdfStorePrivate::StatementToRdfTriple(librdf_statement* statement) const { librdf_node *subject = librdf_statement_get_subject(statement); librdf_node *predicate = librdf_statement_get_predicate(statement); librdf_node *object = librdf_statement_get_object(statement); RdfTriple triple(LibRdfNodeToRdfNode(subject), LibRdfNodeToRdfNode(predicate), LibRdfNodeToRdfNode(object)); return triple; } RdfNode RdfStorePrivate::LibRdfNodeToRdfNode(librdf_node* node) const { RdfNode mitkNode; - if (!node) return 0; + if (!node) return mitkNode; if (librdf_node_is_resource(node)) { mitkNode.SetType(RdfNode::URI); librdf_uri *uri = librdf_node_get_uri(node); mitkNode.SetValue(LibRdfUriToRdfUri(uri).ToString()); } else if (librdf_node_is_literal(node)) { mitkNode.SetType(RdfNode::LITERAL); std::string value = (const char*) librdf_node_get_literal_value(node); if (!value.empty()) mitkNode.SetValue(value); librdf_uri* typeUri = librdf_node_get_literal_value_datatype_uri(node); if (typeUri) mitkNode.SetDatatype(LibRdfUriToRdfUri(typeUri)); } else if (librdf_node_is_blank(node)) { mitkNode.SetType(RdfNode::BLANK); std::string str = (const char*) librdf_node_get_blank_identifier(node); if (!str.empty()) mitkNode.SetValue(str); } return mitkNode; } RdfUri RdfStorePrivate::LibRdfUriToRdfUri(librdf_uri* uri) const { std::string str = (const char*) librdf_uri_as_string(uri); if (!str.empty()) return RdfUri(str); return RdfUri(); } /**************************************************************************** ******************************* mitkRdfStore ******************************** ****************************************************************************/ typedef std::map > ResultMap; typedef std::map PrefixMap; RdfStore::RdfStore() :d(new RdfStorePrivate) { } RdfStore::~RdfStore() { delete d; } void RdfStore::SetBaseUri(RdfUri uri) { d->SetBaseUri(uri); } RdfUri RdfStore::GetBaseUri() const { return d->GetBaseUri(); } void RdfStore::AddPrefix(std::string prefix, RdfUri uri) { d->AddPrefix(prefix, uri); } PrefixMap RdfStore::GetPrefixes() const { return d->GetPrefixes(); } void RdfStore::CleanUp() { d->CleanUp(); } bool RdfStore::Add(RdfTriple triple) { return d->Add(triple); } bool RdfStore::Remove(RdfTriple triple) { return d->Remove(triple); } bool RdfStore::Contains(RdfTriple triple) { return d->Contains(triple); } ResultMap RdfStore::Query(std::string query) const { return d->Query(query); } void RdfStore::Save(std::string filename, std::string format) { d->Save(filename, format); } void RdfStore::Import(std::string url, std::string format) { d->Import(url, format); } } // end of namespace mitk diff --git a/Modules/RDF/mitkRdfTriple.cpp b/Modules/RDF/mitkRdfTriple.cpp index 23ef8fcdbe..81f7170e27 100644 --- a/Modules/RDF/mitkRdfTriple.cpp +++ b/Modules/RDF/mitkRdfTriple.cpp @@ -1,92 +1,94 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #include "mitkRdfTriple.h" +#include + namespace mitk { RdfTriple::RdfTriple() { } RdfTriple::RdfTriple(RdfNode subject, RdfNode predicate, RdfNode object) : m_Subject(subject), m_Predicate(predicate), m_Object(object) { } RdfTriple::RdfTriple(RdfNode subject, RdfNode property, std::string value) : m_Subject(subject), m_Predicate(property), m_Object(RdfNode(value)) { } RdfTriple::~RdfTriple() { } void RdfTriple::SetTripleSubject(RdfNode subject) { m_Subject = subject; } void RdfTriple::SetTriplePredicate(RdfNode predicate) { m_Predicate = predicate; } void RdfTriple::SetTripleObject(RdfNode object) { m_Object = object; } void RdfTriple::SetTripleObject(std::string text) { mitk::RdfNode object = mitk::RdfNode(text); m_Object = object; } RdfNode RdfTriple::GetTripleSubject() const { return m_Subject; } RdfNode RdfTriple::GetTriplePredicate() const { return m_Predicate; } RdfNode RdfTriple::GetTripleObject() const { return m_Object; } bool RdfTriple::operator==(const RdfTriple &u) const { if (this->m_Subject != u.m_Subject) return false; if (this->m_Predicate != m_Predicate) return false; if (this->m_Object != u.m_Object) return false; return true; } bool RdfTriple::operator!=(const RdfTriple &u) const { return !operator==(u); } // Define outstream of a Triple std::ostream & operator<<(std::ostream &out, const RdfTriple &t) { return out << "( " << t.GetTripleSubject() << " " << t.GetTriplePredicate() << " " << t.GetTripleObject() << " )"; } } // end of namespace mitk