void PropertyEditor::Private::setTargetState(const QString &label) { Transition* transition = current<Transition>(); Q_ASSERT(transition); if (transition) { State *targetState = ElementUtil::findState(transition->sourceState()->machine(), label); if (transition->targetState() != targetState) { ModifyTransitionCommand *command = new ModifyTransitionCommand(transition); command->setTargetState(targetState); m_commandController->undoStack()->push(command); } } }
Transition* TransitionBase::getTransitionLocally(string transitionId) { vector<Transition*>::iterator i; Transition* transition; i = transitionSet->begin(); while (i != transitionSet->end()) { transition = *i; if (transition->getId() == transitionId) { return transition; } ++i; } return NULL; }
void Thread::run_one_step() { process_messages(); Net *net = process->get_net(); if (net == NULL) { return; } Transition *tr = net->pick_active_transition(); if (tr == NULL) { return; } tr->set_active(false); tr->full_fire(this, net); }
void Simulation::PrintStatistics() { Log->Write("\nRooms Egress Time:"); Log->Write("=================="); Log->Write("id\tcaption\tegress time (s)"); for (const auto& it:_building->GetAllRooms()) { auto&& room = it.second; if (room->GetCaption()!="outside") Log->Write("%d\t%s\t%.2f", room->GetID(), room->GetCaption().c_str(), room->GetEgressTime()); } Log->Write("\nUsage of Exits"); Log->Write("=========="); for (const auto& itr : _building->GetAllTransitions()) { Transition* goal = itr.second; if (goal->GetDoorUsage()) { Log->Write( "\nExit ID [%d] used by [%d] pedestrians. Last passing time [%0.2f] s", goal->GetID(), goal->GetDoorUsage(), goal->GetLastPassingTime()); string statsfile = _config->GetTrajectoriesFile()+"_flow_exit_id_"+to_string(goal->GetID())+".dat"; Log->Write("More Information in the file: %s", statsfile.c_str()); auto output = new FileHandler(statsfile.c_str()); output->Write("#Flow at exit "+goal->GetCaption()+"( ID "+to_string(goal->GetID())+" )"); output->Write("#Time (s) cummulative number of agents \n"); output->Write(goal->GetFlowCurve()); } } Log->Write("\n"); }
// Consider merging this funciton with nullInputTransit() int Fsm::transit(MessageTuple* inMsg, vector<MessageTuple*>& outMsgs, bool& high_prob, int startIdx ) { State* cs = _states[_current]; outMsgs.clear(); // Go through the possible transitions, find that matches the message for( int tid = startIdx ; tid < cs->getNumTrans(); ++tid ) { Transition tr = cs->getTrans((int)tid); if( tr.getFromMachineId() == inMsg->subjectId() && tr.getInputMessageId() == inMsg->destMsgId() ) { // Matching found. Get all the outLabels for( size_t oid = 0 ; oid < tr.getNumOutLabels() ; ++oid ) { OutLabel lbl = tr.getOutLabel(oid); MessageTuple* out = new FsmMessage(tr.getFromMachineId(), lbl.first, tr.getInputMessageId(), lbl.second, _macLookup->toInt(this->_name)) ; outMsgs.push_back(out); } // Change state State* next = cs->getNextState((int)tid); _current = next->getID(); if( tr.isHigh() ) high_prob = true; else high_prob = false; return tid+1; } } // The function will get to this line when no more matching transition is found return -1; }
//Transit from current state int StateMachine::loop() { int current_state = this->current_state(); for(int i=0; i < stored_transitions; i++) { Transition transition = this->transitions[i]; if(transition.origin == current_state && transition.transition_function()) { this->set_current_state(transition.dest); current_state = transition.dest; return transition.dest; } } if (state_functions[current_state] != 0) { state_functions[current_state](); } return current_state; }
returnValue ShootingMethod::addTransition( const Transition& transition_ ){ if( transition_.getNXA() != 0 ) return ACADOERROR( RET_TRANSITION_DEPENDS_ON_ALGEBRAIC_STATES ); integrator[N-1]->setTransition( transition_ ); return SUCCESSFUL_RETURN; }
void State::add_epsilon(State* dest) { for (size_t i = 0; i < this->transitions.size(); i++) { if (this->transitions[i]->get_dest() == dest) { return; } } Transition* t = new Transition(this->location, '\0', this, dest); t->set_epsilon(true); transitions.push_back(t); dest->add_incoming(t); return; }
void XMLizer::writeClip( QDomDocument &document, QDomNode &parent, Clip *clip ) { QDomElement n1 = document.createElement( "Clip" ); parent.appendChild( n1 ); if ( clip->getSpeed() != 1.0 ) n1.setAttribute( "speed", QString::number( clip->getSpeed(), 'e', 17 ) ); XMLizer::createText( document, n1, "Name", clip->sourcePath() ); XMLizer::createDouble( document, n1, "PosInTrack", clip->position() ); XMLizer::createDouble( document, n1, "StartTime", clip->start() ); XMLizer::createDouble( document, n1, "Length", clip->length() ); for ( int i = 0; i < clip->videoFilters.count(); ++i ) XMLizer::writeFilter( document, n1, false, clip->videoFilters.at( i ) ); for ( int i = 0; i < clip->audioFilters.count(); ++i ) XMLizer::writeFilter( document, n1, true, clip->audioFilters.at( i ) ); Transition *trans = clip->getTransition(); if ( trans ) { QDomElement t = document.createElement( "Transition" ); n1.appendChild( t ); XMLizer::createDouble( document, t, "PosInTrack", trans->position() ); XMLizer::createDouble( document, t, "Length", trans->length() ); if ( !trans->getVideoFilter().isNull() ) XMLizer::writeFilter( document, t, false, trans->getVideoFilter() ); if ( !trans->getAudioFilter().isNull() ) XMLizer::writeFilter( document, t, true, trans->getAudioFilter() ); } }
bool SimulatedState::transitionIsCompatible(const Transition& transition) const { if (_currentState != transition.sourceStateIndex()) { return false; } if (tapes.size() != transition.numberOfTapes()) { return false; } for (int i = 0; i < transition.numberOfTapes(); ++i) { if (!transition.isCurrentTapeSymbolForTape(i, characterAtTapehead(i)) && (!_tm->anySymbolSymbolSet() || transition.currentTapeSymbolForTape(i) != _tm->anySymbolSymbol())) { return false; } } return true; }
/** * @brief Starts a transition effect on this object. * * The transition will be automatically deleted when finished or stopped. * Any previous transition is stopped. * * @param transition The transition to start. * @param callback_ref A Lua registry ref to the function to call when * the transition finishes, or LUA_REFNIL. * @param lua_context The Lua world for the callback (or NULL). */ void Drawable::start_transition(Transition& transition, int callback_ref, LuaContext* lua_context) { stop_transition(); this->transition = &transition; this->transition_callback_ref = callback_ref; this->lua_context = lua_context; transition.start(); }
void StateMachineViewerWidgetNG::transitionAdded(const TransitionId transitionId, const StateId sourceId, const StateId targetId, const QString& label) { if (m_idToTransitionMap.contains(transitionId)) return; IF_DEBUG(qDebug() << "transitionAdded" << transitionId << label << sourceId << targetId); State* source = m_idToStateMap.value(sourceId); State* target = m_idToStateMap.value(targetId); if (!source || !target) { qDebug() << "Null source or target for transition:" << transitionId; return; } Transition* transition = new Transition(source); transition->setTargetState(target); transition->setLabel(label); m_idToTransitionMap[transitionId] = transition; }
void State::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *mouseEvent) { if(mouseEvent->button() == Qt::LeftButton && dynamic_cast<GraphGraphicsScene* >(this->scene())->mode() == MODE::DELETE) { for(Transition *t : m_transitions) { t->removeSelf(); } updateStateId(this->m_id); delete this; } else if(mouseEvent->button() == Qt::LeftButton && dynamic_cast<GraphGraphicsScene* >(this->scene())->mode() == MODE::TRANSITION) { Transition *transition = new Transition(); transition->setFrom(this); transition->setTo(this); transition->setDrawMode(DRAW_SHAPE::NORMAL); transition->setFlag(true); this->scene()->addItem(transition); this->addTransiton(transition); instructionLab->addToInstructionlab(transition); } }
// // Notification // void Script::State::Notify(U32 message, U32 data) { // Ask the action to translate this notification if (action) { U32 translation = action->Notify(message, data); // Was the notification ignored ? if (translation != Status::Ignored) { // Find the transition Transition *transition = transitions.Find(translation); if (transition) { // Perform the transition transition->Perform(GetScript()); } } } }
/* Name: view * Purpose: Prints out all of the transitions. * Operation: This method is used to print out the value of the transition. This is used by class Show_Command though the class Turing_Machine. */ void Transition_Function::view() const{ // Display a empty set if it is empty. if (transitions.size() == 0){ cout << "Delta = {}\n\n"; return; } for (unsigned int i = 0; i < transitions.size(); i++){ Transition Temp = transitions[i]; cout << "Delta(" << Temp.Source_State() << ", " << Temp.Read_Character() << ") = (" << Temp.Destination_State() << ", " << Temp.Write_Character() << ", " << Temp.Move_Direction() << ")\n"; } cout << "\n"; }
void Place::produceTokens(unsigned int nbOfTokens, unsigned int colorLabel, int tokensTime) { unsigned int oldNumberOfTokens = getNbOfTokens(colorLabel); for (unsigned int i = 0; i < nbOfTokens; ++i) { Token token(tokensTime); m_tokenByColor[colorLabel - 1].push_back(token); } // if(tokensTime < 0){tokensTime = 0;} // CB incompatible with deactivation (tokenTime = -1) if ((oldNumberOfTokens < NB_OF_TOKEN_TO_ACTIVE_ARC) && (getNbOfTokens(colorLabel) >= NB_OF_TOKEN_TO_ACTIVE_ARC)) { // CB WTF : Si un token et deux arcs sortant, bug ? arcList outGoingArcs = outGoingArcsOf(colorLabel); for (unsigned int i = 0 ; i < outGoingArcs.size() ; ++i) { PetriNetArc* arc = outGoingArcs[i]; // if (!arc->getCondition()) { // CB check if the arc can be activated // continue; // } Transition* transitionTo = dynamic_cast<Transition*>(arc->getTo()); if (!transitionTo) { throw IncoherentStateException(); } transitionTo->setArcAsActive(arc, tokensTime, true); if (transitionTo->isStatic()) { if(arc->getRelativeMinValue().getValue() < (int) tokensTime) { getPetriNet()->pushTransitionToCrossWhenAcceleration(transitionTo); } } else { if(arc->getRelativeMaxValue().getValue() < (int) tokensTime) { getPetriNet()->pushTransitionToCrossWhenAcceleration(transitionTo); } } } } }
void Simulation::UpdateFlowAtDoors(const Pedestrian& ped) const { if (_config->ShowStatistics()) { Transition* trans = _building->GetTransitionByUID(ped.GetExitIndex()); if (trans) { //check if the pedestrian left the door correctly if (trans->DistTo(ped.GetPos())>0.5) { Log->Write("WARNING:\t pedestrian [%d] left room/subroom [%d/%d] in an unusual way. Please check", ped.GetID(), ped.GetRoomID(), ped.GetSubRoomID()); Log->Write(" :\t distance to last door (%d | %d) is %f. That should be smaller.", trans->GetUniqueID(), ped.GetExitIndex(), trans->DistTo(ped.GetPos())); Log->Write(" :\t correcting the door statistics"); //ped.Dump(ped.GetID()); //checking the history and picking the nearest previous destination double biggest = 0.3; bool success = false; for (const auto& dest:ped.GetLastDestinations()) { if (dest!=-1) { Transition* trans_tmp = _building->GetTransitionByUID(dest); if (trans_tmp && trans_tmp->DistTo(ped.GetPos())<biggest) { biggest = trans_tmp->DistTo(ped.GetPos()); trans = trans_tmp; Log->Write(" :\t Best match found at door %d", dest); success = true;//at least one door was found } } } if (!success) { Log->Write("WARNING :\t correcting the door statistics"); return; //todo we need to check if the ped is in a subroom neighboring the target. If so, no problems! } } //#pragma omp critical trans->IncreaseDoorUsage(1, ped.GetGlobalTime()); } } }
bool Automaton::step() { //cout << this->name << " state: " << this->cur->id << " "; for (int i=0; i < cur->transitions.size(); i++) { Transition * t = cur->transitions[i]; if (t->guard() && t->next->inv()) { // если выполнено условие if (t->needSync() ) {// если есть действия по синхронизации bool sync = t->synchronize(); //cout << " channel " << t->channelParticipant->channel->id << " "; if (sync) { t->action(); //выполняем действия перехода cerr << "time = " << net->timeForInternalUse << " " << name << ": " << cur->name << " -> " << t->next->name << endl; cur = t->next; //изменяем текущее состояние //cout << this->cur->id << "\n"; return true; //был совершен переход } } else { // синхронизации нет, условие выполнено t->action(); //выполняем действия перехода cerr << "time = " << net->timeForInternalUse << " " << name << ": " << cur->name << " -> " << t->next->name << endl; cur = t->next; //изменяем текущее состояние //cout << this->cur->id << "\n"; return true; //был совершен переход } } } //cout << "no trans\n"; return false; //перехода не было }
void Place::produceTokens(unsigned int nbOfTokens, unsigned int colorLabel, unsigned int tokensTime) { unsigned int oldNumberOfTokens = getNbOfTokens(colorLabel); for (unsigned int i = 0; i < nbOfTokens; ++i) { Token token; token.setRemainingTime(tokensTime); m_tokenByColor[colorLabel - 1].push_back(token); } if ((oldNumberOfTokens < NB_OF_TOKEN_TO_ACTIVE_ARC) && (getNbOfTokens(colorLabel) >= NB_OF_TOKEN_TO_ACTIVE_ARC)) { arcList outGoingArcs = outGoingArcsOf(colorLabel); for (unsigned int i = 0 ; i < outGoingArcs.size() ; ++i) { Arc* arc = outGoingArcs[i]; if (!(dynamic_cast<Transition*>(arc->getTo()))) { throw IncoherentStateException(); } Transition* transitionTo = ((Transition*) arc->getTo()); transitionTo->setArcAsActive(arc, tokensTime, true); if (transitionTo->isStatic()) { if(arc->getRelativeMinValue().getValue() < (int) tokensTime) { getPetriNet()->pushTransitionToCrossWhenAcceleration(transitionTo); } } else { if(arc->getRelativeMaxValue().getValue() < (int) tokensTime) { getPetriNet()->pushTransitionToCrossWhenAcceleration(transitionTo); } } } } }
void Simulation::oneStep() { //Search for possible transitions by source state vector<Transition*> filteredTransitions; //std::cout << curState << " ==> "; auto ret = transitions.equal_range(curState); for (auto it=ret.first;it!=ret.second;++it) { filteredTransitions.push_back((*it).second); } if (filteredTransitions.empty()) { curState = "reject"; return; } //Search for possible transitions by read character vector<Transition*> possibleTransitions; char readValue = tape->getChar(); for (Transition* tr : filteredTransitions ) { if (tr->getRead() == readValue) { possibleTransitions.push_back(tr); } } if (possibleTransitions.empty()) { curState = "reject"; return; } // transition assert(possibleTransitions.size() == 1); // cannot copy with multi transitions Transition* select = possibleTransitions[0]; char wt = select->getWrite(); char mv = select->getMove(); std::string nextState = select->getNextState(); tape->setChar(wt); tape->move(mv); curState = nextState; //std::cout << nextState << std::endl; }
void State::add_transition(char name, State* dest) { if (dest == NULL) { return; } size_t i = 0; Transition* t = NULL; for (; i < this->transitions.size(); i++) { t = this->transitions[i]; if (t->get_token() == name && t->get_dest() == dest) { return; } } Transition* transition = new Transition(this->location, name, this, dest); this->transitions.push_back(transition); dest->add_incoming(transition); return; }
void ResultBecomesNegative::logNegativeResult (const Transition& tr, const SBase& object) { msg = "The Transition with id '"; msg += tr.getId(); msg += "' includes a resultLevel"; msg += " that may cause the QualitativeSpecies '"; msg += object.getId(); msg += "' to become negative."; logFailure(object); }
void ResultExceedsMaximum::logExceedsMaximum (const Transition& tr, const SBase& object) { msg = "The <transition> with id '"; msg += tr.getId(); msg += "' includes a resultLevel"; msg += " that may cause the <qualitativeSpecies> '"; msg += object.getId(); msg += "' to exceed its maximumLevel."; logFailure(object); }
void QSAssignedOnce::logMultipleAssignment (const Transition& tr, const SBase& object, std::string name) { msg = "The Transition with id '"; msg += tr.getId(); msg += "' includes an Output"; msg += " that uses an assignment to the QualitativeSpecies '"; msg += name; msg += "' that has already been assigned."; logFailure(object); }
Place* PNP::addAction(string name, Node *p0) { Transition *ts = addTransition(name+".start"); Place *pe = addPlace(name+".exec"); Transition *te = addTransition(name+".end"); Place *pf = addPlace("X",-1); ts->setY(p0->getY()); pe->setY(p0->getY()); // same line as p0 te->setY(p0->getY()); pf->setY(p0->getY()); ts->setX(p0->getX()+1); pe->setX(p0->getX()+2); // X pos after p0 te->setX(p0->getX()+3); pf->setX(p0->getX()+4); connect(p0,ts); connect(ts,pe); connect(pe,te); connect(te,pf); nactions++; return pf; }
void *Transition::process(void *ptr) { Transition* transition = (Transition*) ptr; do { Token* current = transition->getToken(); if (current != NULL) { #ifdef P_EVENT transition->dispatchPStartEvent(); #endif //Process token //1.BIN Routing //2.Dynamic Fuzzy Routing double result = FuzzyLogicDSL::Evaluate(1, 1, 1, 1, 0.3, 0, 1); cout << result << endl; transition->forwardToken(current); } else { pthread_mutex_t* mutex = transition->getMutex();//TODO remove from transition pthread_cond_t* cond_var = transition->getCondVar(); pthread_mutex_lock(mutex); pthread_cond_wait(cond_var, mutex); pthread_mutex_unlock(mutex); } } while (!transition->isStopped()); pthread_exit(0); return 0; }
void ModuleInstance::add_transition(const Transition& transition) { #ifndef NDEBUG if (0 <= globalIndex_ || 0 <= firstClock_) throw_FigException("this module has already been added to the network"); if (!is_our_clock(transition.triggeringClock)) throw_FigException(std::string("triggering clock \"") .append(transition.triggeringClock) .append("\" does not reside in module \"") .append(name).append("\"")); for (const auto& clockName: transition.resetClocksList()) if (!is_our_clock(clockName)) throw_FigException(std::string("reset clock \"").append(clockName) .append("\" does not reside in module \"") .append(name).append("\"")); #else if (0 <= globalIndex_ || 0 <= firstClock_) return; #endif transitions_.emplace_back(transition); }
vector<Place*> PNP::addSensingAction(string name, Place* p0, vector<string> outcomes) { vector<Place *> v; Transition *ts = addTransition(name+".start"); Place *pe = addPlace(name+".exec"); ts->setY(p0->getY()); pe->setY(p0->getY()); // same line as p0 ts->setX(p0->getX()+1); pe->setX(p0->getX()+2); // X pos after p0 connect(p0,ts); connect(ts,pe); int k=0; for (vector<string>::iterator it = outcomes.begin(); it!=outcomes.end(); it++, k++) { Transition *te = addTransition("["+(*it)+"] "+name+".end"); Place *pf = addPlace("X",-1); te->setY(p0->getY()+k); pf->setY(p0->getY()+k); te->setX(p0->getX()+3); pf->setX(p0->getX()+4); connect(pe,te); connect(te,pf); v.push_back(pf); } nactions++; return v; }
void ManhattanStyle::drawPrimitive(PrimitiveElement element, const QStyleOption *option, QPainter *painter, const QWidget *widget) const { if (!panelWidget(widget)) return d->style->drawPrimitive(element, option, painter, widget); bool animating = (option->state & State_Animating); int state = option->state; QRect rect = option->rect; QRect oldRect; QRect newRect; if (widget && (element == PE_PanelButtonTool) && !animating) { QWidget *w = const_cast<QWidget *> (widget); int oldState = w->property("_q_stylestate").toInt(); oldRect = w->property("_q_stylerect").toRect(); newRect = w->rect(); w->setProperty("_q_stylestate", (int)option->state); w->setProperty("_q_stylerect", w->rect()); // Determine the animated transition bool doTransition = ((state & State_On) != (oldState & State_On) || (state & State_MouseOver) != (oldState & State_MouseOver)); if (oldRect != newRect) { doTransition = false; d->animator.stopAnimation(widget); } if (doTransition) { QImage startImage(option->rect.size(), QImage::Format_ARGB32_Premultiplied); QImage endImage(option->rect.size(), QImage::Format_ARGB32_Premultiplied); Animation *anim = d->animator.widgetAnimation(widget); QStyleOption opt = *option; opt.state = (QStyle::State)oldState; opt.state |= (State)State_Animating; startImage.fill(0); Transition *t = new Transition; t->setWidget(w); QPainter startPainter(&startImage); if (!anim) { drawPrimitive(element, &opt, &startPainter, widget); } else { anim->paint(&startPainter, &opt); d->animator.stopAnimation(widget); } QStyleOption endOpt = *option; endOpt.state |= (State)State_Animating; t->setStartImage(startImage); d->animator.startAnimation(t); endImage.fill(0); QPainter endPainter(&endImage); drawPrimitive(element, &endOpt, &endPainter, widget); t->setEndImage(endImage); t->setDuration(130); t->setStartTime(QTime::currentTime()); } } switch (element) { case PE_PanelLineEdit: { painter->save(); if (option->state & State_Enabled) drawCornerImage(d->lineeditImage, painter, option->rect, 2, 2, 2, 2); else drawCornerImage(d->lineeditImage_disabled, painter, option->rect, 2, 2, 2, 2); if (option->state & State_HasFocus || option->state & State_MouseOver) { QColor hover = StyleHelper::baseColor(); if (state & State_HasFocus) hover.setAlpha(100); else hover.setAlpha(50); painter->setPen(QPen(hover, 1)); painter->drawRect(option->rect.adjusted(1, 1, -2 ,-2)); } painter->restore(); } break; case PE_FrameStatusBarItem: break; case PE_PanelButtonTool: { Animation *anim = d->animator.widgetAnimation(widget); if (!animating && anim) { anim->paint(painter, option); } else { bool pressed = option->state & State_Sunken || option->state & State_On; QColor shadow(0, 0, 0, 30); painter->setPen(shadow); if (pressed) { QColor shade(0, 0, 0, 40); painter->fillRect(rect, shade); painter->drawLine(rect.topLeft() + QPoint(1, 0), rect.topRight() - QPoint(1, 0)); painter->drawLine(rect.topLeft(), rect.bottomLeft()); painter->drawLine(rect.topRight(), rect.bottomRight()); // painter->drawLine(rect.bottomLeft() + QPoint(1, 0), rect.bottomRight() - QPoint(1, 0)); QColor highlight(255, 255, 255, 30); painter->setPen(highlight); } else if (option->state & State_Enabled && option->state & State_MouseOver) { QColor lighter(255, 255, 255, 37); painter->fillRect(rect, lighter); } } } break; case PE_PanelStatusBar: { painter->save(); QLinearGradient grad(option->rect.topLeft(), QPoint(rect.center().x(), rect.bottom())); QColor startColor = StyleHelper::shadowColor().darker(164); QColor endColor = StyleHelper::baseColor().darker(130); grad.setColorAt(0, endColor); grad.setColorAt(1, endColor); painter->fillRect(option->rect, grad); painter->setPen(QColor(255, 255, 255, 60)); painter->drawLine(rect.topLeft() + QPoint(0,1), rect.topRight()+ QPoint(0,1)); painter->setPen(StyleHelper::borderColor().darker(110)); painter->drawLine(rect.topLeft(), rect.topRight()); painter->restore(); } break; case PE_IndicatorToolBarSeparator: { QColor separatorColor = StyleHelper::borderColor(); separatorColor.setAlpha(100); painter->setPen(separatorColor); const int margin = 3; if (option->state & State_Horizontal) { const int offset = rect.width()/2; painter->drawLine(rect.bottomLeft().x() + offset, rect.bottomLeft().y() - margin, rect.topLeft().x() + offset, rect.topLeft().y() + margin); } else { //Draw vertical separator const int offset = rect.height()/2; painter->setPen(QPen(option->palette.background().color().darker(110))); painter->drawLine(rect.topLeft().x() + margin , rect.topLeft().y() + offset, rect.topRight().x() - margin, rect.topRight().y() + offset); } } break; case PE_IndicatorToolBarHandle: { bool horizontal = option->state & State_Horizontal; painter->save(); QPainterPath path; int x = option->rect.x() + horizontal ? 2 : 6; int y = option->rect.y() + horizontal ? 6 : 2; static const int RectHeight = 2; if (horizontal) { while (y < option->rect.height() - RectHeight - 6) { path.moveTo(x, y); path.addRect(x, y, RectHeight, RectHeight); y += 6; } } else { while (x < option->rect.width() - RectHeight - 6) { path.moveTo(x, y); path.addRect(x, y, RectHeight, RectHeight); x += 6; } } painter->setPen(Qt::NoPen); QColor dark = StyleHelper::borderColor(); dark.setAlphaF(0.4); QColor light = StyleHelper::baseColor(); light.setAlphaF(0.4); painter->fillPath(path, light); painter->save(); painter->translate(1, 1); painter->fillPath(path, dark); painter->restore(); painter->translate(3, 3); painter->fillPath(path, light); painter->translate(1, 1); painter->fillPath(path, dark); painter->restore(); } break; case PE_IndicatorArrowUp: case PE_IndicatorArrowDown: case PE_IndicatorArrowRight: case PE_IndicatorArrowLeft: { // From windowsstyle but modified to enable AA if (option->rect.width() <= 1 || option->rect.height() <= 1) break; QRect r = option->rect; int size = qMin(r.height(), r.width()); QPixmap pixmap; QString pixmapName; pixmapName.sprintf("%s-%s-%d-%d-%d-%lld", "$qt_ia", metaObject()->className(), uint(option->state), element, size, option->palette.cacheKey()); if (!QPixmapCache::find(pixmapName, pixmap)) { int border = size/5; int sqsize = 2*(size/2); QImage image(sqsize, sqsize, QImage::Format_ARGB32); image.fill(Qt::transparent); QPainter imagePainter(&image); imagePainter.setRenderHint(QPainter::Antialiasing, true); imagePainter.translate(0.5, 0.5); QPolygon a; switch (element) { case PE_IndicatorArrowUp: a.setPoints(3, border, sqsize/2, sqsize/2, border, sqsize - border, sqsize/2); break; case PE_IndicatorArrowDown: a.setPoints(3, border, sqsize/2, sqsize/2, sqsize - border, sqsize - border, sqsize/2); break; case PE_IndicatorArrowRight: a.setPoints(3, sqsize - border, sqsize/2, sqsize/2, border, sqsize/2, sqsize - border); break; case PE_IndicatorArrowLeft: a.setPoints(3, border, sqsize/2, sqsize/2, border, sqsize/2, sqsize - border); break; default: break; } int bsx = 0; int bsy = 0; if (option->state & State_Sunken) { bsx = pixelMetric(PM_ButtonShiftHorizontal); bsy = pixelMetric(PM_ButtonShiftVertical); } QRect bounds = a.boundingRect(); int sx = sqsize / 2 - bounds.center().x() - 1; int sy = sqsize / 2 - bounds.center().y() - 1; imagePainter.translate(sx + bsx, sy + bsy); if (!(option->state & State_Enabled)) { QColor foreGround(150, 150, 150, 150); imagePainter.setBrush(option->palette.mid().color()); imagePainter.setPen(option->palette.mid().color()); } else { QColor shadow(0, 0, 0, 100); imagePainter.translate(0, 1); imagePainter.setPen(shadow); imagePainter.setBrush(shadow); QColor foreGround(255, 255, 255, 210); imagePainter.drawPolygon(a); imagePainter.translate(0, -1); imagePainter.setPen(foreGround); imagePainter.setBrush(foreGround); } imagePainter.drawPolygon(a); imagePainter.end(); pixmap = QPixmap::fromImage(image); QPixmapCache::insert(pixmapName, pixmap); } int xOffset = r.x() + (r.width() - size)/2; int yOffset = r.y() + (r.height() - size)/2; painter->drawPixmap(xOffset, yOffset, pixmap); } break; default: d->style->drawPrimitive(element, option, painter, widget); break; } }
std::vector<size_t> ATNSerializer::serialize() { std::vector<size_t> data; data.push_back(ATNDeserializer::SERIALIZED_VERSION); serializeUUID(data, ATNDeserializer::SERIALIZED_UUID()); // convert grammar type to ATN const to avoid dependence on ANTLRParser data.push_back((size_t)atn->grammarType); data.push_back((size_t)atn->maxTokenType); size_t nedges = 0; std::unordered_map<misc::IntervalSet, int> setIndices; std::vector<misc::IntervalSet> sets; // dump states, count edges and collect sets while doing so std::vector<int> nonGreedyStates; std::vector<int> precedenceStates; data.push_back(atn->states.size()); for (ATNState *s : atn->states) { if (s == nullptr) { // might be optimized away data.push_back(ATNState::ATN_INVALID_TYPE); continue; } int stateType = s->getStateType(); if (is<DecisionState *>(s) && (static_cast<DecisionState *>(s))->nonGreedy) { nonGreedyStates.push_back(s->stateNumber); } if (is<RuleStartState *>(s) && (static_cast<RuleStartState *>(s))->isLeftRecursiveRule) { precedenceStates.push_back(s->stateNumber); } data.push_back((size_t)stateType); if (s->ruleIndex == -1) { data.push_back(0xFFFF); } else { data.push_back((size_t)s->ruleIndex); } if (s->getStateType() == ATNState::LOOP_END) { data.push_back((size_t)(static_cast<LoopEndState *>(s))->loopBackState->stateNumber); } else if (is<BlockStartState *>(s)) { data.push_back((size_t)(static_cast<BlockStartState *>(s))->endState->stateNumber); } if (s->getStateType() != ATNState::RULE_STOP) { // the deserializer can trivially derive these edges, so there's no need // to serialize them nedges += s->getNumberOfTransitions(); } for (size_t i = 0; i < s->getNumberOfTransitions(); i++) { Transition *t = s->transition(i); int edgeType = t->getSerializationType(); if (edgeType == Transition::SET || edgeType == Transition::NOT_SET) { SetTransition *st = static_cast<SetTransition *>(t); if (setIndices.find(st->set) != setIndices.end()) { sets.push_back(st->set); setIndices.insert({ st->set, (int)sets.size() - 1 }); } } } } // non-greedy states data.push_back(nonGreedyStates.size()); for (size_t i = 0; i < nonGreedyStates.size(); i++) { data.push_back((size_t)nonGreedyStates.at(i)); } // precedence states data.push_back(precedenceStates.size()); for (size_t i = 0; i < precedenceStates.size(); i++) { data.push_back((size_t)precedenceStates.at(i)); } size_t nrules = atn->ruleToStartState.size(); data.push_back(nrules); for (size_t r = 0; r < nrules; r++) { ATNState *ruleStartState = atn->ruleToStartState[r]; data.push_back((size_t)ruleStartState->stateNumber); if (atn->grammarType == ATNType::LEXER) { if (atn->ruleToTokenType[r] == Token::EOF) { data.push_back(0xFFFF); } else { data.push_back((size_t)atn->ruleToTokenType[r]); } } } size_t nmodes = atn->modeToStartState.size(); data.push_back(nmodes); if (nmodes > 0) { for (const auto &modeStartState : atn->modeToStartState) { data.push_back((size_t)modeStartState->stateNumber); } } size_t nsets = sets.size(); data.push_back(nsets); for (auto set : sets) { bool containsEof = set.contains(Token::EOF); if (containsEof && set.getIntervals().at(0).b == Token::EOF) { data.push_back(set.getIntervals().size() - 1); } else { data.push_back(set.getIntervals().size()); } data.push_back(containsEof ? 1 : 0); for (auto &interval : set.getIntervals()) { if (interval.a == Token::EOF) { if (interval.b == Token::EOF) { continue; } else { data.push_back(0); } } else { data.push_back((size_t)interval.a); } data.push_back((size_t)interval.b); } } data.push_back(nedges); for (ATNState *s : atn->states) { if (s == nullptr) { // might be optimized away continue; } if (s->getStateType() == ATNState::RULE_STOP) { continue; } for (size_t i = 0; i < s->getNumberOfTransitions(); i++) { Transition *t = s->transition(i); if (atn->states[(size_t)t->target->stateNumber] == nullptr) { throw IllegalStateException("Cannot serialize a transition to a removed state."); } int src = s->stateNumber; int trg = t->target->stateNumber; int edgeType = t->getSerializationType(); int arg1 = 0; int arg2 = 0; int arg3 = 0; switch (edgeType) { case Transition::RULE: trg = (static_cast<RuleTransition *>(t))->followState->stateNumber; arg1 = (static_cast<RuleTransition *>(t))->target->stateNumber; arg2 = (static_cast<RuleTransition *>(t))->ruleIndex; arg3 = (static_cast<RuleTransition *>(t))->precedence; break; case Transition::PRECEDENCE: { PrecedencePredicateTransition *ppt = static_cast<PrecedencePredicateTransition *>(t); arg1 = ppt->precedence; } break; case Transition::PREDICATE: { PredicateTransition *pt = static_cast<PredicateTransition *>(t); arg1 = pt->ruleIndex; arg2 = pt->predIndex; arg3 = pt->isCtxDependent ? 1 : 0; } break; case Transition::RANGE: arg1 = (int)(static_cast<RangeTransition *>(t))->from; arg2 = (int)(static_cast<RangeTransition *>(t))->to; if (arg1 == Token::EOF) { arg1 = 0; arg3 = 1; } break; case Transition::ATOM: arg1 = (int)(static_cast<AtomTransition *>(t))->_label; if (arg1 == Token::EOF) { arg1 = 0; arg3 = 1; } break; case Transition::ACTION: { ActionTransition *at = static_cast<ActionTransition *>(t); arg1 = at->ruleIndex; arg2 = at->actionIndex; if (arg2 == -1) { arg2 = 0xFFFF; } arg3 = at->isCtxDependent ? 1 : 0; } break; case Transition::SET: arg1 = setIndices[(static_cast<SetTransition *>(t))->set]; break; case Transition::NOT_SET: arg1 = setIndices[(static_cast<SetTransition *>(t))->set]; break; case Transition::WILDCARD: break; } data.push_back((size_t)src); data.push_back((size_t)trg); data.push_back((size_t)edgeType); data.push_back((size_t)arg1); data.push_back((size_t)arg2); data.push_back((size_t)arg3); } } size_t ndecisions = atn->decisionToState.size(); data.push_back(ndecisions); for (DecisionState *decStartState : atn->decisionToState) { data.push_back((size_t)decStartState->stateNumber); } // LEXER ACTIONS if (atn->grammarType == ATNType::LEXER) { data.push_back(atn->lexerActions.size()); for (Ref<LexerAction> action : atn->lexerActions) { data.push_back((size_t)action->getActionType()); switch (action->getActionType()) { case LexerActionType::CHANNEL: { int channel = std::dynamic_pointer_cast<LexerChannelAction>(action)->getChannel(); data.push_back(channel != -1 ? channel : 0xFFFF); data.push_back(0); break; } case LexerActionType::CUSTOM: { int ruleIndex = std::dynamic_pointer_cast<LexerCustomAction>(action)->getRuleIndex(); int actionIndex = std::dynamic_pointer_cast<LexerCustomAction>(action)->getActionIndex(); data.push_back(ruleIndex != -1 ? ruleIndex : 0xFFFF); data.push_back(actionIndex != -1 ? actionIndex : 0xFFFF); break; } case LexerActionType::MODE: { int mode = std::dynamic_pointer_cast<LexerModeAction>(action)->getMode(); data.push_back(mode != -1 ? mode : 0xFFFF); data.push_back(0); break; } case LexerActionType::MORE: data.push_back(0); data.push_back(0); break; case LexerActionType::POP_MODE: data.push_back(0); data.push_back(0); break; case LexerActionType::PUSH_MODE: { int mode = std::dynamic_pointer_cast<LexerPushModeAction>(action)->getMode(); data.push_back(mode != -1 ? mode : 0xFFFF); data.push_back(0); break; } case LexerActionType::SKIP: data.push_back(0); data.push_back(0); break; case LexerActionType::TYPE: { int type = std::dynamic_pointer_cast<LexerTypeAction>(action)->getType(); data.push_back(type != -1 ? type : 0xFFFF); data.push_back(0); break; } default: throw IllegalArgumentException("The specified lexer action type " + std::to_string((size_t)action->getActionType()) + " is not valid."); } } } // don't adjust the first value since that's the version number for (size_t i = 1; i < data.size(); i++) { if (data.at(i) > 0xFFFF) { throw UnsupportedOperationException("Serialized ATN data element out of range."); } size_t value = (data.at(i) + 2) & 0xFFFF; data.assign(i, value); } return data; }