#ifndef PSEARCHDB_H_
#define PSEARCHDB_H_
#include "psearch_core.h"
#include "psearch_node.h"
#include "psearch_category.h"
#include "psearch_rule.h"
#include "psearch_pattern.h"
namespace psearch {
inline std::ostream& operator<<(std::ostream& out, Pattern const& pattern)
{
out << "Pattern '" << pattern.get_name() << "': " << pattern.get_rdf_index()->get_name() << " c1[ ";
for(node_const_iterator_type itor = pattern.get_c1_nodes_begin();
itor!=pattern.get_c1_nodes_end(); ++itor)
out << "'" << (*itor)->get_name() << "' ";
out << "] c2[ ";
for(node_const_iterator_type itor = pattern.get_c2_nodes_begin();
itor!=pattern.get_c2_nodes_end(); ++itor)
if(!pattern.is_c1_node(*itor)) out << "'" << (*itor)->get_name() << "' ";
out << "] not[ ";
for(node_const_iterator_type itor = pattern.get_negated_nodes_begin();
itor!=pattern.get_negated_nodes_end(); ++itor)
out << "'" << (*itor)->get_name() << "' ";
out << "] " << pattern.get_weight();
return out;
};
inline std::ostream& operator<<(std::ostream& out, Rule const& rule)
{
out << "Rule '" << rule.get_name() << "': " << rule.get_rdf_index()->get_name() << " ex[ ";
for(category_const_iterator_type itor = rule.get_ex_categories_begin();
itor!=rule.get_ex_categories_end(); ++itor)
out << "'" << (*itor)->get_name() << "' ";
out << "] c1[ ";
for(node_const_iterator_type itor = rule.get_c1_nodes_begin();
itor!=rule.get_c1_nodes_end(); ++itor)
out << "'" << (*itor)->get_name() << "' ";
out << "] c2[ ";
for(node_const_iterator_type itor = rule.get_c2_nodes_begin();
itor!=rule.get_c2_nodes_end(); ++itor)
if(!rule.is_c1_node(*itor)) out << "'" << (*itor)->get_name() << "' ";
out << "] not[ ";
for(node_const_iterator_type itor = rule.get_negated_nodes_begin();
itor!=rule.get_negated_nodes_end(); ++itor)
out << "'" << (*itor)->get_name() << "' ";
out << "] " << rule.get_weight();
return out;
};
inline std::ostream& operator<<(std::ostream& out, Node const& node)
{
out << "Node '" << node.get_name() << "': " << node.get_rdf_index()->get_name() << " [ ";
for(pattern_const_iterator_type itor = node.get_patterns_begin();
itor!=node.get_patterns_end(); ++itor)
out << "'" << (*itor)->get_name() << "' ";
out << "] " << (node.is_skip_pattern_activation() ? "skip_pattern_activation":"");
return out;
};
inline std::ostream& operator<<(std::ostream& out, Category const& category)
{
out << "Category '" << category.get_name() << "': " << category.get_rdf_index()->get_name() << " [ ";
for(node_const_iterator_type itor = category.get_nodes_begin();
itor!=category.get_nodes_end(); ++itor)
out << "'" << (*itor)->get_name() << "' ";
out << "] " << (category.is_value_partition() ? "value_partition":"");
return out;
};
/////////////////////////////////////////////////////////////////////////////////////////
// class PSearchDB
//
/////////////////////////////////////////////////////////////////////////////////////////
class PSearchDB
{
public:
inline PSearchDB(rdf::rdf_graph_ptr_type meta_graph_p):
m_meta_graph_p(meta_graph_p),
m_node_ptr_list(),
m_category_ptr_list(),
m_pattern_ptr_list(),
m_rule_ptr_list(),
m_node_index_map(),
m_category_index_map(),
m_rule_index_map(),
m_node_name_map(),
m_category_name_map(),
m_rule_name_map()
{
top_PSearchDB = m_meta_graph_p->create_resource_as_index("top:PSearchDB");
top_Node = m_meta_graph_p->create_resource_as_index("top:Node");
top_skip_activation = m_meta_graph_p->create_resource_as_index("top:skip_activation");
top_name = m_meta_graph_p->create_resource_as_index("top:name");
top_Rule = m_meta_graph_p->create_resource_as_index("top:Rule");
top_is_active = m_meta_graph_p->create_resource_as_index("top:is_active");
top_weight = m_meta_graph_p->create_resource_as_index("top:weight");
top_has_ex_category = m_meta_graph_p->create_resource_as_index("top:has_ex_category");
top_has_c1_node = m_meta_graph_p->create_resource_as_index("top:has_c1_node");
top_has_c2_node = m_meta_graph_p->create_resource_as_index("top:has_c2_node");
top_has_negated_node = m_meta_graph_p->create_resource_as_index("top:has_negated_node");
top_Category = m_meta_graph_p->create_resource_as_index("top:Category");
top_value_partition = m_meta_graph_p->create_resource_as_index("top:value_partition");
top_has_node = m_meta_graph_p->create_resource_as_index("top:has_node");
rdf_type = m_meta_graph_p->create_resource_as_index("rdf:type");
top_true = m_meta_graph_p->create_literal_as_index("true", int(1));
top_false = m_meta_graph_p->create_literal_as_index("false", int(0));
top_10u = m_meta_graph_p->create_literal_as_index("10u", (unsigned int)10);
};
virtual ~PSearchDB()
{};
inline void
clear()
{
m_node_ptr_list.clear();
m_pattern_ptr_list.clear();
m_rule_ptr_list.clear();
m_category_ptr_list.clear();
m_node_index_map.clear();
m_rule_index_map.clear();
m_category_index_map.clear();
m_node_name_map.clear();
m_category_name_map.clear();
m_rule_name_map.clear();
};
inline unsigned int
get_nbr_patterns()
{
return m_pattern_ptr_list.size();
};
inline unsigned int
get_nbr_rules()
{
return m_rule_ptr_list.size();
};
inline unsigned int
get_nbr_nodes()
{
return m_node_ptr_list.size();
};
inline unsigned int
get_nbr_categories()
{
return m_category_ptr_list.size();
};
//////////////////////////////////////////////////////////////////////////////////////////
// Node
//////////////////////////////////////////////////////////////////////////////////////////
inline bool
has_node(index_type index)const
{
return m_node_index_map.find(index) != m_node_index_map.end();
};
inline bool
has_node(std::string const& name)const
{
return m_node_name_map.find(name) != m_node_name_map.end();
};
inline node_index_type
get_node_index(index_type index)const
{
node_index_map_type::const_iterator itor = m_node_index_map.find(index);
if(itor == m_node_index_map.end()) return NULL;
return itor->second;
};
inline node_index_type
get_node_index(std::string const& name)const
{
node_name_map_type::const_iterator itor = m_node_name_map.find(name);
if(itor == m_node_name_map.end()) return NULL;
return itor->second;
};
inline node_index_type
add_node(index_type index, std::string const& name)
{
node_index_type node_index = get_node_index(index);
if(node_index) return node_index;
node_index = create_node(index, name);
m_meta_graph_p->insert(index, rdf_type, top_Node);
m_meta_graph_p->insert(index, top_skip_activation, top_false);
m_meta_graph_p->insert(index, top_name, get_next_name_index(name));
return node_index;
};
inline node_index_type
add_node(std::string const& name)
{
node_index_type node_index = get_node_index(name);
if(node_index) return node_index;
return add_node(m_meta_graph_p->create_bnode_as_index(), name);
};
inline void
set_node_skip_activation(node_index_type node_index, bool skip_activation)
{
if(not node_index) return;
get_node(node_index).set_skip_pattern_activation(skip_activation);
index_type index = node_index->get_rdf_index();
m_meta_graph_p->erase(index, top_skip_activation);
if(skip_activation) {
m_meta_graph_p->insert(index, top_skip_activation, top_true);
} else {
m_meta_graph_p->insert(index, top_skip_activation, top_false);
}
};
int
set_node_name(node_index_type node_index, std::string const& name);
void
remove_node(node_index_type node_index);
inline void
remove_node(std::string const& name)
{
node_index_type node_index = get_node_index(name);
if(not node_index) return;
remove_node(node_index);
};
inline node_map_const_iterator
get_nodes_iterator()const
{
return node_map_const_iterator(m_node_index_map.begin(), m_node_index_map.end());
};
//////////////////////////////////////////////////////////////////////////////////////////
// Category
//////////////////////////////////////////////////////////////////////////////////////////
inline bool
has_category(index_type index)const
{
return m_category_index_map.find(index) != m_category_index_map.end();
};
inline bool
has_category(std::string const& name)const
{
return m_category_name_map.find(name) != m_category_name_map.end();
};
inline category_index_type
get_category_index(index_type index)const
{
category_index_map_type::const_iterator itor = m_category_index_map.find(index);
if(itor == m_category_index_map.end()) return NULL;
return itor->second;
};
inline category_index_type
get_category_index(std::string const& name)const
{
category_name_map_type::const_iterator itor = m_category_name_map.find(name);
if(itor == m_category_name_map.end()) return NULL;
return itor->second;
};
inline category_index_type
add_category(index_type index, std::string const& name)
{
category_index_type category_index = get_category_index(index);
if(category_index) return category_index;
category_index = create_category(index, name);
m_meta_graph_p->insert(index, rdf_type, top_Category);
m_meta_graph_p->insert(index, top_value_partition, top_false);
m_meta_graph_p->insert(index, top_name, get_next_name_index(name));
return category_index;
};
inline category_index_type
add_category(std::string const& name)
{
category_index_type category_index = get_category_index(name);
if(category_index) return category_index;
return add_category(m_meta_graph_p->create_bnode_as_index(), name);
};
inline void
set_category_value_partition(category_index_type category_index, bool is_value_partition)
{
if(category_index->is_value_partition() == is_value_partition) return;
index_type index = category_index->get_rdf_index();
get_category(category_index).set_value_partition(is_value_partition);
m_meta_graph_p->erase(index, top_value_partition);
if(is_value_partition) {
m_meta_graph_p->insert(index, top_value_partition, top_true);
} else {
m_meta_graph_p->insert(index, top_value_partition, top_false);
}
};
int
set_category_name(category_index_type category_index, std::string const& name);
void
remove_category(category_index_type category_index);
inline void
remove_category(std::string const& name)
{
category_index_type category_index = get_category_index(name);
if(not category_index) return;
remove_category(category_index);
};
inline category_map_const_iterator
get_categories_iterator()const
{
return category_map_const_iterator(m_category_index_map.begin(), m_category_index_map.end());
};
inline void
add_node_to_category(category_index_type category_index, node_index_type node_index)
{
if(not node_index or not category_index) return;
get_category(category_index).add_node(node_index);
get_node(node_index).add_category(category_index);
m_meta_graph_p->insert(
category_index->get_rdf_index(),
top_has_node,
node_index->get_rdf_index());
};
inline void
add_nodes_to_category(category_index_type category_index, node_const_iterator_type nodes_begin, node_const_iterator_type nodes_end)
{
if(not category_index) return;
for(node_const_iterator_type itor = nodes_begin; itor!=nodes_end; ++itor) {
add_node_to_category(category_index, *itor);
}
};
inline void
remove_node_from_category(category_index_type category_index, node_index_type node_index)
{
if(not node_index or not category_index) return;
get_category(category_index).remove_node(node_index);
get_node(node_index).remove_category(category_index);
m_meta_graph_p->erase(
category_index->get_rdf_index(),
top_has_node,
node_index->get_rdf_index());
};
//////////////////////////////////////////////////////////////////////////////////////////////
// Rule
//////////////////////////////////////////////////////////////////////////////////////////////
inline bool
is_rule_index(index_type index)const
{
rule_index_map_type::const_iterator itor = m_rule_index_map.find(index);
if(itor == m_rule_index_map.end()) return false;
return true;
};
inline bool
is_rule_index(std::string const& name)const
{
rule_name_map_type::const_iterator itor = m_rule_name_map.find(name);
if(itor == m_rule_name_map.end()) return false;
return true;
};
inline rule_index_type
get_rule_index(index_type index)const
{
rule_index_map_type::const_iterator itor = m_rule_index_map.find(index);
if(itor == m_rule_index_map.end()) return NULL;
return itor->second;
};
inline rule_index_type
get_rule_index(std::string const& name)const
{
rule_name_map_type::const_iterator itor = m_rule_name_map.find(name);
if(itor == m_rule_name_map.end()) return NULL;
return itor->second;
};
rule_index_type
copy_rule(rule_index_type rule_index);
rule_index_type
add_rule(index_type index,
std::string const& name,
unsigned int weight,
category_set_type const& ex_categories,
node_set_type const& c1_nodes,
node_set_type const& c2_nodes,
node_set_type const& negated_nodes);
rule_index_type
add_rule(index_type index, std::string const& name)
{
return add_rule(index,
name,
10,
category_set_type(),
node_set_type(),
node_set_type(),
node_set_type());
};
inline rule_index_type
add_rule(std::string const& name, unsigned int weight)
{
return add_rule(m_meta_graph_p->create_bnode_as_index(),
name,
weight,
category_set_type(),
node_set_type(),
node_set_type(),
node_set_type());
};
inline void
set_rule_weight(rule_index_type rule_index, unsigned int weight)
{
index_type index = rule_index->get_rdf_index();
get_rule(rule_index).set_weight(weight);
m_meta_graph_p->erase(index, top_weight);
index_type windex = m_meta_graph_p->create_literal_as_index(
boost::lexical_cast<std::string>(weight)+"u",
weight);
m_meta_graph_p->insert(index, top_weight, windex);
};
inline void
set_rule_active(rule_index_type rule_index, bool active)
{
index_type index = rule_index->get_rdf_index();
get_rule(rule_index).set_active(active);
m_meta_graph_p->erase(index, top_is_active);
if(active) {
m_meta_graph_p->insert(index, top_is_active, top_true);
} else {
m_meta_graph_p->insert(index, top_is_active, top_false);
}
};
int
set_rule_name(rule_index_type rule_index, std::string const& name);
void
remove_rule(rule_index_type rule_index);
inline void
remove_rule(std::string const& name)
{
rule_index_type rule_index = get_rule_index(name);
if(not rule_index) return;
remove_rule(rule_index);
};
inline void
add_ex_category_to_rule(rule_index_type rule_index, category_index_type category_index)
{
if(not category_index or not rule_index) return;
get_rule(rule_index).add_ex_category(category_index);
m_meta_graph_p->insert(
rule_index->get_rdf_index(),
top_has_ex_category,
category_index->get_rdf_index());
};
inline void
remove_ex_category_from_rule(rule_index_type rule_index, category_index_type category_index)
{
if(not category_index or not rule_index) return;
get_rule(rule_index).remove_ex_category(category_index);
m_meta_graph_p->erase(
rule_index->get_rdf_index(),
top_has_ex_category,
category_index->get_rdf_index());
};
inline void
add_c1_node_to_rule(rule_index_type rule_index, node_index_type node_index)
{
if(not node_index or not rule_index) return;
get_rule(rule_index).add_c1_node(node_index);
get_node(node_index).add_rule(rule_index);
m_meta_graph_p->insert(
rule_index->get_rdf_index(),
top_has_c1_node,
node_index->get_rdf_index());
};
inline void
remove_c1_node_from_rule(rule_index_type rule_index, node_index_type node_index)
{
if(not node_index or not rule_index) return;
get_rule(rule_index).remove_c1_node(node_index);
get_node(node_index).remove_rule(rule_index);
m_meta_graph_p->erase(
rule_index->get_rdf_index(),
top_has_c1_node,
node_index->get_rdf_index());
};
inline void
add_c2_node_to_rule(rule_index_type rule_index, node_index_type node_index)
{
if(not node_index or not rule_index) return;
get_rule(rule_index).add_c2_node(node_index);
m_meta_graph_p->insert(
rule_index->get_rdf_index(),
top_has_c2_node,
node_index->get_rdf_index());
};
inline void
remove_c2_node_from_rule(rule_index_type rule_index, node_index_type node_index)
{
if(not node_index or not rule_index) return;
get_rule(rule_index).remove_c2_node(node_index);
m_meta_graph_p->erase(
rule_index->get_rdf_index(),
top_has_c2_node,
node_index->get_rdf_index());
};
inline void
add_negated_node_to_rule(rule_index_type rule_index, node_index_type node_index)
{
if(not node_index or not rule_index) return;
get_rule(rule_index).add_negated_node(node_index);
m_meta_graph_p->insert(
rule_index->get_rdf_index(),
top_has_negated_node,
node_index->get_rdf_index());
};
inline void
remove_negated_node_from_rule(rule_index_type rule_index, node_index_type node_index)
{
if(not node_index or not rule_index) return;
get_rule(rule_index).remove_negated_node(node_index);
m_meta_graph_p->erase(
rule_index->get_rdf_index(),
top_has_negated_node,
node_index->get_rdf_index());
};
inline rule_map_const_iterator
get_rules_iterator()const
{
return rule_map_const_iterator(m_rule_index_map.begin(), m_rule_index_map.end());
};
//////////////////////////////////////////////////////////////////////////////////////////////
// Pattern
//////////////////////////////////////////////////////////////////////////////////////////////
inline pattern_list_iterator
get_patterns_begin()const
{
return m_pattern_ptr_list.begin();
};
inline pattern_list_iterator
get_patterns_end()const
{
return m_pattern_ptr_list.end();
};
void printAllNodes()const;
void printAllPatterns()const;
void printAllRules()const;
void printAllCategories()const;
inline Node &
get_node(node_index_type node_index)
{
return const_cast<Node&>(*node_index);
};
inline Category &
get_category(category_index_type category_index)
{
return const_cast<Category&>(*category_index);
};
inline Pattern &
get_pattern(pattern_index_type pattern_index)
{
return const_cast<Pattern&>(*pattern_index);
};
inline Rule &
get_rule(rule_index_type rule_index)
{
return const_cast<Rule&>(*rule_index);
};
void
load_from_meta_graph(bool verbose);
void
generate_patterns(bool verbose);
protected:
index_type
get_next_name_index(std::string const& name);
rule_index_type
create_rule(index_type index, std::string const& name)
{
rule_index_type rule_index = get_rule_index(index);
if(rule_index) return rule_index;
rule_ptr_type rule_p(new Rule(this, index));
rule_p->set_name(name);
rule_index = &*rule_p;
m_rule_ptr_list.push_front(rule_p);
m_rule_index_map.insert(std::make_pair(index, rule_index));
m_rule_name_map.insert(std::make_pair(name, rule_index));
return rule_index;
};
Pattern &
create_pattern()
{
index_type index = m_meta_graph_p->create_bnode_as_index();
pattern_ptr_type pattern_p(new Pattern(this, index));
m_pattern_ptr_list.push_front(pattern_p);
return *pattern_p;
};
node_index_type
create_node(index_type index, std::string const& name)
{
node_index_type node_index = get_node_index(index);
if(node_index) return node_index;
node_ptr_type node_p(new Node(this, index));
node_p->set_name(name);
m_node_ptr_list.push_back(node_p);
node_index = &*node_p;
m_node_index_map.insert(std::make_pair(index, node_index));
m_node_name_map.insert(std::make_pair(name, node_index));
return node_index;
};
category_index_type
create_category(index_type index, std::string const& name)
{
category_index_type category_index = get_category_index(index);
if(category_index) return category_index;
category_ptr_type category_p(new Category(this, index));
category_p->set_name(name);
m_category_ptr_list.push_back(category_p);
category_index = &*category_p;
m_category_index_map.insert(std::make_pair(index, category_index));
m_category_name_map.insert(std::make_pair(name, category_index));
return category_index;
};
private:
friend class Pattern;
friend class Rule;
friend class Node;
friend class Category;
rdf::rdf_graph_ptr_type m_meta_graph_p;
node_list_type m_node_ptr_list;
category_list_type m_category_ptr_list;
pattern_list_type m_pattern_ptr_list;
rule_list_type m_rule_ptr_list;
node_index_map_type m_node_index_map;
category_index_map_type m_category_index_map;
rule_index_map_type m_rule_index_map;
node_name_map_type m_node_name_map;
category_name_map_type m_category_name_map;
rule_name_map_type m_rule_name_map;
public:
index_type top_PSearchDB;
index_type top_Node;
index_type top_skip_activation;
index_type top_name;
index_type top_Rule;
index_type top_is_active;
index_type top_weight;
index_type top_has_ex_category;
index_type top_has_c1_node;
index_type top_has_c2_node;
index_type top_has_negated_node;
index_type top_Category;
index_type top_value_partition;
index_type top_has_node;
index_type rdf_type;
index_type top_10u;
index_type top_true;
index_type top_false;
};
}; /* psearch namespace */
#endif /*PSEARCHDB_H_*/
