bool Callback::isValid( Graph const & g
, Graph::Node const & i
, NodeSet const & dS
, NodeSet const & S) const {
if ( S.find( i ) == S.end() ) {
// i must be in S
return false;
}
if ( dS.find( i ) != dS.end() ) {
// i must not be in dS
return false;
}
// determine dS again
NodeSet ddS;
for ( Graph::Node i : S ) {
for ( Graph::Edge e : g.incEdges( i) ) {
Graph::Node j = g.oppositeNode( i, e );
if ( S.find( j ) == S.end() )
{
ddS.insert( j );
}
}
}
return dS == ddS;
}
void State::removeTrees(const NodeSet& a_nodeSet)
{
for (NodeSetConstIter iter = a_nodeSet.begin(); iter != a_nodeSet.end(); iter++)
{
removeTree(*iter);
}
}
void ActionChoiceWindow::createButtons(
ActionNode* actions, const CEGUI::Point& center,
float radius, float angle, float angleWidth)
{
PushButton* button = NULL;
if (actions->isLeaf())
{
button = createButton(actions->getAction()->getName(), center);
}
else
{
if (actions->getGroup() != NULL)
{
button = createButton(actions->getGroup()->getName(), center);
}
const NodeSet children = actions->getChildren();
float angleStep = angleWidth / (float)children.size();
float ang = children.size()>1 ? angle - angleWidth : angle - 180;
for (NodeSet::const_iterator iter = children.begin();
iter != children.end(); iter++)
{
CEGUI::Point centerChild = getPositionOnCircle(center, radius, ang);
createButtons(*iter, centerChild, radius, ang, 60);
ang += angleStep;
}
}
actions->setButton(button);
if (button != NULL)
mWindow->addChildWindow(button);
}
Item::Ptr UTransform::TransformResult::next(DynamicContext *context)
{
context->testInterrupt();
AutoVariableStoreReset reset(context, &scope_);
if(toDo_) {
toDo_ = false;
NodeSet copiedNodes = NodeSet(nodecompare(context));
VectorOfCopyBinding::const_iterator end = transform_->getBindings()->end();
for(VectorOfCopyBinding::const_iterator it = transform_->getBindings()->begin();
it != end; ++it) {
if((*it)->qname_ == 0) continue;
Sequence values = (*it)->expr_->createResult(context)->toSequence(context);
// Keep a record of the nodes that have been copied
Result valIt = values;
Item::Ptr val;
while((val = valIt->next(context)).notNull()) {
copiedNodes.insert((Node*)val.get());
}
scope_.setVar((*it)->uri_, (*it)->name_, values);
}
// Get the pending update list
PendingUpdateList pul = transform_->getModifyExpr()->createUpdateList(context);
// Check that the targets of the pending updates are copied nodes
for(PendingUpdateList::const_iterator i = pul.begin(); i != pul.end(); ++i) {
Node::Ptr target = i->getTarget();
while(copiedNodes.find(target) == copiedNodes.end()) {
target = target->dmParent(context);
if(target.isNull()) {
XQThrow3(StaticErrorException,X("UTransform::staticTyping"),
X("The target node of an update expression in the transform expression is not a node from the copy clauses [err:XUDY0014]"), &(*i));
}
}
}
// Apply the updates
AutoDelete<UpdateFactory> ufactory(context->createUpdateFactory());
ufactory->applyUpdates(pul, context, transform_->getRevalidationMode());
// Execute the return expression
result_ = transform_->getReturnExpr()->createResult(context);
}
Item::Ptr result = result_->next(context);
if(result.isNull()) {
result_ = 0;
return 0;
}
return result;
}
void ConfigFileWriter::writeRadiosFile(std::string filename, NodeSet& ns)
{
std::fstream out;
out.open(filename.c_str(), std::fstream::out | std::fstream::trunc);
NodeSet::iterator it = ns.begin();
while (it != ns.end())
{
EntityStruct* ent = (*it)->entity;
int len = strlen((char*)ent->marking.markingData);
if (len == 0 || len > 11)
{
it++;
continue;
}
RadioStruct* radio = (*it)->radio;
if (radio)
{
out << (*it)->NodeId << ", ";
out << ent->marking << ", ";
out << radio->radioIndex << ", ";
out << radio->relativePosition << ", ";
out << radio->radioSystemType ;
out << std::endl;
}
it++;
}
out.close();
}
void State::functionGreaterEqual(const string& a_name, int a_value)
{
NodeSet* parentSet = getVariableNodes(a_name);
if (parentSet == NULL)
{
error("State::functionGreaterEqual - variable " + a_name + " doesn't exist" , false);
return;
}
NodeSet removedRoots;
for (NodeSetConstIter iter = parentSet->begin(); iter != parentSet->end(); iter++)
{
if ((*iter) == NULL)
{
error("State::functionGreaterEqual - iterator for variable " + a_name + " is NULL", false);
continue;
}
if ((*iter)->getMaxValue() < a_value)
{
debug("State::functionGreaterEqual - Adding " + a_name + "'s root to removedRoots set");
removedRoots.insert((*iter)->getRoot());
continue;
}
if ((*iter)->getMinValue() < a_value)
{
(*iter)->setMinValue(a_value);
}
}
debug("State::functionGreaterEqual - removing trees");
removeTrees(removedRoots);
}
void GraphicsContext::removeCamera(osg::Camera* camera)
{
Cameras::iterator itr = std::find(_cameras.begin(), _cameras.end(), camera);
if (itr != _cameras.end())
{
// find a set of nodes attached the camera that we are removing that isn't
// shared by any other cameras on this GraphicsContext
typedef std::set<Node*> NodeSet;
NodeSet nodes;
for(unsigned int i=0; i<camera->getNumChildren(); ++i)
{
nodes.insert(camera->getChild(i));
}
for(Cameras::iterator citr = _cameras.begin();
citr != _cameras.end();
++citr)
{
if (citr != itr)
{
osg::Camera* otherCamera = *citr;
for(unsigned int i=0; i<otherCamera->getNumChildren(); ++i)
{
NodeSet::iterator nitr = nodes.find(otherCamera->getChild(i));
if (nitr != nodes.end()) nodes.erase(nitr);
}
}
}
// now release the GLobjects associated with these non shared nodes
for(NodeSet::iterator nitr = nodes.begin();
nitr != nodes.end();
++nitr)
{
const_cast<osg::Node*>(*nitr)->releaseGLObjects(_state.get());
}
// release the context of the any RenderingCache that the Camera has.
if (camera->getRenderingCache())
{
camera->getRenderingCache()->releaseGLObjects(_state.get());
}
_cameras.erase(itr);
}
}
void ActionChoiceWindow::ActionNode::getAllNodes(ActionNode* treeRoot, NodeSet& nodes)
{
nodes.insert(treeRoot);
const NodeSet children = treeRoot->getChildren();
for (NodeSet::const_iterator iter = children.begin(); iter != children.end(); iter++)
getAllNodes(*iter, nodes);
}
explicit RemovePlaceholdersVisitor(AstNode* nodep) {
iterate(nodep);
for (NodeSet::const_iterator it = m_removeSet.begin();
it != m_removeSet.end(); ++it) {
AstNode* np = *it;
np->unlinkFrBack(); // Without next
np->deleteTree(); VL_DANGLING(np);
}
}
void ConfigFileWriter::writeNetworksFile(std::string filename, NodeSet& ns)
{
std::fstream out;
out.open(filename.c_str(), std::fstream::out | std::fstream::trunc);
NodeSet::iterator it = ns.begin();
out << "N1;3000000000;";
while (it != ns.end())
{
out << (*it)->NodeId;
it++;
if (it != ns.end())
{
out << ", ";
}
}
out << ";255.255.255.255";
out.close();
}
uint64_t CVC4::theory::bv::utils::numNodes(TNode node, NodeSet& seen) {
if (seen.find(node) != seen.end())
return 0;
uint64_t size = 1;
for (unsigned i = 0; i < node.getNumChildren(); ++i) {
size += numNodes(node[i], seen);
}
seen.insert(node);
return size;
}
void writeHostnameSection(std::ostream& out, NodeSet& ns)
{
NodeSet::iterator it = ns.begin();
while (it != ns.end())
{
out << "[" << (*it)->NodeId << "] HOSTNAME\t\""
<< (*it)->entity->marking.markingData << "\"" << std::endl;
it++;
}
out << std::endl;
}
void CVC4::theory::bv::utils::collectVariables(TNode node, NodeSet& vars) {
if (vars.find(node) != vars.end())
return;
if (Theory::isLeafOf(node, THEORY_BV) && node.getKind() != kind::CONST_BITVECTOR) {
vars.insert(node);
return;
}
for (unsigned i = 0; i < node.getNumChildren(); ++i) {
collectVariables(node[i], vars);
}
}
/**
* Prepares constraints in order to apply VPSC vertically to remove ALL overlap.
*/
int generateYConstraints(const int n, Rectangle** rs, Variable** vars, Constraint** &cs) {
events=new Event*[2*n];
int ctr=0,i,m;
for(i=0;i<n;i++) {
vars[i]->desiredPosition=rs[i]->getCentreY();
Node *v = new Node(vars[i],rs[i],rs[i]->getCentreY());
events[ctr++]=new Event(Open,v,rs[i]->getMinX());
events[ctr++]=new Event(Close,v,rs[i]->getMaxX());
}
qsort((Event*)events, (size_t)2*n, sizeof(Event*), compare_events );
NodeSet scanline;
vector<Constraint*> constraints;
for(i=0;i<2*n;i++) {
Event *e=events[i];
Node *v=e->v;
if(e->type==Open) {
scanline.insert(v);
NodeSet::iterator i=scanline.find(v);
if(i--!=scanline.begin()) {
Node *u=*i;
v->firstAbove=u;
u->firstBelow=v;
}
i=scanline.find(v);
if(++i!=scanline.end()) {
Node *u=*i;
v->firstBelow=u;
u->firstAbove=v;
}
} else {
// Close event
Node *l=v->firstAbove, *r=v->firstBelow;
if(l!=NULL) {
double sep = (v->r->height()+l->r->height())/2.0;
constraints.push_back(new Constraint(l->v,v->v,sep));
l->firstBelow=v->firstBelow;
}
if(r!=NULL) {
double sep = (v->r->height()+r->r->height())/2.0;
constraints.push_back(new Constraint(v->v,r->v,sep));
r->firstAbove=v->firstAbove;
}
scanline.erase(v);
delete v;
}
delete e;
}
delete [] events;
cs=new Constraint*[m=constraints.size()];
for(i=0;i<m;i++) cs[i]=constraints[i];
return m;
}
void TheoryEngineModelBuilder::checkTerms(TNode n, TheoryModel* tm, NodeSet& cache)
{
if (cache.find(n) != cache.end()) {
return;
}
if (isAssignable(n)) {
tm->d_equalityEngine.addTerm(n);
}
for(TNode::iterator child_it = n.begin(); child_it != n.end(); ++child_it) {
checkTerms(*child_it, tm, cache);
}
cache.insert(n);
}
void sort(const DOMNode& node,
NodeSet& nodes,
ExecutionContext<string_type, string_adaptor>& context) const
{
if(!sort_)
{
if(!nodes.forward())
nodes.to_document_order();
return;
}
sort_->set_context(node, context);
std::stable_sort(nodes.begin(), nodes.end(), SortP(*sort_));
} // sort
/** Get parsed fields.
* Get fields stored below the given node.
* @param node root node where to start searching
* @return vector of field representations.
*/
std::vector<InterfaceField>
InterfaceParser::getFields(xmlpp::Node *node)
{
vector<InterfaceField> result;
NodeSet set = node->find("field");
for (NodeSet::iterator i = set.begin(); i != set.end(); ++i) {
InterfaceField f(&enum_constants);
const Element * el = dynamic_cast<const Element *>(*i);
if ( el ) {
// valid element
const Element::AttributeList& attrs = el->get_attributes();
for(Element::AttributeList::const_iterator iter = attrs.begin(); iter != attrs.end(); ++iter) {
const Attribute* attr = *iter;
//std::cout << " Attribute " << attr->get_name() << " = " << attr->get_value() << std::endl;
f.setAttribute(attr->get_name(), attr->get_value());
}
} else {
throw InterfaceGeneratorInvalidContentException("constant is not an element");
}
// Get field comment
NodeSet nameset = (*i)->find("text()");
if ( nameset.size() == 0 ) {
throw InterfaceGeneratorInvalidContentException("no comment for field %s", f.getName().c_str());
}
const TextNode *comment_node = dynamic_cast<const TextNode *>(nameset[0]);
if ( ! comment_node ) {
throw InterfaceGeneratorInvalidContentException("comment node not text node for constant");
}
f.setComment(comment_node->get_content());
//std::cout << "Field name: " << field_name << std::endl;
try {
f.valid();
result.push_back(f);
} catch ( fawkes::Exception &e ) {
e.print_trace();
}
}
for (vector<InterfaceField>::iterator i = result.begin(); i != result.end(); ++i) {
for (vector<InterfaceField>::iterator j = i + 1; j != result.end(); ++j) {
if ( (*i).getName() == (*j).getName() ) {
throw InterfaceGeneratorAmbiguousNameException((*i).getName().c_str(), "field");
}
}
}
return result;
}
void State::join(const State& a_otherState)
{
NodePairSet commonRoots;
NodeSet myUniqueRoots;
NodeSet otherUniqueRoots;
debug("State::join - joining state: " + string(*this));
debug("State::join - with state: " + string(a_otherState));
divideTrees(a_otherState, commonRoots, myUniqueRoots, otherUniqueRoots);
m_rootSet.clear();
for (NodePairSetIter iter = commonRoots.begin(); iter != commonRoots.end(); iter++)
{
TreeNode* myTree = iter->first;
TreeNode* otherTree = iter->second;
myTree->join(otherTree);
m_rootSet.insert(myTree);
}
for (NodeSetIter iter = myUniqueRoots.begin(); iter != myUniqueRoots.end(); iter++)
{
m_rootSet.insert(*iter);
}
for (NodeSetIter iter = otherUniqueRoots.begin(); iter != otherUniqueRoots.end(); iter++)
{
TreeNode* node = new TreeNode(*(*iter));
m_rootSet.insert(node);
}
buildVariableMap();
debug("State::join - joined state: " + string(*this));
}
NodeSet Liveness::getAllReachedUses(RegisterRef RefRR,
NodeAddr<DefNode*> DefA, const RegisterAggr &DefRRs) {
NodeSet Uses;
// If the original register is already covered by all the intervening
// defs, no more uses can be reached.
if (DefRRs.hasCoverOf(RefRR))
return Uses;
// Add all directly reached uses.
// If the def is dead, it does not provide a value for any use.
bool IsDead = DefA.Addr->getFlags() & NodeAttrs::Dead;
NodeId U = !IsDead ? DefA.Addr->getReachedUse() : 0;
while (U != 0) {
auto UA = DFG.addr<UseNode*>(U);
if (!(UA.Addr->getFlags() & NodeAttrs::Undef)) {
RegisterRef UR = UA.Addr->getRegRef(DFG);
if (PRI.alias(RefRR, UR) && !DefRRs.hasCoverOf(UR))
Uses.insert(U);
}
U = UA.Addr->getSibling();
}
// Traverse all reached defs. This time dead defs cannot be ignored.
for (NodeId D = DefA.Addr->getReachedDef(), NextD; D != 0; D = NextD) {
auto DA = DFG.addr<DefNode*>(D);
NextD = DA.Addr->getSibling();
RegisterRef DR = DA.Addr->getRegRef(DFG);
// If this def is already covered, it cannot reach anything new.
// Similarly, skip it if it is not aliased to the interesting register.
if (DefRRs.hasCoverOf(DR) || !PRI.alias(RefRR, DR))
continue;
NodeSet T;
if (DFG.IsPreservingDef(DA)) {
// If it is a preserving def, do not update the set of intervening defs.
T = getAllReachedUses(RefRR, DA, DefRRs);
} else {
RegisterAggr NewDefRRs = DefRRs;
NewDefRRs.insert(DR);
T = getAllReachedUses(RefRR, DA, NewDefRRs);
}
Uses.insert(T.begin(), T.end());
}
return Uses;
}
void emptyTree(NodeSet roots)
{
TreeNode *tempNode = 0, *parentNode = 0;
NodeSetIter setIter;
NodeList nodeList;
NodeListIter listIter;
for(setIter=roots.begin(); setIter!=roots.end(); ++setIter)
{
tempNode=0;
parentNode=0;
if(*setIter!=0)
{
nodeList.push_front(*setIter);
while (nodeList.size()!=0)
{
listIter=nodeList.begin();
tempNode=(*listIter);
nodeList.pop_front();
if (tempNode->right==0 && tempNode->left==0)
{
parentNode=tempNode->parent;
if (parentNode->right->ID==tempNode->ID)
parentNode->right = 0;
else
parentNode->left=0;
delete tempNode;
tempNode=0;
}
else
{
if(tempNode->right!=0)
nodeList.push_front(tempNode->right);
if(tempNode->left!=0)
nodeList.push_front(tempNode->left);
}
}
}
nodeList.clear();
}
}
void writeNodeIconSection(std::ostream& out, NodeSet& ns, Config& config)
{
iconNames.clear();
NodeSet::iterator it = ns.begin();
while (it != ns.end())
{
EntityTypeStruct type = (*it)->entity->entityType;
const std::string& icon = (*it)->getIconName();
if (!icon.empty())
{
std::string filename = config.getFileName(icon);
out << "[" << (*it)->NodeId << "] NODE-ICON";
out << "\t\ticons" << config.dirSep << filename << std::endl;
iconNames.insert(icon);
}
it++;
}
out << std::endl;
}
NodeSet Liveness::getAllReachedUses(RegisterRef RefRR,
NodeAddr<DefNode*> DefA, const RegisterSet &DefRRs) {
NodeSet Uses;
// If the original register is already covered by all the intervening
// defs, no more uses can be reached.
if (RAI.covers(DefRRs, RefRR, DFG))
return Uses;
// Add all directly reached uses.
NodeId U = DefA.Addr->getReachedUse();
while (U != 0) {
auto UA = DFG.addr<UseNode*>(U);
if (!(UA.Addr->getFlags() & NodeAttrs::Undef)) {
auto UR = UA.Addr->getRegRef();
if (RAI.alias(RefRR, UR, DFG) && !RAI.covers(DefRRs, UR, DFG))
Uses.insert(U);
}
U = UA.Addr->getSibling();
}
// Traverse all reached defs.
for (NodeId D = DefA.Addr->getReachedDef(), NextD; D != 0; D = NextD) {
auto DA = DFG.addr<DefNode*>(D);
NextD = DA.Addr->getSibling();
auto DR = DA.Addr->getRegRef();
// If this def is already covered, it cannot reach anything new.
// Similarly, skip it if it is not aliased to the interesting register.
if (RAI.covers(DefRRs, DR, DFG) || !RAI.alias(RefRR, DR, DFG))
continue;
NodeSet T;
if (DFG.IsPreservingDef(DA)) {
// If it is a preserving def, do not update the set of intervening defs.
T = getAllReachedUses(RefRR, DA, DefRRs);
} else {
RegisterSet NewDefRRs = DefRRs;
NewDefRRs.insert(DR);
T = getAllReachedUses(RefRR, DA, NewDefRRs);
}
Uses.insert(T.begin(), T.end());
}
return Uses;
}
void State::functionSetRight(const string& a_parent, const string& a_child)
{
TreeNode* childNode = getUniqueRoot(a_child);
if (childNode == NULL)
{
error("State::functionSetRight - Can't set a node as a child if it already has a parent", false);
return;
}
NodeSet* parentSet = getVariableNodes(a_parent);
if (parentSet == NULL)
{
error("State::functionSetRight - variable " + a_parent + " doesn't exist", false);
return;
}
for (NodeSetConstIter iter = parentSet->begin(); iter != parentSet->end(); iter++)
{
if ((*iter) == NULL)
{
error("State::functionSetRight - iterator for variable " + a_parent + " is NULL", false);
continue;
}
TreeNode* rightChild = (*iter)->getRightChild();
if (rightChild == NULL)
{
TreeNode* node = new TreeNode(*childNode);
node->setParent(*iter);
(*iter)->setRightChild(node);
}
else
{
rightChild->join(childNode);
}
}
m_rootSet.erase(childNode);
delete childNode;
buildVariableMap();
}
void State::functionSetValue(const string& a_name, int a_value)
{
NodeSet* parentSet = getVariableNodes(a_name);
if (parentSet == NULL)
{
stringstream ss;
error("State::functionSetValue - variable " + a_name + " doesn't exist", false);
return;
}
for (NodeSetConstIter iter = parentSet->begin(); iter != parentSet->end(); iter++)
{
if ((*iter) == NULL)
{
error("State::functionSetValue - iterator for variable " + a_name + " is NULL", false);
continue;
}
(*iter)->setMaxValue(a_value);
(*iter)->setMinValue(a_value);
}
}
void SchedViz::Visit_Deployment( const Semantics::Deployment &deployment ) {
// Determine the hyperperiod
// TODO: quick fix -- this needs to be changed if we have multiple hyperperiods
BusSet busSet = deployment.CommMedium_children();
BusSet::iterator busIter = busSet.begin();
this->_hyperperiodSec = busIter->hyperperiodsecs();
// Get the set of children Nodes
NodeSet nodeSet = deployment.Node_children();
NodeSet::iterator nodeIter = nodeSet.begin();
// For each node ...
for ( ; nodeIter != nodeSet.end(); nodeIter++ ) {
// Visit the node
this->Visit_Node( *nodeIter );
}
// For each bus ...
for ( ; busIter != busSet.end(); busIter++ ) {
// Visit each bus
this->Visit_Bus( *busIter );
}
}
void State::divideTrees(const State& a_other, NodePairSet& a_commonRoots, NodeSet& a_myUniqueRoots, NodeSet& a_otherUniqueRoots)
{
NodeSet otherRootSet = a_other.getRootSet(); // Copy the entire set
a_commonRoots.clear();
a_myUniqueRoots.clear();
a_otherUniqueRoots.clear();
for (NodeSetIter iter = m_rootSet.begin(); iter != m_rootSet.end(); iter++)
{
bool isUnique = true;
string rootName;
if (!((*iter)->getUniqueName(rootName)))
{
error("State::divideTrees - Multiple roots (in this state) with the same name " + rootName + " exist! " + string(*this), true);
}
for (NodeSetIter otherIter = otherRootSet.begin(); otherIter != otherRootSet.end(); otherIter++)
{
string otherRootName;
if (!((*otherIter)->getUniqueName(otherRootName)))
{
error("State::divideTrees - Multiple roots (in joined state) with the same name " + otherRootName + " exist! " + string(a_other), true);
}
if (rootName == otherRootName)
{
a_commonRoots.insert(make_pair((*iter), (*otherIter)));
otherRootSet.erase(otherIter);
isUnique = false;
break;
}
}
if (isUnique)
{
a_myUniqueRoots.insert(*iter);
}
}
a_otherUniqueRoots = otherRootSet;
}
void State::functionIncrement(const string& a_name, int a_value)
{
NodeSet* parentSet = getVariableNodes(a_name);
if (parentSet == NULL)
{
verbose("State::functionIncrement - variable " + a_name + " doesn't exist");
return;
}
for (NodeSetConstIter iter = parentSet->begin(); iter != parentSet->end(); iter++)
{
if ((*iter) == NULL)
{
error("State::functionIncrement - iterator for variable " + a_name + " is NULL", false);
continue;
}
int maxValue = (*iter)->getMaxValue();
int minValue = (*iter)->getMinValue();
(*iter)->setMaxValue(maxValue + a_value);
(*iter)->setMinValue(minValue + a_value);
}
}
/*
* DeleteCFG()
* Remove one CFG.
*/
void DeleteCFG(GraphNode *Root)
{
NodeVec VisitStack;
NodeSet Visited;
VisitStack.push_back(Root);
while(VisitStack.size())
{
GraphNode *Parent = VisitStack.back();
VisitStack.pop_back();
if (Visited.count(Parent))
continue;
Visited.insert(Parent);
NodeVec &Child = Parent->getSuccessor();
for (int i = 0, e = Child.size(); i < e; i++)
VisitStack.push_back(Child[i]);
}
for (NodeSet::iterator I = Visited.begin(), E = Visited.end(); I != E; I++)
delete *I;
}
void ConfigFileWriter::writeNodesFile(std::string filename, NodeSet& ns)
{
std::fstream out;
out.open(filename.c_str(), std::fstream::out | std::fstream::trunc);
out.precision(10);
NodeSet::iterator it = ns.begin();
while (it != ns.end())
{
EntityStruct* ent = (*it)->entity;
double lat = ent->worldLocation.lat;
double lon = ent->worldLocation.lon;
if (fabs(lat) > 90.0 || fabs(lon) > 180.0)
{
lat = 0.0;
lon = 0.0;
}
RadioStruct* radio = (*it)->radio;
if (radio)
{
double lat, lon, alt;
lat = radio->absoluteNodePosInLatLonAlt.lat;
lon = radio->absoluteNodePosInLatLonAlt.lon;
alt = radio->absoluteNodePosInLatLonAlt.alt;
out << (*it)->NodeId << " 0 ";
out << "(" << lat << ", " << lon << ", " << alt << ") ";
out << ent->orientation.azimuth << " ";
out << ent->orientation.elevation;
out << std::endl;
}
it++;
}
out.close();
}
void SomeFunction(DominatorMap &dominators, NodeSet &newDominators, ControlFlowNode *n, _Func func)
{
newDominators.insert(n);
if (!func(n).empty())
{
NodeSet result;
bool first = true;
for (ControlFlowNode *pred : func(n))
{
if (first)
{
result = dominators[pred];
first = false;
}
else
{
NodeSet resultTemp;
NodeSet &temp = dominators[pred];
set_intersection(result.begin(), result.end(),
temp.begin(), temp.end(),
inserter(resultTemp, resultTemp.begin()),
std::less<ControlFlowNode*>()
);
swap(resultTemp, result);
}
}
for (ControlFlowNode *node : result)
{
newDominators.insert(node);
}
}
// Now look at all the predecessors p of n.
// Add in the intersection of all those dominators for them.
}
