#include "knowledge_base.h"
#include "rule_session.h"
#include "rule_term.h"
namespace rule {
namespace internal {
// aav
rule_term_ptr_type create_rt(rule_term_ptr_type const& left_term, var_set_t const& right_vars, index_type const& u, index_type const& v, std::string const& w, bool is_negation)
{
rule_term_ptr_type rule_term_p;
var_set_t::const_iterator right_vars_end = right_vars.end();
bool is_w_index = false;
if(left_term and left_term->has_index(w)) is_w_index = true;
if(!is_negation) {
if(is_w_index) rule_term_p = rule_term_ptr_type(new T_aai(u, v, left_term->get_index(w).first));
else {
rule_term_p = rule_term_ptr_type(new T_aav(u, v, w));
if(right_vars.find(w) != right_vars_end) rule_term_p->add_right_index(w);
}
} else {
if(is_w_index) rule_term_p = rule_term_ptr_type(new Not_T_aai(u, v, left_term->get_index(w).first));
else throw rdf::rdf_exception(rdf::invalid_rule_def, std::string("ERROR-R3: negation term with unbind variable: "+w).c_str());
}
// setup the index_map
if(left_term) {
index_map_helper::label_iterator itor = left_term->label_iterator_begin();
index_map_helper::label_iterator end = left_term->label_iterator_end();
for(; itor!=end; ++itor) if(right_vars.find(*itor) != right_vars_end) rule_term_p->add_left_index(left_term->get_index(*itor));
}
return rule_term_p;
};
// ava
rule_term_ptr_type create_rt(rule_term_ptr_type const& left_term, var_set_t const& right_vars, index_type const& u, std::string const& v, index_type const& w, bool is_negation)
{
rule_term_ptr_type rule_term_p;
var_set_t::const_iterator right_vars_end = right_vars.end();
bool is_v_index = false;
if(left_term and left_term->has_index(v)) is_v_index = true;
if(!is_negation) {
if(is_v_index) rule_term_p = rule_term_ptr_type(new T_aia(u, left_term->get_index(v).first, w));
else {
rule_term_p = rule_term_ptr_type(new T_ava(u, v, w));
if(right_vars.find(v) != right_vars_end) rule_term_p->add_right_index(v);
}
} else {
if(is_v_index) rule_term_p = rule_term_ptr_type(new Not_T_aia(u, left_term->get_index(v).first, w));
else throw rdf::rdf_exception(rdf::invalid_rule_def, std::string("ERROR-R3: negation term with unbind variable: "+v).c_str());
}
// setup the index_map
if(left_term) {
index_map_helper::label_iterator itor = left_term->label_iterator_begin();
index_map_helper::label_iterator end = left_term->label_iterator_end();
for(; itor!=end; ++itor) if(right_vars.find(*itor) != right_vars_end) rule_term_p->add_left_index(left_term->get_index(*itor));
}
return rule_term_p;
};
// avv
rule_term_ptr_type create_rt(rule_term_ptr_type const& left_term, var_set_t const& right_vars, index_type const& u, std::string const& v, std::string const& w, bool is_negation)
{
rule_term_ptr_type rule_term_p;
var_set_t::const_iterator right_vars_end = right_vars.end();
bool is_v_index = false;
if(left_term and left_term->has_index(v)) is_v_index = true;
bool is_w_index = false;
if(left_term and left_term->has_index(w)) is_w_index = true;
if(!is_negation) {
if(is_v_index and is_w_index) {
rule_term_p = rule_term_ptr_type(new T_aii(u, left_term->get_index(v).first, left_term->get_index(w).first));
} else if(is_v_index and !is_w_index) {
rule_term_p = rule_term_ptr_type(new T_aiv(u, left_term->get_index(v).first, w));
if(right_vars.find(w) != right_vars_end) rule_term_p->add_right_index(w);
} else if(!is_v_index and is_w_index) {
rule_term_p = rule_term_ptr_type(new T_avi(u, v, left_term->get_index(w).first));
if(right_vars.find(v) != right_vars_end) rule_term_p->add_right_index(v);
} else {
rule_term_p = rule_term_ptr_type(new T_avv(u, v, w));
if(right_vars.find(v) != right_vars_end) rule_term_p->add_right_index(v);
if(right_vars.find(w) != right_vars_end) rule_term_p->add_right_index(w);
}
} else {
if(is_v_index and is_w_index) rule_term_p = rule_term_ptr_type(new Not_T_aii(u, left_term->get_index(v).first, left_term->get_index(w).first));
else throw rdf::rdf_exception(rdf::invalid_rule_def, std::string("ERROR-R3: negation term with unbind variable: "+v+", "+w).c_str());
}
// setup the index_map
if(left_term) {
index_map_helper::label_iterator itor = left_term->label_iterator_begin();
index_map_helper::label_iterator end = left_term->label_iterator_end();
for(; itor!=end; ++itor) if(right_vars.find(*itor) != right_vars_end) rule_term_p->add_left_index(left_term->get_index(*itor));
}
return rule_term_p;
};
// vaa
rule_term_ptr_type create_rt(rule_term_ptr_type const& left_term, var_set_t const& right_vars, std::string const& u, index_type const& v, index_type const& w, bool is_negation)
{
rule_term_ptr_type rule_term_p;
var_set_t::const_iterator right_vars_end = right_vars.end();
bool is_u_index = false;
if(left_term and left_term->has_index(u)) is_u_index = true;
if(!is_negation) {
if(is_u_index) rule_term_p = rule_term_ptr_type(new T_iaa(left_term->get_index(u).first, v, w));
else {
rule_term_p = rule_term_ptr_type(new T_vaa(u, v, w));
if(right_vars.find(u) != right_vars_end) rule_term_p->add_right_index(u);
}
} else {
if(is_u_index) rule_term_p = rule_term_ptr_type(new Not_T_iaa(left_term->get_index(u).first, v, w));
else throw rdf::rdf_exception(rdf::invalid_rule_def, std::string("ERROR-R3: negation term with unbind variable: "+u).c_str());
}
// setup the index_map
if(left_term) {
index_map_helper::label_iterator itor = left_term->label_iterator_begin();
index_map_helper::label_iterator end = left_term->label_iterator_end();
for(; itor!=end; ++itor) if(right_vars.find(*itor) != right_vars_end) rule_term_p->add_left_index(left_term->get_index(*itor));
}
return rule_term_p;
};
// vav
rule_term_ptr_type create_rt(rule_term_ptr_type const& left_term, var_set_t const& right_vars, std::string const& u, index_type const& v, std::string const& w, bool is_negation)
{
rule_term_ptr_type rule_term_p;
var_set_t::const_iterator right_vars_end = right_vars.end();
unsigned int ui=0, wi=0;
bool is_u_index = false;
if(left_term and left_term->has_index(u)) {
is_u_index = true;
ui = left_term->get_index(u).first;
}
bool is_w_index = false;
if(left_term and left_term->has_index(w)) {
is_w_index = true;
wi = left_term->get_index(w).first;
}
if(!is_negation) {
if(is_u_index and is_w_index) {
rule_term_p = rule_term_ptr_type(new T_iai(ui, v, wi));
} else if(is_u_index and !is_w_index) {
rule_term_p = rule_term_ptr_type(new T_iav(ui, v, w));
if(right_vars.find(w) != right_vars_end) rule_term_p->add_right_index(w);
} else if(!is_u_index and is_w_index) {
rule_term_p = rule_term_ptr_type(new T_vai(u, v, wi));
if(right_vars.find(u) != right_vars_end) rule_term_p->add_right_index(u);
} else {
rule_term_p = rule_term_ptr_type(new T_vav(u, v, w));
if(right_vars.find(u) != right_vars_end) rule_term_p->add_right_index(u);
if(right_vars.find(w) != right_vars_end) rule_term_p->add_right_index(w);
}
} else {
if(is_u_index and is_w_index) rule_term_p = rule_term_ptr_type(new Not_T_iai(ui, v, wi));
else throw rdf::rdf_exception(rdf::invalid_rule_def, std::string("ERROR-R3: negation term with unbind variable: "+u+", "+w).c_str());
}
// setup the index_map
if(left_term) {
index_map_helper::label_iterator itor = left_term->label_iterator_begin();
index_map_helper::label_iterator end = left_term->label_iterator_end();
for(; itor!=end; ++itor) if(right_vars.find(*itor) != right_vars_end) rule_term_p->add_left_index(left_term->get_index(*itor));
}
return rule_term_p;
};
// vva
rule_term_ptr_type create_rt(rule_term_ptr_type const& left_term, var_set_t const& right_vars, std::string const& u, std::string const& v, index_type const& w, bool is_negation)
{
rule_term_ptr_type rule_term_p;
var_set_t::const_iterator right_vars_end = right_vars.end();
unsigned int ui=0, vi=0;
bool is_u_index = false;
if(left_term and left_term->has_index(u)) {
is_u_index = true;
ui = left_term->get_index(u).first;
}
bool is_v_index = false;
if(left_term and left_term->has_index(v)) {
is_v_index = true;
vi = left_term->get_index(v).first;
}
if(!is_negation) {
if(is_u_index and is_v_index) {
rule_term_p = rule_term_ptr_type(new T_iia(ui, vi, w));
} else if(is_u_index and !is_v_index) {
rule_term_p = rule_term_ptr_type(new T_iva(ui, v, w));
if(right_vars.find(v) != right_vars_end) rule_term_p->add_right_index(v);
} else if(!is_u_index and is_v_index) {
rule_term_p = rule_term_ptr_type(new T_via(u, vi, w));
if(right_vars.find(u) != right_vars_end) rule_term_p->add_right_index(u);
} else {
rule_term_p = rule_term_ptr_type(new T_vva(u, v, w));
if(right_vars.find(u) != right_vars_end) rule_term_p->add_right_index(u);
if(right_vars.find(v) != right_vars_end) rule_term_p->add_right_index(v);
}
} else {
if(is_u_index and is_v_index) rule_term_p = rule_term_ptr_type(new Not_T_iia(ui, vi, w));
else throw rdf::rdf_exception(rdf::invalid_rule_def, std::string("ERROR-R3: negation term with unbind variable: "+v+", "+v).c_str());
}
// setup the index_map
if(left_term) {
index_map_helper::label_iterator itor = left_term->label_iterator_begin();
index_map_helper::label_iterator end = left_term->label_iterator_end();
for(; itor!=end; ++itor) if(right_vars.find(*itor) != right_vars_end) rule_term_p->add_left_index(left_term->get_index(*itor));
}
return rule_term_p;
};
// vvv
rule_term_ptr_type create_rt(rule_term_ptr_type const& left_term, var_set_t const& right_vars, std::string const& u, std::string const& v, std::string const& w, bool is_negation)
{
rule_term_ptr_type rule_term_p;
var_set_t::const_iterator right_vars_end = right_vars.end();
unsigned int ui=0, vi=0, wi=0;
bool is_u_index = false;
if(left_term and left_term->has_index(u)) {
is_u_index = true;
ui = left_term->get_index(u).first;
}
bool is_v_index = false;
if(left_term and left_term->has_index(v)) {
is_v_index = true;
vi = left_term->get_index(v).first;
}
bool is_w_index = false;
if(left_term and left_term->has_index(w)) {
is_w_index = true;
wi = left_term->get_index(w).first;
}
if(!is_negation) {
if(is_u_index and is_v_index and is_w_index) {
rule_term_p = rule_term_ptr_type(new T_iii(ui, vi, wi));
} else if(is_u_index and is_v_index and !is_w_index) {
rule_term_p = rule_term_ptr_type(new T_iiv(ui, vi, w));
if(right_vars.find(w) != right_vars_end) rule_term_p->add_right_index(w);
} else if(is_u_index and !is_v_index and is_w_index) {
rule_term_p = rule_term_ptr_type(new T_ivi(ui, v, wi));
if(right_vars.find(v) != right_vars_end) rule_term_p->add_right_index(v);
} else if(is_u_index and !is_v_index and !is_w_index) {
rule_term_p = rule_term_ptr_type(new T_ivv(ui, v, w));
if(right_vars.find(v) != right_vars_end) rule_term_p->add_right_index(v);
if(right_vars.find(w) != right_vars_end) rule_term_p->add_right_index(w);
} else if(!is_u_index and is_v_index and is_w_index) {
rule_term_p = rule_term_ptr_type(new T_vii(u, vi, wi));
if(right_vars.find(u) != right_vars_end) rule_term_p->add_right_index(u);
} else if(!is_u_index and is_v_index and !is_w_index) {
rule_term_p = rule_term_ptr_type(new T_viv(u, vi, w));
if(right_vars.find(u) != right_vars_end) rule_term_p->add_right_index(u);
if(right_vars.find(w) != right_vars_end) rule_term_p->add_right_index(w);
} else if(!is_u_index and !is_v_index and is_w_index) {
rule_term_p = rule_term_ptr_type(new T_vvi(u, v, wi));
if(right_vars.find(u) != right_vars_end) rule_term_p->add_right_index(u);
if(right_vars.find(v) != right_vars_end) rule_term_p->add_right_index(v);
} else {
rule_term_p = rule_term_ptr_type(new T_vvv(u, v, w));
if(right_vars.find(u) != right_vars_end) rule_term_p->add_right_index(u);
if(right_vars.find(v) != right_vars_end) rule_term_p->add_right_index(v);
if(right_vars.find(w) != right_vars_end) rule_term_p->add_right_index(w);
}
} else {
if(is_u_index and is_v_index and is_w_index) rule_term_p = rule_term_ptr_type(new Not_T_iii(ui, vi, wi));
else throw rdf::rdf_exception(rdf::invalid_rule_def, std::string("ERROR-R3: negation term with unbind variable: "+u+", "+v+", "+w).c_str());
}
// setup the index_map
if(left_term) {
index_map_helper::label_iterator itor = left_term->label_iterator_begin();
index_map_helper::label_iterator end = left_term->label_iterator_end();
for(; itor!=end; ++itor) if(right_vars.find(*itor) != right_vars_end) rule_term_p->add_left_index(left_term->get_index(*itor));
}
return rule_term_p;
};
// aaf
rule_term_ptr_type create_rt(rule_term_ptr_type const& left_term, var_set_t const& right_vars, index_type const& u, index_type const& v, expression_term_ptr_type const& w, bool is_negation)
{
rule_term_ptr_type rule_term_p;
if(!is_negation) {
expression_rule_term_ptr_type et_p = w->create_expression_term(left_term);
rule_term_p = rule_term_ptr_type(new T_aax(u, v, rule::internal::F_expression(et_p, "<*-*expresion term>")));
} else {
throw rdf::rdf_exception(rdf::invalid_rule_def, "ERROR-R4: negation term with expression term in consequent term: ");
}
// setup the index_map
if(left_term) {
index_map_helper::label_iterator itor = left_term->label_iterator_begin();
index_map_helper::label_iterator end = left_term->label_iterator_end();
var_set_t::const_iterator right_vars_end = right_vars.end();
for(; itor!=end; ++itor) if(right_vars.find(*itor) != right_vars_end) rule_term_p->add_left_index(left_term->get_index(*itor));
}
return rule_term_p;
};
// aif
rule_term_ptr_type create_rt(rule_term_ptr_type const& left_term, var_set_t const& right_vars, index_type const& u, std::string const& v, expression_term_ptr_type const& w, bool is_negation)
{
rule_term_ptr_type rule_term_p;
if(!left_term or !left_term->has_index(v)) throw rdf::rdf_exception(rdf::invalid_rule_def, "ERROR-R5: consequent term with unbound variable: ");
if(!is_negation) {
expression_rule_term_ptr_type et_p = w->create_expression_term(left_term);
rule_term_p = rule_term_ptr_type(new T_aix(u, left_term->get_index(v).first, rule::internal::F_expression(et_p, "<*-*expresion term>")));
} else {
throw rdf::rdf_exception(rdf::invalid_rule_def, "ERROR-R4: negation term with expression term in consequent term: ");
}
// setup the index_map
if(left_term) {
index_map_helper::label_iterator itor = left_term->label_iterator_begin();
index_map_helper::label_iterator end = left_term->label_iterator_end();
var_set_t::const_iterator right_vars_end = right_vars.end();
for(; itor!=end; ++itor) if(right_vars.find(*itor) != right_vars_end) rule_term_p->add_left_index(left_term->get_index(*itor));
}
return rule_term_p;
};
// iaf
rule_term_ptr_type create_rt(rule_term_ptr_type const& left_term, var_set_t const& right_vars, std::string const& u, index_type const& v, expression_term_ptr_type const& w, bool is_negation)
{
rule_term_ptr_type rule_term_p;
if(!left_term or !left_term->has_index(u)) throw rdf::rdf_exception(rdf::invalid_rule_def, std::string("ERROR-R5: consequent term with unbound variable: "+u).c_str());
if(!is_negation) {
expression_rule_term_ptr_type et_p = w->create_expression_term(left_term);
rule_term_p = rule_term_ptr_type(new T_iax(left_term->get_index(u).first, v, rule::internal::F_expression(et_p, "<*-*expresion term>")));
} else {
throw rdf::rdf_exception(rdf::invalid_rule_def, "ERROR-R4: negation term with expression term in consequent term: ");
}
// setup the index_map
if(left_term) {
index_map_helper::label_iterator itor = left_term->label_iterator_begin();
index_map_helper::label_iterator end = left_term->label_iterator_end();
var_set_t::const_iterator right_vars_end = right_vars.end();
for(; itor!=end; ++itor) if(right_vars.find(*itor) != right_vars_end) rule_term_p->add_left_index(left_term->get_index(*itor));
}
return rule_term_p;
};
// iif
rule_term_ptr_type create_rt(rule_term_ptr_type const& left_term, var_set_t const& right_vars, std::string const& u, std::string const& v, expression_term_ptr_type const& w, bool is_negation)
{
rule_term_ptr_type rule_term_p;
if(!left_term or !left_term->has_index(u)) throw rdf::rdf_exception(rdf::invalid_rule_def, std::string("ERROR-R5: consequent term with unbound variable: "+u).c_str());
if(!left_term or !left_term->has_index(v)) throw rdf::rdf_exception(rdf::invalid_rule_def, std::string("ERROR-R5: consequent term with unbound variable: "+v).c_str());
if(!is_negation) {
expression_rule_term_ptr_type et_p = w->create_expression_term(left_term);
rule_term_p = rule_term_ptr_type(new T_iix(left_term->get_index(u).first, left_term->get_index(v).first, rule::internal::F_expression(et_p, "<*-*expresion term>")));
} else {
throw rdf::rdf_exception(rdf::invalid_rule_def, "ERROR-R4: negation term with expression term in consequent term: ");
}
// setup the index_map
if(left_term) {
index_map_helper::label_iterator itor = left_term->label_iterator_begin();
index_map_helper::label_iterator end = left_term->label_iterator_end();
var_set_t::const_iterator right_vars_end = right_vars.end();
for(; itor!=end; ++itor) if(right_vars.find(*itor) != right_vars_end) rule_term_p->add_left_index(left_term->get_index(*itor));
}
return rule_term_p;
};
}; /* rule namespace */
}; /* internal namespace */
