#ifndef RDF_SESSION_H_
#define RDF_SESSION_H_
#include "rdf_rule_core.h"
#include "rdf_rule_cback.h"
#include "rdf_graph.h"
namespace rdf {
/////////////////////////////////////////////////////////////////////////////////////////
// rdf_session_triple_iterator
//
/////////////////////////////////////////////////////////////////////////////////////////
class rdf_session_triple_iterator {
private:
typedef rdf_graph::iterator iterator_t;
public:
inline rdf_session_triple_iterator(
iterator_t const& meta_itor,
iterator_t const& asserted_itor,
iterator_t const& inferred_itor):
m_meta_itor(meta_itor),
m_asserted_itor(asserted_itor),
m_inferred_itor(inferred_itor)
{};
inline rdf_session_triple_iterator(rdf_session_triple_iterator const& rhs):
m_meta_itor(rhs.m_meta_itor),
m_asserted_itor(rhs.m_asserted_itor),
m_inferred_itor(rhs.m_inferred_itor) {};
inline bool
is_end() const
{
return m_meta_itor.is_end() and m_asserted_itor.is_end() and m_inferred_itor.is_end();
};
inline bool
next()
{
if(m_meta_itor.is_end()) {
if( m_asserted_itor.is_end()) return m_inferred_itor.next();
return m_asserted_itor.next();
}
return m_meta_itor.next();
};
inline triple
get_triple() const
{
if(m_meta_itor.is_end()) {
if( m_asserted_itor.is_end()) return m_inferred_itor.get_triple();
return m_asserted_itor.get_triple();
}
return m_meta_itor.get_triple();
};
private:
iterator_t m_meta_itor;
iterator_t m_asserted_itor;
iterator_t m_inferred_itor;
};
/////////////////////////////////////////////////////////////////////////////////////////
// rdf_session_index_triple_iterator
//
/////////////////////////////////////////////////////////////////////////////////////////
class rdf_session_index_triple_iterator {
private:
typedef rdf_graph::index_iterator iterator_t;
public:
inline rdf_session_index_triple_iterator(
iterator_t const& meta_itor,
iterator_t const& asserted_itor,
iterator_t const& inferred_itor):
m_meta_itor(meta_itor),
m_asserted_itor(asserted_itor),
m_inferred_itor(inferred_itor)
{};
inline rdf_session_index_triple_iterator():
m_meta_itor(),
m_asserted_itor(),
m_inferred_itor()
{};
inline rdf_session_index_triple_iterator(rdf_session_index_triple_iterator const& rhs):
m_meta_itor(rhs.m_meta_itor),
m_asserted_itor(rhs.m_asserted_itor),
m_inferred_itor(rhs.m_inferred_itor)
{};
inline bool
is_end() const
{
return m_meta_itor.is_end() and m_asserted_itor.is_end() and m_inferred_itor.is_end();
};
inline bool
next()
{
if(m_meta_itor.is_end()) {
if( m_asserted_itor.is_end()) return m_inferred_itor.next();
return m_asserted_itor.next();
}
return m_meta_itor.next();
};
inline index_triple
get_triple() const
{
if(m_meta_itor.is_end()) {
if( m_asserted_itor.is_end()) return m_inferred_itor.get_triple();
return m_asserted_itor.get_triple();
}
return m_meta_itor.get_triple();
};
inline index_type*
get_triple_as_array(index_type* t3)const
{
if(m_meta_itor.is_end()) {
if( m_asserted_itor.is_end()) return m_inferred_itor.get_triple_as_array(t3);
return m_asserted_itor.get_triple_as_array(t3);
}
return m_meta_itor.get_triple_as_array(t3);
};
private:
iterator_t m_meta_itor;
iterator_t m_asserted_itor;
iterator_t m_inferred_itor;
};
/////////////////////////////////////////////////////////////////////////////////////////
// rdf_session
//
/////////////////////////////////////////////////////////////////////////////////////////
class rdf_session {
public:
typedef rdf_graph_ptr_type graph_ptr_t;
typedef rdf::var all;
typedef rdf_session_triple_iterator iterator;
typedef rdf_session_index_triple_iterator index_iterator;
inline rdf_session(
unsigned int const pool_size,
unsigned int const inferred_pool_size,
unsigned int const triple_size,
graph_ptr_t const& asserted_graph_p,
graph_ptr_t const& inferred_graph_p):
m_pool_size(pool_size),
m_inferred_pool_size(inferred_pool_size),
m_triple_size(triple_size),
m_asserted_graph_p(asserted_graph_p),
m_inferred_graph_p(inferred_graph_p),
m_meta_graph_p()
{};
inline rdf_session(
unsigned int const pool_size,
unsigned int const inferred_pool_size,
unsigned int const triple_size,
graph_ptr_t const& asserted_graph_p,
graph_ptr_t const& inferred_graph_p,
graph_ptr_t const& meta_graph_p):
m_pool_size(pool_size),
m_inferred_pool_size(inferred_pool_size),
m_triple_size(triple_size),
m_asserted_graph_p(asserted_graph_p),
m_inferred_graph_p(inferred_graph_p),
m_meta_graph_p(meta_graph_p)
{};
inline rdf_session(rdf_session const& rhs):
m_pool_size(rhs.m_pool_size),
m_inferred_pool_size(rhs.m_inferred_pool_size),
m_triple_size(rhs.m_triple_size),
m_asserted_graph_p(rhs.m_asserted_graph_p),
m_inferred_graph_p(rhs.m_inferred_graph_p),
m_meta_graph_p(rhs.m_meta_graph_p)
{};
inline void
set_initial_triple_size(unsigned int triple_size)
{
m_asserted_graph_p->set_initial_triple_size(triple_size);
m_inferred_graph_p->set_initial_triple_size(triple_size);
};
inline void
clear_inferred()
{
m_inferred_graph_p = rdf_graph_ptr_type(new rdf_graph(
m_inferred_pool_size,
m_triple_size,
m_asserted_graph_p->get_resource_map_ptr()));
};
inline void
clear()
{
clear_inferred();
m_asserted_graph_p = rdf_graph_ptr_type(new rdf_graph(
m_pool_size,
m_triple_size,
m_asserted_graph_p->get_resource_map_ptr()));
};
inline unsigned int
size()const
{
return m_meta_graph_p->size() + m_asserted_graph_p->size() + m_inferred_graph_p->size();
};
inline graph_ptr_t
get_asserted_graph()const
{
return m_asserted_graph_p;
};
inline graph_ptr_t
get_inferred_graph()const
{
return m_inferred_graph_p;
};
inline graph_ptr_t
get_meta_graph()const
{
return m_meta_graph_p;
};
/*
* return true if (u, v, w) exist, false otherwise.
*/
inline bool
contains(index_type s, index_type p, index_type o) const
{
return m_meta_graph_p->contains(s, p, o) or
m_asserted_graph_p->contains(s, p, o) or
m_inferred_graph_p->contains(s, p, o);
};
inline bool
contains(index_type s, index_type p, all_objects o) const
{
return m_meta_graph_p->contains(s, p, o) or
m_asserted_graph_p->contains(s, p, o) or
m_inferred_graph_p->contains(s, p, o);
};
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_index_type(s_str), get_index_type(p_str), get_index_type(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(
m_meta_graph_p->find_index(),
m_asserted_graph_p->find_index(),
m_inferred_graph_p->find_index());
};
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(
m_meta_graph_p->find_index(s, all(), all()),
m_asserted_graph_p->find_index(s, all(), all()),
m_inferred_graph_p->find_index(s, all(), all()));
};
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(
m_meta_graph_p->find_index(s, p, all()),
m_asserted_graph_p->find_index(s, p, all()),
m_inferred_graph_p->find_index(s, p, all()));
};
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(
m_meta_graph_p->find_index(all(), p, all()),
m_asserted_graph_p->find_index(all(), p, all()),
m_inferred_graph_p->find_index(all(), p, all()));
};
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(
m_meta_graph_p->find_index(all(), p, o),
m_asserted_graph_p->find_index(all(), p, o),
m_inferred_graph_p->find_index(all(), 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(
m_meta_graph_p->find_index(all(), all(), o),
m_asserted_graph_p->find_index(all(), all(), o),
m_inferred_graph_p->find_index(all(), all(), 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(
m_meta_graph_p->find_index(s, all(), o),
m_asserted_graph_p->find_index(s, all(), o),
m_inferred_graph_p->find_index(s, all(), o));
};
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(
m_meta_graph_p->find(),
m_asserted_graph_p->find(),
m_inferred_graph_p->find());
};
inline iterator
find_all()const
{
return find();
};
inline iterator
find(all_subjects, all_predicates, all_objects)const
{
return find();
};
inline iterator
find(resource const& s, all_predicates, all_objects) const
{
return iterator(
m_meta_graph_p->find(s, all(), all()),
m_asserted_graph_p->find(s, all(), all()),
m_inferred_graph_p->find(s, all(), all()));
};
inline iterator
find(resource const& s, resource const& p, all_objects) const
{
return iterator(
m_meta_graph_p->find(s, p, all()),
m_asserted_graph_p->find(s, p, all()),
m_inferred_graph_p->find(s, p, all()));
};
inline iterator
find(all_subjects, resource const& p, all_objects) const
{
return iterator(
m_meta_graph_p->find(all(), p, all()),
m_asserted_graph_p->find(all(), p, all()),
m_inferred_graph_p->find(all(), p, all()));
};
inline iterator
find(all_subjects, resource const& p, resource const& o) const
{
return iterator(
m_meta_graph_p->find(all(), p, o),
m_asserted_graph_p->find(all(), p, o),
m_inferred_graph_p->find(all(), p, o));
};
inline iterator
find(all_subjects, all_predicates, resource const& o) const
{
return iterator(
m_meta_graph_p->find(all(), all(), o),
m_asserted_graph_p->find(all(), all(), o),
m_inferred_graph_p->find(all(), all(), o));
};
inline iterator
find(resource const& s, all_predicates, resource const& o) const
{
return iterator(
m_meta_graph_p->find(s, all(), o),
m_asserted_graph_p->find(s, all(), o),
m_inferred_graph_p->find(s, all(), o));
};
inline unsigned int
insert(resource const& s, resource const& p, resource const& o)
{
return m_asserted_graph_p->insert(s, p, o);
};
inline unsigned int
insert(index_type s, index_type p, index_type o)
{
return m_asserted_graph_p->insert(s, p, o);
};
inline unsigned int
insert(std::string const& s, std::string const& p, std::string const& o)
{
return m_asserted_graph_p->insert(s, p, o);
};
// 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_inferred_graph_p->get_ref_count(s, p, o);
};
inline unsigned int
insert_inferred(resource const& s, resource const& p, resource const& o)
{
if(m_meta_graph_p->contains(s, p, o)) return 0;
if(m_asserted_graph_p->contains(s, p, o)) return 0;
return m_inferred_graph_p->insert(s, p, o);
};
inline unsigned int
insert_inferred(index_type const s, index_type const p, index_type const o)
{
if(m_meta_graph_p->contains(s, p, o)) return 0;
if(m_asserted_graph_p->contains(s, p, o)) return 0;
return m_inferred_graph_p->insert_internal(s, p, o, true);
};
// same as insert_inferred but don't fire any events back to the rules.
inline unsigned int
insert_inferred_no_events(index_type const s, index_type const p, index_type const o)
{
if(m_meta_graph_p->contains(s, p, o)) return 0;
if(m_asserted_graph_p->contains(s, p, o)) return 0;
return m_inferred_graph_p->insert_internal(s, p, o, false);
};
inline unsigned int
erase(index_type s, index_type p, index_type o)
{
return m_asserted_graph_p->erase(s, p, o) + m_inferred_graph_p->erase(s, p, o);
};
inline void
erase(index_type s, index_type p)
{
m_asserted_graph_p->erase(s, p);
m_inferred_graph_p->erase(s, p);
};
inline unsigned int
erase(std::string const& s, std::string const& p, std::string const& o)
{
return m_asserted_graph_p->erase(s, p, o) + m_inferred_graph_p->erase(s, p, o);
};
inline void
erase(std::string const& s, std::string const& p)
{
m_asserted_graph_p->erase(s, p);
m_inferred_graph_p->erase(s, p);
};
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 unsigned int
retract_inferred(index_type s, index_type p, index_type o)
{
return m_inferred_graph_p->retract(s, p, o);
};
inline unsigned int
retract_inferred(resource const& s, resource const& p, resource const& o)
{
return retract_inferred(s.get_index(), p.get_index(), o.get_index());
};
//// resource ///////////////////////////////////////////////////////////////////////////////////-
// for functional relationship
inline index_type
get_object(index_type s, index_type p)const
{
index_type index = m_meta_graph_p->get_object(s, p);
if(index) return index;
index = m_asserted_graph_p->get_object(s, p);
if(index) return index;
index = m_inferred_graph_p->get_object(s, p);
return NULL;
};
// 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_asserted_graph_p->get_index_type(name);
};
inline index_type
get_index_type(unsigned int key)const
{
return m_asserted_graph_p->get_index_type(key);
};
inline bool
is_resource(std::string const& r_str) const
{
return m_asserted_graph_p->is_resource(r_str);
};
inline resource const&
get_resource(index_type r)const
{
return m_asserted_graph_p->get_resource(r);
};
inline resource const&
get_resource(std::string const& r_str)const
{
return m_asserted_graph_p->get_resource(r_str);
};
inline resource const&
create_resource(std::string const& r_str)
{
return m_asserted_graph_p->create_resource(r_str);
};
inline index_type
create_resource_as_index (std::string const& name)
{
return m_asserted_graph_p->create_resource_as_index(name);
};
//// literal ///////////////////////////////////////////////////////////////////////////////////-
// for functional relationship
inline literal const&
get_literal_object(index_type s, index_type p)const
{
if(m_meta_graph_p->contains(s, p, all_objects())) return m_meta_graph_p->get_literal_object(s, p);
if(m_asserted_graph_p->contains(s, p, all_objects())) return m_asserted_graph_p->get_literal_object(s, p);
if(m_inferred_graph_p->contains(s, p, all_objects())) return m_inferred_graph_p->get_literal_object(s, p);
throw rdf_exception(invalid_index, "ERROR-L1: No literal found for arguments.");
};
// 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_asserted_graph_p->is_literal(r);
};
inline bool
is_literal(std::string const& name) const
{
return m_asserted_graph_p->is_literal(name);
};
inline literal const&
get_literal(index_type r)const
{
return m_asserted_graph_p->get_literal(r);
};
inline literal const&
get_literal(std::string const& r_str)const
{
return m_asserted_graph_p->get_literal(r_str);
};
inline literal const&
create_literal(std::string const& r_str)
{
return m_asserted_graph_p->create_literal(r_str);
};
template<class T>inline literal const&
create_literal(std::string const& r_str, T const& c)
{
return m_asserted_graph_p->create_literal(r_str, c);
};
inline index_type
create_literal_as_index (std::string const& name)
{
return m_asserted_graph_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_asserted_graph_p->create_literal_as_index(name, c);
};
////////////////////////////////////////////////////////////////////////////////////////////////
// string literal
////////////////////////////////////////////////////////////////////////////////////////////////
inline literal const&
create_string_literal(std::string const& data)
{
return m_asserted_graph_p->create_string_literal(data);
};
inline index_type
create_string_literal_as_index(std::string const& data)
{
return m_asserted_graph_p->create_string_literal_as_index(data);
};
inline index_type
get_string_literal(std::string const& data)const
{
return m_asserted_graph_p->get_string_literal(data);
};
////////////////////////////////////////////////////////////////////////////////////////////////
// int literal
////////////////////////////////////////////////////////////////////////////////////////////////
inline literal const&
create_int_literal(int_type data)
{
return m_asserted_graph_p->create_int_literal(data);
};
inline index_type
create_int_literal_as_index(int_type data)
{
return m_asserted_graph_p->create_int_literal_as_index(data);
};
inline index_type
get_int_literal(int_type data)const
{
return m_asserted_graph_p->get_int_literal(data);
};
////////////////////////////////////////////////////////////////////////////////////////////////
// uint literal
////////////////////////////////////////////////////////////////////////////////////////////////
inline literal const&
create_uint_literal(u_int_type data)
{
return m_asserted_graph_p->create_uint_literal(data);
};
inline index_type
create_uint_literal_as_index(u_int_type data)
{
return m_asserted_graph_p->create_uint_literal_as_index(data);
};
inline index_type
get_uint_literal(u_int_type data)const
{
return m_asserted_graph_p->get_uint_literal(data);
};
////////////////////////////////////////////////////////////////////////////////////////////////
// real literal
////////////////////////////////////////////////////////////////////////////////////////////////
inline literal const&
create_real_literal(real_type data)
{
return m_asserted_graph_p->create_real_literal(data);
};
inline index_type
create_real_literal_as_index(real_type data)
{
return m_asserted_graph_p->create_real_literal_as_index(data);
};
inline index_type
get_real_literal(real_type data)const
{
return m_asserted_graph_p->get_real_literal(data);
};
////////////////////////////////////////////////////////////////////////////////////////////////
// date literal
////////////////////////////////////////////////////////////////////////////////////////////////
inline literal const&
create_date_literal(date_type data)
{
return m_asserted_graph_p->create_date_literal(data);
};
inline index_type
create_date_literal_as_index(date_type data)
{
return m_asserted_graph_p->create_date_literal_as_index(data);
};
inline index_type
get_date_literal(date_type data)const
{
return m_asserted_graph_p->get_date_literal(data);
};
////////////////////////////////////////////////////////////////////////////////////////////////
// time literal
////////////////////////////////////////////////////////////////////////////////////////////////
inline literal const&
create_time_literal(time_type data)
{
return m_asserted_graph_p->create_time_literal(data);
};
inline index_type
create_time_literal_as_index(time_type data)
{
return m_asserted_graph_p->create_time_literal_as_index(data);
};
inline index_type
get_time_literal(time_type data)const
{
return m_asserted_graph_p->get_time_literal(data);
};
////////////////////////////////////////////////////////////////////////////////////////////////
// duration literal
////////////////////////////////////////////////////////////////////////////////////////////////
inline literal const&
create_duration_literal(duration_type data)
{
return m_asserted_graph_p->create_duration_literal(data);
};
inline index_type
create_duration_literal_as_index(duration_type data)
{
return m_asserted_graph_p->create_duration_literal_as_index(data);
};
inline index_type
get_duration_literal(duration_type data)const
{
return m_asserted_graph_p->get_duration_literal(data);
};
//// bnode ///////////////////////////////////////////////////////////////////////////////////-
inline bool
is_bnode(index_type r)const
{
return m_asserted_graph_p->is_bnode(r);
};
inline bnode const&
create_bnode()
{
return m_asserted_graph_p->create_bnode();
};
inline index_type
create_bnode_as_index()
{
return m_asserted_graph_p->create_bnode_as_index();
};
inline std::string
get_name(index_type r)const
{
return m_asserted_graph_p->get_name(r);
};
private:
unsigned int m_pool_size;
unsigned int m_inferred_pool_size;
unsigned int m_triple_size;
graph_ptr_t m_asserted_graph_p;
graph_ptr_t m_inferred_graph_p;
graph_ptr_t m_meta_graph_p;
};
typedef std::tr1::shared_ptr<rdf_session> rdf_session_ptr_type;
/////////////////////////////////////////////////////////////////////////////////////////
// create_rdf_session
//
/////////////////////////////////////////////////////////////////////////////////////////
inline rdf_session_ptr_type
create_rdf_session(unsigned int pool_size=50, unsigned int inferred_pool_size=50, unsigned int triple_size=20)
{
internal::resource_base_map_ptr_type resource_map_p (new internal::resource_base_map (pool_size));
rdf_graph_ptr_type asserted_graph_p(new rdf_graph(pool_size, triple_size, resource_map_p));
rdf_graph_ptr_type inferred_graph_p(new rdf_graph(inferred_pool_size, triple_size, resource_map_p));
rdf_session_ptr_type session_p = rdf_session_ptr_type(new rdf_session(pool_size, inferred_pool_size, triple_size, asserted_graph_p, inferred_graph_p));
return session_p;
};
inline rdf_session_ptr_type
create_rdf_session(
rdf_graph_ptr_type const& meta_graph_p,
unsigned int pool_size=50, unsigned int inferred_pool_size=50, unsigned int triple_size=20)
{
internal::resource_base_map_ptr_type resource_map_p(
new internal::resource_base_map(&*meta_graph_p->get_resource_map_ptr(), pool_size)
);
rdf_graph_ptr_type asserted_graph_p(new rdf_graph(pool_size, triple_size, resource_map_p));
rdf_graph_ptr_type inferred_graph_p(new rdf_graph(inferred_pool_size, triple_size, resource_map_p));
rdf_session_ptr_type session_p = rdf_session_ptr_type(new rdf_session(pool_size, inferred_pool_size, triple_size, asserted_graph_p, inferred_graph_p, meta_graph_p));
return session_p;
};
inline rdf_session_ptr_type
create_rdf_session(
rdf_graph_ptr_type const& meta_graph_p,
rdf_graph_ptr_type const& asserted_graph_p,
unsigned int pool_size=50, unsigned int inferred_pool_size=50, unsigned int triple_size=20)
{
rdf_graph_ptr_type inferred_graph_p(new rdf_graph(inferred_pool_size, triple_size, asserted_graph_p->get_resource_map_ptr()));
rdf_session_ptr_type session_p = rdf_session_ptr_type(new rdf_session(pool_size, inferred_pool_size, triple_size, asserted_graph_p, inferred_graph_p, meta_graph_p));
return session_p;
};
}; /*namespace rdf */
#endif /*RDF_SESSION_H_*/
