Top Engine Code

#include "py_rule_session.h"


using namespace boost::python;


/////////////////////////////////////////////////////////////////////////////////////////
// export_rule_session
//
/////////////////////////////////////////////////////////////////////////////////////////
void
export_rule_session()
{
	rule::explain_ptr_type (rule::rule_session::*explain_why_x1)(std::string const& s, std::string const& p, std::string const& o) = &rule::rule_session::explain_why;
	rule::explain_ptr_type (rule::rule_session::*explain_why_x2)(unsigned int s, unsigned int p, unsigned int o) = &rule::rule_session::explain_why;
    
    rule::query_rule_wrapper (rule::rule_session::*get_query_x1)(std::string const&) = &rule::rule_session::get_query;
    rule::query_rule_wrapper (rule::rule_session::*get_query_x2)(std::string const&, rule::query_params_map const&) = &rule::rule_session::get_query;
    
	void (rule::rule_session::*execute_rules_x1)() = &rule::rule_session::execute_rules;
	
    class_<rule::rule_session, rule::rule_session_ptr_type>("rule_session", no_init)
    
        .def("get_resource", &rule::rule_session::get_index_type, return_internal_reference<1>())
        
        .def("is_verbose", &rule::rule_session::is_verbose)
        .def("set_verbose", &rule::rule_session::set_verbose)
        
        .def("is_logging_rule_events", &rule::rule_session::is_logging_rule_events)
        .def("set_logging_rule_events", &rule::rule_session::set_logging_rule_events)
        .def("get_rule_event_iterator", &rule::rule_session::get_rule_event_iterator)
        .def("clear_rule_events", &rule::rule_session::clear_rule_events)
        .def("print_rule_events", &rule::rule_session::print_rule_events)
        
        .def("execute_rules", execute_rules_x1)
        
        .def("get_query", get_query_x1)
        .def("get_query", get_query_x2)
        
        .def("explain_why", explain_why_x1)
        .def("explain_why", explain_why_x2)

        .def("print_beta_relations", &rule::rule_session::print_beta_relations)
        
        .def("set_rule_stat_collector_ptr", &rule::rule_session::set_rule_stat_collector_ptr)
        .def("get_rule_stat_collector_ptr", &rule::rule_session::get_rule_stat_collector_ptr)
    ;
};


/////////////////////////////////////////////////////////////////////////////////////////
// export_rule_event
//
/////////////////////////////////////////////////////////////////////////////////////////
void
export_rule_event()
{
	//
	// rule::rule_event_iterator
	//
	typedef rule::rule_session::rule_event_iterator_t		top_iterator;
	
    class_<top_iterator>("rule_event_iterator", no_init)
        .def("is_end", &top_iterator::is_end)
        .def("next_internal", &top_iterator::next)
        .def("get_value", &top_iterator::get_value_by_value)
    ;


	//
	// rule::rule_event_base
	//
	void (rule::rule_event_base::*print_event_x1)()const = &rule::rule_event_base::print_event;

    class_<rule::rule_event_base, rule::rule_event_ptr_type, boost::noncopyable>("rule_event", no_init)
    
        .def("print_event", print_event_x1)
        .def("get_event_text", &rule::rule_event_base::get_event_text)

        .def("get_knowledge_rule", &rule::rule_event_base::get_knowledge_rule_p, return_internal_reference<1>())
        .def(self_ns::str(self))
    ;
};


/////////////////////////////////////////////////////////////////////////////////////////
// export_query_rule_wrapper
//
/////////////////////////////////////////////////////////////////////////////////////////
void
export_query_rule_wrapper()
{
	//
	// rule::query_params_map
	//
    class_<rule::query_params_map>("query_params_map")
        .def("add_param", &rule::query_params_map::add_param)
        .def("insert", &rule::query_params_map::insert)
        .def("clear", &rule::query_params_map::clear)
    ;


	//
	// rule::query_rule_wrapper
	//
    void (rule::query_rule_wrapper::*add_param_x1)(std::string const&, rdf::index_type) = &rule::query_rule_wrapper::add_param;
    void (rule::query_rule_wrapper::*add_param_x2)(std::string const&, std::string const&) = &rule::query_rule_wrapper::add_param;
    
    class_<rule::query_rule_wrapper>("query_rule_wrapper", no_init)
    
        .def("add_param", add_param_x1)
        .def("add_param", add_param_x2)
        
        .def("get_params", &rule::query_rule_wrapper::get_params, return_internal_reference<1>())
        
        .def("execute", &rule::query_rule_wrapper::execute)
        
        .def("get_knowledge_rule", &rule::query_rule_wrapper::get_knowledge_rule_ptr)
    ;


	//
	// rule::column_name_iterator
	//
	typedef rule::query_result::column_name_iterator	column_name_iterator;
    class_<column_name_iterator>("column_name_iterator", no_init)
        .def("is_end", &column_name_iterator::is_end)
        .def("next_internal", &column_name_iterator::next)
        .def("get_value", &column_name_iterator::get_value, return_value_policy<copy_const_reference>())
    ;

	//
	// rule::query_result
	//
    class_<rule::query_result, rule::query_result_ptr_type>("query_result", no_init)
    
        .def("get_row_count", &rule::query_result::get_row_count)
        .def("get_column_count", &rule::query_result::get_column_count)

        .def("is_end", &rule::query_result::is_end)
        .def("next_internal", &rule::query_result::next)
        .def("get_value", &rule::query_result::get_row)
        .def("get_row", &rule::query_result::get_row)
        
        .def("get_column_name_iterator", &rule::query_result::get_column_name_iterator)
    ;

	//
	// rule::query_result_row
	//
	rdf::index_type (rule::query_result_row::*get_x1)(std::string const&)const = &rule::query_result_row::get;
	rdf::index_type (rule::query_result_row::*get_x2)(unsigned int)const = &rule::query_result_row::get;

    class_<rule::query_result_row>("query_result_row", no_init)

        .def("get_size", &rule::query_result_row::get_column_count)

        .def("get", get_x1, return_internal_reference<1>())
        .def("get", get_x2, return_internal_reference<1>())
        
        .def("keys_iterator", &rule::query_result_row::get_column_name_iterator)
        .def("contains_key", &rule::query_result_row::contains_column_name)
    ;
};


/////////////////////////////////////////////////////////////////////////////////////////
// export_explain
//
/////////////////////////////////////////////////////////////////////////////////////////
void
export_explain()
{
     class_<rule::explain_info_base, rule::explain_info_ptr_type, boost::noncopyable>("explain_info", no_init)
        .def("get_explain_text", &rule::explain_info_base::get_explain_text)
        .def("get_explain_vertex", &rule::explain_info_base::get_explain_vertex)
        .def("is_rule", pure_virtual(&rule::explain_info_base::is_rule))
        .def(self_ns::str(self))
    ;


    class_<rule::explain_info_lookup_iterator>("explain_info_lookup_iterator", no_init)
        .def("is_end", &rule::explain_info_lookup_iterator::is_end)
        .def("next_internal", &rule::explain_info_lookup_iterator::next)
        .def("get_value", &rule::explain_info_lookup_iterator::get_value_by_value)
    ;
    

	//
	// rule::explain
	//
    class_<rule::explain, rule::explain_ptr_type, boost::noncopyable>("explain", no_init)
//    class_<rule::explain, rule::explain_ptr_type>("explain", init<rule::rule_session *>())
    
//        .def("print_why", &rule::explain::print_why, print_why_overloads())
        .def("get_explain_info_iterator", &rule::explain::get_explain_info_iterator)
    ;
};


/////////////////////////////////////////////////////////////////////////////////////////
// export_rule_stat_collector_base
//
/////////////////////////////////////////////////////////////////////////////////////////
void
export_rule_stat_collector()
{
	//
	// rule::rule_stat_collector_base
	//
    class_<rule::rule_stat_collector_base, rule::rule_stat_collector_ptr_type, boost::noncopyable>("rule_stat_collector", no_init)
        .def("print_statistics", &rule::rule_stat_collector_base::print_statistics)
    ;


	//
	// rule::basic_rule_stat_collector
	//
    class_<rule::basic_rule_stat_collector, bases<rule::rule_stat_collector_base> >("basic_rule_stat_collector")
        .def("print_statistics", &rule::basic_rule_stat_collector::print_statistics)
    ;
};