int callfunc(struct rule *r,struct function *f,void *dp,int type){
int i=0;
int fid=f->fid;
for(i=0;i<10;i++){
if(!fid)
break;
switch (fid)
{
case 1:
_addself(r,f->pt);
break;
case 2:
_delself(r,f->pt);
break;
case 3:
_greater(r,f->pt);
break;
case 4:
_less(r,f->pt);
break;
case 5:
_equal(r,f->pt);
break;
case 6:
_unequal(r,f->pt);
break;
case FUNC_LOG:
_log(r,f->pt);
case FUNC_ALERT:
_alert(r,f->pt);
}
}
}
void merge_list( sq_list list_a, sq_list list_b, sq_list merged_list ){
//Suppose that the lists have been sorted
//Suppose that all lists exist
Length total_length = list_a->length + list_b->length;
if( total_length > merged_list->size ){
merged_list->elem = ( ElemType * )realloc( merged_list->elem, sizeof(ElemType) * ( total_length + 10 ) );
merged_list->size = total_length + 10;
}
//Begin merge
Length a = 0;
Length b = 0;
merged_list->length = total_length;
while( a != list_a->length && b != list_b->length ){
if( _less( &(list_a->elem[a]), &(list_b->elem[b]) ) ){
merged_list->elem[a+b] = list_a->elem[a];
++a;
}else{
merged_list->elem[a+b] = list_b->elem[b];
++b;
}
}
if( a == list_a->length ){
while( b != list_b->length ){
merged_list->elem[a+b] = list_b->elem[b];
++b;
}
}else{
while( a != list_a->length ){
merged_list->elem[a+b] = list_a->elem[a];
++a;
}
}
}
inline bool _string<init_size, inc_bit>::operator<(const _Self & s) const
{
size_t cmp_sz = (this->__len > s.length()) ? this->__len : s.length();
for(size_t i = 0; i < cmp_sz; ++i)
if(!_less(this->__p_string[i], s[i]))
return false;
return true;
}//operator<(base_string)
void fuzzy_search(
const trie_t &dict_trie,
const trie_t &word_trie,
const char_t *lower_limit,
const char_t *upper_limit,
size_t max_dist,
output_t &output) {
less_t _less;
typedef _fuzzy_search_task_t task_t;
typedef _fuzzy_search_greater_task_t greater_task_t;
struct equal_task_t {
bool operator()(const task_t &lhs, const task_t &rhs) {
return
lhs.word_node == rhs.word_node and
lhs.dict_node == rhs.dict_node;// and
// lhs.ttl <= rhs.ttl;
}
};
//queue_t<task_t, (sizeof(task_t) * 1024 - sizeof(void*)) / sizeof(task_t)> q;
std::priority_queue<task_t, typename std::vector<task_t>, greater_task_t> q;
q.push((task_t){dict_trie.root_node, word_trie.root_node, max_dist});
// size_t step_no = 0;
// size_t skip_no = 0;
while (! q.empty() ) {
//++step_no;
const task_t task = q.top();
q.pop();
// while (! q.empty() and equal_task_t()(q.top(), task)) {
// ++skip_no;
// q.pop();
// }
// if (step_no % 10000 == 0) {
// std::cout << "step_no:" << step_no << "\tq_size:" << q.size() << "\tskip_no:" << skip_no <<"\t"<<task.word_node << "\t"<<task.dict_node << "\t" << task.ttl<< std::endl;
// }
const size_t *dict_offset_begin = _get_offset_begin(task.dict_node);
const size_t *word_offset_begin = _get_offset_begin(task.word_node);
if (task.ttl) {
//delete
for (size_t i = 0; i < task.dict_node->child_count; ++i) {
const plane_node_t *dict_child = _get_node(dict_trie, dict_offset_begin[i]);
if (_empty_node(dict_child)) continue;
task_t new_task = task;
new_task.ttl -= 1;
new_task.dict_node = dict_child;
q.push(new_task);
}
// insert
for (size_t i = 0; i < task.word_node->child_count; ++i) {
const plane_node_t *word_child = _get_node(word_trie, word_offset_begin[i]);
if (_empty_node(word_child)) continue;
task_t new_task = task;
new_task.ttl -= 1;
new_task.word_node = word_child;
q.push(new_task);
}
// replace
// foreach curr_node keys
for (size_t dict_child_id = 0; dict_child_id < task.dict_node->child_count; ++dict_child_id) {
const plane_node_t *dict_child = _get_node(dict_trie, dict_offset_begin[dict_child_id]);
if (_empty_node(dict_child)) continue;
for (size_t word_child_id = 0; word_child_id < task.word_node->child_count; ++word_child_id) {
const plane_node_t *word_child = _get_node(word_trie, word_offset_begin[word_child_id]);
if (_empty_node(word_child)) continue;
const char_t &dict_key = ((char_t*)((char*)task.dict_node + sizeof(plane_node_t)))[dict_child_id];
const char_t &word_key = ((char_t*)((char*)task.word_node + sizeof(plane_node_t)))[word_child_id];
if (dict_key == word_key) {
continue; // ignore replace if it's the same as paste
}
task_t new_task = task;
new_task.ttl -= 1;
new_task.dict_node = dict_child;
new_task.word_node = word_child;
q.push(new_task);
}
}
}
// paste
for (size_t i = 0, j = 0; i < task.dict_node->child_count && j < task.word_node->child_count; ) {
const char_t &dict_key = ((char_t*)((char*)task.dict_node + sizeof(plane_node_t)))[i];
const char_t &word_key = ((char_t*)((char*)task.word_node + sizeof(plane_node_t)))[j];
if (_less(dict_key, word_key)) {
++i;
continue;
} else if (_less(word_key, dict_key)) {
++j;
continue;
} else {
const plane_node_t *dict_child = _get_node(dict_trie, dict_offset_begin[i]);
if (_empty_node(dict_child)) {
++i;
++j;
continue;
}
const plane_node_t *word_child = _get_node(word_trie, word_offset_begin[j]);
if (_empty_node(word_child)) {
++i;
++j;
continue;
}
//std::cout << "EQ " << i << " " << j << " : " << word_key << " " << dict_key << std::endl;
task_t new_task = task;
new_task.dict_node = dict_child;
new_task.word_node = word_child;
q.push(new_task);
++i;
++j;
}
}
if (task.dict_node->value && task.word_node->value) {
output.insert(std::make_pair(task.word_node->value, task.dict_node->value));
}
}
}
bool operator ()(size_t i, size_t j)
{
return _less(data_[i], data_[j]);
}
