Top Engine Code

#ifndef QUERY_RULE_WRAPPER_H_
#define QUERY_RULE_WRAPPER_H_

#include "rdf_rule_core.h"
#include "rule_internal.h"
#include "rule_session.h"
#include "rule_term_base.h"
#include "knowledge_base.h"


namespace rule {
	

	// class query_params_map defined in rule_session.h

	class query_result;

	typedef std::tr1::shared_ptr<query_result> 		query_result_ptr_type;
	
	/////////////////////////////////////////////////////////////////////////////////////////
	// class query_rule_wrapper
	//
	/////////////////////////////////////////////////////////////////////////////////////////
	class query_rule_wrapper
	{
		public:
		typedef knowledge_rule::string_const_iterator		string_const_iterator;

		query_rule_wrapper(knowledge_base const& kbase, rule_session & session, std::string const& name, query_params_map const& params):
			m_kbase(kbase),
			m_rule_session(session),
			m_query_rule_p(kbase.get_query_rule(name)),
			m_params(params)
			{};
			
		~query_rule_wrapper(){};


        inline void 
        add_param(std::string const& name, rdf::index_type value)
        {
            m_params.add_param(name, value);
        };


        inline void 
        add_param(std::string const& name, std::string const& value)
        {
            add_param(name, m_rule_session.get_rdf_session().create_resource_as_index(value));
        };
		
		
		inline query_params_map & 
		get_params()
		{
			return m_params;
		};
		
		
		// defined in rule_session.cpp
		query_result_ptr_type 
		execute();
		
		
		// return ptr to the knowledge rule associated with this query object.
		inline knowledge_rule_ptr_type
		get_knowledge_rule_ptr()
		{
			return m_query_rule_p;
		};
		
		
		inline unsigned int
		get_column_count()const
		{
			return m_query_rule_p->get_select_vars_count();
		};

		
		inline string_const_iterator 
		get_column_name_begin()const
		{
			return m_query_rule_p->get_select_vars_begin();
		};
		
		
		inline string_const_iterator 
		get_column_name_end()const  
		{
			return m_query_rule_p->get_select_vars_end();
		};
		
		
		inline unsigned int 
		get_column_position(std::string col_name)const
		{
			return m_query_rule_p->get_select_var_mapping(col_name);
		};
		
		
		inline bool 
		contains_column_name(std::string var)const
		{
			return m_query_rule_p->contains_select_var(var);
		};

		
		protected:
		friend class query_result;
		
		
		inline internal::rule_term_ptr_type 
		get_head_rule_term_p()const
		{
			return m_query_rule_p->get_head_term()->get_rule_term();
		};
		
		
		inline internal::rule_term_ptr_type 
		get_tail_rule_term_p()const
		{
			return m_kbase.get_knowledge_term(get_tail_query_vertex()).get_rule_term();
		};
		
		
		// defined in rule_session.cpp
		std::size_t 
		initialize_head_row(internal::relation_row_ptr_type head_row_p)const;
		
		
		inline internal::rule_vertex 
		get_rule_vertex()const
		{
			return m_query_rule_p->get_dependency_graph_vertex();
		};
		
		
		inline internal::rule_vertex 
		get_tail_query_vertex()const
		{
			return m_query_rule_p->get_tail_body_term_vertex();
		};
		
		
		private:
		knowledge_base const&		m_kbase;
		rule_session &				m_rule_session;
		knowledge_rule_ptr_type 	m_query_rule_p;
		query_params_map			m_params;
	};


	class query_result;

	/////////////////////////////////////////////////////////////////////////////////////////
	// class query_result_row
	//
	/////////////////////////////////////////////////////////////////////////////////////////
	class query_result_row
	{
		public:
		typedef knowledge_rule::string_const_iterator					string_const_iterator;
		typedef rdf::top_iterator<string_const_iterator>				column_name_iterator;
		
		~query_result_row(){};
		
		
		unsigned int
		get_column_count()const;
		
		
		bool 
		contains_column_name(std::string var)const;
		
		
		column_name_iterator
		get_column_name_iterator()const;
		
		
		inline rdf::index_type 
		get(std::string const& col_name)const;
		
		
		inline rdf::index_type 
		get(unsigned int col_id)const
		{
			return (*m_relation_row_p)[col_id];
		};
		
		
		protected:
		friend class query_result;
		
		query_result_row(query_result const& qr, internal::relation_row_ptr_type const& relation_row_p):
			m_query_result(qr),
			m_relation_row_p(relation_row_p)
			{};


		private:
		query_result const&					m_query_result;
		internal::relation_row_ptr_type 	m_relation_row_p;
	};


	/////////////////////////////////////////////////////////////////////////////////////////
	// class query_result
	//
	/////////////////////////////////////////////////////////////////////////////////////////
	class query_result
	{
		public:
		typedef knowledge_rule::string_const_iterator					string_const_iterator;
		typedef rdf::top_iterator<string_const_iterator>				column_name_iterator;
		
		query_result(knowledge_base const& , query_rule_wrapper & query, internal::beta_relation const& relation):
			m_query(query),
			m_rule_term(m_query.get_tail_rule_term_p()),
			m_relation(relation),
			m_row_itor(relation.beta_relation_iterator_all())
			{};
			
		~query_result(){};


		inline unsigned int 
		get_row_count()const
		{
			return m_relation.get_row_count();
		};


		inline unsigned int 
		get_column_count()const
		{
			return m_query.get_column_count();
		};
		
		
		inline bool 
		contains_column_name(std::string var)const
		{
			return m_query.contains_column_name(var);
		};
		
		
		inline unsigned int 
		get_column_position(std::string const& name)const
		{
			return m_query.get_column_position(name);
		};
		
		
		inline bool 
		is_end()const
		{
			return m_row_itor.is_end();
		};
		
		
		inline bool 
		next()
		{
			return m_row_itor.next();
		};
		
		
		inline query_result_row
		get_row()const
		{
			return query_result_row(*this, m_row_itor.get_relation_row_ptr());
		};
		
		
		inline string_const_iterator 
		get_column_name_begin()const
		{
			return m_query.get_column_name_begin();
		};
		
		
		inline string_const_iterator 
		get_column_name_end()const  
		{
			return m_query.get_column_name_end();
		};
		
		
		inline column_name_iterator
		get_column_name_iterator()const
		{
			return column_name_iterator(get_column_name_begin(), get_column_name_end());
		};

		
		private:
		friend class query_result_row;
		query_rule_wrapper & 						m_query;
		internal::rule_term_ptr_type				m_rule_term;
		internal::beta_relation const&				m_relation;
		internal::beta_relation::const_iterator		m_row_itor;
	};
		

	/////////////////////////////////////////////////////////////////////////////////////////
	// query_result_row::get_column_count
	//
	/////////////////////////////////////////////////////////////////////////////////////////
	inline unsigned int
	query_result_row::get_column_count()const
	{
		return m_query_result.get_column_count();
	};
		
		
	/////////////////////////////////////////////////////////////////////////////////////////
	// query_result_row::column_name_iterator
	//
	/////////////////////////////////////////////////////////////////////////////////////////
	inline query_result_row::column_name_iterator
	query_result_row::get_column_name_iterator()const
	{
		return m_query_result.get_column_name_iterator();
	};
		
		
	/////////////////////////////////////////////////////////////////////////////////////////
	// query_result_row::contains_select_var
	//
	/////////////////////////////////////////////////////////////////////////////////////////
	inline bool 
	query_result_row::contains_column_name(std::string var)const
	{
		return m_query_result.contains_column_name(var);
	};

		
	/////////////////////////////////////////////////////////////////////////////////////////
	// query_result_row::get
	//
	/////////////////////////////////////////////////////////////////////////////////////////
	inline rdf::index_type 
	query_result_row::get(std::string const& col_name)const
	{
		return get(m_query_result.get_column_position(col_name));
	};
	
};	/* rule namespace */
#endif /*QUERY_RULE_WRAPPER_H_*/