#ifndef PY_KNOWLEDGE_BASE_H_
#define PY_KNOWLEDGE_BASE_H_
#include "py_rule_module.h"
#include "knowledge_base.h"
#include "owl_import.h"
#include "kb_parser.h"
#include "kb_term_builder.h"
BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(create_knowledge_rule_overloads, create_knowledge_rule, 2, 3);
/////////////////////////////////////////////////////////////////////////////////////////
// knowledge_rule::set_head_term template
//
/////////////////////////////////////////////////////////////////////////////////////////
inline rule::kterm_ptr_type
set_head_term_str(rule::knowledge_rule * rule_p, std::string const& s, rdf::resource const& p, std::string const& o)
{
return rule_p->set_head_term(s, p.get_index(), o);
};
inline rule::kterm_ptr_type
set_head_term_idx(rule::knowledge_rule * rule_p, std::string const& s, rdf::resource const& p, rdf::resource const& o)
{
return rule_p->set_head_term(s, p.get_index(), o.get_index());
};
inline rule::kterm_ptr_type
set_head_term_xpr(rule::knowledge_rule * rule_p, std::string const& s, rdf::resource const& p, rule::internal::expression_term_ptr_type const& o)
{
return rule_p->set_head_term(s, p.get_index(), o);
};
/////////////////////////////////////////////////////////////////////////////////////////
// knowledge_rule::add_rule_term templates
//
/////////////////////////////////////////////////////////////////////////////////////////
inline rule::kterm_ptr_type
add_rule_term_x1(rule::knowledge_rule * rule_p, rdf::resource const& s, rdf::resource const& p, std::string const& o)
{
return rule_p->add_rule_term(s.get_index(), p.get_index(), o);
};
inline rule::kterm_ptr_type
add_rule_term_x2(rule::knowledge_rule * rule_p, rdf::resource const& s, std::string const& p, rdf::resource const& o)
{
return rule_p->add_rule_term(s.get_index(), p, o.get_index());
};
inline rule::kterm_ptr_type
add_rule_term_x3(rule::knowledge_rule * rule_p, rdf::resource const& s, std::string const& p, std::string const& o)
{
return rule_p->add_rule_term(s.get_index(), p, o);
};
inline rule::kterm_ptr_type
add_rule_term_x4(rule::knowledge_rule * rule_p, std::string const& s, rdf::resource const& p, rdf::resource const& o)
{
return rule_p->add_rule_term(s, p.get_index(), o.get_index());
};
inline rule::kterm_ptr_type
add_rule_term_x5(rule::knowledge_rule * rule_p, std::string const& s, rdf::resource const& p, std::string const& o)
{
return rule_p->add_rule_term(s, p.get_index(), o);
};
inline rule::kterm_ptr_type
add_rule_term_x6(rule::knowledge_rule * rule_p, std::string const& s, std::string const& p, rdf::resource const& o)
{
return rule_p->add_rule_term(s, p, o.get_index());
};
inline rule::kterm_ptr_type
add_rule_term_x7(rule::knowledge_rule * rule_p, std::string const& s, std::string const& p, std::string const& o)
{
return rule_p->add_rule_term(s, p, o);
};
/////////////////////////////////////////////////////////////////////////////////////////
// knowledge_rule::add_negated_rule_term templates
//
/////////////////////////////////////////////////////////////////////////////////////////
inline rule::kterm_ptr_type
add_negated_rule_term_x1(rule::knowledge_rule * rule_p, rdf::resource const& s, rdf::resource const& p, std::string const& o)
{
return rule_p->add_negated_rule_term(s.get_index(), p.get_index(), o);
};
inline rule::kterm_ptr_type
add_negated_rule_term_x2(rule::knowledge_rule * rule_p, rdf::resource const& s, std::string const& p, rdf::resource const& o)
{
return rule_p->add_negated_rule_term(s.get_index(), p, o.get_index());
};
inline rule::kterm_ptr_type
add_negated_rule_term_x3(rule::knowledge_rule * rule_p, rdf::resource const& s, std::string const& p, std::string const& o)
{
return rule_p->add_negated_rule_term(s.get_index(), p, o);
};
inline rule::kterm_ptr_type
add_negated_rule_term_x4(rule::knowledge_rule * rule_p, std::string const& s, rdf::resource const& p, rdf::resource const& o)
{
return rule_p->add_negated_rule_term(s, p.get_index(), o.get_index());
};
inline rule::kterm_ptr_type
add_negated_rule_term_x5(rule::knowledge_rule * rule_p, std::string const& s, rdf::resource const& p, std::string const& o)
{
return rule_p->add_negated_rule_term(s, p.get_index(), o);
};
inline rule::kterm_ptr_type
add_negated_rule_term_x6(rule::knowledge_rule * rule_p, std::string const& s, std::string const& p, rdf::resource const& o)
{
return rule_p->add_negated_rule_term(s, p, o.get_index());
};
inline rule::kterm_ptr_type
add_negated_rule_term_x7(rule::knowledge_rule * rule_p, std::string const& s, std::string const& p, std::string const& o)
{
return rule_p->add_negated_rule_term(s, p, o);
};
/////////////////////////////////////////////////////////////////////////////////////////
// knowledge_rule::add_consequent_term templates
//
/////////////////////////////////////////////////////////////////////////////////////////
inline rule::kterm_ptr_type
add_consequent_term_x1(rule::knowledge_rule * rule_p, rdf::resource const& s, rdf::resource const& p, std::string const& o)
{
return rule_p->add_consequent_term(s.get_index(), p.get_index(), o);
};
inline rule::kterm_ptr_type
add_consequent_term_x2(rule::knowledge_rule * rule_p, rdf::resource const& s, std::string const& p, rdf::resource const& o)
{
return rule_p->add_consequent_term(s.get_index(), p, o.get_index());
};
inline rule::kterm_ptr_type
add_consequent_term_x3(rule::knowledge_rule * rule_p, rdf::resource const& s, std::string const& p, std::string const& o)
{
return rule_p->add_consequent_term(s.get_index(), p, o);
};
inline rule::kterm_ptr_type
add_consequent_term_x4(rule::knowledge_rule * rule_p, std::string const& s, rdf::resource const& p, rdf::resource const& o)
{
return rule_p->add_consequent_term(s, p.get_index(), o.get_index());
};
inline rule::kterm_ptr_type
add_consequent_term_x5(rule::knowledge_rule * rule_p, std::string const& s, rdf::resource const& p, std::string const& o)
{
return rule_p->add_consequent_term(s, p.get_index(), o);
};
inline rule::kterm_ptr_type
add_consequent_term_x6(rule::knowledge_rule * rule_p, std::string const& s, std::string const& p, rdf::resource const& o)
{
return rule_p->add_consequent_term(s, p, o.get_index());
};
inline rule::kterm_ptr_type
add_consequent_term_x7(rule::knowledge_rule * rule_p, std::string const& s, std::string const& p, std::string const& o)
{
return rule_p->add_consequent_term(s, p, o);
};
inline rule::kterm_ptr_type
add_consequent_term_x8(rule::knowledge_rule * rule_p, rdf::resource const& s, rdf::resource const& p, rule::knowledge_rule::xprsn_ptr_t const& o)
{
return rule_p->add_consequent_term(s.get_index(), p.get_index(), o);
};
inline rule::kterm_ptr_type
add_consequent_term_x9(rule::knowledge_rule * rule_p, rdf::resource const& s, std::string const& p, rule::knowledge_rule::xprsn_ptr_t const& o)
{
return rule_p->add_consequent_term(s.get_index(), p, o);
};
inline rule::kterm_ptr_type
add_consequent_term_x10(rule::knowledge_rule * rule_p, std::string const& s, rdf::resource const& p, rule::knowledge_rule::xprsn_ptr_t const& o)
{
return rule_p->add_consequent_term(s, p.get_index(), o);
};
inline rule::kterm_ptr_type
add_consequent_term_x11(rule::knowledge_rule * rule_p, std::string const& s, std::string const& p, rule::knowledge_rule::xprsn_ptr_t const& o)
{
return rule_p->add_consequent_term(s, p, o);
};
/////////////////////////////////////////////////////////////////////////////////////////
// knowledge_rule::create_expression templates
//
// Create binary expressions
/////////////////////////////////////////////////////////////////////////////////////////
inline rule::knowledge_rule::xprsn_ptr_t
create_binary_term_x1(rule::knowledge_rule * rule_p, rdf::index_type const& first, std::string const& oper, rdf::index_type const& second)
{
return parser::create_binary_term(rule_p, first, oper, second);
};
inline rule::knowledge_rule::xprsn_ptr_t
create_binary_term_x2(rule::knowledge_rule * rule_p, rdf::index_type const& first, std::string const& oper, std::string const& second)
{
return parser::create_binary_term(rule_p, first, oper, second);
};
inline rule::knowledge_rule::xprsn_ptr_t
create_binary_term_x3(rule::knowledge_rule * rule_p, rdf::index_type const& first, std::string const& oper, rule::knowledge_rule::xprsn_ptr_t const& second)
{
return parser::create_binary_term(rule_p, first, oper, second);
};
inline rule::knowledge_rule::xprsn_ptr_t
create_binary_term_x4(rule::knowledge_rule * rule_p, std::string const& first, std::string const& oper, rdf::index_type const& second)
{
return parser::create_binary_term(rule_p, first, oper, second);
};
inline rule::knowledge_rule::xprsn_ptr_t
create_binary_term_x5(rule::knowledge_rule * rule_p, std::string const& first, std::string const& oper, std::string const& second)
{
return parser::create_binary_term(rule_p, first, oper, second);
};
inline rule::knowledge_rule::xprsn_ptr_t
create_binary_term_x6(rule::knowledge_rule * rule_p, std::string const& first, std::string const& oper, rule::knowledge_rule::xprsn_ptr_t const& second)
{
return parser::create_binary_term(rule_p, first, oper, second);
};
inline rule::knowledge_rule::xprsn_ptr_t
create_binary_term_x7(rule::knowledge_rule * rule_p, rule::knowledge_rule::xprsn_ptr_t const& first, std::string const& oper, rdf::index_type const& second)
{
return parser::create_binary_term(rule_p, first, oper, second);
};
inline rule::knowledge_rule::xprsn_ptr_t
create_binary_term_x8(rule::knowledge_rule * rule_p, rule::knowledge_rule::xprsn_ptr_t const& first, std::string const& oper, std::string const& second)
{
return parser::create_binary_term(rule_p, first, oper, second);
};
inline rule::knowledge_rule::xprsn_ptr_t
create_binary_term_x9(rule::knowledge_rule * rule_p, rule::knowledge_rule::xprsn_ptr_t const& first, std::string const& oper, rule::knowledge_rule::xprsn_ptr_t const& second)
{
return parser::create_binary_term(rule_p, first, oper, second);
};
/////////////////////////////////////////////////////////////////////////////////////////
// knowledge_rule::create_expression templates
//
// Create unary expressions
/////////////////////////////////////////////////////////////////////////////////////////
rule::knowledge_rule::xprsn_ptr_t
create_unary_term_x1(rule::knowledge_rule * rule_p, std::string const& oper, rdf::index_type const& operant)
{
return parser::create_unary_term(rule_p, oper, operant);
};
rule::knowledge_rule::xprsn_ptr_t
create_unary_term_x2(rule::knowledge_rule * rule_p, std::string const& oper, std::string const& operant)
{
return parser::create_unary_term(rule_p, oper, operant);
};
rule::knowledge_rule::xprsn_ptr_t
create_unary_term_x3(rule::knowledge_rule * rule_p, std::string const& oper, rule::knowledge_rule::xprsn_ptr_t const& operant)
{
return parser::create_unary_term(rule_p, oper, operant);
};
/////////////////////////////////////////////////////////////////////////////////////////
// load knowledge base / import owl model function wrappers
//
/////////////////////////////////////////////////////////////////////////////////////////
//
// rule::create_empty_knowledge_base
//
inline rule::knowledge_base_ptr_type
create_empty_knowledge_base_x1(rdf::rdf_graph_ptr_type meta_graph_p)
{
return rule::create_empty_knowledge_base(meta_graph_p);
};
inline rule::knowledge_base_ptr_type
create_empty_knowledge_base_x2()
{
return rule::create_empty_knowledge_base();
};
/////////////////////////////////////////////////////////////////////////////////////////
// parser::load_knowledge_base
//
/////////////////////////////////////////////////////////////////////////////////////////
inline rule::knowledge_base_ptr_type
load_knowledge_base_x1(std::string const& fname, bool verbose)
{
return parser::load_knowledge_base(fname, verbose);
};
inline rule::knowledge_base_ptr_type
load_knowledge_base_x2(std::string const& fname)
{
return parser::load_knowledge_base(fname);
};
inline rule::knowledge_base_ptr_type
load_knowledge_base_x3(std::string const& fname, rdf::rdf_graph_ptr_type meta_graph_p, bool verbose)
{
return parser::load_knowledge_base(fname, meta_graph_p, verbose);
};
inline rule::knowledge_base_ptr_type
load_knowledge_base_x4(std::string const& fname, rdf::rdf_graph_ptr_type meta_graph_p)
{
return parser::load_knowledge_base(fname, meta_graph_p);
};
inline rule::knowledge_base_ptr_type
load_knowledge_base_x5(std::string const& fname, rdf::rdf_graph_ptr_type meta_graph_p, rdf::rdf_graph_ptr_type asserted_graph_p, bool verbose)
{
return parser::load_knowledge_base(fname, meta_graph_p, asserted_graph_p, verbose);
};
/////////////////////////////////////////////////////////////////////////////////////////
// parser::load_knowledge_base_from_buffer
//
/////////////////////////////////////////////////////////////////////////////////////////
inline rule::knowledge_base_ptr_type
load_knowledge_base_from_buffer_x1(std::string const& mem_buffer, bool verbose)
{
return parser::load_knowledge_base_from_buffer(mem_buffer, verbose);
};
inline rule::knowledge_base_ptr_type
load_knowledge_base_from_buffer_x2(std::string const& mem_buffer)
{
return parser::load_knowledge_base_from_buffer(mem_buffer);
};
inline rule::knowledge_base_ptr_type
load_knowledge_base_from_buffer_x3(std::string const& mem_buffer, rdf::rdf_graph_ptr_type meta_graph_p, bool verbose)
{
return parser::load_knowledge_base_from_buffer(mem_buffer, meta_graph_p, verbose);
};
inline rule::knowledge_base_ptr_type
load_knowledge_base_from_buffer_x4(std::string const& mem_buffer, rdf::rdf_graph_ptr_type meta_graph_p)
{
return parser::load_knowledge_base_from_buffer(mem_buffer, meta_graph_p);
};
inline rule::knowledge_base_ptr_type
load_knowledge_base_from_buffer_x5(std::string const& mem_buffer, rdf::rdf_graph_ptr_type meta_graph_p, rdf::rdf_graph_ptr_type asserted_graph_p, bool verbose)
{
return parser::load_knowledge_base_from_buffer(mem_buffer, meta_graph_p, asserted_graph_p, verbose);
};
/////////////////////////////////////////////////////////////////////////////////////////
// parser::xml::import_owl_model
//
/////////////////////////////////////////////////////////////////////////////////////////
inline rdf::rdf_graph_ptr_type
import_owl_model_x1(std::string const& fname, bool verbose)
{
return parser::xml::import_owl_model(fname, verbose);
};
inline rdf::rdf_graph_ptr_type
import_owl_model_x2(std::string const& fname)
{
return parser::xml::import_owl_model(fname);
};
inline rdf::rdf_graph_ptr_type
import_owl_model_x3(std::string const& fname, rdf::rdf_graph_ptr_type graph_p, bool verbose)
{
return parser::xml::import_owl_model(fname, graph_p, verbose);
};
inline rdf::rdf_graph_ptr_type
import_owl_model_x4(std::string const& fname, rdf::rdf_graph_ptr_type graph_p)
{
return parser::xml::import_owl_model(fname, graph_p);
};
/////////////////////////////////////////////////////////////////////////////////////////
// parser::xml::import_owl_model_membuffer
//
/////////////////////////////////////////////////////////////////////////////////////////
inline rdf::rdf_graph_ptr_type
import_owl_model_membuffer_x1(std::string const& buffer, bool verbose)
{
return parser::xml::import_owl_model_membuffer(buffer, verbose);
};
inline rdf::rdf_graph_ptr_type
import_owl_model_membuffer_x2(std::string const& buffer)
{
return parser::xml::import_owl_model_membuffer(buffer);
};
inline rdf::rdf_graph_ptr_type
import_owl_model_membuffer_x3(std::string const& buffer, rdf::rdf_graph_ptr_type graph_p, bool verbose)
{
return parser::xml::import_owl_model_membuffer(buffer, graph_p, verbose);
};
inline rdf::rdf_graph_ptr_type
import_owl_model_membuffer_x4(std::string const& buffer, rdf::rdf_graph_ptr_type graph_p)
{
return parser::xml::import_owl_model_membuffer(buffer, graph_p);
};
#endif /*PY_KNOWLEDGE_BASE_H_*/
