#ifndef RDF_GRAPH_H_
#define RDF_GRAPH_H_
#include "rdf_rule_core.h"
#include "rdf_index.h"
#include "rdf_rule_cback.h"
#include "rdf_index.h"
// index required:
// ---------------------------------------------------------------
//
// Considering that generally we have: num(o) > num(s) > num(p)
//
// - index 0: map(s, map(p, set(o))) most common
// - index 1: map(p, map(o, set(s))) common
// - index 2: map(o, map(s, set(p))) least common
//
// All possible query types:
// ---------------------------------------------------------------
//
// - query type 0: ( s, ?p, ?o) use index 0
// - query type 1: (?s, p, ?o) use index 1
// - query type 2: (?s, ?p, o) use index 2
//
// - query type 3: ( s, p, ?o) use index 0
// - query type 4: ( s, ?p, o) use index 2
// - query type 5: (?s, p, o) use index 1
// - query type 6: ( s, p, ?o) use index 0
//
// - query type 7: ( s, p, o) use index 0
//
// String pools requirement:
// ---------------------------------------------------------------
//
// - subject, predicate and object in single pool: map(name, id) and slist(resource_shared_ptr)
// - index above contains id only.
// - Assumption: predicate is never a subject or object in any triples.
//
// Data structure notes:
// ---------------------------------------------------------------
//
// - subjects and objects must co-habit in same container but can be of different
// types: subject are string (or uri), object can be of type uri, string, int, unsigned int,
// long, unsigned long, float, double, and boolean.
// > use the boost::variant type.
//
// - String pools are of structure map(name, id) and map(id, name) can be effectively
// implemented using:
// > boost:multi_index, in particular the bidirectional map
namespace rdf {
class rdf_session;
/////////////////////////////////////////////////////////////////////////////////////////
// class index_triple_iterator
//
/////////////////////////////////////////////////////////////////////////////////////////
class index_triple_iterator {
typedef internal::index_graph::iterator index_graph_iterator_t;
public:
inline index_triple_iterator(char const lookup_, index_graph_iterator_t const& index_itor_):
m_lookup(lookup_),
m_index_itor(index_itor_)
{};
inline index_triple_iterator():
m_lookup('s'),
m_index_itor()
{};
inline index_triple_iterator(index_triple_iterator const& rhs):
m_lookup(rhs.m_lookup),
m_index_itor(rhs.m_index_itor)
{};
inline bool
is_end()const
{
return m_index_itor.is_end();
};
inline bool
next()
{
return m_index_itor.next();
};
inline index_triple
get_triple() const{
index_type s;
index_type p;
index_type o;
internal::lookup_spo(m_lookup, s, p, o, m_index_itor);
return index_triple(s, p, o);
};
inline index_type*
get_triple_as_array(index_type* t3)const{
index_type s;
index_type p;
index_type o;
internal::lookup_spo(m_lookup, s, p, o, m_index_itor);
t3[0] = s; t3[1] = p; t3[2] = o;
return t3;
};
private:
char m_lookup; // case 's' for 'spo' lookup, 'p' for 'pos' lookup, and 'o' for 'osp' lookup
index_graph_iterator_t m_index_itor;
};
/////////////////////////////////////////////////////////////////////////////////////////
// class triple
//
/////////////////////////////////////////////////////////////////////////////////////////
class triple {
public:
inline triple(resource const &s, resource const &p, resource const &o):
m_subject(s),
m_predicate(p),
m_object(o)
{};
inline triple(index_type const s, index_type const p, index_type const o):
m_subject (internal::to_resource(s)),
m_predicate(internal::to_resource(p)),
m_object (internal::to_resource(o))
{};
inline resource const& get_subject() const{return m_subject;};
inline resource const& get_predicate() const{return m_predicate;};
inline resource const& get_object() const{return m_object;};
inline index_type* as_array(index_type* t3)const{
t3[0] = m_subject.get_index();
t3[1] = m_predicate.get_index();
t3[2] = m_object.get_index();
return t3;
};
private:
resource const& m_subject;
resource const& m_predicate;
resource const& m_object;
friend std::ostream& operator<<(std::ostream& out, triple const& t);
};
inline std::ostream& operator<<(std::ostream& out, triple const& t)
{
out << "(" << t.m_subject << ", " << t.m_predicate << ", " << t.m_object << ")";
return out;
};
/////////////////////////////////////////////////////////////////////////////////////////
// class triple_iterator
//
/////////////////////////////////////////////////////////////////////////////////////////
class triple_iterator {
typedef internal::index_graph::iterator index_graph_iterator_t;
public:
inline triple_iterator(
char const lookup_,
index_graph_iterator_t const& index_itor_):
m_lookup(lookup_),
m_index_itor(index_itor_)
{};
inline triple_iterator(triple_iterator const& rhs):
m_lookup(rhs.m_lookup),
m_index_itor(rhs.m_index_itor)
{};
inline bool is_end() const{return m_index_itor.is_end();};
inline bool next() {return m_index_itor.next();};
inline triple get_triple() const{
index_type s;
index_type p;
index_type o;
internal::lookup_spo(m_lookup, s, p, o, m_index_itor);
return triple(s, p, o);
};
private:
char m_lookup; // case 's' for 'spo' lookup, 'p' for 'pos' lookup, and 'o' for 'osp' lookup
index_graph_iterator_t m_index_itor;
};
/////////////////////////////////////////////////////////////////////////////////////////
// class rdf_graph
//
/////////////////////////////////////////////////////////////////////////////////////////
class rdf_graph
{
public:
typedef internal::resource_base_map::resource_ptr_const_iterator resource_ptr_const_iterator;
typedef internal::resource_base_map_ptr_type resource_map_ptr_t;
typedef index_triple_iterator index_iterator;
typedef triple_iterator iterator;
inline rdf_graph(
unsigned int pool_size,
unsigned int triple_size,
resource_map_ptr_t const& resource_map_p):
m_size(0),
m_idx_spo(pool_size),
m_idx_pos(pool_size),
m_idx_osp(pool_size),
m_resource_map_p(resource_map_p)
{
set_initial_triple_size(triple_size);
};
inline rdf_graph(rdf_graph const&rhs):
m_size(rhs.m_size),
m_idx_spo(rhs.m_idx_spo),
m_idx_pos(rhs.m_idx_pos),
m_idx_osp(rhs.m_idx_osp),
m_resource_map_p(rhs.m_resource_map_p)
{};
~rdf_graph(){};
inline void
set_initial_triple_size(unsigned int triple_size)
{
m_idx_spo.set_initial_size(triple_size);
m_idx_pos.set_initial_size(triple_size);
m_idx_osp.set_initial_size(triple_size);
};
inline unsigned int
size()const{return m_size;};
//// utility ///////////////////////////////////////////////////////////////////////////////////-
inline resource_ptr_const_iterator
get_resources_iterator_begin()const
{
return m_resource_map_p->get_resources_iterator_begin();
};
inline resource_ptr_const_iterator
get_resources_iterator_end()const
{
return m_resource_map_p->get_resources_iterator_end();
};
//// contains ///////////////////////////////////////////////////////////////////////////////////-
/*
* return true if (u, v, w) exist, false otherwise.
*/
inline bool
contains(index_type s, index_type p, index_type o) const
{
return m_idx_spo.contains(s, p, o);
};
inline bool
contains(index_type s, index_type p, all_objects) const
{
return m_idx_spo.contains(s, p);
};
inline bool
contains(index_triple t) const
{
return contains(t.get_subject(), t.get_predicate(), t.get_object());
};
inline bool
contains(std::string const& s_str, std::string const& p_str, std::string const& o_str) const
{
if(not is_resource(s_str)) return false;
if(not is_resource(p_str)) return false;
if(not is_resource(o_str)) return false;
return contains(get_resource(s_str), get_resource(p_str), get_resource(o_str));
};
inline bool
contains(std::string const& s_str, std::string const& p_str) const
{
if(not is_resource(s_str)) return false;
if(not is_resource(p_str)) return false;
return contains(get_index_type(s_str), get_index_type(p_str), all_objects());
};
inline bool
contains(resource const& s, resource const& p, resource const& o) const
{
return contains(s.get_index(), p.get_index(), o.get_index());
};
//// find_index ///////////////////////////////////////////////////////////////////////////////////-
///////////////////////////////////////////////////////////////////////////////////////
// find(*, *, *)
///////////////////////////////////////////////////////////////////////////////////////
inline index_iterator
find_index()const
{
return index_iterator('s', m_idx_spo.find());
};
inline index_iterator
find_all_index()const
{
return find_index();
};
inline index_iterator
find_index(all_subjects, all_predicates, all_objects)const
{
return find_index();
};
///////////////////////////////////////////////////////////////////////////////////////
// find(s, *, *)
///////////////////////////////////////////////////////////////////////////////////////
inline index_iterator
find_index(index_type s, all_predicates, all_objects)const
{
return index_iterator('s', m_idx_spo.find(s));
};
inline index_iterator
find_index(std::string const& s, all_predicates p, all_objects o)const
{
if(not is_resource(s)) return index_iterator();
return find_index(get_index_type(s), p, o);
};
///////////////////////////////////////////////////////////////////////////////////////
// find(s, p, *)
///////////////////////////////////////////////////////////////////////////////////////
inline index_iterator
find_index(index_type s, index_type p, all_objects)const
{
return index_iterator('s', m_idx_spo.find(s, p));
};
inline index_iterator
find_index(std::string const& s, std::string const& p, all_objects o)const
{
if(not is_resource(s)) return index_iterator();
if(not is_resource(p)) return index_iterator();
return find_index(get_index_type(s), get_index_type(p), o);
};
///////////////////////////////////////////////////////////////////////////////////////
// find(*, p, *)
///////////////////////////////////////////////////////////////////////////////////////
inline index_iterator
find_index(all_subjects, index_type p, all_objects)const
{
return index_iterator('p', this->m_idx_pos.find(p));
};
inline index_iterator
find_index(all_subjects s, std::string const& p, all_objects o)const
{
if(not is_resource(p)) return index_iterator();
return find_index(s, get_index_type(p), o);
};
///////////////////////////////////////////////////////////////////////////////////////
// find(*, p, o)
///////////////////////////////////////////////////////////////////////////////////////
inline index_iterator
find_index(all_subjects, index_type p, index_type o)const
{
return index_iterator('p', this->m_idx_pos.find(p, o));
};
inline index_iterator
find_index(all_subjects s, std::string const& p, std::string const& o)const
{
if(not is_resource(p)) return index_iterator();
if(not is_resource(o)) return index_iterator();
return find_index(s, get_index_type(p), get_index_type(o));
};
///////////////////////////////////////////////////////////////////////////////////////
// find(*, *, o)
///////////////////////////////////////////////////////////////////////////////////////
inline index_iterator
find_index(all_subjects, all_predicates, index_type o)const
{
return index_iterator('o', this->m_idx_osp.find(o));
};
inline index_iterator
find_index(all_subjects s, all_predicates p, std::string const& o)const
{
if(not is_resource(o)) return index_iterator();
return find_index(s, p, get_index_type(o));
};
///////////////////////////////////////////////////////////////////////////////////////
// find(s, *, o)
///////////////////////////////////////////////////////////////////////////////////////
inline index_iterator
find_index(index_type s, all_predicates, index_type o)const
{
return index_iterator('o', this->m_idx_osp.find(o, s));
};
inline index_iterator
find_index(std::string const& s, all_predicates p, std::string const& o)const
{
if(not is_resource(s)) return index_iterator();
if(not is_resource(o)) return index_iterator();
return find_index(get_index_type(s), p, get_index_type(o));
};
//// count_triples ///////////////////////////////////////////////////////////////////////////////////-
protected:
inline unsigned int
count_triples(index_iterator itor)const
{
unsigned int count = 0;
while(not itor.is_end()) {
count++;
itor.next();
}
return count;
};
public:
///////////////////////////////////////////////////////////////////////////////////////
// count_triples(*, *, *)
///////////////////////////////////////////////////////////////////////////////////////
inline unsigned int
count_triples(all_subjects, all_predicates, all_objects)const
{
return size();
};
///////////////////////////////////////////////////////////////////////////////////////
// count_triples(s, *, *)
///////////////////////////////////////////////////////////////////////////////////////
inline unsigned int
count_triples(index_type s, all_predicates p, all_objects o)const
{
return count_triples(find_index(s, p, o));
};
inline unsigned int
count_triples(std::string const& s, all_predicates p, all_objects o)const
{
if(not is_resource(s)) return 0;
return count_triples(find_index(s, p, o));
};
///////////////////////////////////////////////////////////////////////////////////////
// count_triples(s, p, *)
///////////////////////////////////////////////////////////////////////////////////////
inline unsigned int
count_triples(index_type s, index_type p, all_objects o)const
{
return count_triples(find_index(s, p, o));
};
inline unsigned int
count_triples(std::string const& s, std::string const& p, all_objects o)const
{
if(not is_resource(s)) return 0;
if(not is_resource(p)) return 0;
return count_triples(find_index(s, p, o));
};
///////////////////////////////////////////////////////////////////////////////////////
// count_triples(*, p, *)
///////////////////////////////////////////////////////////////////////////////////////
inline unsigned int
count_triples(all_subjects s, index_type p, all_objects o)const
{
return count_triples(find_index(s, p, o));
};
inline unsigned int
count_triples(all_subjects s, std::string const& p, all_objects o)const
{
if(not is_resource(p)) return 0;
return count_triples(find_index(s, p, o));
};
///////////////////////////////////////////////////////////////////////////////////////
// count_triples(*, p, o)
///////////////////////////////////////////////////////////////////////////////////////
inline unsigned int
count_triples(all_subjects s, index_type p, index_type o)const
{
return count_triples(find_index(s, p, o));
};
inline unsigned int
count_triples(all_subjects s, std::string const& p, std::string const& o)const
{
if(not is_resource(p)) return 0;
if(not is_resource(o)) return 0;
return count_triples(find_index(s, p, o));
};
///////////////////////////////////////////////////////////////////////////////////////
// count_triples(*, *, o)
///////////////////////////////////////////////////////////////////////////////////////
inline unsigned int
count_triples(all_subjects s, all_predicates p, index_type o)const
{
return count_triples(find_index(s, p, o));
};
inline unsigned int
count_triples(all_subjects s, all_predicates p, std::string const& o)const
{
if(not is_resource(o)) return 0;
return count_triples(find_index(s, p, o));
};
///////////////////////////////////////////////////////////////////////////////////////
// count_triples(s, *, o)
///////////////////////////////////////////////////////////////////////////////////////
inline unsigned int
count_triples(index_type s, all_predicates p, index_type o)const
{
return count_triples(find_index(s, p, o));
};
inline unsigned int
count_triples(std::string const& s, all_predicates p, std::string const& o)const
{
if(not is_resource(s)) return 0;
if(not is_resource(o)) return 0;
return count_triples(find_index(s, p, o));
};
//// find ///////////////////////////////////////////////////////////////////////////////////-
inline iterator
find()const
{
return iterator('s', m_idx_spo.find());
};
inline iterator
find_all()const
{
return find();
};
inline iterator
find(resource const& s, all_predicates, all_objects)const
{
return iterator('s', m_idx_spo.find(s.get_index()));
};
inline iterator
find(resource const& s, resource const& p, all_objects)const
{
return iterator('s', m_idx_spo.find(s.get_index(), p.get_index()));
};
inline iterator
find(all_subjects, resource const& p, all_objects)const
{
return iterator('p', m_idx_pos.find(p.get_index()));
};
inline iterator
find(all_subjects, resource const& p, resource const& o)const
{
return iterator('p', m_idx_pos.find(p.get_index(), o.get_index()));
};
inline iterator
find(all_subjects, all_predicates, resource const& o)const
{
return iterator('o', m_idx_osp.find(o.get_index()));
};
inline iterator
find(resource const& s, all_predicates, resource const& o)const
{
return iterator('o', m_idx_osp.find(o.get_index(), s.get_index()));
};
//// insert ///////////////////////////////////////////////////////////////////////////////////-
protected:
inline unsigned int
insert_internal(index_type s, index_type p, index_type o, bool notify_listners=true)
{
// if(m_idx_spo.insert(s, p, o)) {
// m_idx_pos.insert(p, o, s);
// m_idx_osp.insert(o, s, p);
// ++m_size;
// return 1;
// };
// return 0;
bool inserted = m_idx_spo.insert(s, p, o, notify_listners);
m_idx_pos.insert(p, o, s, notify_listners);
m_idx_osp.insert(o, s, p, notify_listners);
if(inserted) {
++m_size;
return 1;
}
return 0;
};
public:
// returns the reference count in the inferred graph.
// used by rule_term to determine if an inferred triple will
// be removed as result of retract call.
inline unsigned int
get_ref_count(index_type s, index_type p, index_type o)const
{
return m_idx_spo.get_ref_count(s, p, o);
};
inline unsigned int
insert(index_type s, index_type p, index_type o)
{
if(!s or !p or !o) throw rdf_exception(invalid_index, "rdf_graph::insert: trying to insert a triple with a null index");
return insert_internal(s, p, o);
};
inline unsigned int
insert(std::string const& s, std::string const& p, std::string const& o)
{
return insert_internal(
create_resource_as_index(s),
create_resource_as_index(p),
create_resource_as_index(o)
);
};
inline unsigned int
insert(resource const& s, resource const& p, resource const& o)
{
return insert_internal(s.get_index(), p.get_index(), o.get_index());
};
//// erase ///////////////////////////////////////////////////////////////////////////////////-
inline void
erase(index_type s, index_type p)
{
index_iterator itor = find_index(s, p, all_objects());
std::vector<index_type> v;
while(not itor.is_end()) {
v.push_back(itor.get_triple().get_object());
itor.next();
}
for(std::vector<index_type>::iterator itor=v.begin(); itor!=v.end(); ++itor)
erase(s, p, *itor);
};
inline void
erase_triples_for(index_type s)
{
index_iterator itor = find_index(s, all_predicates(), all_objects());
std::vector<index_triple> v;
while(not itor.is_end()) {
v.push_back(itor.get_triple());
itor.next();
}
for(std::vector<index_triple>::iterator itor=v.begin(); itor!=v.end(); ++itor)
erase(itor->get_subject(),itor->get_predicate(),itor->get_object());
};
inline unsigned int
erase(index_type s, index_type p, index_type o)
{
// only possible values for count are 0, 1 since cannot have duplicate triples
unsigned int count = m_idx_spo.erase(s, p, o);
if(count > 0) {
m_idx_pos.erase(p, o, s);
m_idx_osp.erase(o, s, p);
--m_size;
}
return count;
};
inline unsigned int
erase(resource const& s, resource const& p, resource const& o)
{
return erase(s.get_index(), p.get_index(), o.get_index());
};
inline void
erase(std::string const& s, std::string const& p)
{
if(not is_resource(s)) return;
if(not is_resource(p)) return;
erase(get_index_type(s), get_index_type(p));
};
inline void
erase_triples_for(std::string const& s)
{
if(not is_resource(s)) return;
erase_triples_for(get_index_type(s));
};
inline unsigned int
erase(std::string const& s, std::string const& p, std::string const& o)
{
if(not is_resource(s)) return 0;
if(not is_resource(p)) return 0;
if(not is_resource(o)) return 0;
return erase(get_index_type(s), get_index_type(p), get_index_type(o));
};
//// retract ///////////////////////////////////////////////////////////////////////////////////-
inline unsigned int
retract(index_type s, index_type p, index_type o)
{
// only possible values for count are 0, 1 since cannot have duplicate triples
unsigned int count = m_idx_spo.retract(s, p, o);
m_idx_pos.retract(p, o, s);
m_idx_osp.retract(o, s, p);
if(count > 0) --m_size;
return count;
};
inline unsigned int
retract(resource const& s, resource const& p, resource const& o)
{
return retract(s.get_index(), p.get_index(), o.get_index());
};
inline unsigned int
retract(std::string const& s, std::string const& p, std::string const& o)
{
if(not is_resource(s)) return 0;
if(not is_resource(p)) return 0;
if(not is_resource(o)) return 0;
return retract(get_index_type(s), get_index_type(p), get_index_type(o));
};
//// call_back_managers ///////////////////////////////////////////////////////////////////////////////////-
inline void
register_call_back_manager(rule::rule_session *session_p, rdf_cback_mgr const& cback_mgr)
{
m_idx_spo.register_call_back_manager(session_p, &cback_mgr.get_spo_cback_mgr());
m_idx_pos.register_call_back_manager(session_p, &cback_mgr.get_pos_cback_mgr());
m_idx_osp.register_call_back_manager(session_p, &cback_mgr.get_osp_cback_mgr());
};
inline void
unregister_call_back_manager()
{
m_idx_spo.unregister_call_back_manager();
m_idx_pos.unregister_call_back_manager();
m_idx_osp.unregister_call_back_manager();
};
inline resource_base const&
get_resource_base(index_type r)const{return internal::to_resource_base(r);};
//// resource ///////////////////////////////////////////////////////////////////////////////////-
// for functional relationship
inline index_type
get_object(index_type s, index_type p)const
{
index_iterator itor = find_index(s, p, all_objects());
if(itor.is_end()) return NULL;
return itor.get_triple().get_object();
};
// for functional relationship
inline index_type
get_object(std::string const& s, std::string const& p)const
{
return get_object(get_index_type(s), get_index_type(p));
};
inline index_type
get_index_type(std::string const& name)const
{
return m_resource_map_p->get_index_type(name);
};
inline index_type
get_index_type(unsigned int key)const
{
return m_resource_map_p->get_index_type(key);
};
inline bool
is_resource(std::string const& name)const
{
return m_resource_map_p->is_resource(name);
};
inline resource const&
get_resource(index_type r)const
{
return internal::to_resource(r);
};
inline resource const&
get_resource(std::string const& name)const
{
return m_resource_map_p->get_resource(name);
};
inline resource const&
create_resource(std::string const& name)
{
return m_resource_map_p->create_resource(name);
};
inline index_type
create_resource_as_index (std::string const& name)
{
return m_resource_map_p->create_resource_as_index(name);
};
//// literal ///////////////////////////////////////////////////////////////////////////////////-
// for functional relationship
inline literal const&
get_literal_object(index_type s, index_type p)const
{
index_iterator itor = find_index(s, p, all_objects());
if(itor.is_end()) throw rdf_exception(invalid_index, "ERROR-L1: No literal found for arguments.");
return get_literal(itor.get_triple().get_object());
};
// for functional relationship
inline literal const&
get_literal_object(std::string const& s, std::string const& p)const
{
return get_literal_object(get_index_type(s), get_index_type(p));
};
inline bool
is_literal(index_type r)const
{
return m_resource_map_p->is_literal(r);
};
inline bool
is_literal(std::string const& name) const
{
return m_resource_map_p->is_literal(name);
};
inline literal const&
get_literal(index_type r)const
{
if(!is_literal(r)) throw rdf_exception(invalid_index, "ERROR-G1: Cannot convert to literal, index_type argument is not a literal.");
return internal::to_literal(r);
};
inline literal const&
get_literal(std::string const& name)const
{
return m_resource_map_p->get_literal(name);
};
inline literal const&
create_literal(std::string const& name)
{
return m_resource_map_p->create_literal(name);
};
template<class T>
inline literal const&
create_literal(std::string const& name, T const& c)
{
return m_resource_map_p->create_literal(name, c);
};
inline index_type
create_literal_as_index(std::string const& name)
{
return m_resource_map_p->create_literal_as_index(name);
};
template<class T>
inline index_type
create_literal_as_index (std::string const& name, T const& c)
{
return m_resource_map_p->create_literal_as_index(name, c);
};
////////////////////////////////////////////////////////////////////////////////////////////////
// string literal
////////////////////////////////////////////////////////////////////////////////////////////////
inline literal const&
create_string_literal(std::string const& data)
{
return m_resource_map_p->create_string_literal(data);
};
inline index_type
create_string_literal_as_index(std::string const& data)
{
return m_resource_map_p->create_string_literal_as_index(data);
};
inline index_type
get_string_literal(std::string const& data)const
{
return m_resource_map_p->get_string_literal(data);
};
////////////////////////////////////////////////////////////////////////////////////////////////
// int literal
////////////////////////////////////////////////////////////////////////////////////////////////
inline literal const&
create_int_literal(int_type data)
{
return m_resource_map_p->create_int_literal(data);
};
inline index_type
create_int_literal_as_index(int_type data)
{
return m_resource_map_p->create_int_literal_as_index(data);
};
inline index_type
get_int_literal(int_type data)const
{
return m_resource_map_p->get_int_literal(data);
};
////////////////////////////////////////////////////////////////////////////////////////////////
// uint literal
////////////////////////////////////////////////////////////////////////////////////////////////
inline literal const&
create_uint_literal(u_int_type data)
{
return m_resource_map_p->create_uint_literal(data);
};
inline index_type
create_uint_literal_as_index(u_int_type data)
{
return m_resource_map_p->create_uint_literal_as_index(data);
};
inline index_type
get_uint_literal(u_int_type data)const
{
return m_resource_map_p->get_uint_literal(data);
};
////////////////////////////////////////////////////////////////////////////////////////////////
// real literal
////////////////////////////////////////////////////////////////////////////////////////////////
inline literal const&
create_real_literal(real_type data)
{
return m_resource_map_p->create_real_literal(data);
};
inline index_type
create_real_literal_as_index(real_type data)
{
return m_resource_map_p->create_real_literal_as_index(data);
};
inline index_type
get_real_literal(real_type data)const
{
return m_resource_map_p->get_real_literal(data);
};
////////////////////////////////////////////////////////////////////////////////////////////////
// date literal
////////////////////////////////////////////////////////////////////////////////////////////////
inline literal const&
create_date_literal(date_type data)
{
return m_resource_map_p->create_date_literal(data);
};
inline index_type
create_date_literal_as_index(date_type data)
{
return m_resource_map_p->create_date_literal_as_index(data);
};
inline index_type
get_date_literal(date_type data)const
{
return m_resource_map_p->get_date_literal(data);
};
////////////////////////////////////////////////////////////////////////////////////////////////
// time literal
////////////////////////////////////////////////////////////////////////////////////////////////
inline literal const&
create_time_literal(time_type data)
{
return m_resource_map_p->create_time_literal(data);
};
inline index_type
create_time_literal_as_index(time_type data)
{
return m_resource_map_p->create_time_literal_as_index(data);
};
inline index_type
get_time_literal(time_type data)const
{
return m_resource_map_p->get_time_literal(data);
};
////////////////////////////////////////////////////////////////////////////////////////////////
// duration literal
////////////////////////////////////////////////////////////////////////////////////////////////
inline literal const&
create_duration_literal(duration_type data)
{
return m_resource_map_p->create_duration_literal(data);
};
inline index_type
create_duration_literal_as_index(duration_type data)
{
return m_resource_map_p->create_duration_literal_as_index(data);
};
inline index_type
get_duration_literal(duration_type data)const
{
return m_resource_map_p->get_duration_literal(data);
};
//// bnode ///////////////////////////////////////////////////////////////////////////////////-
inline bool
is_bnode(index_type r)const
{
return m_resource_map_p->is_bnode(r);
};
inline bnode const&
create_bnode()
{
return m_resource_map_p->create_bnode();
};
inline index_type
create_bnode_as_index()
{
return m_resource_map_p->create_bnode_as_index();
};
// merge bn1 and bn2, keeping bn1 and removing bn2
// there is no consideration for reference count - basically assumed to be 1 (not expected to be used against inferred triples.)
inline void
merge_bnodes(index_type bn1, index_type bn2)
{
if(!is_bnode(bn1) or !is_bnode(bn2)) throw rdf_exception(invalid_index, "ERROR-N1: Requesting to merge bnodes but at least one f the argument is not of type bnode!");
// predicate cannot be bnodes - find all subjects and objects that are bn2
index_type t3[3];
index_iterator itor = find_index(bn2, all_predicates(), all_objects());
while(!itor.is_end()) {
itor.get_triple_as_array(t3);
itor.next();
erase(t3[0], t3[1], t3[2]);
insert_internal(bn1, t3[1], t3[2]==bn2 ? bn1:t3[2]);
}
itor = find_index(all_subjects(), all_predicates(), bn2);
while(!itor.is_end()) {
itor.get_triple_as_array(t3);
itor.next();
erase(t3[0], t3[1], t3[2]);
insert_internal(t3[0]==bn2 ? bn1:t3[0], t3[1], bn1);
}
//* m_resource_map_p->remove_bnode(bn2);
};
// -- ----------------------------------------------------------------------------------------------------
inline std::string
get_name(index_type r)const
{
return r->get_name();
};
inline resource_map_ptr_t
get_resource_map_ptr()const
{
return m_resource_map_p;
};
inline void
enumerate_resources()const
{
m_resource_map_p->enumerate_resources();
};
private:
friend class rdf_session;
unsigned int m_size;
internal::index_graph m_idx_spo;
internal::index_graph m_idx_pos;
internal::index_graph m_idx_osp;
resource_map_ptr_t m_resource_map_p;
};
typedef std::tr1::shared_ptr<rdf_graph> rdf_graph_ptr_type;
/////////////////////////////////////////////////////////////////////////////////////////
// create_rdf_graph
//
/////////////////////////////////////////////////////////////////////////////////////////
inline rdf_graph_ptr_type
create_rdf_graph(unsigned int pool_size=50, unsigned int triple_size=20)
{
internal::resource_base_map_ptr_type resource_map_p (new internal::resource_base_map (pool_size));
return rdf_graph_ptr_type(new rdf_graph(pool_size, triple_size, resource_map_p));
};
inline rdf_graph_ptr_type
create_rdf_graph(internal::resource_base_map_ptr_type meta_resources_p, unsigned int pool_size=50, unsigned int triple_size=20)
{
internal::resource_base_map_ptr_type resource_map_p(
new internal::resource_base_map(&*meta_resources_p, pool_size)
);
return rdf_graph_ptr_type(new rdf_graph(pool_size, triple_size, resource_map_p));
};
inline rdf_graph_ptr_type
create_rdf_graph(rdf_graph_ptr_type meta_graph_p)
{
return create_rdf_graph(meta_graph_p->get_resource_map_ptr());
};
/////////////////////////////////////////////////////////////////////////////////////////
// print_resource_names
//
// utility function
/////////////////////////////////////////////////////////////////////////////////////////
void
print_resource_names(rdf_graph_ptr_type const& graph_p, bool including_literals=false);
}; /*namespace rdf */
#endif /*RDF_GRAPH_H_*/
