Trigger* DatabaseManager::getTrigger(const QString& id) { SDPASSERT(Logger::instancePtr()); Trigger* trig = NULL; if ( __db.isOpen() ) { Logger::instancePtr()->addMessage(Logger::CRITICAL, __func__, QString("Failed to fetch trigger %1. Database couldn't be opened.") .arg(id), true); return trig; } QSqlQuery query(QString("SELECT data FROM main.Trigger WHERE id LIKE '%1'").arg(id)); if ( query.next() ) { QByteArray data = qUncompress(query.value(0).toByteArray()); QDataStream stream(&data, QIODevice::ReadOnly); #if (QT_VERSION >= QT_VERSION_CHECK(4, 8, 0)) stream.setVersion(QDataStream::Qt_4_8); #else stream.setVersion(QDataStream::Qt_4_6); #endif trig = Trigger::create(""); trig->fromDataStream(stream); } return trig; }
char *Trigger::getTriggers() { std::stringstream ss; { boost::recursive_mutex::scoped_lock scoped_lock(trigger_list_mutex); std::list<Trigger*>::iterator iter = all_triggers.begin(); while (iter != all_triggers.end()) { Trigger *t = *iter++; ss << t->getName() << " (" << t->refs; if (t->_internals->holders.size()) { ss << ":"; std::list<Action*>::iterator h_iter = t->_internals->holders.begin(); while (h_iter != t->_internals->holders.end()) { ss << *(*h_iter++) << " "; } } ss << ")\n"; } } if (!ss.str().length()) return 0; size_t len = ss.str().length(); char *res = new char[len+1]; strncpy(res, ss.str().c_str(), len); res[len] = 0; return res; }
void faultcheck_packet_setTriggerAfterIterations(const char *identifier, unsigned long iterations) { Trigger *trg = packetTool.trigger(identifier); if (trg) { trg->setAfterItr(iterations); } }
DatabaseManager::TriggerList DatabaseManager::triggers(const QString& detectionID) { TriggerList l; if ( !__db.isOpen() ) return l; QSqlQuery query(QString("SELECT data FROM main.Trigger WHERE detection_id LIKE '%1'") .arg(detectionID)); while ( query.next() ) { QByteArray data = qUncompress(query.value(0).toByteArray()); QDataStream stream(&data, QIODevice::ReadOnly); #if (QT_VERSION >= QT_VERSION_CHECK(4, 8, 0)) stream.setVersion(QDataStream::Qt_4_8); #else stream.setVersion(QDataStream::Qt_4_6); #endif Trigger* trig = Trigger::create(""); trig->fromDataStream(stream); l << trig; } return l; }
void faultcheck_packet_setDurationAfterTrigger(const char *identifier, int iterations) { Trigger *trg = packetTool.trigger(identifier); if (trg) { trg->setDuration(iterations); } }
int callback(void *outputBuffer, void *inputBuffer, unsigned int nBufferFrames, double streamTime, RtAudioStreamStatus status, void *dataPointer) { Trigger *trigger = static_cast<Trigger *>(dataPointer); StkFloat *samples = static_cast<StkFloat *>(inputBuffer); trigger->feedMe(samples, nBufferFrames); return (0); }
void collisionFilter(SceneObject* object,void *key) { SceneContainer::CallbackInfo* info = reinterpret_cast<SceneContainer::CallbackInfo*>(key); ShapeBase* ptr = reinterpret_cast<ShapeBase*>(info->key); if (object->getTypeMask() & ItemObjectType) { // We've hit it's bounding box, that's close enough for items. Item* item = static_cast<Item*>(object); if (ptr != item->getCollisionObject()) ptr->queueCollision(item,ptr->getVelocity() - item->getVelocity()); } else if (object->getTypeMask() & TriggerObjectType) { // We've hit it's bounding box, that's close enough for triggers Trigger* pTrigger = static_cast<Trigger*>(object); pTrigger->potentialEnterObject(ptr); } else if (object->getTypeMask() & CorpseObjectType) { // Ok, guess it's close enough for corpses too... ShapeBase* col = static_cast<ShapeBase*>(object); ptr->queueCollision(col,ptr->getVelocity() - col->getVelocity()); } else object->buildPolyList(info->context,info->polyList,info->boundingBox,info->boundingSphere); }
bool Scenario::read(bool save_triggers) { printf("[R] Reading scenario\n"); FILE *scx=fopen("scndata.hex", "rb"); if (scx==NULL) return false; //must open scn before reading data trigger_start = skiptotriggers("scndata.hex"); long bytes_read = 0; SKIP(scx, trigger_start); int numtriggers; READ(&numtriggers, sizeof(long), 1, scx); printf("\t[R] numtriggers=%d\n",numtriggers); long trigger_skip=0; bool displayed=0; std::vector<Trigger *> scen_triggers; for (int i=0; i<numtriggers; i++) { //printf("[R] TRIGGER %d\n", i); Trigger *t = new Trigger; t->read(scx); scen_triggers.push_back(t); //printf("[R] END TRIGGER %d. triggerskip=%d\n", i, ftell(scx)-bytes_read); } if (save_triggers) triggers = scen_triggers; printf("\t[R] Done reading triggers\n"); trigger_skip = ftell(scx) - bytes_read; bytes_read+=trigger_skip; //at the end is numtriggers longs representing order of triggers. //skip them. they're just the display order, not execution order SKIP(scx, 4*numtriggers); trigger_end = bytes_read; scenario_end = skiptoscenarioend("scndata.hex"); long filesize=fsize("scndata.hex"); printf("\t[R] trigger start=%d, trigger end=%d\n", trigger_start, trigger_end); printf("\t[R] scenario_end=%d\n", scenario_end); printf("\t[R] scndata.hex size: %d, size without triggers: %d\n", filesize, filesize-trigger_skip-4*numtriggers-4); printf("\t[R] Read done\n"); fclose(scx); return true; }
int InstStrategyAutoGenTriggers::process( Node f, Theory::Effort effort, int e ){ int peffort = f.getNumChildren()==3 ? 2 : 1; //int peffort = f.getNumChildren()==3 ? 2 : 1; //int peffort = 1; if( e<peffort ){ return STATUS_UNFINISHED; }else{ bool gen = false; if( e==peffort ){ if( d_counter.find( f )==d_counter.end() ){ d_counter[f] = 0; gen = true; }else{ d_counter[f]++; gen = d_regenerate && d_counter[f]%d_regenerate_frequency==0; } }else{ gen = true; } if( gen ){ generateTriggers( f ); } Debug("quant-uf-strategy") << "Try auto-generated triggers... " << d_tr_strategy << " " << e << std::endl; //Notice() << "Try auto-generated triggers..." << std::endl; for( std::map< Trigger*, bool >::iterator itt = d_auto_gen_trigger[f].begin(); itt != d_auto_gen_trigger[f].end(); ++itt ){ Trigger* tr = itt->first; if( tr ){ bool processTrigger = itt->second; if( effort!=Theory::EFFORT_LAST_CALL && tr->isMultiTrigger() ){ #ifdef MULTI_TRIGGER_FULL_EFFORT_HALF processTrigger = d_counter[f]%2==0; #endif } if( processTrigger ){ //if( tr->isMultiTrigger() ) Debug("quant-uf-strategy-auto-gen-triggers") << " Process " << (*tr) << "..." << std::endl; InstMatch baseMatch; int numInst = tr->addInstantiations( baseMatch ); //if( tr->isMultiTrigger() ) Debug("quant-uf-strategy-auto-gen-triggers") << " Done, numInst = " << numInst << "." << std::endl; if( d_tr_strategy==Trigger::TS_MIN_TRIGGER ){ d_quantEngine->getInstantiationEngine()->d_statistics.d_instantiations_auto_gen_min += numInst; }else{ d_quantEngine->getInstantiationEngine()->d_statistics.d_instantiations_auto_gen += numInst; } if( tr->isMultiTrigger() ){ d_quantEngine->d_statistics.d_multi_trigger_instantiations += numInst; } //d_quantEngine->d_hasInstantiated[f] = true; } } } Debug("quant-uf-strategy") << "done." << std::endl; //Notice() << "done" << std::endl; } return STATUS_UNKNOWN; }
void Etherform::findContact(VectorF *contactNormal) { SceneObject *contactObject = NULL; Vector<SceneObject*> overlapObjects; _findContact(&contactObject, contactNormal, &overlapObjects ); // Check for triggers, corpses and items. const U32 filterMask = isGhost() ? sClientCollisionContactMask : sServerCollisionContactMask; for ( U32 i=0; i < overlapObjects.size(); i++ ) { SceneObject *obj = overlapObjects[i]; U32 objectMask = obj->getTypeMask(); if ( !( objectMask & filterMask ) ) continue; // Check: triggers, tactical zones, corpses and items... // if (objectMask & TriggerObjectType) { Trigger* pTrigger = static_cast<Trigger*>( obj ); pTrigger->potentialEnterObject(this); } else if (objectMask & TacticalZoneObjectType) { TacticalZone* pZone = static_cast<TacticalZone*>( obj ); pZone->potentialEnterObject(this); } else if (objectMask & CorpseObjectType) { // If we've overlapped the worldbounding boxes, then that's it... if ( getWorldBox().isOverlapped( obj->getWorldBox() ) ) { ShapeBase* col = static_cast<ShapeBase*>( obj ); queueCollision(col,getVelocity() - col->getVelocity()); } } else if (objectMask & ItemObjectType) { // If we've overlapped the worldbounding boxes, then that's it... Item* item = static_cast<Item*>( obj ); if ( getWorldBox().isOverlapped(item->getWorldBox()) && item->getCollisionObject() != this && !item->isHidden() ) queueCollision(item,getVelocity() - item->getVelocity()); } } mContactInfo.clear(); mContactInfo.contacted = contactObject != NULL; mContactInfo.contactObject = contactObject; if(mContactInfo.contacted) mContactInfo.contactNormal = *contactNormal; }
void TrigGeneralWindow::SetIgnoreDefeatDraw(bool ignoreDefeatDraw) { Trigger* trigger; if ( CM->getTrigger(trigger, trigIndex) ) { trigger->setIgnoreDefeatDraw(ignoreDefeatDraw); CM->notifyChange(false); RefreshWindow(trigIndex); } }
void TrigGeneralWindow::SetPausedTrigger(bool paused) { Trigger* trigger; if ( CM->getTrigger(trigger, trigIndex) ) { trigger->setFlagPaused(paused); CM->notifyChange(false); RefreshWindow(trigIndex); } }
END_TEST START_TEST ( test_Trigger ) { Trigger* t = new Trigger(2, 4); fail_unless (t->hasRequiredAttributes()); delete t; }
void TrigGeneralWindow::SetIgnoreMiscActionsOnce(bool ignoreMiscActionsOnce) { Trigger* trigger; if ( CM->getTrigger(trigger, trigIndex) ) { trigger->setIgnoreMiscActionsOnce(ignoreMiscActionsOnce); CM->notifyChange(false); RefreshWindow(trigIndex); } }
void TrigGeneralWindow::SetDisabledTrigger(bool disabled) { Trigger* trigger; if ( CM->getTrigger(trigger, trigIndex) ) { trigger->setDisabled(disabled); CM->notifyChange(false); RefreshWindow(trigIndex); } }
void TrigGeneralWindow::SetPreserveTrigger(bool preserve) { Trigger* trigger; if ( CM->getTrigger(trigger, trigIndex) ) { trigger->setPreserveTriggerFlagged(preserve); CM->notifyChange(false); RefreshWindow(trigIndex); } }
// // -- ResetRecursionCounter() // // When triggerDB is allocated from the contextHeap (see func heap()), // then we must make sure that after each statement the recursion counter // of every Trigger object is 0. Called from TriggerDB::cleanupPerStatement(). // // only used when triggers are allocated from the cntext heap. // Currently triggers are allocated from the statement heap. // See method Trigger::Heap() in file Triggers.h for more details // LCOV_EXCL_START static void ResetRecursionCounter(TriggerList* triggerList) { if (triggerList == NULL) return; Trigger * trg; for (CollIndex i=0; i<triggerList->entries(); i++) { trg=(*triggerList)[i]; trg->resetRecursionCounter(); } }
bool Store::IsItemAvailable(unsigned int slot) const { Game * game = core->GetGame(); //0 - not infinite, not conditional //-1 - infinite //other - pst trigger ref Trigger *trigger = items[slot]->trigger; if (trigger) { return trigger->Evaluate(game->GetSelectedPCSingle(false)) != 0; } return true; }
END_TEST START_TEST (test_WriteL3SBML_Trigger) { const char* expected = "<trigger/>"; Trigger *t = D->createModel()->createEvent()->createTrigger(); char* tsbml = t->toSBML(); fail_unless( equals(expected,tsbml) ); safe_free(tsbml); }
END_TEST START_TEST ( test_Trigger ) { Trigger* t = new Trigger(2, 4); fail_unless (!(t->hasRequiredElements())); t->setMath(SBML_parseFormula("ar")); fail_unless (t->hasRequiredElements()); delete t; }
u32 G_BoxTriggers( const aabb& bb, arraySTD_c<Trigger*>& out ) { out.clear(); // TODO: speed this up with kd tree for ( u32 i = 0; i < g_triggers.size(); i++ ) { Trigger* t = g_triggers[i]; const aabb& tBB = t->getAbsBounds(); if ( tBB.intersect( bb ) ) { out.push_back( t ); } } return out.size(); }
END_TEST START_TEST (test_WriteL3SBML_Trigger_persistent) { const char* expected = "<trigger initialValue=\"true\" persistent=\"false\"/>"; Trigger *t = D->createModel()->createEvent()->createTrigger(); t->setPersistent(false); t->setInitialValue(true); char* tsbml = t->toSBML(); fail_unless( equals(expected,tsbml) ); safe_free(tsbml); }
static void callbackRoutineExit(THREADID threadId, PyObject *callback) { if (!analysisTrigger.getState()) /* Analysis locked */ return; processingPyConf.callbackRoutine(threadId, callback); }
static void callbackBefore(IRBuilder *irb, CONTEXT *ctx, BOOL hasEA, ADDRINT ea, THREADID threadId) { /* Some configurations must be applied before processing */ processingPyConf.applyConfBeforeProcessing(irb); if (!analysisTrigger.getState()) /* Analysis locked */ return; if (hasEA) irb->setup(ea); /* Update the current context handler */ ap.updateCurrentCtxH(new PINContextHandler(ctx, threadId)); /* Setup Information into Irb */ irb->setThreadID(ap.getThreadID()); /* Python callback before IR processing */ processingPyConf.callbackBeforeIRProc(irb, &ap); Inst *inst = irb->process(ap); ap.addInstructionToTrace(inst); /* Export some information from Irb to Inst */ inst->setOpcode(irb->getOpcode()); inst->setOpcodeCategory(irb->getOpcodeCategory()); inst->setOperands(irb->getOperands()); /* Python callback before instruction processing */ processingPyConf.callbackBefore(inst, &ap); }
double VillageControl::Villain::getTriggerValue(const Trigger& trigger, const VillageControl* self) const { double powerMaxProb = 1.0 / 10000; // rather small chance that they attack just because you are strong double victimsMaxProb = 1.0 / 500; double populationMaxProb = 1.0 / 500; double goldMaxProb = 1.0 / 500; double stolenMaxProb = 1.0 / 300; double entryMaxProb = 1.0 / 20.0; switch (trigger.getId()) { case AttackTriggerId::TIMER: return collective->getTime() >= trigger.get<int>() ? 0.05 : 0; case AttackTriggerId::ROOM_BUILT: return collective->getSquares(trigger.get<SquareType>()).size() * getRoomProb(trigger.get<SquareType>().getId()); case AttackTriggerId::POWER: return powerMaxProb * powerClosenessFun(self->getCollective()->getDangerLevel(), collective->getDangerLevel()); case AttackTriggerId::SELF_VICTIMS: return victimsMaxProb * victimsFun(self->victims.count(collective) ? self->victims.at(collective) : 0, 0); case AttackTriggerId::ENEMY_POPULATION: return populationMaxProb * populationFun( collective->getCreatures(MinionTrait::FIGHTER).size(), trigger.get<int>()); case AttackTriggerId::GOLD: return goldMaxProb * goldFun(collective->numResource(Collective::ResourceId::GOLD), trigger.get<int>()); case AttackTriggerId::STOLEN_ITEMS: return stolenMaxProb * stolenItemsFun(self->stolenItemCount.count(collective) ? self->stolenItemCount.at(collective) : 0); case AttackTriggerId::ENTRY: return entryMaxProb * self->entries.count(collective); } return 0; }
void Creature::addAttack(string& prt, list<Condition>::iterator s1, list<Condition>::iterator e1, list<Action>::iterator s2, list<Action>::iterator e2) { Trigger trig = Trigger("attack",prt,true); list<Condition>::iterator i; for(i=s1; i!=e1; ++i) { trig.addCondition(*i); } list<Action>::iterator t; for(t=s2; t!=e2; ++t) { trig.addAction(*t); } addTrigger(trig); }
int main(int length, char * arguments[]) { if (length == 3) { Trigger trigger; trigger.Url = arguments[1]; trigger.ProjectName = arguments[2]; trigger.Process(); } else { fprintf(stdout,"Syntax: dctrigger <url> <project_name>\n"); } return 0; }
RETCODE World::EntityLoad_Trigger(hQBSP qbsp, const EntityParse & entityDat) { //create new trigger Trigger *newObj = new Trigger; assert(newObj); /////////////////////////////////////////////////////// //load up the common stuff EntityLoad_CommonObject(qbsp, entityDat, dynamic_cast<Object *>(newObj)); const char *pStr; int iVal; /////////////////////////////////////////////////////// //can it only be turned on once? pStr = entityDat.GetVal("bOnce"); if(pStr) sscanf(pStr, "%d", &iVal); else iVal = 0; newObj->SetFlag(OBJ_FLAG_ONCE_ONLY, iVal ? true : false); //get script file char scriptPath[MAXCHARBUFF]; strcpy(scriptPath, m_filePath.c_str()); strcpy(GetExtension(scriptPath), SCENE_EXT); /////////////////////////////////////////////////////// //check if we want multiple entities to activate the trigger pStr = entityDat.GetVal("bAllowMultiple"); if(pStr) { sscanf(pStr, "%d", &iVal); newObj->AllowMultipleEntities(iVal == 1 ? true : false); } /////////////////////////////////////////////////////// //set the script for 'on' pStr = entityDat.GetVal("script"); if(pStr) newObj->LoadScript(scriptPath, pStr); return RETCODE_SUCCESS; }
END_TEST START_TEST ( test_Event_parent_NULL ) { SBMLDocument *d = new SBMLDocument(2, 4); Model *m = d->createModel(); Event *c = m->createEvent(); EventAssignment *ea = c->createEventAssignment(); Trigger *t = new Trigger(2, 4); t->setMath(new ASTNode()); Delay *dy = new Delay(2, 4); dy->setMath(new ASTNode()); c->setTrigger(t); c->setDelay(dy); fail_unless(c->getAncestorOfType(SBML_MODEL) == m); fail_unless(c->getTrigger()->getParentSBMLObject() == c); fail_unless (c->getDelay()->getSBMLDocument() == d); fail_unless(ea->getAncestorOfType(SBML_EVENT) == c); Event *c1 = c->clone(); delete d; fail_unless(c1->getAncestorOfType(SBML_MODEL) == NULL); fail_unless(c1->getParentSBMLObject() == NULL); fail_unless (c1->getSBMLDocument() == NULL); fail_unless(c1->getEventAssignment(0)->getAncestorOfType(SBML_MODEL) == NULL); fail_unless(c1->getEventAssignment(0)->getAncestorOfType(SBML_EVENT) == c1); fail_unless(c1->getEventAssignment(0)->getParentSBMLObject() != NULL); fail_unless(c1->getEventAssignment(0)->getSBMLDocument() == NULL); fail_unless(c1->getTrigger()->getAncestorOfType(SBML_MODEL) == NULL); fail_unless(c1->getTrigger()->getAncestorOfType(SBML_EVENT) == c1); fail_unless(c1->getTrigger()->getParentSBMLObject() != NULL); fail_unless(c1->getTrigger()->getSBMLDocument() == NULL); fail_unless(c1->getDelay()->getAncestorOfType(SBML_MODEL) == NULL); fail_unless(c1->getDelay()->getAncestorOfType(SBML_EVENT) == c1); fail_unless(c1->getDelay()->getParentSBMLObject() != NULL); fail_unless(c1->getDelay()->getSBMLDocument() == NULL); delete c1; }
static void TRACE_Instrumentation(TRACE trace, VOID *programName) { boost::filesystem::path pname(reinterpret_cast<char*>(programName)); for (BBL bbl = TRACE_BblHead(trace); BBL_Valid(bbl); bbl = BBL_Next(bbl)) { for (INS ins = BBL_InsHead(bbl); INS_Valid(ins); ins = INS_Next(ins)) { /* ---- Speed up process ---- */ IMG currentImgName = IMG_FindByAddress(INS_Address(ins)); if (!IMG_Valid(currentImgName)) continue; boost::filesystem::path pcurrent(IMG_Name(currentImgName)); if (!analysisTrigger.getState() && strcmp(pname.leaf().c_str(), pcurrent.leaf().c_str())) continue; /* ---- End of speed up process ---- */ IRBuilder *irb = createIRBuilder(ins); /* Callback before */ if (INS_MemoryOperandCount(ins) > 0) INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR) callbackBefore, IARG_PTR, irb, IARG_CONTEXT, IARG_BOOL, true, IARG_MEMORYOP_EA, 0, IARG_THREAD_ID, IARG_END); else INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR) callbackBefore, IARG_PTR, irb, IARG_CONTEXT, IARG_BOOL, false, IARG_ADDRINT, 0, IARG_THREAD_ID, IARG_END); /* Callback after */ /* Syscall after context must be catcher with IDREF.CALLBACK.SYSCALL_EXIT */ if (INS_IsSyscall(ins) == false) { IPOINT where = IPOINT_AFTER; if (INS_HasFallThrough(ins) == false) where = IPOINT_TAKEN_BRANCH; INS_InsertCall(ins, where, (AFUNPTR)callbackAfter, IARG_CONTEXT, IARG_THREAD_ID, IARG_END); } /* I/O memory monitoring for snapshot */ if (INS_OperandCount(ins) > 1 && INS_MemoryOperandIsWritten(ins, 0)) INS_InsertCall( ins, IPOINT_BEFORE, (AFUNPTR)callbackSnapshot, IARG_MEMORYOP_EA, 0, IARG_UINT32, INS_MemoryWriteSize(ins), IARG_END); } } }