void Kneader::continuos_program(){ switch(mixing_step){ case waiting2Mix: started_kenading=millis(); mixing_step=firstMix; on(); break; case firstMix: case secondMix: if(isExpired(started_kenading,kp->ki.firstMix_milli)){ started_pause=millis(); mixing_step=firstPause; off(); } break; case firstPause: case secondPause: if(isExpired(started_pause,kp->ki.frequency_milli) ){ started_kenading=millis(); mixing_step=firstMix; on(); } break; } }
bool CachedResource::mustRevalidateDueToCacheHeaders(CachePolicy cachePolicy) const { ASSERT(cachePolicy == CachePolicyRevalidate || cachePolicy == CachePolicyCache || cachePolicy == CachePolicyVerify); if (cachePolicy == CachePolicyRevalidate) return true; if (m_response.cacheControlContainsNoCache() || m_response.cacheControlContainsNoStore()) { LOG(ResourceLoading, "CachedResource %p mustRevalidate because of m_response.cacheControlContainsNoCache() || m_response.cacheControlContainsNoStore()\n", this); return true; } if (cachePolicy == CachePolicyCache) { if (m_response.cacheControlContainsMustRevalidate() && isExpired()) { LOG(ResourceLoading, "CachedResource %p mustRevalidate because of cachePolicy == CachePolicyCache and m_response.cacheControlContainsMustRevalidate() && isExpired()\n", this); return true; } return false; } // CachePolicyVerify if (isExpired()) { LOG(ResourceLoading, "CachedResource %p mustRevalidate because of isExpired()\n", this); return true; } return false; }
CachedResource::RevalidationDecision CachedResource::makeRevalidationDecision(CachePolicy cachePolicy) const { switch (cachePolicy) { case CachePolicyHistoryBuffer: return RevalidationDecision::No; case CachePolicyReload: case CachePolicyRevalidate: return RevalidationDecision::YesDueToCachePolicy; case CachePolicyVerify: if (m_response.cacheControlContainsNoCache()) return RevalidationDecision::YesDueToNoCache; // FIXME: Cache-Control:no-store should prevent storing, not reuse. if (m_response.cacheControlContainsNoStore()) return RevalidationDecision::YesDueToNoStore; if (isExpired()) return RevalidationDecision::YesDueToExpired; return RevalidationDecision::No; }; ASSERT_NOT_REACHED(); return RevalidationDecision::No; }
bool Timer::onRestart() { if(isExpired()) { restart(); return true; } return false; }
void Kneader::run(){ if(!active) return ; /* first check if is the first time we run*/ if(started==0){ /* in that case mark when the program is started*/ started=millis(); } /* check if the program is ended */ if(kp==NULL || isExpired(kp->ki.length_seconds*1000,started) ){ delay(2000); return; } switch(kp->ki.mode){ case continuos: continuos_program(); break; case dashed: dashed_program(); break; case alternated: alternated_program(); break; default: /* unsupported bake */ break; } }
xpcc::Timestamp xpcc::Timeout<T>::remaining() { if (isExpired()) return 0; else return (endTime - T::now()); }
void CallbackTimer::update() { // When not flagged as "just expired" yet, do it now, and call listeners if (isExpired() && !mJustExpired) { mJustExpired = true; mListeners.call(*this); } }
// isValid: // bool Cacheable::isValid() { if (isExpired()) return false; if (this->m_isValidFlag == VALID) return true; else return false; } // END OF MEMBER FUNCTION isValid
void Schedule::start() { if (isExpired() || isActive()) return; ///////////////////////////////////////////// _timer->connect(_timer, SIGNAL(timeout()), this, SLOT(timeout())); _timer->start(QDateTime::currentDateTime().msecsTo(_launchAt)); ////////////////////////////////////////////// }
Lease::Lease (const Client& c) { m = SharedPtr<ClientData>(c.m); if ( !m->fHasLease || ( isExpired() && !isInBindingPhase())) { m->fHasLease = true; m->fBinding = true; phaseStart(RTTimeMilliTS()); } }
sc::result StGetBackOnTrackPrepare::react(const EvProcess&) { if (detectedErrornousTransitions()) return transit<StGlobalRecover> (); // return transit<StDrive>(); // return transit<StPause>(); ChsmPlanner& planner = context<ChsmPlanner> (); if (isExpired(context<StGetBackOnTrack> ().map_timer)) { return transit<StGetBackOnTrackAStar> (); } else { planner.generateStopTrajectory(); return forward_event(); } }
Volatility CapFloor::impliedVolatility(Real targetValue, const Handle<YieldTermStructure>& d, Volatility guess, Real accuracy, Natural maxEvaluations, Volatility minVol, Volatility maxVol) const { //calculate(); QL_REQUIRE(!isExpired(), "instrument expired"); ImpliedVolHelper f(*this, d, targetValue); //Brent solver; NewtonSafe solver; solver.setMaxEvaluations(maxEvaluations); return solver.solve(f, accuracy, guess, minVol, maxVol); }
bool Clock::isExpired(const dtn::data::Bundle &b) { if (b.timestamp == 0) { // use the AgeBlock to verify the age try { const dtn::data::AgeBlock &agebl = b.find<dtn::data::AgeBlock>(); return (b.lifetime < agebl.getSeconds()); } catch (const dtn::data::Bundle::NoSuchBlockFoundException&) { // if there is no AgeBlock this bundle is not valid return true; } } return isExpired(b.timestamp, b.lifetime); }
Volatility CallableBond::impliedVolatility( Real targetValue, const Handle<YieldTermStructure>& discountCurve, Real accuracy, Size maxEvaluations, Volatility minVol, Volatility maxVol) const { calculate(); QL_REQUIRE(!isExpired(), "instrument expired"); Volatility guess = 0.5*(minVol + maxVol); blackDiscountCurve_.linkTo(*discountCurve, false); ImpliedVolHelper f(*this,targetValue); Brent solver; solver.setMaxEvaluations(maxEvaluations); return solver.solve(f, accuracy, guess, minVol, maxVol); }
void SubscriptionManager::checkMissedPublication( const Timer::TimerId id) { std::lock_guard<std::recursive_mutex> subscriptionLocker(&mutex); if (!isExpired() && !subscription->isStopped) { JOYNR_LOG_DEBUG(logger, "Running MissedPublicationRunnable for subscription id= {}",subscriptionId); std::int64_t delay = 0; std::int64_t now = duration_cast<milliseconds>( system_clock::now().time_since_epoch()).count(); std::int64_t timeSinceLastPublication = now - subscription->timeOfLastPublication; bool publicationInTime = timeSinceLastPublication < alertAfterInterval; if (publicationInTime) { JOYNR_LOG_TRACE(logger, "Publication in time!"); delay = alertAfterInterval - timeSinceLastPublication; } else { JOYNR_LOG_DEBUG(logger, "Publication missed!"); std::shared_ptr<ISubscriptionCallback> callback = subscription->subscriptionCaller; callback->onError(); delay = alertAfterInterval - timeSinceLastExpectedPublication(timeSinceLastPublication); } JOYNR_LOG_DEBUG(logger, "Resceduling MissedPublicationRunnable with delay: {}",std::string::number(delay)); subscription->missedPublicationRunnableHandle = subscriptionManager.missedPublicationScheduler->schedule( new MissedPublicationRunnable(decayTime, expectedIntervalMSecs, subscriptionId, subscription, subscriptionManager, alertAfterInterval), delay); } else { JOYNR_LOG_DEBUG(logger, "Publication expired / interrupted. Expiring on subscription id={}",subscriptionId); } }
void EntityList::update( void *updateState ) { Entity::update( updateState ); if ( isExpired() ) { return; } for (auto e : entities) { e->update( updateState ); onEntityUpdated( e, updateState ); } clean(); }
//Checks for expiry of all tasks in the multimap void Storage::checkForExpiry() { multimap<DEADLINE, Task*>::iterator it; it=timedTaskMap.begin(); while(it != timedTaskMap.end()){ if(isExpired((*it).second)) { (*it).second->indicateExpired(); } if(isToday((*it).second)) { (*it).second->indicateToday(true); } else { (*it).second->indicateToday(false); } it++; } }
Volatility CdsOption::impliedVolatility( Real targetValue, const Handle<YieldTermStructure>& termStructure, const Handle<DefaultProbabilityTermStructure>& probability, Real recoveryRate, Real accuracy, Size maxEvaluations, Volatility minVol, Volatility maxVol) const { calculate(); QL_REQUIRE(!isExpired(), "instrument expired"); Volatility guess = 0.10; ImpliedVolHelper f(*this, probability, recoveryRate, termStructure, targetValue); Brent solver; solver.setMaxEvaluations(maxEvaluations); return solver.solve(f, accuracy, guess, minVol, maxVol); }
Volatility DoubleBarrierOption::impliedVolatility( Real targetValue, const boost::shared_ptr<GeneralizedBlackScholesProcess>& process, Real accuracy, Size maxEvaluations, Volatility minVol, Volatility maxVol) const { QL_REQUIRE(!isExpired(), "option expired"); boost::shared_ptr<SimpleQuote> volQuote = boost::make_shared<SimpleQuote>(); boost::shared_ptr<GeneralizedBlackScholesProcess> newProcess = detail::ImpliedVolatilityHelper::clone(process, volQuote); // engines are built-in for the time being boost::scoped_ptr<PricingEngine> engine; switch (exercise_->type()) { case Exercise::European: engine.reset(new AnalyticDoubleBarrierEngine(newProcess)); break; case Exercise::American: case Exercise::Bermudan: QL_FAIL("engine not available for non-European barrier option"); break; default: QL_FAIL("unknown exercise type"); } return detail::ImpliedVolatilityHelper::calculate(*this, *engine, *volQuote, targetValue, accuracy, maxEvaluations, minVol, maxVol); }
sc::result StWaitForActivation::react(const EvProcess&) { if (detectedErrornousTransitions()) return transit<StGlobalRecover> (); ChsmPlanner& planner = context<ChsmPlanner> (); Topology* topology = planner.topology_; // set velocity to 0 -> park mode context<ChsmPlanner> ().generateStopTrajectory(); // context<ChsmPlanner> ().vehiclecmd.beeper_on = 1; // context<ChsmPlanner> ().vehiclecmd.hazard_lights_on = 1; if (isExpired(wait_until_)) { // Transition: Replanning (because ego vehicle is off track) if (topology->isOffTrack() || moved) return transit<StReplan> (); // Transition: restore history return transit<StActiveHistory> (); } else { return forward_event(); } }
bool Timer::onExpired() { if(!_has_been_expired && isExpired()) { return _has_been_expired = true; } return false; }
bool CNameData::isExpired () const { return isExpired (chainActive.Height ()); }
bool Timer::isRunning() const { return mStopWatch.isRunning() && !isExpired(); }
sc::result StIntersectionTrafficLightStop::react(const EvProcess&) { if (detectedErrornousTransitions()) return transit<StGlobalRecover>(); ChsmPlanner& planner = context<ChsmPlanner>(); IntersectionManager* isec_man = context<StIntersection>().isec_man; Topology* topology = context<ChsmPlanner>().topology_; assert(isec_man); // Transition: Recovery Mode if (isec_man->hasPrioMovement()) { context<StIntersection>().clearRecoveryIndicator(); } if (planner.params().enable_recovery && (context<StIntersection>().checkRecovery() || isExpired(context<StIntersection>().max_wait_at_intersection))) { // measure progress in the parent state return transit<StIntersectionRecover>(); } // Transition: Replanning (because ego vehicle is off track) if (topology->isOffTrack()) return transit<StReplan>(); // Transition: Replanning (because route is blocked) if ( topology->isRouteBlocked() ) return transit<StReplan>(); // Transition: If traffic light switched to green while slowing down cross intersection if(!context<StIntersection>().isec_man->hasToStop()) { return transit<StIntersectionDriveInside>(); } // calculate distances // TODO: make sure that stop line belongs to intersection double traffic_light_dist = topology->distToTrafficLight(isec_man->intersection(), NULL, &planner.stop_point_); double intersec_dist = topology->distToIntersection(isec_man->intersection()); double mv_veh_dist, sv_veh_dist; planner.getVehicleDistances(sv_veh_dist, mv_veh_dist); // set turn signal planner.turn_signal_.signal = context<StIntersection>().turnDirection; // printf("STOP IN %f m;\t CURRENT SPEED %f\n", traffic_light_dist, currentPose().v()); // Transition: Wait at stop line (because ego_vehicle stopped at stopline) if ( traffic_light_dist < TRAFFIC_LIGHT_DIST_THRESHOLD && planner.currentPose().v() < STOP_SPEED_THRESHOLD ) { return transit<StIntersectionTrafficLightWait>(); } else if (traffic_light_dist == std::numeric_limits<double>::infinity()) { std::cout << "WE RAN OVER A (NON GREEN) TRAFFIC LIGHT!!\n"; return transit<StIntersectionDriveInside>(); } // Transition: Queueing (if vehicle backed up) if ( traffic_light_dist < TRIGGER_DIST_TRAFFIC_LIGHT && (mv_veh_dist < traffic_light_dist || sv_veh_dist < traffic_light_dist) ) return transit<StIntersectionQueue>(); // Transition: To get states right if something goes wrong: leave intersection mode if we behind intersection if ( intersec_dist <= -0.1 ) { return transit<StDrive>(); } // generate curvepoints context<StIntersection>().generateCurvepoints(traffic_light_dist, planner.params().max_speed_traffic_light_approach); return forward_event(); }
UtlBoolean SipSubscriptionMgr::insertDialogInfo(const SipMessage& subscribeRequest, const UtlString& resourceId, const UtlString& eventTypeKey, UtlString& subscribeDialogHandle, UtlBoolean& isNew, UtlBoolean& isSubscriptionExpired, SipMessage& subscribeResponse) { isNew = FALSE; UtlBoolean subscriptionSucceeded = FALSE; UtlString dialogHandle; subscribeRequest.getDialogHandle(dialogHandle); SubscriptionServerState* state = NULL; int expiration = -1; isSubscriptionExpired = TRUE; // If this is an early dialog we need to make it an established dialog. if(SipDialog::isEarlyDialog(dialogHandle)) { UtlString establishedDialogHandle; if(mDialogMgr.getEstablishedDialogHandleFor(dialogHandle, establishedDialogHandle)) { OsSysLog::add(FAC_SIP, PRI_WARNING, "Incoming early SUBSCRIBE dialog: %s matches established dialog: %s", dialogHandle.data(), establishedDialogHandle.data()); } // make up a To tag and set it UtlString toTag; CallId::getNewTag(dialogHandle.data(), toTag); // Get and validate the expires period // This potentially should be delegated to the event handler specifics if(!subscribeRequest.getExpiresField(&expiration)) { expiration = mDefaultExpiration; } else if(expiration > mMaxExpiration) { expiration = mMaxExpiration; } // Acceptable expiration, create a subscription and dialog if(expiration >= mMinExpiration || expiration == 0 || // :WORKAROUND: Also allow expiration == 1, to support the // 1-second subscriptions the pick-up agent makes because // current Snom phones do not respond to 0-second subscriptions. // See XPB-399 and ENG-319. expiration == 1) { // Create a dialog and subscription state even if // the expiration is zero as we need the dialog info // to route the one-time NOTIFY. The immediately // expired dialog will be garbage collected. SipMessage* subscribeCopy = new SipMessage(subscribeRequest); subscribeCopy->setToFieldTag(toTag); // Re-get the dialog handle now that the To tag is set subscribeCopy->getDialogHandle(dialogHandle); // Create the dialog mDialogMgr.createDialog(*subscribeCopy, FALSE, dialogHandle); isNew = TRUE; // Create a subscription state state = new SubscriptionServerState(); *((UtlString*) state) = dialogHandle; state->mEventTypeKey = eventTypeKey; state->mpLastSubscribeRequest = subscribeCopy; state->mResourceId = resourceId; subscribeCopy->getAcceptField(state->mAcceptHeaderValue); long now = OsDateTime::getSecsSinceEpoch(); state->mExpirationDate = now + expiration; // TODO: currently the SipSubsribeServer does not handle timeout // events to send notifications that the subscription has ended. // So we do not set a timer at the end of the subscription state->mpExpirationTimer = NULL; // Create the index by resourceId and eventTypeKey key SubscriptionServerStateIndex* stateKey = new SubscriptionServerStateIndex; *((UtlString*) stateKey) = resourceId; stateKey->append(eventTypeKey); stateKey->mpState = state; subscribeResponse.setResponseData(subscribeCopy, SIP_ACCEPTED_CODE, SIP_ACCEPTED_TEXT, NULL); subscribeResponse.setExpiresField(expiration); subscribeCopy->getDialogHandle(subscribeDialogHandle); lock(); mSubscriptionStatesByDialogHandle.insert(state); mSubscriptionStateResourceIndex.insert(stateKey); if (OsSysLog::willLog(FAC_SIP, PRI_DEBUG)) { UtlString requestContact; subscribeRequest.getContactField(0, requestContact); OsSysLog::add(FAC_SIP, PRI_DEBUG, "SipSubscriptionMgr::insertDialogInfo insert early-dialog subscription for dialog handle '%s', key '%s', contact '%s', mExpirationDate %ld", state->data(), stateKey->data(), requestContact.data(), state->mExpirationDate); } // Not safe to touch these after we unlock stateKey = NULL; state = NULL; subscribeCopy = NULL; unlock(); subscriptionSucceeded = TRUE; // One time subscribe? isSubscriptionExpired = expiration == 0; } // Expiration too small else { // Set expiration too small error subscribeResponse.setResponseData(&subscribeRequest, SIP_TOO_BRIEF_CODE, SIP_SUB_TOO_BRIEF_TEXT); subscribeResponse.setMinExpiresField(mMinExpiration); isSubscriptionExpired = TRUE; } } // Not an early dialog handle -- The dialog for this message may already exist else { // Get and validate the expires period // This potentially should be delegated to the event handler specifics if(!subscribeRequest.getExpiresField(&expiration)) { expiration = mDefaultExpiration; } else if(expiration > mMaxExpiration) { expiration = mMaxExpiration; } // Acceptable expiration, create a subscription and dialog if(expiration > mMinExpiration || expiration == 0) { // Update the dialog state mDialogMgr.updateDialog(subscribeRequest, dialogHandle); // Get the subscription state and update that // TODO: This assumes that no one reuses the same dialog // to subscribe to more than one event type. mSubscriptionStatesByDialogHandle // will need to be changed to a HashBag and we will need to // search through to find a matching event type lock(); state = (SubscriptionServerState*) mSubscriptionStatesByDialogHandle.find(&dialogHandle); if(state) { long now = OsDateTime::getSecsSinceEpoch(); state->mExpirationDate = now + expiration; if(state->mpLastSubscribeRequest) { delete state->mpLastSubscribeRequest; } state->mpLastSubscribeRequest = new SipMessage(subscribeRequest); subscribeRequest.getAcceptField(state->mAcceptHeaderValue); // Set the contact to the same request URI that came in UtlString contact; subscribeRequest.getRequestUri(&contact); // Add the angle brackets for contact Url url(contact); url.includeAngleBrackets(); contact = url.toString(); subscribeResponse.setResponseData(&subscribeRequest, SIP_ACCEPTED_CODE, SIP_ACCEPTED_TEXT, contact); subscribeResponse.setExpiresField(expiration); subscriptionSucceeded = TRUE; isSubscriptionExpired = FALSE; subscribeDialogHandle = dialogHandle; } // No state, but SUBSCRIBE had a to-tag. else { SipMessage* subscribeCopy = new SipMessage(subscribeRequest); // Create the dialog mDialogMgr.createDialog(*subscribeCopy, FALSE, dialogHandle); isNew = TRUE; // Create a subscription state state = new SubscriptionServerState(); *((UtlString*)state) = dialogHandle; state->mEventTypeKey = eventTypeKey; state->mpLastSubscribeRequest = subscribeCopy; state->mResourceId = resourceId; subscribeCopy->getAcceptField(state->mAcceptHeaderValue); long now = OsDateTime::getSecsSinceEpoch(); state->mExpirationDate = now + expiration; // TODO: currently the SipSubsribeServer does not handle timeout // events to send notifications that the subscription has ended. // So we do not set a timer at the end of the subscription state->mpExpirationTimer = NULL; // Create the index by resourceId and eventTypeKey key SubscriptionServerStateIndex* stateKey = new SubscriptionServerStateIndex; *((UtlString*)stateKey) = resourceId; stateKey->append(eventTypeKey); stateKey->mpState = state; mSubscriptionStatesByDialogHandle.insert(state); mSubscriptionStateResourceIndex.insert(stateKey); if (OsSysLog::willLog(FAC_SIP, PRI_DEBUG)) { UtlString requestContact; subscribeRequest.getContactField(0, requestContact); OsSysLog::add(FAC_SIP, PRI_DEBUG, "SipSubscriptionMgr::insertDialogInfo insert subscription for key '%s', contact '%s', mExpirationDate %ld", stateKey->data(), requestContact.data(), state->mExpirationDate); } // Not safe to touch these after we unlock stateKey = NULL; state = NULL; subscribeCopy = NULL; // Set the contact to the same request URI that came in UtlString contact; subscribeRequest.getRequestUri(&contact); // Add the angle brackets for contact Url url(contact); url.includeAngleBrackets(); contact = url.toString(); subscribeResponse.setResponseData(&subscribeRequest, SIP_ACCEPTED_CODE, SIP_ACCEPTED_TEXT, contact); subscribeResponse.setExpiresField(expiration); subscriptionSucceeded = TRUE; // Unsubscribe if(expiration == 0) { isSubscriptionExpired = TRUE; } else { isSubscriptionExpired = FALSE; } subscribeDialogHandle = dialogHandle; } unlock(); } // Expiration too small else { // Set expiration too small error subscribeResponse.setResponseData(&subscribeRequest, SIP_TOO_BRIEF_CODE, SIP_SUB_TOO_BRIEF_TEXT); subscribeResponse.setMinExpiresField(mMinExpiration); isSubscriptionExpired = isExpired(dialogHandle); } } return(subscriptionSucceeded); }
void CButton::run() { bitWrite(state,PREVIOUS,bitRead(state,CURRENT)); timing[PREVIOUS] = timing[CURRENT]; bitWrite(state,CURRENT,(digitalRead(pin) != mode)); timing[CURRENT] = millis(); if (bitRead(state,CURRENT) != bitRead(state,PREVIOUS)){ bitWrite(state,CHANGED,true); timing[CHANGED] = timing[CURRENT]; }else{ bitWrite(state,CHANGED,false); } /* check if we need to reset a sequence that has been recorded * and is aged. * */ if(stopCountingSequence==false){ if(stateChanged()){ /* check if was a transition from * pressed to release */ if(!bitRead(state,PREVIOUS)){ /* new Pressure start * reset the timeout for the sequence */ timing[START_OF_SEQ] = millis(); shortCounted=longCounted=false; } }else{ /* status doesn't change*/ if(isPressed()){ if( shortCounted==false && isExpired(timing[START_OF_SEQ],shortPushMilli) ){ /* count it only once*/ shortPressureCount++; shortCounted=true; timing[START_OF_SEQ] = millis(); } if( longCounted==false && isExpired(timing[START_OF_SEQ],longPushMilli) ){ /* count it only once*/ longPressureCount++; shortPressureCount--; longCounted=true; timing[START_OF_SEQ] = millis(); } if(longCounted && isExpired(timing[START_OF_SEQ],resetSequenceMilli)){ shortPressureCount=longPressureCount=0; stopCountingSequence=false; } } } } if(!isPressed() && (longCounted || shortCounted)){ if(isExpired(timing[START_OF_SEQ],timeOut4SequenceMilli) && stopCountingSequence==false ){ stopCountingSequence=true; } if(stopCountingSequence && isExpired(timing[START_OF_SEQ],expireSequenceMilli)){ shortPressureCount=longPressureCount=0; stopCountingSequence=false; } } delay(20); }
/** Returns true if there exists a mapping for <b>addr</b> and that mapping is * not expired. */ bool AddressMap::isMapped(const QString &addr) const { return (contains(addr) && !isExpired(value(addr))); }
UtlBoolean SipSubscriptionMgr::updateDialogInfo(const SipMessage& subscribeRequest, UtlString& resourceId, UtlString& eventTypeKey, UtlString& eventType, UtlString& subscribeDialogHandle, UtlBoolean& isNew, UtlBoolean& isSubscriptionExpired, SipMessage& subscribeResponse, SipSubscribeServerEventHandler& handler) { isNew = FALSE; UtlBoolean subscriptionSucceeded = FALSE; UtlString dialogHandle; subscribeRequest.getDialogHandle(dialogHandle); SubscriptionServerState* state = NULL; int expiration = -1; isSubscriptionExpired = TRUE; // Double check the sanity of the class attributes if(mMaxExpiration < mMinExpiration) { // This is an error case. Switch the values so that we do not // run into any negative expiration times. int tmp = mMaxExpiration; mMaxExpiration = mMinExpiration; mMinExpiration = tmp; OsSysLog::add(FAC_SIP, PRI_WARNING, "Swapping values as mMinExpiration => %d is greater than mMaxExpiration => %d", mMinExpiration, mMaxExpiration); } if(mMaxExpiration < mDefaultExpiration) { // This is an error case. Switch the values so that we do not // run into any negative expiration times. int tmp = mMaxExpiration; mMaxExpiration = mDefaultExpiration; mDefaultExpiration = tmp; OsSysLog::add(FAC_SIP, PRI_WARNING, "Swapping values as mDefaultExpiration => %d is greater than mMaxExpiration => %d", mDefaultExpiration, mMaxExpiration); } // Set the expires period randomly int spreadFloor = mMinExpiration*2; if(!subscribeRequest.getExpiresField(&expiration)) { // no expires field // spread it between the default expiration and max allowed expiration expiration = ( (rand() % (mMaxExpiration - mDefaultExpiration)) + mDefaultExpiration); } else if ( expiration >= mMaxExpiration ) { if (mMaxExpiration > spreadFloor) { // - spread it between the spreadFloor and the max allowed expiration expiration = ( (rand() % (mMaxExpiration - spreadFloor)) + spreadFloor); } else { // Max Expiration is smaller than the spreadFloor, hence // spread it between the min and the max allowed expiration expiration = ( (rand() % (mMaxExpiration - mMinExpiration)) + mMinExpiration); } } else if ( expiration > spreadFloor ) { // a normal (long) expiration // - spread it between the spreadFloor and the longest they asked for expiration = ( (rand() % (expiration - spreadFloor)) + spreadFloor); } else if ( expiration > mMinExpiration ) { // a short but greater than minimum expiration // - spread it between the min and the longest they asked for expiration = ( (rand() % (expiration - mMinExpiration)) + mMinExpiration); } // Cases where the expiration is less than the min value is handled below. // If this is an early dialog we need to make it an established dialog. if(SipDialog::isEarlyDialog(dialogHandle)) { UtlString establishedDialogHandle; if(mDialogMgr.getEstablishedDialogHandleFor(dialogHandle, establishedDialogHandle)) { OsSysLog::add(FAC_SIP, PRI_WARNING, "Incoming early SUBSCRIBE dialog: %s matches established dialog: %s", dialogHandle.data(), establishedDialogHandle.data()); } // make up a To tag and set it UtlString toTag; CallId::getNewTag(dialogHandle.data(), toTag); // Acceptable expiration, create a subscription and dialog if(expiration >= mMinExpiration || expiration == 0 || // :WORKAROUND: Also allow expiration == 1, to support the // 1-second subscriptions the pick-up agent makes because // current Snom phones do not respond to 0-second subscriptions. // See XPB-399 and ENG-319. expiration == 1) { // Call the event-specific function to determine the resource ID // and event type for this SUBSCRIBE. handler.getKeys(subscribeRequest, resourceId, eventTypeKey, eventType); // Create a dialog and subscription state even if // the expiration is zero as we need the dialog info // to route the one-time NOTIFY. The immediately // expired dialog will be garbage collected. SipMessage* subscribeCopy = new SipMessage(subscribeRequest); subscribeCopy->setToFieldTag(toTag); // Re-get the dialog handle now that the To tag is set subscribeCopy->getDialogHandle(dialogHandle); // Create the dialog mDialogMgr.createDialog(*subscribeCopy, FALSE, dialogHandle); isNew = TRUE; // Create a subscription state state = new SubscriptionServerState(); *((UtlString*) state) = dialogHandle; state->mEventTypeKey = eventTypeKey; state->mpLastSubscribeRequest = subscribeCopy; state->mResourceId = resourceId; subscribeCopy->getAcceptField(state->mAcceptHeaderValue); long now = OsDateTime::getSecsSinceEpoch(); state->mExpirationDate = now + expiration; // TODO: currently the SipSubsribeServer does not handle timeout // events to send notifications that the subscription has ended. // So we do not set a timer at the end of the subscription state->mpExpirationTimer = NULL; // Create the index by resourceId and eventTypeKey key SubscriptionServerStateIndex* stateKey = new SubscriptionServerStateIndex; *((UtlString*) stateKey) = resourceId; stateKey->append(eventTypeKey); stateKey->mpState = state; subscribeResponse.setResponseData(subscribeCopy, SIP_ACCEPTED_CODE, SIP_ACCEPTED_TEXT, NULL); subscribeResponse.setExpiresField(expiration); subscribeCopy->getDialogHandle(subscribeDialogHandle); lock(); mSubscriptionStatesByDialogHandle.insert(state); mSubscriptionStateResourceIndex.insert(stateKey); if (OsSysLog::willLog(FAC_SIP, PRI_DEBUG)) { UtlString requestContact; subscribeRequest.getContactField(0, requestContact); OsSysLog::add(FAC_SIP, PRI_DEBUG, "SipSubscriptionMgr::updateDialogInfo insert early-dialog subscription for dialog handle '%s', key '%s', contact '%s', mExpirationDate %ld", state->data(), stateKey->data(), requestContact.data(), state->mExpirationDate); } // Not safe to touch these after we unlock stateKey = NULL; state = NULL; subscribeCopy = NULL; unlock(); subscriptionSucceeded = TRUE; // One time subscribe? isSubscriptionExpired = expiration == 0; } // Expiration too small else { // Set expiration too small error subscribeResponse.setResponseData(&subscribeRequest, SIP_TOO_BRIEF_CODE, SIP_SUB_TOO_BRIEF_TEXT); subscribeResponse.setMinExpiresField(mMinExpiration); isSubscriptionExpired = TRUE; } } // Not an early dialog handle -- The dialog for this message should already exist else { // Acceptable expiration, create a subscription and dialog if(expiration > mMinExpiration || expiration == 0) { // Update the dialog state mDialogMgr.updateDialog(subscribeRequest, dialogHandle); // Get the subscription state and update that // TODO: This assumes that no one reuses the same dialog // to subscribe to more than one event type. mSubscriptionStatesByDialogHandle // will need to be changed to a HashBag and we will need to // search through to find a matching event type lock(); state = (SubscriptionServerState*) mSubscriptionStatesByDialogHandle.find(&dialogHandle); if(state) { // Update the expiration time. long now = OsDateTime::getSecsSinceEpoch(); state->mExpirationDate = now + expiration; // Record this SUBSCRIBE as the latest SUBSCRIBE request. if(state->mpLastSubscribeRequest) { delete state->mpLastSubscribeRequest; } state->mpLastSubscribeRequest = new SipMessage(subscribeRequest); subscribeRequest.getAcceptField(state->mAcceptHeaderValue); // Set our Contact to the same request URI that came in UtlString contact; subscribeRequest.getRequestUri(&contact); // Add the angle brackets to Contact, since it is a name-addr. Url url(contact); url.includeAngleBrackets(); contact = url.toString(); subscribeResponse.setResponseData(&subscribeRequest, SIP_ACCEPTED_CODE, SIP_ACCEPTED_TEXT, contact); subscribeResponse.setExpiresField(expiration); subscriptionSucceeded = TRUE; isSubscriptionExpired = FALSE; subscribeDialogHandle = dialogHandle; // Set the resource information so our caller can generate a NOTIFY. resourceId = state->mResourceId; eventTypeKey = state->mEventTypeKey; // Unfortuantely, we don't record the eventType separately. eventType = state->mEventTypeKey; } // No state, but SUBSCRIBE had a to-tag. else { // Unknown subscription. subscribeResponse.setResponseData(&subscribeRequest, SIP_BAD_SUBSCRIPTION_CODE, SIP_BAD_SUBSCRIPTION_TEXT); } unlock(); } // Expiration too small else { // Set expiration too small error subscribeResponse.setResponseData(&subscribeRequest, SIP_TOO_BRIEF_CODE, SIP_SUB_TOO_BRIEF_TEXT); subscribeResponse.setMinExpiresField(mMinExpiration); isSubscriptionExpired = isExpired(dialogHandle); } } return(subscriptionSucceeded); }
void PUParticleSystem3D::processParticle( ParticlePool &pool, bool &firstActiveParticle, bool &firstParticle, float elapsedTime ) { PUParticle3D *particle = static_cast<PUParticle3D *>(pool.getFirst()); //Mat4 ltow = getNodeToWorldTransform(); //Vec3 scl; //Quaternion rot; //ltow.decompose(&scl, &rot, nullptr); while (particle){ if (!isExpired(particle, elapsedTime)){ particle->process(elapsedTime); //if (_emitter && _emitter->isEnabled()) // _emitter->updateEmitter(particle, elapsedTime); for (auto it : _emitters) { if (it->isEnabled() && !it->isMarkedForEmission()){ (static_cast<PUEmitter*>(it))->updateEmitter(particle, elapsedTime); } } for (auto& it : _affectors) { if (it->isEnabled()){ (static_cast<PUAffector*>(it))->process(particle, elapsedTime, firstActiveParticle); } } if (_render) static_cast<PURender *>(_render)->updateRender(particle, elapsedTime, firstActiveParticle); if (_isEnabled && particle->particleType != PUParticle3D::PT_VISUAL){ if (particle->particleType == PUParticle3D::PT_EMITTER){ auto emitter = static_cast<PUEmitter *>(particle->particleEntityPtr); emitter->setLocalPosition(particle->position); executeEmitParticles(emitter, emitter->calculateRequestedParticles(elapsedTime), elapsedTime); }else if (particle->particleType == PUParticle3D::PT_TECHNIQUE){ auto system = static_cast<PUParticleSystem3D *>(particle->particleEntityPtr); system->setPosition3D(particle->position); system->setRotationQuat(particle->orientation); //system->setScaleX(scl.x);system->setScaleY(scl.y);system->setScaleZ(scl.z); system->forceUpdate(elapsedTime); } } firstActiveParticle = false; // Keep latest position particle->latestPosition = particle->position; //if (_maxVelocitySet && particle->calculateVelocity() > _maxVelocity) //{ // particle->direction *= (_maxVelocity / particle->direction.length()); //} //// Update the position with the direction. //particle->position += (particle->direction * _particleSystemScaleVelocity * elapsedTime); //particle->positionInWorld = particle->position; //particle->orientationInWorld = particle->orientation; //particle->widthInWorld = particle->width; //particle->heightInWorld = particle->height; //particle->depthInWorld = particle->depth; //bool keepLocal = _keepLocal; //PUParticleSystem3D *parent = dynamic_cast<PUParticleSystem3D *>(getParent()); //if (parent) keepLocal = keepLocal || parent->isKeepLocal(); //if (keepLocal){ // ltow.transformPoint(particle->positionInWorld, &particle->positionInWorld); // Vec3 ori; // ltow.transformVector(Vec3(particle->orientation.x, particle->orientation.y, particle->orientation.z), &ori); // particle->orientationInWorld.x = ori.x; particle->orientationInWorld.y = ori.y; particle->orientationInWorld.z = ori.z; // particle->widthInWorld = scl.x * particle->width; // particle->heightInWorld = scl.y * particle->height; // particle->depthInWorld = scl.z * particle->depth; //} processMotion(particle, elapsedTime, firstActiveParticle); } else{ initParticleForExpiration(particle, elapsedTime); pool.lockLatestData(); } for (auto it : _observers){ if (it->isEnabled()){ it->updateObserver(particle, elapsedTime, firstParticle); } } if (particle->hasEventFlags(PUParticle3D::PEF_EXPIRED)) { particle->setEventFlags(0); particle->addEventFlags(PUParticle3D::PEF_EXPIRED); } else { particle->setEventFlags(0); } particle->timeToLive -= elapsedTime; firstParticle = false; particle = static_cast<PUParticle3D *>(pool.getNext()); } }
/** Returns the address to which <b>addr</b> is currently mapped. If there is * no mapping for <b>addr</b> (or the mapping is expired), then an empty * string is returned. */ QString AddressMap::mappedTo(const QString &addr) const { AddressMapEntry entry = value(addr); return (isExpired(entry) ? QString() : entry.first); }