TEST(Matching, StaticTest_2) {
TestAutoIndex order;
Nodes nodes;
order.addSearch(121);
nodes.insert(121);
order.addSearch(104);
nodes.insert(104);
order.addSearch(53);
nodes.insert(53);
order.addSearch(49);
nodes.insert(49);
order.addSearch(39);
nodes.insert(39);
order.addSearch(33);
nodes.insert(33);
order.addSearch(32);
nodes.insert(32);
order.addSearch(23);
nodes.insert(23);
order.addSearch(11);
nodes.insert(11);
order.addSearch(7);
nodes.insert(7);
order.solve();
int num = order.getNumMatchings();
EXPECT_EQ(num, 5);
}
void Apta::generateData()
{
Q nodeIds;
Fp acceptedNodes;
Fm rejectedNodes;
Nodes allNodes;
allNodes.insert(this->_redNodes.begin(), this->_redNodes.end());
allNodes.insert(this->_blueNodes.begin(), this->_blueNodes.end());
allNodes.insert(this->_whiteNodes.begin(), this->_whiteNodes.end());
for (pair<string, string> node : allNodes) {
if (node.second == Apta::ACCEPTED) {
acceptedNodes.insert(node.first);
} else if (node.second == Apta::REJECTED) {
rejectedNodes.insert(node.first);
}
nodeIds.insert(node.first);
}
this->_data.Q = nodeIds;
this->_data.Z = this->_alphabet;
this->_data.s = this->_rootId;
this->_data.Fp = acceptedNodes;
this->_data.Fm = rejectedNodes;
}
int main()
{
boost::archive::text_oarchive oa(std::cout);
using namespace Input::EMMA;
Nodes nodes;
nodes.address = "Mr.";
nodes.country = "Puerto Mazarique";
nodes.insert(nodes.end(), Node{"John", "Doe"});
nodes.insert(nodes.end(), Node{"Jane", "Greenwalt"});
nodes.insert(nodes.end(), Node{"Morgan", "Cheese"});
nodes.insert(nodes.end(), Node{"Walton", "Whiz"});
oa << nodes;
}
const set<const TypeRef *> & TypeHierarchy::leaves(PTypeRef & t)
{
static Nodes empty;
GI gi = leafNodes.find(&t);
if(gi != leafNodes.end())
{
return (gi->second);
};
gi = downGraph.find(&t);
if(gi == downGraph.end()) return empty;
Nodes ns;
PTypeRef pt(0);
closure(downGraph,gi,ns,gi,&pt);
Nodes ms;
for(Nodes::const_iterator i = ns.begin();i != ns.end();++i)
{
Nodes xs;
gi = downGraph.find(*i);
closure(downGraph,gi,xs,gi,&pt);
if(xs.empty()) ms.insert(*i);
};
leafNodes[downGraph.find(&t)->first] = ms;
return leafNodes[downGraph.find(&t)->first];
};
bool TypeHierarchy::closure(Graph & gr,GI & gi,Nodes & vs,GI & gs,const TypeRef * t)
{
if(gi == gr.end())
{
return false;
};
if(*(gi->first) == *t)
{
for(Nodes::const_iterator i = vs.begin();i != vs.end();++i)
{
gs->second.insert(*i);
//insert(vs.begin(),vs.end());
};
//gs->second.insert(vs.begin(),vs.end());
return true;
};
for(Nodes::iterator n = gi->second.begin();n != gi->second.end();++n)
{
if(vs.find(*n) == vs.end())
{
vs.insert(*n);
GI tmp = gr.find(*n);
if(closure(gr,tmp,vs,gs,t)) return true;
};
};
return false;
};
Nodes NetworkManager::getNodeCandidates()
{
Nodes result;
while ( !depthSearcher->isExhausted() )
{
Elements elements = depthSearcher->getElementCandidates();
cerr << "[NM]\tDepth search returned " << elements.size() << endl;
for ( Elements::iterator i = elements.begin(); i != elements.end(); i++ )
{
Element * element = *i;
if ( ! element->isNode() )
continue;
Node * node = (Node *) element;
if ( rejectedNodes.find(node) != rejectedNodes.end() )
continue;
result.insert(node);
}
depthSearcher->increaseSearchSpace();
if ( !result.empty() )
break;
}
rejectedNodes.insert(result.begin(), result.end());
cerr << "[NM]\tPrepared " << result.size() << " candidates" << endl;
return result;
}
void Node::add(const string& str)
{
string::size_type pos = str.find(c_separator);
string name = str.substr(0, pos);
Node target(name);
CNodeIter iter = m_nodes.find(&target);
if (iter == m_nodes.end()) {
iter = m_nodes.insert(new Node(name)).first;
}
if (pos != string::npos) {
Node* pNode = *iter;
pNode->add(str.substr(pos + 1));
}
}
TEST(Matching, StaticTest_1) {
TestAutoIndex order;
Nodes nodes;
order.addSearch(31);
nodes.insert(31);
order.addSearch(23);
nodes.insert(23);
order.addSearch(15);
nodes.insert(15);
order.addSearch(7);
nodes.insert(7);
order.addSearch(5);
nodes.insert(5);
order.addSearch(3);
nodes.insert(3);
order.addSearch(1);
nodes.insert(1);
order.solve();
int num = order.getNumMatchings();
EXPECT_EQ(num, 5);
}
