/* * *@DESC : Copying trie is a recursive function, checking if it is NULL do nothing, * if not create a new node and assign it to original (priority and value) and then recursive call to all the prev node and next node in the trie. * *@Input : Original Node. * *@Output: Returning new node. * */ Node<char>* Trie::copyTrie(Node<char> *original) { if(original == NULL) return NULL; Node<char> *node = new Node<char>(); node->value = original->value; node->priority = original->priority; node->prev = copyTrie(original->prev); delete original->prev; node->next = copyTrie(original->next); delete original->next; return node; }
/* * *@DESC : Operator Overloading, overloads = operator, It calls copyTrie. * *@Input : cnode * *@Output: returning trie pointer. * */ Trie& Trie::operator=(const Trie& cnode) { if (this != &cnode) { Node<char> *temp = copyTrie(cnode.getRoot()); delete cnode.root; this->root = temp; } return *this; }
void align_template(Iterator begin, Iterator end, int gap, score_matrix const & matrix, Callable & callfunc) { typedef std::pair<std::string, simple_matrix2i> node_cache_type; std::string query(begin, end); alicont ali(query, gap, matrix); trie<node_cache_type>* tmp; copyTrie(&tmp); std::string target; std::stack<size_t> index_stack; for (trie<node_cache_type>::iterator i = tmp->begin() + 1; i != tmp->end(); ++i) { target.push_back(i.symbol()); if (!index_stack.empty() && i.prev().fork() && i.prev().index() != index_stack.top()) { while (!index_stack.empty() && index_stack.top() != i.prev().index()) { *(tmp->iter(index_stack.top())) = node_cache_type(); index_stack.pop(); ali.pop(); } } if (i.leaf()) { *i = std::move(std::make_pair(target, ali.score(target))); ali.push(i->first, &(i->second)); index_stack.push(i.index()); target.clear(); alignment_result res = ali.alignment(); res.target_id = iter(i.index())->back().record; if (!callfunc(std::move(res))) { break; } } else if (i.fork()) { *i = std::move(std::make_pair(target, ali.score(target))); ali.push(i->first, &(i->second)); index_stack.push(i.index()); target.clear(); } } delete tmp; }
std::vector<index_type> find(Iterator begin, Iterator end) { typedef typename trie<bool>::iterator tb_iterator; std::vector<index_type> result; trie<bool>* tmp = nullptr; copyTrie(&tmp); size_t deep = 0; const std::set<index_type>* nodes = nullptr; for (Iterator iter = begin; iter != end; ++iter) { nodes = m_stat.get(iter, end); if (nodes == nullptr) { nodes = m_stat.get(iter-1, end); break; } for (auto niter = nodes->begin(); niter != nodes->end(); ++niter) { tb_iterator t(tmp, *niter); *t = true; } deep++; } if (nodes == nullptr) { return result; } for (auto niter = nodes->begin(); niter != nodes->end(); ++niter) { bool breakflag = false; tb_iterator t(tmp, *niter); for (size_t i = deep-1; i != 0; --i) { --t; if (t == tmp->end() || !*t) { breakflag = true; break; } } if (!breakflag) { result.push_back(t.index()); } } delete tmp; return result; }