NodePath* Dijkstra::calculate_path(Node* start, Node* dest) {
/**
* This is the dijkstra algorithm that searches through the node graph for
* the most efficiant way from start node to destination node.
*/
//Initialize; set cost to startnode to zero and rest to inf.
Node* current_node = start;
NodeVector graph = grid->get_nodes();
for (NodeVector::iterator it = graph.begin(); it != graph.end(); it++) {
(*it)->set_cost_from_start(max_cost);
}
start->set_cost_from_start(0);
prio_queue.push(current_node);
//Core loop
while (!prio_queue.empty()) {
current_node = prio_queue.top();
prio_queue.pop();
if (current_node == dest) {
save_path(start, dest);
while (!prio_queue.empty())
{
prio_queue.pop();
}
return create_path_copy(saved_paths[NodePair(start, dest)]);
}
NodeVector neighbors = current_node->get_neighbors();
for (NodeVector::iterator neighbor = neighbors.begin(); neighbor != neighbors.end(); neighbor++) {
if (*neighbor == current_node)
continue;
if (!(*neighbor)->is_allowed())
continue;
int new_cost = current_node->get_cost_from_start();
new_cost++;
int neighbor_cost = (*neighbor)->get_cost_from_start();
if (new_cost < neighbor_cost) {
(*neighbor)->set_cost_from_start(new_cost);
(*neighbor)->set_parent(current_node);
prio_queue.push((*neighbor));
}
}
}
save_path(start, dest);
return create_path_copy(saved_paths[NodePair(start, dest)]);
}
/**
* Copies the entries of the input vector of types to the output vector,
* omitting duplicate types. Useful for TypeSet and UnionType simplification.
*/
void copyUnique(const NodeVector& input, NodeVector& output)
{
for (NodeVector::const_iterator it = input.begin(); it != input.end(); it++) {
bool exists = false;
for (NodeVector::iterator is = output.begin(); is != output.end(); is++) {
if (equal(*it, *is)) {
exists = true;
break;
}
}
if (!exists) output.push_back(*it);
}
assert(output.size() <= input.size());
assert(output.empty() == input.empty());
}
void ContainerNode::parserInsertBefore(PassRefPtr<Node> newChild, Node* nextChild)
{
ASSERT(newChild);
ASSERT(nextChild);
ASSERT(nextChild->parentNode() == this);
NodeVector targets;
collectTargetNodes(newChild.get(), targets);
if (targets.isEmpty())
return;
if (nextChild->previousSibling() == newChild || nextChild == newChild) // nothing to do
return;
RefPtr<Node> next = nextChild;
RefPtr<Node> nextChildPreviousSibling = nextChild->previousSibling();
for (NodeVector::const_iterator it = targets.begin(); it != targets.end(); ++it) {
Node* child = it->get();
insertBeforeCommon(next.get(), child);
childrenChanged(true, nextChildPreviousSibling.get(), nextChild, 1);
ChildNodeInsertionNotifier(this).notify(child);
}
}
void CUniformGrid::GetUnitsInRadius(NodeVector * dstVector, const Vector3 & point, float radius)
{
const Vector3 radiusPoint(radius, radius, 0);
int minX, minY;
CellCoordFromMapPoint(&minX, &minY, point - radiusPoint);
minX = math::max(0, math::min(minX, (m_Width - 1)));
minY = math::max(0, math::min(minY, (m_Height - 1)));
int maxX, maxY;
CellCoordFromMapPoint(&maxX, &maxY, point + radiusPoint);
maxX = math::max(0, math::min(maxX, (m_Width - 1)));
maxY = math::max(0, math::min(maxY, (m_Height - 1)));
dstVector->clear();
for (int y = minY; y <= maxY; ++y)
{
for (int x = minX; x <= maxX; ++x)
{
// FIXME: non optimal - square, refactor me
NodeVector * gridVector = GetCell(x, y);
dstVector->insert(dstVector->end(), gridVector->begin(), gridVector->end());
}
}
}
void sortNodes(NodeVector& all){
// int count=0;
int max=0;
deque<Node*> sorted;
for (int i=0; i<all.size(); i++) {
Node* n=all[i];
if(n->statementCount>max){
sorted.push_front(n);
max=n->statementCount;
}
else sorted.push_back(n);
}
for (int i=0; i<all.size(); i++) {
all[i]=sorted[i];
}
std::sort(all.begin(), all.end(),sortNodePredicate);
// auto x=all.begin();
// auto y=all.end();
// std::sort(x, y, sortNodePredicate);// [] (Node* a, Node* b){ return a->statementCount > b->statementCount; });
// std::sort(all.begin(), all.end(), [] (Node* a, Node* b)->bool { return a->statementCount < b->statementCount; });
// showNodes(all,false,false,false);
// std::sort(all.begin(), all.end(), [] (Node* a, Node* b) { return a->statementCount < b->statementCount; });
// showNodes(all,false,false,false);
// std::sort(all.begin(),all.end(),);
}
/**
* Returns the intersection between the TypeSet and the other node. The other
* node may also be a type set, in which case this function is called
* recursively to resolve the intersect.
*/
NodePtr intersect(const TypeSet::Ptr& typeSet, const NodePtr& other)
{
// Intersect all types in the type set with the other type.
NodeVector newTypes;
const NodeVector& types = typeSet->getTypes();
for (NodeVector::const_iterator it = types.begin(); it != types.end(); it++) {
NodePtr type = intersect(*it, other);
if (type->isKindOf(kInvalidType)) continue; // skip if the intersect was impossible
bool exists = false;
for (NodeVector::iterator is = newTypes.begin(); is != newTypes.end(); is++) {
if (equal(type, *is)) {
exists = true;
break;
}
}
if (!exists) newTypes.push_back(type);
}
// Return the new type set if it contains multiple types, a single type if
// there's only one left after the intersect, or InvalidType if the
// intersect yielded no types in the set.
if (newTypes.empty()) {
return NodePtr(new InvalidType);
} else if (newTypes.size() == 1) {
return newTypes.front();
} else {
TypeSet::Ptr ts(new TypeSet);
ts->setTypes(newTypes);
return ts;
}
}
static void willRemoveChildren(ContainerNode* container)
{
NodeVector children;
getChildNodes(container, children);
container->document()->nodeChildrenWillBeRemoved(container);
#if ENABLE(MUTATION_OBSERVERS)
ChildListMutationScope mutation(container);
#endif
for (NodeVector::const_iterator it = children.begin(); it != children.end(); it++) {
Node* child = it->get();
#if ENABLE(MUTATION_OBSERVERS)
mutation.willRemoveChild(child);
child->notifyMutationObserversNodeWillDetach();
#endif
#if ENABLE(UNDO_MANAGER)
if (UndoManager::isRecordingAutomaticTransaction(container))
UndoManager::addTransactionStep(NodeRemovingDOMTransactionStep::create(container, child));
#endif
// fire removed from document mutation events.
dispatchChildRemovalEvents(child);
}
ChildFrameDisconnector(container, ChildFrameDisconnector::DoNotIncludeRoot).disconnect();
}
template<class NodeVector> void FileSystem::debugPrintNodes(NodeVector nodes) {
if( debug) {
unsigned int ix;
NodeInfo* node;
for (ix = 0; ix < nodes.size(); ++ix) {
node = nodes.at(ix);
cout << "Node: " << node->getName()
<< "\t\tSize: " << node->getSize()
<< "\tModify: " << node->getModifyTime()
<< "\tPath: " << node->getPath()
<< "\tSimilars: ";
vector<NodeInfo*>::iterator it;
vector<NodeInfo*> nodes = node->getSimilar();
for(it=nodes.begin(); it != nodes.end(); ++it) {
cout << (*it)->getPath() << ", ";
}
cout << endl;
}
}
}
bool ContainerNode::appendChild(PassRefPtr<Node> newChild, ExceptionCode& ec, AttachBehavior attachBehavior)
{
RefPtr<ContainerNode> protect(this);
// Check that this node is not "floating".
// If it is, it can be deleted as a side effect of sending mutation events.
ASSERT(refCount() || parentOrShadowHostNode());
ec = 0;
// Make sure adding the new child is ok
if (!checkAddChild(this, newChild.get(), ec))
return false;
if (newChild == m_lastChild) // nothing to do
return newChild;
NodeVector targets;
collectChildrenAndRemoveFromOldParent(newChild.get(), targets, ec);
if (ec)
return false;
if (targets.isEmpty())
return true;
// We need this extra check because collectChildrenAndRemoveFromOldParent() can fire mutation events.
if (!checkAcceptChildGuaranteedNodeTypes(this, newChild.get(), ec))
return false;
InspectorInstrumentation::willInsertDOMNode(document(), this);
// Now actually add the child(ren)
ChildListMutationScope mutation(this);
for (NodeVector::const_iterator it = targets.begin(); it != targets.end(); ++it) {
Node* child = it->get();
// If the child has a parent again, just stop what we're doing, because
// that means someone is doing something with DOM mutation -- can't re-parent
// a child that already has a parent.
if (child->parentNode())
break;
treeScope()->adoptIfNeeded(child);
// Append child to the end of the list
{
NoEventDispatchAssertion assertNoEventDispatch;
appendChildToContainer(child, this);
}
updateTreeAfterInsertion(this, child, attachBehavior);
}
dispatchSubtreeModifiedEvent();
return true;
}
void InitRootTypes::wrapFuncArgs(NodeVector& args, const NodeVector& funcArgs)
{
for (NodeVector::const_iterator it = funcArgs.begin(); it != funcArgs.end(); it++) {
const FuncArg::Ptr& funcArg = FuncArg::from(*it);
TupleTypeArg::Ptr arg(new TupleTypeArg);
arg->setName(funcArg->getName());
arg->setType(funcArg->getPossibleType());
args.push_back(arg);
}
}
bool isEmbedded()
{
if (isAssocClass)
for (NodeVector::const_iterator it = oFields.begin(); it != oFields.end(); ++it)
{
if (*it == NULL) continue;
if (CSLTestBoolean(CPLGetXMLValue( *it, "EmbeddedTransfer", "FALSE" )))
return true;
}
return false;
}
void Class::addFields(const NodeVector& fields)
{
// Make sure all the nodes given as parameters have the right kind
for ( Node* field: fields )
{
if ( field->nodeKind() != nkFeatherDeclVar )
REP_INTERNAL(field->location(), "Node %1% must be a field") % field;
}
children_.insert(children_.end(), fields.begin(), fields.end());
}
void Dijkstra::clear_saved_paths() {
for (std::map<NodePair, NodePath*>::iterator it = saved_paths.begin();
it != saved_paths.end(); it++) {
delete (*it).second;
(*it).second = NULL;
}
saved_paths.clear();
NodeVector nodes = grid->get_nodes();
for (NodeVector::iterator node = nodes.begin(); node != nodes.end(); node++) {
(*node)->set_cost_from_start(max_cost);
}
}
// todo: presorted jumplists
NodeVector intersect(NodeVector a, NodeVector b) {
NodeVector c;
NodeVector::iterator it;
for(it = a.begin(); it != a.end(); ++it)
if (contains(b, *it))
// c.insert(*it);
c.push_back(*it);
// for (int i=0; i < a.size(); i++) {
// Node* n=a[0];
// if (contains(b, n)) c.push_back(n);
// }
return c;
}
Algorithm* Network::findAlgorithm(const std::string& name) {
NodeVector nodes = depthFirstSearch(_visibleNetworkRoot);
for (NodeVector::iterator node = nodes.begin(); node != nodes.end(); ++node) {
if ((*node)->algorithm()->name() == name) return (*node)->algorithm();
}
ostringstream msg;
msg << "Could not find algorithm with name '" << name << "'. Known algorithms are: ";
if (!nodes.empty()) msg << '\'' << nodes[0]->algorithm()->name() << '\'';
for (int i=1; i<(int)nodes.size(); i++) {
msg << ", '" << nodes[i]->algorithm()->name() << '\'';
}
throw EssentiaException(msg);
}
void Network::deleteAlgorithms() {
E_DEBUG(ENetwork, "Network::deleteAlgorithms()");
NodeVector nodes = depthFirstSearch(_visibleNetworkRoot);
for (NodeVector::iterator node = nodes.begin(); node != nodes.end(); ++node) {
E_DEBUG(ENetwork, "deleting " << (*node)->algorithm()->name());
delete (*node)->algorithm();
}
// we need to set this to false anyway, because it doesn't make sense anymore
// to have it to true and it would cause the destructor to crash
_takeOwnership = false;
E_DEBUG(ENetwork, "Network::deleteAlgorithms() ok!");
}
void CUniformGrid::Collide(NodeVector * dstVector, IUniformGridDelegate * delegate)
{
for (int y = 0; y < m_Height; ++y)
{
for (int x = 0; x < m_Width; ++x)
{
dstVector->clear();
NodeVector * cellList = GetCell(x, y);
dstVector->insert(dstVector->end(), cellList->begin(), cellList->end());
cellList = GetCell(x + 1, y);
if (NULL != cellList)
{
dstVector->insert(dstVector->end(), cellList->begin(), cellList->end());
}
cellList = GetCell(x + 1, y + 1);
if (NULL != cellList)
{
dstVector->insert(dstVector->end(), cellList->begin(), cellList->end());
}
cellList = GetCell(x, y + 1);
if (NULL != cellList)
{
dstVector->insert(dstVector->end(), cellList->begin(), cellList->end());
}
if (dstVector->size() > 0)
{
delegate->ProcessNeighbourNodes(dstVector);
}
}
}
}
/**
* Returns true if the types in vector %a are all present in %b, and vice versa.
* Useful for equality checks on TypeSet and UnionType nodes. The algorithm is
* quite allergic to vectors that contain duplicate types.
*/
bool equalTypes(const NodeVector& a, const NodeVector& b)
{
// Catch the trivial case of vectors that are not of equal length.
if (a.size() != b.size()) return false;
// Iterate through the first vector, counting the removed nodes in the other.
// If a node cannot be found in the other, equality fails. If any nodes are
// left in the other afterwards, equality fails as well.
int found = 0;
for (NodeVector::const_iterator ia = a.begin(); ia != a.end(); ia++) {
bool anythingFound = false;
for (NodeVector::const_iterator ib = b.begin(); ib != b.end(); ib++) {
if (equal(*ia,*ib)) {
found++;
anythingFound = true;
}
}
if (!anythingFound) return false; // since *ia is not present in b
}
// If 'found' does not equal b's length, there are elements left in
// b that were not present in a, in which case the equality fails.
return (found == b.size());
}
void GenImplicitAccessors::process(const NodePtr& node)
{
// Process children.
processChildren(node);
// Gather implicit accessors for root type definitions.
if (const TypeDef::Ptr& typeDef = TypeDef::from(node)) {
NodeVector implicits;
gatherImplAccessors(typeDef, implicits);
println(0, "Gathered " + lexical_cast<string>(implicits.size()) + " implicit accessors of " + typeDef->getId().str() + ".");
// Add the accessors to the repository.
for (NodeVector::iterator it = implicits.begin(); it != implicits.end(); it++) {
repository.addExportedSymbol((*it)->getId(), (*it)->needNamed()->getName());
}
}
}
virtual void encode(const NodeVector& nodes) {
if (nodes.empty()) {
out << "[] ";
} else {
out << "[ ";
bool first = true;
for (NodeVector::const_iterator it = nodes.begin(); it != nodes.end(); it++) {
if (first) {
first = false;
} else {
out << ", ";
}
encode(*it);
}
out << "] ";
}
}
void TrueTimeSourceVisitor::Visit_Deployment( const Semantics::Deployment & deployment ) {
// Must be second pass
// Iterate over all of the bus objects and create a header file list for each of them.
CommMediumSet cmSet = deployment.CommMedium_children();
for ( CommMediumSet::iterator cmIter = cmSet.begin(); cmIter != cmSet.end(); cmIter++ )
{
string busName = (*cmIter).name();
ostringstream out;
out << "#define " << busName << "_HYPERPERIOD " << (*cmIter).hyperperiodsecs();
_BusHeaderLines[ busName ].insert( out.str() );
}
_BusHeaderLines[ string( "bus" ) ].insert( string( "#define bus_HYPERPERIOD 0.0" ) );
// Get set of Node children - create _init files
NodeVector nodeVector = deployment.Node_children();
// Visit them all
NodeVector::iterator nodeIter = nodeVector.begin();
for ( ; nodeIter != nodeVector.end(); nodeIter++ ) {
// Visit the node again to gen _init files
nodeIter->Accept( *this );
}
// Once all is said and done, generate the headers for the buses
std::string directoryName = ConfigKeeper::inst().GetDirectoryName();
for ( std::map< std::string, std::set< std::string > >::iterator mapIter = _BusHeaderLines.begin();
mapIter != _BusHeaderLines.end(); mapIter++ )
{
if ( !( ( mapIter->first == string( "bus" ) ) && ( mapIter->second.size() < 2 ) ) )
{
string filename = directoryName + "\\" + mapIter->first + "_init_defines.h";
ofstream headerFile( filename.c_str() );
for ( std::set< std::string >::iterator lineIter = (mapIter->second).begin();
lineIter != (mapIter->second).end(); lineIter++ )
{
headerFile << *lineIter << endl;
}
headerFile.close();
}
}
_BusHeaderLines.clear();
}
static void willRemoveChildren(ContainerNode& container)
{
NodeVector children;
getChildNodes(container, children);
ChildListMutationScope mutation(container);
for (auto it = children.begin(); it != children.end(); ++it) {
Node& child = it->get();
mutation.willRemoveChild(child);
child.notifyMutationObserversNodeWillDetach();
// fire removed from document mutation events.
dispatchChildRemovalEvents(child);
}
container.document().nodeChildrenWillBeRemoved(container);
disconnectSubframesIfNeeded(container, DescendantsOnly);
}
static void willRemoveChildren(ContainerNode* container)
{
NodeVector children;
getChildNodes(container, children);
container->document()->nodeChildrenWillBeRemoved(container);
ChildListMutationScope mutation(container);
for (NodeVector::const_iterator it = children.begin(); it != children.end(); it++) {
Node* child = it->get();
mutation.willRemoveChild(child);
child->notifyMutationObserversNodeWillDetach();
// fire removed from document mutation events.
dispatchChildRemovalEvents(child);
}
ChildFrameDisconnector(container).disconnect(ChildFrameDisconnector::DescendantsOnly);
}
/**
* Returns true if both qualified types %a and %b are equivalent, i.e. have the
* same members, interfaces, ranges and native type equivalents.
*/
bool equal(const QualifiedType::Ptr& a, const QualifiedType::Ptr& b)
{
// Treat the trivial cases where the number of fields does not match.
const NodeVector& membersA = a->getMembers(), membersB = b->getMembers();
if (membersA.size() != membersB.size()) return false;
const NodeVector& funcsA = a->getFuncs(), funcsB = b->getFuncs();
if (funcsA.size() != funcsB.size()) return false;
// Check each member separately.
for (NodeVector::const_iterator ia = membersA.begin(), ib = membersB.begin(); ia != membersA.end() && ib != membersB.end(); ia++, ib++) {
const QualifiedTypeMember::Ptr& memberA = QualifiedTypeMember::needFrom(*ia), memberB = QualifiedTypeMember::needFrom(*ib);
if (memberA->getName() != memberB->getName())
return false;
if (!equal(memberA->getType(), memberB->getType()))
return false;
}
// TODO: do the same for interface stuff.
return true;
}
void CUniformGrid::RemoveBody(CGameNode * node)
{
const int Idx = node->GetGridIndex();
if (-1 != Idx)
{
NodeVector * cellList = (m_GridArray + Idx);
NodeVector::iterator it = cellList->begin();
while (cellList->end() != it)
{
if (node == (*it))
{
cellList->erase(it);
return;
}
++it;
}
}
}
void ps(NodeVector v) {
if (quiet) return;
NodeVector::iterator it;
for(it = v.begin(); it != v.end(); ++it)
show(*it);
}
bool ContainerNode::replaceChild(PassRefPtr<Node> newChild, Node* oldChild, ExceptionCode& ec, AttachBehavior attachBehavior)
{
// Check that this node is not "floating".
// If it is, it can be deleted as a side effect of sending mutation events.
ASSERT(refCount() || parentOrShadowHostNode());
RefPtr<Node> protect(this);
ec = 0;
if (oldChild == newChild) // nothing to do
return true;
if (!oldChild) {
ec = NOT_FOUND_ERR;
return false;
}
// Make sure replacing the old child with the new is ok
if (!checkReplaceChild(this, newChild.get(), oldChild, ec))
return false;
// NOT_FOUND_ERR: Raised if oldChild is not a child of this node.
if (oldChild->parentNode() != this) {
ec = NOT_FOUND_ERR;
return false;
}
ChildListMutationScope mutation(this);
RefPtr<Node> next = oldChild->nextSibling();
// Remove the node we're replacing
RefPtr<Node> removedChild = oldChild;
removeChild(oldChild, ec);
if (ec)
return false;
if (next && (next->previousSibling() == newChild || next == newChild)) // nothing to do
return true;
// Does this one more time because removeChild() fires a MutationEvent.
if (!checkReplaceChild(this, newChild.get(), oldChild, ec))
return false;
NodeVector targets;
collectChildrenAndRemoveFromOldParent(newChild.get(), targets, ec);
if (ec)
return false;
// Does this yet another check because collectChildrenAndRemoveFromOldParent() fires a MutationEvent.
if (!checkReplaceChild(this, newChild.get(), oldChild, ec))
return false;
InspectorInstrumentation::willInsertDOMNode(document(), this);
// Add the new child(ren)
for (NodeVector::const_iterator it = targets.begin(); it != targets.end(); ++it) {
Node* child = it->get();
// Due to arbitrary code running in response to a DOM mutation event it's
// possible that "next" is no longer a child of "this".
// It's also possible that "child" has been inserted elsewhere.
// In either of those cases, we'll just stop.
if (next && next->parentNode() != this)
break;
if (child->parentNode())
break;
treeScope()->adoptIfNeeded(child);
// Add child before "next".
{
NoEventDispatchAssertion assertNoEventDispatch;
if (next)
insertBeforeCommon(next.get(), child);
else
appendChildToContainer(child, this);
}
updateTreeAfterInsertion(this, child, attachBehavior);
}
dispatchSubtreeModifiedEvent();
return true;
}
void mergeVectors(NodeSet* some, NodeVector more) {
some->insert(more.begin(), more.end());
}
bool ContainerNode::insertBefore(PassRefPtr<Node> newChild, Node* refChild, ExceptionCode& ec, AttachBehavior attachBehavior)
{
// Check that this node is not "floating".
// If it is, it can be deleted as a side effect of sending mutation events.
ASSERT(refCount() || parentOrShadowHostNode());
RefPtr<Node> protect(this);
ec = 0;
// insertBefore(node, 0) is equivalent to appendChild(node)
if (!refChild)
return appendChild(newChild, ec, attachBehavior);
// Make sure adding the new child is OK.
if (!checkAddChild(this, newChild.get(), ec))
return false;
// NOT_FOUND_ERR: Raised if refChild is not a child of this node
if (refChild->parentNode() != this) {
ec = NOT_FOUND_ERR;
return false;
}
if (refChild->previousSibling() == newChild || refChild == newChild) // nothing to do
return true;
RefPtr<Node> next = refChild;
NodeVector targets;
collectChildrenAndRemoveFromOldParent(newChild.get(), targets, ec);
if (ec)
return false;
if (targets.isEmpty())
return true;
// We need this extra check because collectChildrenAndRemoveFromOldParent() can fire mutation events.
if (!checkAcceptChildGuaranteedNodeTypes(this, newChild.get(), ec))
return false;
InspectorInstrumentation::willInsertDOMNode(document(), this);
ChildListMutationScope mutation(this);
for (NodeVector::const_iterator it = targets.begin(); it != targets.end(); ++it) {
Node* child = it->get();
// Due to arbitrary code running in response to a DOM mutation event it's
// possible that "next" is no longer a child of "this".
// It's also possible that "child" has been inserted elsewhere.
// In either of those cases, we'll just stop.
if (next->parentNode() != this)
break;
if (child->parentNode())
break;
treeScope()->adoptIfNeeded(child);
insertBeforeCommon(next.get(), child);
updateTreeAfterInsertion(this, child, attachBehavior);
}
dispatchSubtreeModifiedEvent();
return true;
}
void Network::reset() {
NodeVector nodes = depthFirstSearch(_visibleNetworkRoot);
for (NodeVector::iterator node = nodes.begin(); node != nodes.end(); ++node) {
(*node)->algorithm()->reset();
}
}