bool isSameExpression(bool cpp, const Token *tok1, const Token *tok2, const std::set<std::string> &constFunctions) { if (tok1 == nullptr && tok2 == nullptr) return true; if (tok1 == nullptr || tok2 == nullptr) return false; if (cpp) { if (tok1->str() == "." && tok1->astOperand1() && tok1->astOperand1()->str() == "this") tok1 = tok1->astOperand2(); if (tok2->str() == "." && tok2->astOperand1() && tok2->astOperand1()->str() == "this") tok2 = tok2->astOperand2(); } if (tok1->varId() != tok2->varId() || tok1->str() != tok2->str()) { if ((Token::Match(tok1,"<|>") && Token::Match(tok2,"<|>")) || (Token::Match(tok1,"<=|>=") && Token::Match(tok2,"<=|>="))) { return isSameExpression(cpp, tok1->astOperand1(), tok2->astOperand2(), constFunctions) && isSameExpression(cpp, tok1->astOperand2(), tok2->astOperand1(), constFunctions); } return false; } if (tok1->str() == "." && tok1->originalName() != tok2->originalName()) return false; if (tok1->isExpandedMacro() || tok2->isExpandedMacro()) return false; if (tok1->isName() && tok1->next()->str() == "(" && tok1->str() != "sizeof") { if (!tok1->function() && !Token::Match(tok1->previous(), ".|::") && constFunctions.find(tok1->str()) == constFunctions.end() && !tok1->isAttributeConst() && !tok1->isAttributePure()) return false; else if (tok1->function() && !tok1->function()->isConst() && !tok1->function()->isAttributeConst() && !tok1->function()->isAttributePure()) return false; } // templates/casts if ((Token::Match(tok1, "%name% <") && tok1->next()->link()) || (Token::Match(tok2, "%name% <") && tok2->next()->link())) { // non-const template function that is not a dynamic_cast => return false if (Token::simpleMatch(tok1->next()->link(), "> (") && !(tok1->function() && tok1->function()->isConst()) && tok1->str() != "dynamic_cast") return false; // some template/cast stuff.. check that the template arguments are same const Token *t1 = tok1->next(); const Token *t2 = tok2->next(); const Token *end1 = t1->link(); const Token *end2 = t2->link(); while (t1 && t2 && t1 != end1 && t2 != end2) { if (t1->str() != t2->str()) return false; t1 = t1->next(); t2 = t2->next(); } if (t1 != end1 || t2 != end2) return false; } if (tok1->tokType() == Token::eIncDecOp || tok1->isAssignmentOp()) return false; // bailout when we see ({..}) if (tok1->str() == "{") return false; if (tok1->str() == "(" && tok1->previous() && !tok1->previous()->isName()) { // cast => assert that the casts are equal const Token *t1 = tok1->next(); const Token *t2 = tok2->next(); while (t1 && t2 && t1->str() == t2->str() && (t1->isName() || t1->str() == "*")) { t1 = t1->next(); t2 = t2->next(); } if (!t1 || !t2 || t1->str() != ")" || t2->str() != ")") return false; } bool noncommuative_equals = isSameExpression(cpp, tok1->astOperand1(), tok2->astOperand1(), constFunctions); noncommuative_equals = noncommuative_equals && isSameExpression(cpp, tok1->astOperand2(), tok2->astOperand2(), constFunctions); if (noncommuative_equals) return true; const bool commutative = tok1->astOperand1() && tok1->astOperand2() && Token::Match(tok1, "%or%|%oror%|+|*|&|&&|^|==|!="); bool commuative_equals = commutative && isSameExpression(cpp, tok1->astOperand2(), tok2->astOperand1(), constFunctions); commuative_equals = commuative_equals && isSameExpression(cpp, tok1->astOperand1(), tok2->astOperand2(), constFunctions); // in c++, "a"+b might be different to b+"a" if (cpp && commuative_equals && tok1->str() == "+" && (tok1->astOperand1()->tokType() == Token::eString || tok1->astOperand2()->tokType() == Token::eString)) { const Token * const other = tok1->astOperand1()->tokType() != Token::eString ? tok1->astOperand1() : tok1->astOperand2(); return other && astIsIntegral(other,false); } return commuative_equals; }
bool generate_sql_makefile() { if (new_sql_updates.empty()) return true; // find all files in the update dir snprintf(cmd, MAX_CMD, "git show HEAD:%s", sql_update_dir); if ((cmd_pipe = popen(cmd, "r")) == NULL) return false; // skip first two lines if (!fgets(buffer, MAX_BUF, cmd_pipe)) { pclose(cmd_pipe); return false; } if (!fgets(buffer, MAX_BUF, cmd_pipe)) { pclose(cmd_pipe); return false; } char newname[MAX_PATH]; std::set<std::string> file_list; sql_update_info info; while (fgets(buffer, MAX_BUF, cmd_pipe)) { buffer[strlen(buffer) - 1] = '\0'; if (buffer[strlen(buffer) - 1] != '/' && strncmp(buffer, "Makefile.am", MAX_BUF) != 0) { if (new_sql_updates.find(buffer) != new_sql_updates.end()) { if (!get_sql_update_info(buffer, info)) return false; snprintf(newname, MAX_PATH, REV_PRINT "_%s_%0*d_%s%s%s.sql", rev, info.parentRev, 2, info.nr, info.db, info.has_table ? "_" : "", info.table); file_list.insert(newname); } else file_list.insert(buffer); } } pclose(cmd_pipe); // write the makefile char file_name[MAX_PATH]; snprintf(file_name, MAX_PATH, "%s%s/Makefile.am", path_prefix, sql_update_dir); FILE* fout = fopen(file_name, "w"); if (!fout) { pclose(cmd_pipe); return false; } fprintf(fout, "# This code is part of MaNGOS. Contributor & Copyright details are in AUTHORS/THANKS.\n" "#\n" "# This program is free software; you can redistribute it and/or modify\n" "# it under the terms of the GNU General Public License as published by\n" "# the Free Software Foundation; either version 2 of the License, or\n" "# (at your option) any later version.\n" "#\n" "# This program is distributed in the hope that it will be useful,\n" "# but WITHOUT ANY WARRANTY; without even the implied warranty of\n" "# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n" "# GNU General Public License for more details.\n" "#\n" "# You should have received a copy of the GNU General Public License\n" "# along with this program; if not, write to the Free Software\n" "# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\n" "\n" "## Process this file with automake to produce Makefile.in\n" "\n" "## Sub-directories to parse\n" "SUBDIRS = before_upgrade_to_0.13\n" "\n" "## Change installation location\n" "# datadir = mangos/%s\n" "pkgdatadir = $(datadir)/mangos/%s\n" "\n" "## Files to be installed\n" "# Install basic SQL files to datadir\n" "pkgdata_DATA = \\\n", sql_update_dir, sql_update_dir ); for(std::set<std::string>::iterator itr = file_list.begin(), next; itr != file_list.end(); ++itr) { next = itr; ++next; fprintf(fout, "\t%s%s\n", itr->c_str(), next == file_list.end() ? "" : " \\"); } fprintf(fout, "\n## Additional files to include when running 'make dist'\n" "# SQL update files, to upgrade database schema from older revisions\n" "EXTRA_DIST = \\\n" ); for (std::set<std::string>::iterator itr = file_list.begin(), next; itr != file_list.end(); ++itr) { next = itr; ++next; fprintf(fout, "\t%s%s\n", itr->c_str(), next == file_list.end() ? "" : " \\"); } fclose(fout); snprintf(cmd, MAX_CMD, "git add %s%s/Makefile.am", path_prefix, sql_update_dir); system_switch_index(cmd); return true; }
bool isBpFunction(const char* nm) const { std::set<string>::const_iterator i = enabledFunctions.find(string(nm)); return i != enabledFunctions.end(); }
void SetData(uint32 type, uint32 data) { switch (type) { case DATA_MAGTHERIDON_EVENT: m_auiEncounter[0] = data; if (data == NOT_STARTED) RespawnTimer = 10000; if (data != IN_PROGRESS) HandleGameObject(DoorGUID, true); break; case DATA_CHANNELER_EVENT: switch (data) { case NOT_STARTED: // Reset all channelers once one is reset. if (m_auiEncounter[1] != NOT_STARTED) { m_auiEncounter[1] = NOT_STARTED; for (std::set<uint64>::const_iterator i = ChannelerGUID.begin(); i != ChannelerGUID.end(); ++i) { if (Creature* Channeler = instance->GetCreature(*i)) { if (Channeler->IsAlive()) Channeler->AI()->EnterEvadeMode(); else Channeler->Respawn(); } } CageTimer = 0; HandleGameObject(DoorGUID, true); } break; case IN_PROGRESS: // Event start. if (m_auiEncounter[1] != IN_PROGRESS) { m_auiEncounter[1] = IN_PROGRESS; // Let all five channelers aggro. for (std::set<uint64>::const_iterator i = ChannelerGUID.begin(); i != ChannelerGUID.end(); ++i) { Creature* Channeler = instance->GetCreature(*i); if (Channeler && Channeler->IsAlive()) Channeler->AI()->AttackStart(Channeler->SelectNearestTarget(999)); } // Release Magtheridon after two minutes. Creature* Magtheridon = instance->GetCreature(MagtheridonGUID); if (Magtheridon && Magtheridon->IsAlive()) { Magtheridon->MonsterTextEmote(EMOTE_BONDS_WEAKEN, 0); CageTimer = 120000; } HandleGameObject(DoorGUID, false); } break; case DONE: // Add buff and check if all channelers are dead. for (std::set<uint64>::const_iterator i = ChannelerGUID.begin(); i != ChannelerGUID.end(); ++i) { Creature* Channeler = instance->GetCreature(*i); if (Channeler && Channeler->IsAlive()) { //Channeler->CastSpell(Channeler, SPELL_SOUL_TRANSFER, true); data = IN_PROGRESS; break; } } break; } m_auiEncounter[1] = data; break; case DATA_COLLAPSE: // true - collapse / false - reset for (std::set<uint64>::const_iterator i = ColumnGUID.begin(); i != ColumnGUID.end(); ++i) DoUseDoorOrButton(*i); break; default: break; } }
bool find_sql_updates() { printf("+ finding new sql updates on HEAD\n"); // add all updates from HEAD snprintf(cmd, MAX_CMD, "git show HEAD:%s", sql_update_dir); if ((cmd_pipe = popen(cmd, "r")) == NULL) return false; // skip first two lines if (!fgets(buffer, MAX_BUF, cmd_pipe)) { pclose(cmd_pipe); return false; } if (!fgets(buffer, MAX_BUF, cmd_pipe)) { pclose(cmd_pipe); return false; } sql_update_info info; while (fgets(buffer, MAX_BUF, cmd_pipe)) { buffer[strlen(buffer) - 1] = '\0'; if (!get_sql_update_info(buffer, info)) continue; if (info.db_idx == NUM_DATABASES) { if (info.rev > 0) printf("WARNING: incorrect database name for sql update %s\n", buffer); continue; } new_sql_updates.insert(buffer); } pclose(cmd_pipe); // Add last milestone's file information last_sql_rev[0] = 11785; last_sql_nr[0] = 2; sscanf("11785_02_characters_instance", "%s", last_sql_update[0]); last_sql_rev[2] = 10008; last_sql_nr[2] = 1; sscanf("10008_01_realmd_realmd_db_version", "%s", last_sql_update[2]); // remove updates from the last commit also found on origin snprintf(cmd, MAX_CMD, "git show %s:%s", origin_hash, sql_update_dir); if ((cmd_pipe = popen(cmd, "r")) == NULL) return false; // skip first two lines if (!fgets(buffer, MAX_BUF, cmd_pipe)) { pclose(cmd_pipe); return false; } if (!fgets(buffer, MAX_BUF, cmd_pipe)) { pclose(cmd_pipe); return false; } while (fgets(buffer, MAX_BUF, cmd_pipe)) { buffer[strlen(buffer) - 1] = '\0'; if (!get_sql_update_info(buffer, info)) continue; // find the old update with the highest rev for each database // (will be the required version for the new update) std::set<std::string>::iterator itr = new_sql_updates.find(buffer); if (itr != new_sql_updates.end()) { if (info.rev > 0 && (info.rev > last_sql_rev[info.db_idx] || (info.rev == last_sql_rev[info.db_idx] && info.nr > last_sql_nr[info.db_idx]))) { last_sql_rev[info.db_idx] = info.rev; last_sql_nr[info.db_idx] = info.nr; if (db_sql_rev_parent[info.db_idx]) snprintf(last_sql_update[info.db_idx], MAX_PATH, "%s_%0*d_%s%s%s", info.parentRev, 2, info.nr, info.db, info.has_table ? "_" : "", info.table); else sscanf(buffer, "%[^.]", last_sql_update[info.db_idx]); } new_sql_updates.erase(itr); } } pclose(cmd_pipe); if (!new_sql_updates.empty()) { for (std::set<std::string>::iterator itr = new_sql_updates.begin(); itr != new_sql_updates.end(); ++itr) printf("%s\n", itr->c_str()); } else printf("WARNING: no new sql updates found.\n"); return true; }
bool isPresent(const T *value, const std::set<const T *> &values) { auto result = std::find(values.begin(), values.end(), value); return result != values.end(); }
void inline instrumentert::instrument_minimum_interference_inserter( const std::set<event_grapht::critical_cyclet>& set_of_cycles) { /* Idea: We solve this by a linear programming approach, using for instance glpk lib. Input: the edges to instrument E, the cycles C_j Pb: min sum_{e_i in E} d(e_i).x_i s.t. for all j, sum_{e_i in C_j} >= 1, where e_i is a pair to potentially instrument, x_i is a Boolean stating whether we instrument e_i, and d() is the cost of an instrumentation. Output: the x_i, saying which pairs to instrument For this instrumentation, we propose: d(poW*)=1 d(poRW)=d(rfe)=2 d(poRR)=3 This function can be refined with the actual times we get in experimenting the different pairs in a single IRIW. */ #ifdef HAVE_GLPK /* first, identify all the unsafe pairs */ std::set<event_grapht::critical_cyclet::delayt> edges; for(std::set<event_grapht::critical_cyclet>::iterator C_j=set_of_cycles.begin(); C_j!=set_of_cycles.end(); ++C_j) for(std::set<event_grapht::critical_cyclet::delayt>::const_iterator e_i= C_j->unsafe_pairs.begin(); e_i!=C_j->unsafe_pairs.end(); ++e_i) edges.insert(*e_i); glp_prob* lp; glp_iocp parm; glp_init_iocp(&parm); parm.msg_lev=GLP_MSG_OFF; parm.presolve=GLP_ON; lp=glp_create_prob(); glp_set_prob_name(lp, "instrumentation optimisation"); glp_set_obj_dir(lp, GLP_MIN); message.debug() << "edges: "<<edges.size()<<" cycles:"<<set_of_cycles.size() << messaget::eom; /* sets the variables and coefficients */ glp_add_cols(lp, edges.size()); std::size_t i=0; for(std::set<event_grapht::critical_cyclet::delayt>::iterator e_i=edges.begin(); e_i!=edges.end(); ++e_i) { ++i; std::string name="e_"+std::to_string(i); glp_set_col_name(lp, i, name.c_str()); glp_set_col_bnds(lp, i, GLP_LO, 0.0, 0.0); glp_set_obj_coef(lp, i, cost(*e_i)); glp_set_col_kind(lp, i, GLP_BV); } /* sets the constraints (soundness): one per cycle */ glp_add_rows(lp, set_of_cycles.size()); i=0; for(std::set<event_grapht::critical_cyclet>::iterator C_j=set_of_cycles.begin(); C_j!=set_of_cycles.end(); ++C_j) { ++i; std::string name="C_"+std::to_string(i); glp_set_row_name(lp, i, name.c_str()); glp_set_row_bnds(lp, i, GLP_LO, 1.0, 0.0); /* >= 1*/ } const std::size_t mat_size=set_of_cycles.size()*edges.size(); message.debug() << "size of the system: " << mat_size << messaget::eom; int* imat=(int*)malloc(sizeof(int)*(mat_size+1)); int* jmat=(int*)malloc(sizeof(int)*(mat_size+1)); double* vmat=(double*)malloc(sizeof(double)*(mat_size+1)); /* fills the constraints coeff */ /* tables read from 1 in glpk -- first row/column ignored */ std::size_t col=1; std::size_t row=1; i=1; for(std::set<event_grapht::critical_cyclet::delayt>::iterator e_i=edges.begin(); e_i!=edges.end(); ++e_i) { row=1; for(std::set<event_grapht::critical_cyclet>::iterator C_j=set_of_cycles.begin(); C_j!=set_of_cycles.end(); ++C_j) { imat[i]=row; jmat[i]=col; if(C_j->unsafe_pairs.find(*e_i)!=C_j->unsafe_pairs.end()) vmat[i]=1.0; else vmat[i]=0.0; ++i; ++row; } ++col; } #ifdef DEBUG for(i=1; i<=mat_size; ++i) message.statistics() <<i<<"["<<imat[i]<<","<<jmat[i]<<"]="<<vmat[i] << messaget::eom; #endif /* solves MIP by branch-and-cut */ glp_load_matrix(lp, mat_size, imat, jmat, vmat); glp_intopt(lp, &parm); /* loads results (x_i) */ message.statistics() << "minimal cost: " << glp_mip_obj_val(lp) << messaget::eom; i=0; for(std::set<event_grapht::critical_cyclet::delayt>::iterator e_i=edges.begin(); e_i!=edges.end(); ++e_i) { ++i; if(glp_mip_col_val(lp, i)>=1) { const abstract_eventt& first_ev=egraph[e_i->first]; var_to_instr.insert(first_ev.variable); id2loc.insert( std::pair<irep_idt,source_locationt>(first_ev.variable,first_ev.source_location)); if(!e_i->is_po) { const abstract_eventt& second_ev=egraph[e_i->second]; var_to_instr.insert(second_ev.variable); id2loc.insert( std::pair<irep_idt,source_locationt>(second_ev.variable,second_ev.source_location)); } } } glp_delete_prob(lp); free(imat); free(jmat); free(vmat); #else throw "Sorry, minimum interference option requires glpk; " "please recompile goto-instrument with glpk."; #endif }
bool BlockFlow::identifyOutSet() { bool MadeChange = false; std::vector<GlobalCheck*> outChecks; if (!isEntry && !killAll) { identifyInSet(); #if DEBUG_GLOBAL errs() << "Generating Out-Set: " << blk->getName() << "\n"; #endif // Identify checks from inSet that should be killed for (std::vector<GlobalCheck*>::iterator i = inSet.checks.begin(), e = inSet.checks.end(); i != e; i++) { // For each global check, see if it survives past block, or if we can tell how variable changes GlobalCheck *chk = *i; std::set<Value*>::iterator it = storeSet.find(chk->var); if (it == storeSet.end()) { outChecks.push_back(chk); } else { ConstraintGraph::CompareEnum change = cg->identifyMemoryChange(chk->var); if (chk->isUpper) { // Upper-bound check switch (change) { case ConstraintGraph::EQUALS: case ConstraintGraph::LESS_THAN: outChecks.push_back(chk); break; default: break; } } else { // Lower-bound check switch (change) { case ConstraintGraph::EQUALS: case ConstraintGraph::GREATER_THAN: outChecks.push_back(chk); break; default: break; } } } } } #if DEBUG_GLOBAL else { errs() << "Generating Out-Set: " << blk->getName() << "\n"; } #endif // Just identify checks that are live at the end of set for (std::vector<GlobalCheck*>::iterator i = globalChecks.begin(), e = globalChecks.end(); i != e; i++) { GlobalCheck *chk = *i; bool add = true; for (unsigned int o = 0; o < outChecks.size(); o++) { GlobalCheck *oCheck = outChecks.at(o); ConstantInt *const1 = dyn_cast<ConstantInt>(chk->var); ConstantInt *const2 = dyn_cast<ConstantInt>(oCheck->var); if (chk->isUpper && oCheck->isUpper) { // Both upper bounds checks if (const1 != NULL && const2 != NULL) { // If both constants, replace with the more strict version if (const1->getSExtValue() > const2->getSExtValue()) { outChecks.at(o) = chk; } add = false; break; } else if (const1 == NULL && const2 == NULL) { if (chk->var == oCheck->var) { ConstantInt *bound1 = dyn_cast<ConstantInt>(chk->bound); ConstantInt *bound2 = dyn_cast<ConstantInt>(oCheck->bound); if (bound1 != NULL && bound2 != NULL) { if (bound1->getZExtValue() < bound2->getZExtValue()) { outChecks.at(o) = chk; } add = false; break; } else if (bound1 == NULL && bound2 == NULL) { if (bound1 == bound2) { add = false; break; } } } } } else if (!chk->isUpper && !oCheck->isUpper) { // Both lower bounds checks if (const1 != NULL && const2 != NULL) { // If both constants, replace with the more strict version if (const1->getSExtValue() < const2->getSExtValue()) { outChecks.at(o) = chk; } add = false; break; } else if (const1 == NULL && const2 == NULL) { if (chk->var == oCheck->var) { add = false; break; } } } } if (add) { outChecks.push_back(chk); } } if (isEntry && outChecks.empty()) { outSet.allChecks = false; return true; } if (outChecks.empty()) { if (inSet.allChecks) { bool oldState = outSet.allChecks; outSet.checks.clear(); outSet.allChecks = true; return oldState != true; } else { outSet.allChecks = false; if (outSet.checks.empty()) { return false; } else { outSet.checks.clear(); return true; } } } for (std::vector<GlobalCheck*>::iterator i = outChecks.begin(), e = outChecks.end(); i != e; i++) { #if DEBUG_GLOBAL errs() << "Adding Check to Out Set:\n"; (*i)->print(); #endif MadeChange |= outSet.addAvailableCheck(*i); } return MadeChange; }
void FindFilesOnVol(const std::string &verref, const std::set<std::string> &volset, SeenVers &seen, RebuildVers &found, RebuildNode::CurrentStack ¤tStack, int &count, int interval) { if (seen.find(verref) != seen.end()) { seen[verref]->AddUser(currentStack); return; } AssetVersion version(verref); if (!version) { notify(NFY_WARN, "Unable to load asset version %s", version.Ref().c_str()); } RebuildNode *node = new RebuildNode(verref, currentStack); CurrentStackGuard stackGuard(currentStack, node); seen.insert(make_pair(verref, node)); if (interval && (++count % interval == 0)) { fprintf(stderr, "\r%d", count); } if (version->IsLeaf() && (version->state == AssetDefs::Succeeded)) { std::vector<std::string> outfiles; version->GetOutputFilenames(outfiles); for (std::vector<std::string>::const_iterator outfile = outfiles.begin(); outfile != outfiles.end(); ++outfile) { khFusionURI uri(theVolumeManager.DeduceURIFromPath(*outfile)); if (uri.Volume().empty()) { // non-file outfile (GFS?). Do nothing. } else if (volset.find(uri.Volume()) != volset.end()) { // This outfile is on a volume we care about. Remember the // versionref. node->rebuild = true; found.insert(node); // once we find even one outfile, we're done. We'll have to run // the whole command anyway. No sense checking other outfiles. break; } else { // On a volume we don't care about. Do Nothing } } } for (std::vector<std::string>::const_iterator input = version->inputs.begin(); input != version->inputs.end(); ++input) { FindFilesOnVol(*input, volset, seen, found, currentStack, count, interval); } if (!version->IsLeaf()) { for (std::vector<std::string>::const_iterator child = version->children.begin(); child != version->children.end(); ++child) { FindFilesOnVol(*child, volset, seen, found, currentStack, count, interval); } } }
void check_out(void * const This) { BOOST_TEST(objs.find(This) != objs.end()); objs.erase(This); }
static void free(char * const block) { BOOST_TEST(allocated_blocks.find(block) != allocated_blocks.end()); allocated_blocks.erase(block); UserAllocator::free(block); }
void check_in(void * const This) { BOOST_TEST(objs.find(This) == objs.end()); objs.insert(This); }
void SetData(uint32 type, uint32 data) { switch (type) { case TYPE_MOGRAINE_AND_WHITE_EVENT: if (data == IN_PROGRESS) DoUseDoorOrButton(DoorHighInquisitorGUID); if (data == FAIL) DoUseDoorOrButton(DoorHighInquisitorGUID); Encounter[0] = data; break; case GAMEOBJECT_PUMPKIN_SHRINE: HandleGameObject(PumpkinShrineGUID, false); break; case DATA_HORSEMAN_EVENT: Encounter[1] = data; if (data == DONE) { for (std::set<uint64>::const_iterator itr = HorsemanAdds.begin(); itr != HorsemanAdds.end(); ++itr) { Creature* add = instance->GetCreature(*itr); if (add && add->isAlive()) add->Kill(add); } HorsemanAdds.clear(); HandleGameObject(PumpkinShrineGUID, false); } break; } }
bool isConstExpression(const Token *tok, const std::set<std::string> &constFunctions) { if (!tok) return true; if (tok->isName() && tok->next()->str() == "(") { if (!tok->function() && !Token::Match(tok->previous(), ".|::") && constFunctions.find(tok->str()) == constFunctions.end()) return false; else if (tok->function() && !tok->function()->isConst()) return false; } if (tok->tokType() == Token::eIncDecOp) return false; // bailout when we see ({..}) if (tok->str() == "{") return false; return isConstExpression(tok->astOperand1(),constFunctions) && isConstExpression(tok->astOperand2(),constFunctions); }
::std::string to_string(::std::set<T> const& s) { return to_string(s.begin(), s.end()); }
/// Based on GetAllUndefinedSymbols() from LLVM3.2 /// /// GetAllUndefinedSymbols - calculates the set of undefined symbols that still /// exist in an LLVM module. This is a bit tricky because there may be two /// symbols with the same name but different LLVM types that will be resolved to /// each other but aren't currently (thus we need to treat it as resolved). /// /// Inputs: /// M - The module in which to find undefined symbols. /// /// Outputs: /// UndefinedSymbols - A set of C++ strings containing the name of all /// undefined symbols. /// static void GetAllUndefinedSymbols(Module *M, std::set<std::string> &UndefinedSymbols) { static const std::string llvmIntrinsicPrefix="llvm."; std::set<std::string> DefinedSymbols; UndefinedSymbols.clear(); KLEE_DEBUG_WITH_TYPE("klee_linker", dbgs() << "*** Computing undefined symbols ***\n"); for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I) if (I->hasName()) { if (I->isDeclaration()) UndefinedSymbols.insert(I->getName()); else if (!I->hasLocalLinkage()) { #if LLVM_VERSION_CODE < LLVM_VERSION(3, 5) assert(!I->hasDLLImportLinkage() && "Found dllimported non-external symbol!"); #else assert(!I->hasDLLImportStorageClass() && "Found dllimported non-external symbol!"); #endif DefinedSymbols.insert(I->getName()); } } for (Module::global_iterator I = M->global_begin(), E = M->global_end(); I != E; ++I) if (I->hasName()) { if (I->isDeclaration()) UndefinedSymbols.insert(I->getName()); else if (!I->hasLocalLinkage()) { #if LLVM_VERSION_CODE < LLVM_VERSION(3, 5) assert(!I->hasDLLImportLinkage() && "Found dllimported non-external symbol!"); #else assert(!I->hasDLLImportStorageClass() && "Found dllimported non-external symbol!"); #endif DefinedSymbols.insert(I->getName()); } } for (Module::alias_iterator I = M->alias_begin(), E = M->alias_end(); I != E; ++I) if (I->hasName()) DefinedSymbols.insert(I->getName()); // Prune out any defined symbols from the undefined symbols set // and other symbols we don't want to treat as an undefined symbol std::vector<std::string> SymbolsToRemove; for (std::set<std::string>::iterator I = UndefinedSymbols.begin(); I != UndefinedSymbols.end(); ++I ) { if (DefinedSymbols.count(*I)) { SymbolsToRemove.push_back(*I); continue; } // Strip out llvm intrinsics if ( (I->size() >= llvmIntrinsicPrefix.size() ) && (I->compare(0, llvmIntrinsicPrefix.size(), llvmIntrinsicPrefix) == 0) ) { KLEE_DEBUG_WITH_TYPE("klee_linker", dbgs() << "LLVM intrinsic " << *I << " has will be removed from undefined symbols"<< "\n"); SymbolsToRemove.push_back(*I); continue; } // Symbol really is undefined KLEE_DEBUG_WITH_TYPE("klee_linker", dbgs() << "Symbol " << *I << " is undefined.\n"); } // Remove KLEE intrinsics from set of undefined symbols for (SpecialFunctionHandler::const_iterator sf = SpecialFunctionHandler::begin(), se = SpecialFunctionHandler::end(); sf != se; ++sf) { if (UndefinedSymbols.find(sf->name) == UndefinedSymbols.end()) continue; SymbolsToRemove.push_back(sf->name); KLEE_DEBUG_WITH_TYPE("klee_linker", dbgs() << "KLEE intrinsic " << sf->name << " has will be removed from undefined symbols"<< "\n"); } // Now remove the symbols from undefined set. for (size_t i = 0, j = SymbolsToRemove.size(); i < j; ++i ) UndefinedSymbols.erase(SymbolsToRemove[i]); KLEE_DEBUG_WITH_TYPE("klee_linker", dbgs() << "*** Finished computing undefined symbols ***\n"); }
bool is_ignored(int i) { static std::set<int> ignore = {}; return ignore.find(i) != ignore.end(); }
bool ObjectSelection::add(std::set<long int> ids) { selections.insert(ids.begin(),ids.end()); emit changed(); return true; }
void CSettingManager::RegisterCallback(ISettingCallback *callback, const std::set<std::string> &settingList) { XR::CSingleLock lock(m_settingsCritical); if (callback == nullptr) return; for (std::set<std::string>::const_iterator settingIt = settingList.begin(); settingIt != settingList.end(); ++settingIt) { std::string id = *settingIt; StringUtils::ToLower(id); SettingMap::iterator setting = m_settings.find(id); if (setting == m_settings.end()) { if (m_initialized) continue; Setting tmpSetting = { NULL }; std::pair<SettingMap::iterator, bool> tmpIt = m_settings.insert(make_pair(id, tmpSetting)); setting = tmpIt.first; } setting->second.callbacks.insert(callback); } }
bool ObjectSelection::remove(std::set<long int> ids) { selections.erase(ids.begin(),ids.end()); emit changed(); return true; }
void UpdateData::AddOutOfRangeGUID(std::set<uint64>& guids) { m_outOfRangeGUIDs.insert(guids.begin(), guids.end()); }
template <class C, class V> inline bool CubitLoops<C, V>::recursive_make_loop(V* start_vertex, CoEdge* coedge, std::set<CoEdge* >& used_coedges, std::multimap<V*, CoEdge*>& start_coedge_map, std::vector<CoEdge*>& loop) { V* curr_vertex; if (coedge->sense == CUBIT_FORWARD) curr_vertex = coedge->end; else curr_vertex = coedge->start; loop.push_back(coedge); used_coedges.insert(coedge); while (curr_vertex != start_vertex) { typename std::multimap<V*, CoEdge*>::iterator iter; typename std::multimap<V*, CoEdge*>::iterator last; iter = start_coedge_map.lower_bound(curr_vertex); last = start_coedge_map.upper_bound(curr_vertex); std::vector<CoEdge*> possible_coedges; for (/*preinitialized*/; iter != last; iter++) { if (used_coedges.find(iter->second) == used_coedges.end()) possible_coedges.push_back(iter->second); } if (possible_coedges.size() == 0) return false; else if (possible_coedges.size() == 1) { coedge = possible_coedges[0]; loop.push_back(coedge); used_coedges.insert(coedge); if (coedge->sense == CUBIT_FORWARD) curr_vertex = coedge->end; else curr_vertex = coedge->start; } else { for (size_t i=0; i<possible_coedges.size(); i++) { std::vector<CoEdge*> sub_loop; if (recursive_make_loop(curr_vertex, possible_coedges[i], used_coedges, start_coedge_map, sub_loop) ) { loop.insert(loop.end(), sub_loop.begin(), sub_loop.end()); } else { for (size_t j=0; j<sub_loop.size(); j++) used_coedges.erase(sub_loop[j]); coedge = possible_coedges[i]; } } loop.push_back(coedge); used_coedges.insert(coedge); if (coedge->sense == CUBIT_FORWARD) curr_vertex = coedge->end; else curr_vertex = coedge->start; } } return true; }
void Update(uint32 diff) { if (CageTimer) { if (CageTimer <= diff) { Creature* Magtheridon = instance->GetCreature(MagtheridonGUID); if (Magtheridon && Magtheridon->IsAlive()) { Magtheridon->ClearUnitState(UNIT_STATE_STUNNED); Magtheridon->AI()->AttackStart(Magtheridon->SelectNearestTarget(999)); } CageTimer = 0; } else CageTimer -= diff; } if (RespawnTimer) { if (RespawnTimer <= diff) { for (std::set<uint64>::const_iterator i = ChannelerGUID.begin(); i != ChannelerGUID.end(); ++i) { if (Creature* Channeler = instance->GetCreature(*i)) { if (Channeler->IsAlive()) Channeler->AI()->EnterEvadeMode(); else Channeler->Respawn(); } } RespawnTimer = 0; } else RespawnTimer -= diff; } }
bool ReportCommand::ParseOptions(const std::vector<std::string>& args) { bool print_sample_count = false; std::vector<std::string> sort_keys = {"comm", "pid", "tid", "dso", "symbol"}; for (size_t i = 0; i < args.size(); ++i) { if (args[i] == "-b") { use_branch_address_ = true; } else if (args[i] == "--children") { accumulate_callchain_ = true; } else if (args[i] == "-g") { print_callgraph_ = true; accumulate_callchain_ = true; } else if (args[i] == "-i") { if (!NextArgumentOrError(args, &i)) { return false; } record_filename_ = args[i]; } else if (args[i] == "-n") { print_sample_count = true; } else if (args[i] == "--no-demangle") { DsoFactory::SetDemangle(false); } else if (args[i] == "--sort") { if (!NextArgumentOrError(args, &i)) { return false; } sort_keys = android::base::Split(args[i], ","); } else if (args[i] == "--symfs") { if (!NextArgumentOrError(args, &i)) { return false; } if (!DsoFactory::SetSymFsDir(args[i])) { return false; } } else { ReportUnknownOption(args, i); return false; } } if (!accumulate_callchain_) { displayable_items_.push_back( std::unique_ptr<Displayable>(new SelfOverheadItem(*sample_tree_, "Overhead"))); } else { displayable_items_.push_back( std::unique_ptr<Displayable>(new AccumulatedOverheadItem(*sample_tree_))); displayable_items_.push_back(std::unique_ptr<Displayable>(new SelfOverheadItem(*sample_tree_))); } if (print_sample_count) { displayable_items_.push_back(std::unique_ptr<Displayable>(new SampleCountItem)); } for (auto& key : sort_keys) { if (!use_branch_address_ && branch_sort_keys.find(key) != branch_sort_keys.end()) { LOG(ERROR) << "sort key '" << key << "' can only be used with -b option."; return false; } if (key == "pid") { PidItem* item = new PidItem; displayable_items_.push_back(std::unique_ptr<Displayable>(item)); comparable_items_.push_back(item); } else if (key == "tid") { TidItem* item = new TidItem; displayable_items_.push_back(std::unique_ptr<Displayable>(item)); comparable_items_.push_back(item); } else if (key == "comm") { CommItem* item = new CommItem; displayable_items_.push_back(std::unique_ptr<Displayable>(item)); comparable_items_.push_back(item); } else if (key == "dso") { DsoItem* item = new DsoItem; displayable_items_.push_back(std::unique_ptr<Displayable>(item)); comparable_items_.push_back(item); } else if (key == "symbol") { SymbolItem* item = new SymbolItem; displayable_items_.push_back(std::unique_ptr<Displayable>(item)); comparable_items_.push_back(item); } else if (key == "dso_from") { DsoFromItem* item = new DsoFromItem; displayable_items_.push_back(std::unique_ptr<Displayable>(item)); comparable_items_.push_back(item); } else if (key == "dso_to") { DsoToItem* item = new DsoToItem; displayable_items_.push_back(std::unique_ptr<Displayable>(item)); comparable_items_.push_back(item); } else if (key == "symbol_from") { SymbolFromItem* item = new SymbolFromItem; displayable_items_.push_back(std::unique_ptr<Displayable>(item)); comparable_items_.push_back(item); } else if (key == "symbol_to") { SymbolToItem* item = new SymbolToItem; displayable_items_.push_back(std::unique_ptr<Displayable>(item)); comparable_items_.push_back(item); } else { LOG(ERROR) << "Unknown sort key: " << key; return false; } } return true; }
bool convert_sql_updates() { if (new_sql_updates.empty()) return true; printf("+ converting sql updates\n"); // rename the sql update files and add the required update statement for (std::set<std::string>::iterator itr = new_sql_updates.begin(); itr != new_sql_updates.end(); ++itr) { sql_update_info info; if (!get_sql_update_info(itr->c_str(), info)) return false; if (info.db_idx == NUM_DATABASES) return false; // generating the new name should work for updates with or without a rev char src_file[MAX_PATH], new_name[MAX_PATH], new_req_name[MAX_PATH], dst_file[MAX_PATH]; snprintf(src_file, MAX_PATH, "%s%s/%s", path_prefix, sql_update_dir, itr->c_str()); snprintf(new_name, MAX_PATH, REV_PRINT "_%s_%0*d_%s%s%s", rev, info.parentRev, 2, info.nr, info.db, info.has_table ? "_" : "", info.table); snprintf(dst_file, MAX_PATH, "%s%s/%s.sql", path_prefix, sql_update_dir, new_name); if (db_sql_rev_parent[info.db_idx]) snprintf(new_req_name, MAX_PATH, "%s_%0*d_%s%s%s", info.parentRev, 2, info.nr, info.db, info.has_table ? "_" : "", info.table); else strncpy(new_req_name, new_name, MAX_PATH); FILE* fin = fopen(src_file, "r"); if (!fin) return false; std::ostringstream out_buff; // add the update requirements for non-parent-controlled revision sql update if (!db_sql_rev_parent[info.db_idx]) { // add the update requirements out_buff << "ALTER TABLE " << db_version_table[info.db_idx] << " CHANGE COLUMN required_" << last_sql_update[info.db_idx] << " required_" << new_name << " bit;\n\n"; // skip the first one or two lines from the input // if it already contains update requirements if (fgets(buffer, MAX_BUF, fin)) { char dummy[MAX_BUF]; if (sscanf(buffer, "ALTER TABLE %s CHANGE COLUMN required_%s required_%s bit", dummy, dummy, dummy) == 3) { if (fgets(buffer, MAX_BUF, fin) && buffer[0] != '\n') out_buff << buffer; } else out_buff << buffer; } } // copy the rest of the file while (fgets(buffer, MAX_BUF, fin)) out_buff << buffer; fclose(fin); FILE* fout = fopen(dst_file, "w"); if (!fout) { fclose(fin); return false; } fprintf(fout, "%s", out_buff.str().c_str()); fclose(fout); // rename the file in git snprintf(cmd, MAX_CMD, "git add %s", dst_file); system_switch_index(cmd); // delete src file if it different by name from dst file if (strncmp(src_file, dst_file, MAX_PATH)) { snprintf(cmd, MAX_CMD, "git rm --quiet %s", src_file); system_switch_index(cmd); } // update the last sql update for the current database strncpy(last_sql_update[info.db_idx], new_req_name, MAX_PATH); } return true; }
void actionCollect(const std::string &filename, enum CollectingMode mode, StatisticsCollection &statisticsCollection, HistogramCollection &histogramCollection, bool mwaChannels, size_t flaggedTimesteps, const std::set<size_t> &flaggedAntennae) { MeasurementSet *ms = new MeasurementSet(filename); const unsigned polarizationCount = ms->GetPolarizationCount(); const unsigned bandCount = ms->BandCount(); const bool ignoreChannelZero = ms->ChannelZeroIsRubish(); const std::string stationName = ms->GetStationName(); BandInfo *bands = new BandInfo[bandCount]; double **frequencies = new double*[bandCount]; unsigned totalChannels = 0; for(unsigned b=0;b<bandCount;++b) { bands[b] = ms->GetBandInfo(b); frequencies[b] = new double[bands[b].channels.size()]; totalChannels += bands[b].channels.size(); for(unsigned c=0;c<bands[b].channels.size();++c) { frequencies[b][c] = bands[b].channels[c].frequencyHz; } } delete ms; std::cout << "Polarizations: " << polarizationCount << '\n' << "Bands: " << bandCount << '\n' << "Channels/band: " << (totalChannels / bandCount) << '\n'; if(ignoreChannelZero) std::cout << "Channel zero will be ignored, as this looks like a LOFAR data set with bad channel 0.\n"; else std::cout << "Channel zero will be included in the statistics, as it seems that channel 0 is okay.\n"; // Initialize statisticscollection statisticsCollection.SetPolarizationCount(polarizationCount); if(mode == CollectDefault) { for(unsigned b=0;b<bandCount;++b) { if(ignoreChannelZero) statisticsCollection.InitializeBand(b, (frequencies[b]+1), bands[b].channels.size()-1); else statisticsCollection.InitializeBand(b, frequencies[b], bands[b].channels.size()); } } // Initialize Histograms collection histogramCollection.SetPolarizationCount(polarizationCount); // get columns casa::Table table(filename, casa::Table::Update); const char *dataColumnName = "DATA"; casa::ROArrayColumn<casa::Complex> dataColumn(table, dataColumnName); casa::ROArrayColumn<bool> flagColumn(table, "FLAG"); casa::ROScalarColumn<double> timeColumn(table, "TIME"); casa::ROScalarColumn<int> antenna1Column(table, "ANTENNA1"); casa::ROScalarColumn<int> antenna2Column(table, "ANTENNA2"); casa::ROScalarColumn<int> windowColumn(table, "DATA_DESC_ID"); std::cout << "Collecting statistics..." << std::endl; size_t channelCount = bands[0].channels.size(); bool correlatorFlags[channelCount], correlatorFlagsForBadAntenna[channelCount]; for(size_t ch=0; ch!=channelCount; ++ch) { correlatorFlags[ch] = false; correlatorFlagsForBadAntenna[ch] = true; } if(mwaChannels) { if(channelCount%24 != 0) std::cout << "MWA channels requested, but nr of channels not a multiply of 24. Ignoring.\n"; else { size_t chanPerSb = channelCount/24; for(size_t x=0;x!=24;++x) { correlatorFlags[x*chanPerSb] = true; correlatorFlags[x*chanPerSb + chanPerSb/2] = true; correlatorFlags[x*chanPerSb + chanPerSb-1] = true; } } } const unsigned nrow = table.nrow(); size_t timestepIndex = (size_t) -1; double prevtime = -1.0; for(unsigned row = 0; row!=nrow; ++row) { const double time = timeColumn(row); const unsigned antenna1Index = antenna1Column(row); const unsigned antenna2Index = antenna2Column(row); const unsigned bandIndex = windowColumn(row); if(time != prevtime) { ++timestepIndex; prevtime = time; } const BandInfo &band = bands[bandIndex]; const casa::Array<casa::Complex> dataArray = dataColumn(row); const casa::Array<bool> flagArray = flagColumn(row); std::complex<float> *samples[polarizationCount]; bool *isRFI[polarizationCount]; for(unsigned p = 0; p < polarizationCount; ++p) { isRFI[p] = new bool[band.channels.size()]; samples[p] = new std::complex<float>[band.channels.size()]; } const bool antennaIsFlagged = flaggedAntennae.find(antenna1Index) != flaggedAntennae.end() || flaggedAntennae.find(antenna2Index) != flaggedAntennae.end(); casa::Array<casa::Complex>::const_iterator dataIter = dataArray.begin(); casa::Array<bool>::const_iterator flagIter = flagArray.begin(); const unsigned startChannel = ignoreChannelZero ? 1 : 0; if(ignoreChannelZero) { for(unsigned p = 0; p < polarizationCount; ++p) { ++dataIter; ++flagIter; } } for(unsigned channel = startChannel ; channel<band.channels.size(); ++channel) { for(unsigned p = 0; p < polarizationCount; ++p) { samples[p][channel - startChannel] = *dataIter; isRFI[p][channel - startChannel] = *flagIter; ++dataIter; ++flagIter; } } for(unsigned p = 0; p < polarizationCount; ++p) { switch(mode) { case CollectDefault: if(antennaIsFlagged || timestepIndex < flaggedTimesteps) statisticsCollection.Add(antenna1Index, antenna2Index, time, bandIndex, p, &samples[p]->real(), &samples[p]->imag(), isRFI[p], correlatorFlagsForBadAntenna, band.channels.size() - startChannel, 2, 1, 1); else statisticsCollection.Add(antenna1Index, antenna2Index, time, bandIndex, p, &samples[p]->real(), &samples[p]->imag(), isRFI[p], correlatorFlags, band.channels.size() - startChannel, 2, 1, 1); break; case CollectHistograms: histogramCollection.Add(antenna1Index, antenna2Index, p, samples[p], isRFI[p], band.channels.size() - startChannel); break; } } for(unsigned p = 0; p < polarizationCount; ++p) { delete[] isRFI[p]; delete[] samples[p]; } reportProgress(row, nrow); } for(unsigned b=0;b<bandCount;++b) delete[] frequencies[b]; delete[] frequencies; delete[] bands; std::cout << "100\n"; }
void ElasticFoundationForceImpl::processContact (const State& state, ContactSurfaceIndex meshIndex, ContactSurfaceIndex otherBodyIndex, const Parameters& param, const std::set<int>& insideFaces, Real areaScale, Vector_<SpatialVec>& bodyForces, Real& pe) const { const ContactGeometry& otherObject = subsystem.getBodyGeometry(set, otherBodyIndex); const MobilizedBody& body1 = subsystem.getBody(set, meshIndex); const MobilizedBody& body2 = subsystem.getBody(set, otherBodyIndex); const Transform t1g = body1.getBodyTransform(state)*subsystem.getBodyTransform(set, meshIndex); // mesh to ground const Transform t2g = body2.getBodyTransform(state)*subsystem.getBodyTransform(set, otherBodyIndex); // other object to ground const Transform t12 = ~t2g*t1g; // mesh to other object // Loop over all the springs, and evaluate the force from each one. for (std::set<int>::const_iterator iter = insideFaces.begin(); iter != insideFaces.end(); ++iter) { int face = *iter; UnitVec3 normal; bool inside; Vec3 nearestPoint = otherObject.findNearestPoint(t12*param.springPosition[face], inside, normal); if (!inside) continue; // Find how much the spring is displaced. nearestPoint = t2g*nearestPoint; const Vec3 springPosInGround = t1g*param.springPosition[face]; const Vec3 displacement = nearestPoint-springPosInGround; const Real distance = displacement.norm(); if (distance == 0.0) continue; const Vec3 forceDir = displacement/distance; // Calculate the relative velocity of the two bodies at the contact point. const Vec3 station1 = body1.findStationAtGroundPoint(state, nearestPoint); const Vec3 station2 = body2.findStationAtGroundPoint(state, nearestPoint); const Vec3 v1 = body1.findStationVelocityInGround(state, station1); const Vec3 v2 = body2.findStationVelocityInGround(state, station2); const Vec3 v = v2-v1; const Real vnormal = dot(v, forceDir); const Vec3 vtangent = v-vnormal*forceDir; // Calculate the damping force. const Real area = areaScale * param.springArea[face]; const Real f = param.stiffness*area*distance*(1+param.dissipation*vnormal); Vec3 force = (f > 0 ? f*forceDir : Vec3(0)); // Calculate the friction force. const Real vslip = vtangent.norm(); if (f > 0 && vslip != 0) { const Real vrel = vslip/transitionVelocity; const Real ffriction = f*(std::min(vrel, Real(1)) *(param.dynamicFriction+2*(param.staticFriction-param.dynamicFriction) /(1+vrel*vrel))+param.viscousFriction*vslip); force += ffriction*vtangent/vslip; } body1.applyForceToBodyPoint(state, station1, force, bodyForces); body2.applyForceToBodyPoint(state, station2, -force, bodyForces); pe += param.stiffness*area*displacement.normSqr()/2; } }
inline bool Controller::IsRouteSettled( const RouteID _id ) const { return m_unsettledRoutes.find( _id ) == m_unsettledRoutes.end(); }
std::vector<std::string> toposort() { std::vector<std::string> result; std::vector<std::set<Class>::iterator> classItsWithNoPrereqs; for (auto targetIt = classes.begin(); targetIt != classes.end(); ++targetIt) { bool hasPrereq = false; for (auto potentialPrereqIt = classes.begin(); potentialPrereqIt != classes.end(); ++potentialPrereqIt) { int potentialPrereqIndex = std::distance(classes.begin(), potentialPrereqIt); int targetIndex = std::distance(classes.begin(), targetIt); if (adjMat[potentialPrereqIndex][targetIndex]) { hasPrereq = true; break; } } if (!hasPrereq) { classItsWithNoPrereqs.push_back(targetIt); } } while (!classItsWithNoPrereqs.empty()) { // Find a class with no pre-reqs (resolve ties by # then dept) std::sort(classItsWithNoPrereqs.begin(), classItsWithNoPrereqs.end(), [](std::set<Class>::iterator c1, std::set<Class>::iterator c2) { return *c1 < *c2; }); auto firstClassIt = classItsWithNoPrereqs.begin(); auto prereqIt = *firstClassIt; int prereqIndex = std::distance(classes.begin(), prereqIt); result.push_back(*prereqIt); // Calls std::string() implicitly classItsWithNoPrereqs.erase(firstClassIt); for (auto potentialTargetIt = classes.begin(); potentialTargetIt != classes.end(); ++potentialTargetIt) { int potentialTargetIndex = std::distance(classes.begin(), potentialTargetIt); if (adjMat[prereqIndex][potentialTargetIndex]) { adjMat[prereqIndex][potentialTargetIndex] = false; --numEdges; // Check for other incoming edges to the target bool hasOtherIncomingEdges = false; for (auto potentialPrereqIt = classes.begin(); potentialPrereqIt != classes.end(); ++potentialPrereqIt) { int potentialPrereqIndex = std::distance(classes.begin(), potentialPrereqIt); if (adjMat[potentialPrereqIndex] [potentialTargetIndex]) { hasOtherIncomingEdges = true; break; } } if (!hasOtherIncomingEdges) { classItsWithNoPrereqs.push_back(potentialTargetIt); } } } } if (0 != numEdges) { return {}; } return result; }
BOOL LLWindowManager::isWindowValid(LLWindow *window) { return sWindowList.find(window) != sWindowList.end(); }