#ifndef BACKWARD_REASONER_H_
#define BACKWARD_REASONER_H_
#include "rdf_rule_core.h"
namespace rule {
namespace internal {
typedef std::vector<rule_vertex> pkg_rule_vertices_t;
typedef std::tr1::shared_ptr<pkg_rule_vertices_t> pkg_rule_vertices_ptr_t;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// class back_reasoner_mgr
//
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
class back_reasoner_mgr
{
typedef rdf::internal::uv_t uv_t;
typedef rdf::internal::hash_uv hash_uv;
typedef rdf::internal::eq_uv eq_uv;
public:
// =====================================================================================
// Structures for managing backward chaining rules being registered to this mgr
// =====================================================================================
typedef std::tr1::unordered_multimap<index_type , rule_vertex> backw_p_map_t;
typedef std::tr1::unordered_multimap<uv_t, rule_vertex, hash_uv, eq_uv> backw_po_map_t;
typedef backw_p_map_t::const_iterator p_iterator; // map(p, vertex)
typedef backw_po_map_t::const_iterator po_iterator; // map((p,o), vertex)
// =====================================================================================
// Structures for managing list of backward chaining rules to execute
// for given predicate / object.
// Used by rule_term
// They are pakages of root vertices of backward chaining rules fired by rule_term.
// =====================================================================================
typedef std::tr1::unordered_map<index_type , pkg_rule_vertices_ptr_t> pkg_p_map_t;
typedef std::tr1::unordered_map<uv_t, pkg_rule_vertices_ptr_t, hash_uv, eq_uv> pkg_po_map_t;
inline back_reasoner_mgr():
m_backw_all_map(100), // all rules for given predicate
m_backw_p_any_o_map(100), // rules matching (_ p ?o) - object is a variable in the rule expression
m_backw_po_map(100), // rules matching (_ p o) - keyed by predicate and object
m_pkg_p_map(100), // pakage of root vertices of backward chaining rules for given p of rule_term
m_pkg_po_map(100) // like previous member, but for (p o) combo.
{};
// =====================================================================================
// Member functions for managing backward chaining rules being registered to this mgr
// Called by knowledge_base
// =====================================================================================
// register a rule matching (_ p ?o), i.e. object is a variable in the rule
inline void register_backward_chaining_rule(index_type const predicate, rule_vertex const root_vertex)
{
// insert into map of all rules for this predicate
m_backw_all_map.insert (backw_p_map_t::value_type(predicate, root_vertex));
// insert into map of all rules for which the object part is a variable
m_backw_p_any_o_map.insert(backw_p_map_t::value_type(predicate, root_vertex));
};
// register a rule matching (_ p o), i.e. predicate and object are specified in the rule
inline void register_backward_chaining_rule(index_type const predicate, index_type const object, rule_vertex const root_vertex)
{
// insert into map of all rules for this predicate
m_backw_all_map.insert(backw_p_map_t::value_type(predicate, root_vertex));
// insert into map of rules keyed by (p, o)
m_backw_po_map.insert(backw_po_map_t::value_type (uv_t(predicate, object), root_vertex));
};
// =====================================================================================
// Member functions for creating / accessing backw_root_vertices_t
// Called by rule_term
// =====================================================================================
// returns iterator to backward_chaining rule matching (_ p *) (all rules regardless if they have ?o or o in the object part)
inline std::pair<p_iterator, p_iterator> get_all_backw_for_predicate(index_type const predicate)const
{
return m_backw_all_map.equal_range(predicate);
};
// returns iterator to backward_chaining rule matching (_ p ?o)
inline std::pair<p_iterator, p_iterator> get_backw_for_predicate_any_object(index_type const predicate)const
{
return m_backw_p_any_o_map.equal_range(predicate);
};
// returns iterator to backward_chaining rule matching (_ p o) - for specified p and o
inline std::pair<po_iterator, po_iterator> get_backw_for_predicate_object(index_type const predicate, index_type const object)const
{
return m_backw_po_map.equal_range(uv_t(predicate, object));
};
inline pkg_rule_vertices_ptr_t get_root_vertices_for_p(index_type const predicate)const
{
pkg_p_map_t::const_iterator itor = m_pkg_p_map.find(predicate);
if(itor == m_pkg_p_map.end()) return pkg_rule_vertices_ptr_t();
return itor->second;
};
inline pkg_rule_vertices_ptr_t get_root_vertices_for_p(index_type const predicate, index_type const object)const
{
pkg_po_map_t::const_iterator itor = m_pkg_po_map.find(uv_t(predicate, object));
if(itor == m_pkg_po_map.end()) return pkg_rule_vertices_ptr_t();
return itor->second;
};
inline void insert_rule_vertices_for_p(index_type const predicate, pkg_rule_vertices_ptr_t const& backw_p)
{
m_pkg_p_map.insert(pkg_p_map_t::value_type(predicate, backw_p));
};
inline void insert_rule_vertices_for_p(index_type const predicate, index_type const object, pkg_rule_vertices_ptr_t const& backw_p)
{
m_pkg_po_map.insert(pkg_po_map_t::value_type(uv_t(predicate, object), backw_p));
};
private:
backw_p_map_t m_backw_all_map; // all rules for given predicate
backw_p_map_t m_backw_p_any_o_map; // rules matching (_ p ?o) - object is a variable in the rule expression
backw_po_map_t m_backw_po_map; // rules matching (_ p o) - keyed by predicate and object
pkg_p_map_t m_pkg_p_map; // pakage of root vertices of backward chaining rules for given p of rule_term
pkg_po_map_t m_pkg_po_map; // like previous member, but for (p o) combo.
};
}; /* internal namespace */
}; /* rule namespace */
#endif /*BACKWARD_REASONER_H_*/
