void step(DhtRunner& dht, std::atomic_uint& done, std::shared_ptr<NodeSet> all_nodes, dht::InfoHash cur_h, unsigned cur_depth) { std::cout << "step at " << cur_h << ", depth " << cur_depth << std::endl; done++; dht.get(cur_h, [all_nodes](const std::vector<std::shared_ptr<Value>>& /*values*/) { return true; }, [&,all_nodes,cur_h,cur_depth](bool, const std::vector<std::shared_ptr<Node>>& nodes) { all_nodes->insert(nodes.begin(), nodes.end()); NodeSet sbuck {nodes.begin(), nodes.end()}; if (not sbuck.empty()) { unsigned bdepth = sbuck.size()==1 ? 0u : InfoHash::commonBits((*sbuck.begin())->id, (*std::prev(sbuck.end()))->id); unsigned target_depth = std::min(159u, bdepth+3u); std::cout << cur_h << " : " << nodes.size() << " nodes; target is " << target_depth << " bits deep (cur " << cur_depth << ")" << std::endl; for (unsigned b = cur_depth ; b < target_depth; b++) { auto new_h = cur_h; new_h.setBit(b, 1); step(dht, done, all_nodes, new_h, b+1); } } done--; std::cout << done.load() << " operations left, " << all_nodes->size() << " nodes found." << std::endl; cv.notify_one(); }); }
ElementDeclaration* DeclarationFactory::getDeclaration(Element* element__) { ElementDeclaration* resultElement; string elementName_ = element__->get_attribute_value("name"); NodeSet elementTypeSet = element__->find("@type"); if(!elementTypeSet.empty()) { FE_TRACE(__F(("DeclarationFactory::getDeclaration - Getting declaration for element %1%") % elementName_)); //we're getting an attribute type back, see xpath for @ Attribute* typeAttr = polymorphic_downcast<Attribute*>(elementTypeSet.front()); FE_TRACE(__F(("DeclarationFactory::getDeclaration - Element has type %1%") % typeAttr->get_value())); //checking if type is a basic type defined by the xsd definition //type should start with xs: if this is the namespace used for the xml schema definition if(typeAttr->get_value().substr(0, 3) == "xs:") { resultElement = new ElementDeclaration( elementName_, elementName_, createSimpleBaseTypeDeclaration(typeAttr->get_value()) ); } else { NodeSet typeSet = element__->find("//*[@name='"+typeAttr->get_value()+"']"); //shouldn't have to check if empty, otherwise invalid xsd Element* typeElement_ = polymorphic_downcast<Element*>(typeSet.front()); resultElement = createCustomTypeElementDeclaration(element__, typeElement_); } } else { FE_TRACE("DeclarationFactory::getDeclaration - Couldn't find attribute type so must be anonymous type"); //this means it's probably an anonymous type //first element should be the type //no children and no type attribute should invalid, so we can assume it has children NodeSet nodeSet = element__->find("*"); Element* typeElement_ = polymorphic_downcast<Element*>(nodeSet.front()); FE_TRACE(__F(("DeclarationFactory::getDeclaration - Tag name of the first child is %1%") % typeElement_->get_name() )); resultElement = createCustomTypeElementDeclaration(element__, typeElement_); } int minOccurs = 0; int maxOccurs = 1; string minOccursString = element__->get_attribute_value("minOccurs"); string maxOccursString = element__->get_attribute_value("maxOccurs"); if(maxOccursString == "unbounded"){ maxOccurs = INT_MAX; } else if (!maxOccursString.empty()) { maxOccurs = atoi(maxOccursString.c_str());} minOccurs = atoi(minOccursString.c_str()); FE_TRACE(__F(("DeclarationFactory::getDeclaration - Setting maxOccurs to %1%") % maxOccurs)); FE_TRACE(__F(("DeclarationFactory::getDeclaration - Setting minOccurs to %1%") % minOccurs)); resultElement->setMaxOccurs(maxOccurs); resultElement->setMinOccurs(minOccurs); return resultElement; }
ElementDeclaration* XSDGuru::getElementDeclaration(string elementName__){ Element* rootElement = xsdParser.get_document()->get_root_node(); NodeSet elementDefinitionSet = rootElement->find("//*[local-name() = 'element' and @name='"+elementName__+"']"); if(!elementDefinitionSet.empty()){ Element* element_ = polymorphic_downcast<Element*>(elementDefinitionSet.front()); string elementName_ = element_->get_attribute_value("name"); if(!declarationCache.count(elementName_)){ unique_ptr<ElementDeclaration> elementShared_(DeclarationFactory::getDeclaration(element_)); declarationCache.insert( std::pair<string, unique_ptr<ElementDeclaration> >( elementName_, std::move(elementShared_) ) ); } return declarationCache[elementName_].get(); } else { FE_ERROR(__F(("XSDGuru::getElementDeclaration - Element with name %1% could not be found.") % elementName__)); } //return default constructor return 0; }
DeclarationSet XSDGuru::rootNodes(){ DeclarationSet rootNodes_; Element* rootElement = xsdParser.get_document()->get_root_node(); NodeSet rootNodeSet = rootElement->find("*[local-name() = 'element']"); if(!rootNodeSet.empty()){ for(Node* n : rootNodeSet){ Element* element_ = polymorphic_downcast<Element*>(n); string elementName_ = element_->get_attribute_value("name"); if(!declarationCache.count(elementName_)) { unique_ptr<ElementDeclaration> elementShared_( DeclarationFactory::getDeclaration(element_) ); declarationCache.insert( std::pair<string, unique_ptr<ElementDeclaration> >( elementName_, std::move(elementShared_) ) ); } rootNodes_.push_back( declarationCache[elementName_].get() ); } } return rootNodes_; }
void part_1() { // topological sort with an ordered set NodeSet roots; Graph children, parents; get_graphs("input.txt", children, parents, roots); stringstream res; while (!roots.empty()) { char n = *roots.begin(); roots.erase(roots.begin()); res << n; for (char m : children[n]) { parents[m].erase(n); if (parents[m].empty()) { roots.insert(m); } } children.erase(n); } cout << res.str() << endl; }
void HexagonCommonGEP::common() { // The essence of this commoning is finding gep nodes that are equal. // To do this we need to compare all pairs of nodes. To save time, // first, partition the set of all nodes into sets of potentially equal // nodes, and then compare pairs from within each partition. using NodeSetMap = std::map<unsigned, NodeSet>; NodeSetMap MaybeEq; for (NodeVect::iterator I = Nodes.begin(), E = Nodes.end(); I != E; ++I) { GepNode *N = *I; unsigned H = node_hash(N); MaybeEq[H].insert(N); } // Compute the equivalence relation for the gep nodes. Use two caches, // one for equality and the other for non-equality. NodeSymRel EqRel; // Equality relation (as set of equivalence classes). NodePairSet Eq, Ne; // Caches. for (NodeSetMap::iterator I = MaybeEq.begin(), E = MaybeEq.end(); I != E; ++I) { NodeSet &S = I->second; for (NodeSet::iterator NI = S.begin(), NE = S.end(); NI != NE; ++NI) { GepNode *N = *NI; // If node already has a class, then the class must have been created // in a prior iteration of this loop. Since equality is transitive, // nothing more will be added to that class, so skip it. if (node_class(N, EqRel)) continue; // Create a new class candidate now. NodeSet C; for (NodeSet::iterator NJ = std::next(NI); NJ != NE; ++NJ) if (node_eq(N, *NJ, Eq, Ne)) C.insert(*NJ); // If Tmp is empty, N would be the only element in it. Don't bother // creating a class for it then. if (!C.empty()) { C.insert(N); // Finalize the set before adding it to the relation. std::pair<NodeSymRel::iterator, bool> Ins = EqRel.insert(C); (void)Ins; assert(Ins.second && "Cannot add a class"); } } } LLVM_DEBUG({ dbgs() << "Gep node equality:\n"; for (NodePairSet::iterator I = Eq.begin(), E = Eq.end(); I != E; ++I) dbgs() << "{ " << I->first << ", " << I->second << " }\n"; dbgs() << "Gep equivalence classes:\n"; for (NodeSymRel::iterator I = EqRel.begin(), E = EqRel.end(); I != E; ++I) { dbgs() << '{'; const NodeSet &S = *I; for (NodeSet::const_iterator J = S.begin(), F = S.end(); J != F; ++J) { if (J != S.begin()) dbgs() << ','; dbgs() << ' ' << *J; } dbgs() << " }\n"; } });
void generateConstraints(vector<Node*>& nodes, vector<Edge*>& edges,vector<SimpleConstraint*>& cs,Dim dim) { unsigned nevents=2*nodes.size()+2*edges.size(); events=new Event*[nevents]; unsigned ctr=0; if(dim==HORIZONTAL) { //cout << "Scanning top to bottom..." << endl; for(unsigned i=0;i<nodes.size();i++) { Node *v=nodes[i]; v->scanpos=v->x; events[ctr++]=new Event(Open,v,v->ymin+0.01); events[ctr++]=new Event(Close,v,v->ymax-0.01); } for(unsigned i=0;i<edges.size();i++) { Edge *e=edges[i]; events[ctr++]=new Event(Open,e,e->ymin-1); events[ctr++]=new Event(Close,e,e->ymax+1); } } else { //cout << "Scanning left to right..." << endl; for(unsigned i=0;i<nodes.size();i++) { Node *v=nodes[i]; v->scanpos=v->y; events[ctr++]=new Event(Open,v,v->xmin+0.01); events[ctr++]=new Event(Close,v,v->xmax-0.01); } for(unsigned i=0;i<edges.size();i++) { Edge *e=edges[i]; events[ctr++]=new Event(Open,e,e->xmin-1); events[ctr++]=new Event(Close,e,e->xmax+1); } } qsort((Event*)events, (size_t)nevents, sizeof(Event*), compare_events ); NodeSet openNodes; vector<Edge*> openEdges; for(unsigned i=0;i<nevents;i++) { Event *e=events[i]; Node *v=e->v; if(v!=NULL) { v->open = true; //printf("NEvent@%f,nid=%d,(%f,%f),w=%f,h=%f,openn=%d,opene=%d\n",e->pos,v->id,v->x,v->y,v->width,v->height,(int)openNodes.size(),(int)openEdges.size()); Node *l=NULL, *r=NULL; if(!openNodes.empty()) { // it points to the first node to the right of v NodeSet::iterator it=openNodes.lower_bound(v); // step left to find the first node to the left of v if(it--!=openNodes.begin()) { l=*it; //printf("l=%d\n",l->id); } it=openNodes.upper_bound(v); if(it!=openNodes.end()) { r=*it; } } vector<Node*> L; sortNeighbours(v,l,r,e->pos,openEdges,L,nodes,dim); //printf("L=["); for(unsigned i=0;i<L.size();i++) { //printf("%d ",L[i]->id); } //printf("]\n"); // Case A: create constraints between adjacent edges skipping edges joined // to l,v or r. Node* lastNode=NULL; for(vector<Node*>::iterator i=L.begin();i!=L.end();i++) { if((*i)->dummy) { // node is on an edge Edge *edge=(*i)->edge; if(!edge->isEnd(v->id) &&((l!=NULL&&!edge->isEnd(l->id))||l==NULL) &&((r!=NULL&&!edge->isEnd(r->id))||r==NULL)) { if(lastNode!=NULL) { //printf(" Rule A: Constraint: v%d +g <= v%d\n",lastNode->id,(*i)->id); cs.push_back(createConstraint(lastNode,*i,dim)); } lastNode=*i; } } else { // is an actual node lastNode=NULL; } } // Case B: create constraints for all the edges connected to the right of // their own end, also in the scan line vector<Node*> skipList; lastNode=NULL; for(vector<Node*>::iterator i=L.begin();i!=L.end();i++) { if((*i)->dummy) { // node is on an edge if(lastNode!=NULL) { if((*i)->edge->isEnd(lastNode->id)) { skipList.push_back(*i); } else { for(vector<Node*>::iterator j=skipList.begin(); j!=skipList.end();j++) { //printf(" Rule B: Constraint: v%d +g <= v%d\n",(*j)->id,(*i)->id); cs.push_back(createConstraint(*j,*i,dim)); } skipList.clear(); } } } else { // is an actual node skipList.clear(); skipList.push_back(*i); lastNode=*i; } } skipList.clear(); // Case C: reverse of B lastNode=NULL; for(vector<Node*>::reverse_iterator i=L.rbegin();i!=L.rend();i++) { if((*i)->dummy) { // node is on an edge if(lastNode!=NULL) { if((*i)->edge->isEnd(lastNode->id)) { skipList.push_back(*i); } else { for(vector<Node*>::iterator j=skipList.begin(); j!=skipList.end();j++) { //printf(" Rule C: Constraint: v%d +g <= v%d\n",(*i)->id,(*j)->id); cs.push_back(createConstraint(*i,*j,dim)); } skipList.clear(); } } } else { // is an actual node skipList.clear(); skipList.push_back(*i); lastNode=*i; } } if(e->type==Close) { if(l!=NULL) cs.push_back(createConstraint(l,v,dim)); if(r!=NULL) cs.push_back(createConstraint(v,r,dim)); } } if(e->type==Open) { if(v!=NULL) { openNodes.insert(v); } else { //printf("EdgeOpen@%f,eid=%d,(u,v)=(%d,%d)\n", e->pos,e->e->id,e->e->startNode,e->e->endNode); e->e->openInd=openEdges.size(); openEdges.push_back(e->e); } } else { // Close if(v!=NULL) { openNodes.erase(v); v->open=false; } else { //printf("EdgeClose@%f,eid=%d,(u,v)=(%d,%d)\n", e->pos,e->e->id,e->e->startNode,e->e->endNode); unsigned i=e->e->openInd; openEdges[i]=openEdges[openEdges.size()-1]; openEdges[i]->openInd=i; openEdges.resize(openEdges.size()-1); } } delete e; } delete [] events; }
/* * Checks if the pixel at pixelPosition is wDestructible or not. If it is, * the a pointer to the node this pixel should point to is returned, otherwise, * 0 es returned. */ Node* wDestructible(const Image& image, ComponentTree& componentTree, unsigned int pixelPosition, PIXEL_TYPE& type) { type = MINIMUM; NodeSet nodesFromNeighbor; set<unsigned int> neighbors = image.getLowerNeighbors(pixelPosition); for (auto& neighbor : neighbors) { nodesFromNeighbor.insert(componentTree.getComponent(neighbor)); } if (nodesFromNeighbor.empty()) { Node* n = componentTree.getComponent(pixelPosition); if(componentTree.isLeaf(n)) { type = MINIMUM; } else { type = PLATEAU; } return 0; } if (1 == nodesFromNeighbor.size()) { Node* n = *(nodesFromNeighbor.begin()); if(componentTree.isLeaf(n)) { type = FUTURE_MINIMUM; } else { type = FUTURE_PLATEAU; } return n; } Node* highestFork = componentTree.getHighestFork(nodesFromNeighbor); if (!highestFork) { Node* n = componentTree.getMinimum(nodesFromNeighbor); if(componentTree.isLeaf(n)) { type = FUTURE_MINIMUM; } else { type = FUTURE_PLATEAU; } return n; } if (highestFork->getLevel() <= image.at(pixelPosition)) { type = FUTURE_SEPARATING; return highestFork; } type = SEPARATING; return 0; }
void InterpreterDraft6::mainEventLoop() { monIter_t monIter; while(_running) { NodeSet<std::string> enabledTransitions; _stable = false; // Here we handle eventless transitions and transitions // triggered by internal events until machine is stable while(_running && !_stable) { #if VERBOSE std::cout << "Configuration: "; for (int i = 0; i < _configuration.size(); i++) { std::cout << ATTR(_configuration[i], "id") << ", "; } std::cout << std::endl; #endif enabledTransitions = selectEventlessTransitions(); if (enabledTransitions.size() == 0) { if (_internalQueue.size() == 0) { _stable = true; } else { _currEvent = _internalQueue.front(); _internalQueue.pop_front(); #if VERBOSE std::cout << "Received internal event " << _currEvent.name << std::endl; #endif // --- MONITOR: beforeProcessingEvent ------------------------------ for(monIter_t monIter = _monitors.begin(); monIter != _monitors.end(); monIter++) { try { (*monIter)->beforeProcessingEvent(shared_from_this(), _currEvent); } USCXML_MONITOR_CATCH_BLOCK(beforeProcessingEvent) } if (_dataModel) _dataModel.setEvent(_currEvent); enabledTransitions = selectTransitions(_currEvent.name); } } if (!enabledTransitions.empty()) { // test 403b enabledTransitions.to_document_order(); microstep(enabledTransitions); } } for (unsigned int i = 0; i < _statesToInvoke.size(); i++) { NodeSet<std::string> invokes = filterChildElements(_nsInfo.xmlNSPrefix + "invoke", _statesToInvoke[i]); for (unsigned int j = 0; j < invokes.size(); j++) { if (!HAS_ATTR(invokes[j], "persist") || !DOMUtils::attributeIsTrue(ATTR(invokes[j], "persist"))) { invoke(invokes[j]); } } } _statesToInvoke = NodeSet<std::string>(); if (!_internalQueue.empty()) continue; // assume that we have a legal configuration as soon as the internal queue is empty assert(hasLegalConfiguration()); monIter = _monitors.begin(); // --- MONITOR: onStableConfiguration ------------------------------ for(monIter_t monIter = _monitors.begin(); monIter != _monitors.end(); monIter++) { try { (*monIter)->onStableConfiguration(shared_from_this()); } USCXML_MONITOR_CATCH_BLOCK(onStableConfiguration) } _mutex.unlock(); // whenever we have a stable configuration, run the mainThread hooks with 200fps while(_externalQueue.isEmpty() && _thread == NULL) { runOnMainThread(200); } _mutex.lock(); while(_externalQueue.isEmpty()) { _condVar.wait(_mutex); } _currEvent = _externalQueue.pop(); #if VERBOSE std::cout << "Received externalEvent event " << _currEvent.name << std::endl; if (_running && _currEvent.name == "unblock.and.die") { std::cout << "Still running " << this << std::endl; } else { std::cout << "Aborting " << this << std::endl; } #endif _currEvent.eventType = Event::EXTERNAL; // make sure it is set to external if (!_running) goto EXIT_INTERPRETER; // --- MONITOR: beforeProcessingEvent ------------------------------ for(monIter_t monIter = _monitors.begin(); monIter != _monitors.end(); monIter++) { try { (*monIter)->beforeProcessingEvent(shared_from_this(), _currEvent); } USCXML_MONITOR_CATCH_BLOCK(beforeProcessingEvent) } if (_dataModel && iequals(_currEvent.name, "cancel.invoke." + _sessionId)) break; if (_dataModel) { try { _dataModel.setEvent(_currEvent); } catch (Event e) { LOG(ERROR) << "Syntax error while setting external event:" << std::endl << e << std::endl << _currEvent; } } for (std::map<std::string, Invoker>::iterator invokeIter = _invokers.begin(); invokeIter != _invokers.end(); invokeIter++) { if (iequals(invokeIter->first, _currEvent.invokeid)) { Arabica::XPath::NodeSet<std::string> finalizes = filterChildElements(_nsInfo.xmlNSPrefix + "finalize", invokeIter->second.getElement()); for (int k = 0; k < finalizes.size(); k++) { Element<std::string> finalizeElem = Element<std::string>(finalizes[k]); executeContent(finalizeElem); } } if (HAS_ATTR(invokeIter->second.getElement(), "autoforward") && DOMUtils::attributeIsTrue(ATTR(invokeIter->second.getElement(), "autoforward"))) { try { // do not autoforward to invokers that send to #_parent from the SCXML IO Processor! // Yes do so, see test229! // if (!boost::equals(_currEvent.getOriginType(), "http://www.w3.org/TR/scxml/#SCXMLEventProcessor")) invokeIter->second.send(_currEvent); } catch(...) { LOG(ERROR) << "Exception caught while sending event to invoker " << invokeIter->first; } } } enabledTransitions = selectTransitions(_currEvent.name); if (!enabledTransitions.empty()) { // test 403b enabledTransitions.to_document_order(); microstep(enabledTransitions); } } EXIT_INTERPRETER: // --- MONITOR: beforeCompletion ------------------------------ for(monIter_t monIter = _monitors.begin(); monIter != _monitors.end(); monIter++) { try { (*monIter)->beforeCompletion(shared_from_this()); } USCXML_MONITOR_CATCH_BLOCK(beforeCompletion) } exitInterpreter(); if (_sendQueue) { std::map<std::string, std::pair<InterpreterImpl*, SendRequest> >::iterator sendIter = _sendIds.begin(); while(sendIter != _sendIds.end()) { _sendQueue->cancelEvent(sendIter->first); sendIter++; } } // --- MONITOR: afterCompletion ------------------------------ for(monIter_t monIter = _monitors.begin(); monIter != _monitors.end(); monIter++) { try { (*monIter)->afterCompletion(shared_from_this()); } USCXML_MONITOR_CATCH_BLOCK(afterCompletion) } }
// process transitions until we are in a stable configuration again void InterpreterDraft6::stabilize() { monIter_t monIter; NodeSet<std::string> enabledTransitions; _stable = false; if (_configuration.size() == 0) { // goto initial configuration NodeSet<std::string> initialTransitions = getDocumentInitialTransitions(); assert(initialTransitions.size() > 0); enterStates(initialTransitions); } do { // process microsteps for enabled transitions until there are no more left enabledTransitions = selectEventlessTransitions(); if (enabledTransitions.size() == 0) { if (_internalQueue.size() == 0) { _stable = true; } else { _currEvent = _internalQueue.front(); _internalQueue.pop_front(); #if VERBOSE std::cout << "Received internal event " << _currEvent.name << std::endl; #endif // --- MONITOR: beforeProcessingEvent ------------------------------ for(monIter_t monIter = _monitors.begin(); monIter != _monitors.end(); monIter++) { try { (*monIter)->beforeProcessingEvent(shared_from_this(), _currEvent); } USCXML_MONITOR_CATCH_BLOCK(beforeProcessingEvent) } if (_dataModel) _dataModel.setEvent(_currEvent); enabledTransitions = selectTransitions(_currEvent.name); } } if (!enabledTransitions.empty()) { // test 403b enabledTransitions.to_document_order(); microstep(enabledTransitions); } } while(!_internalQueue.empty() || !_stable); monIter = _monitors.begin(); // --- MONITOR: onStableConfiguration ------------------------------ for(monIter_t monIter = _monitors.begin(); monIter != _monitors.end(); monIter++) { try { (*monIter)->onStableConfiguration(shared_from_this()); } USCXML_MONITOR_CATCH_BLOCK(onStableConfiguration) } // when we reach a stable configuration, invoke for (unsigned int i = 0; i < _statesToInvoke.size(); i++) { NodeSet<std::string> invokes = filterChildElements(_nsInfo.xmlNSPrefix + "invoke", _statesToInvoke[i]); for (unsigned int j = 0; j < invokes.size(); j++) { if (!HAS_ATTR(invokes[j], "persist") || !DOMUtils::attributeIsTrue(ATTR(invokes[j], "persist"))) { invoke(invokes[j]); } } } _statesToInvoke = NodeSet<std::string>(); }
// a macrostep InterpreterState InterpreterDraft6::step(bool blocking) { try { monIter_t monIter; NodeSet<std::string> enabledTransitions; // setup document and interpreter if (!_isInitialized) init(); // if we failed return false if (!_isInitialized) return INIT_FAILED; // run initial transitions if (!_stable) { stabilize(); // we might only need a single step if (!_running) goto EXIT_INTERPRETER; return INITIALIZED; } if (!_running) return FINISHED; // read an external event and react if (blocking) { // wait until an event becomes available while(_externalQueue.isEmpty()) { _condVar.wait(_mutex); } } else { // return immediately if external queue is empty if (_externalQueue.isEmpty()) return NOTHING_TODO; } _currEvent = _externalQueue.pop(); #if VERBOSE std::cout << "Received externalEvent event " << _currEvent.name << std::endl; if (_running && _currEvent.name == "unblock.and.die") { std::cout << "Still running " << this << std::endl; } else { std::cout << "Aborting " << this << std::endl; } #endif _currEvent.eventType = Event::EXTERNAL; // make sure it is set to external // when we were blocking on destructor invocation if (!_running) { goto EXIT_INTERPRETER; return INTERRUPTED; } // --- MONITOR: beforeProcessingEvent ------------------------------ for(monIter_t monIter = _monitors.begin(); monIter != _monitors.end(); monIter++) { try { (*monIter)->beforeProcessingEvent(shared_from_this(), _currEvent); } USCXML_MONITOR_CATCH_BLOCK(beforeProcessingEvent) } if (iequals(_currEvent.name, "cancel.invoke." + _sessionId)) return INTERRUPTED; try { _dataModel.setEvent(_currEvent); } catch (Event e) { LOG(ERROR) << "Syntax error while setting external event:" << std::endl << e << std::endl << _currEvent; } for (std::map<std::string, Invoker>::iterator invokeIter = _invokers.begin(); invokeIter != _invokers.end(); invokeIter++) { if (iequals(invokeIter->first, _currEvent.invokeid)) { Arabica::XPath::NodeSet<std::string> finalizes = filterChildElements(_nsInfo.xmlNSPrefix + "finalize", invokeIter->second.getElement()); for (int k = 0; k < finalizes.size(); k++) { Element<std::string> finalizeElem = Element<std::string>(finalizes[k]); executeContent(finalizeElem); } } if (HAS_ATTR(invokeIter->second.getElement(), "autoforward") && DOMUtils::attributeIsTrue(ATTR(invokeIter->second.getElement(), "autoforward"))) { try { // do not autoforward to invokers that send to #_parent from the SCXML IO Processor! // Yes do so, see test229! // if (!boost::equals(_currEvent.getOriginType(), "http://www.w3.org/TR/scxml/#SCXMLEventProcessor")) invokeIter->second.send(_currEvent); } catch(...) { LOG(ERROR) << "Exception caught while sending event to invoker " << invokeIter->first; } } } // run internal processing until we reach a stable configuration again enabledTransitions = selectTransitions(_currEvent.name); if (!enabledTransitions.empty()) { // test 403b enabledTransitions.to_document_order(); microstep(enabledTransitions); } stabilize(); return PROCESSED; EXIT_INTERPRETER: if (!_running) { // --- MONITOR: beforeCompletion ------------------------------ for(monIter_t monIter = _monitors.begin(); monIter != _monitors.end(); monIter++) { try { (*monIter)->beforeCompletion(shared_from_this()); } USCXML_MONITOR_CATCH_BLOCK(beforeCompletion) } exitInterpreter(); if (_sendQueue) { std::map<std::string, std::pair<InterpreterImpl*, SendRequest> >::iterator sendIter = _sendIds.begin(); while(sendIter != _sendIds.end()) { _sendQueue->cancelEvent(sendIter->first); sendIter++; } } // --- MONITOR: afterCompletion ------------------------------ for(monIter_t monIter = _monitors.begin(); monIter != _monitors.end(); monIter++) { try { (*monIter)->afterCompletion(shared_from_this()); } USCXML_MONITOR_CATCH_BLOCK(afterCompletion) } return FINISHED; } assert(hasLegalConfiguration()); _mutex.unlock(); // remove datamodel if(_dataModel) _dataModel = DataModel(); return PROCESSED; } catch (boost::bad_weak_ptr e) { LOG(ERROR) << "Unclean shutdown " << std::endl << std::endl; return INTERRUPTED; } // set datamodel to null from this thread if(_dataModel) _dataModel = DataModel(); }
DoubleDeclaration::DoubleDeclaration(Element* typeDeclaration__) : NumericDeclaration<double>(typeDeclaration__->get_attribute_value("name")) { //extract info with xpath's //enumeration vector<string> enumStrings_ = extractEnumValues(typeDeclaration__); vector<double> enumValues_; for(string s : enumStrings_ ) { try { double tmp = lexical_cast<double>(s); enumValues_.push_back(tmp); } catch(bad_lexical_cast const& ){ continue; } } setEnumValues(enumValues_); //pattern setPattern(extractPattern(typeDeclaration__)); //min value string min_ = extractMin(typeDeclaration__); try { double tmp = lexical_cast<double>(min_); setMin(tmp); } catch(bad_lexical_cast const& ){ setMin(DBL_MIN); } //max value string max_ = extractMax(typeDeclaration__); try { double tmp = lexical_cast<double>(max_); setMax(tmp); } catch(bad_lexical_cast const& ){ setMax(DBL_MAX); } //total digits //probably won't be used just yet string totalDigits_ = extractTotalDigits(typeDeclaration__); try { int tmp = lexical_cast<int>(totalDigits_); setTotalDigits(tmp); } catch(bad_lexical_cast const& ){ setTotalDigits(DBL_DIG+DBL_MAX_10_EXP); } //double specific precision NodeSet precisionValueSet = typeDeclaration__->find(".//*[local-name() = 'fractionDigits']/@value"); int precision_; if(!precisionValueSet.empty()) { Attribute* attr = polymorphic_downcast<Attribute*>(precisionValueSet.front()); try { string tmp = attr->get_value(); precision_ = lexical_cast<int>(tmp); setPrecision(precision_); } catch(bad_lexical_cast const& ){ setPrecision(DBL_DIG); } } }