void IOComponent::reset() { boost::recursive_mutex::scoped_lock lock(processing_queue_mutex); processing_queue.clear(); regular_polls.clear(); std::list<MachineInstance*>::iterator iter = MachineInstance::begin(); while (iter != MachineInstance::end()) { MachineInstance *m = *iter++; if (m->io_interface) { delete m->io_interface; m->io_interface = 0; } } if (io_process_data) delete[] io_process_data; io_process_data = 0; if (io_process_mask) delete[] io_process_mask; io_process_mask = 0; if (update_data) delete[] update_data; update_data = 0; if (default_data) delete[] default_data; default_data = 0; if (default_mask) delete[] default_mask; default_mask = 0; if (last_process_data) delete[] last_process_data; last_process_data = 0; }
bool cached_zk::list_(const string& path, std::set<std::string>& out) { out.clear(); struct String_vector s; int rc = zoo_wget_children(zh_, path.c_str(), cached_zk::update_cache, this, &s); if (rc == ZOK) { for (int i = 0; i < s.count; ++i) { out.insert(s.data[i]); } return true; } else { LOG(ERROR) << "failed to get children: " << path << " - " << zerror(rc); return false; } }
void Reset() { uiCrystalfireBreathTimer = 10*IN_MILLISECONDS; uiCrystalChainsTimer = 20*IN_MILLISECONDS; uiCrystalizeTimer = urand(10*IN_MILLISECONDS, 15*IN_MILLISECONDS); uiTailSweepTimer = 5*IN_MILLISECONDS; bEnrage = false; lIntenseColdPlayers.clear(); me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_STUNNED); RemovePrison(CheckContainmentSpheres()); if (pInstance) pInstance->SetData(DATA_KERISTRASZA_EVENT, NOT_STARTED); }
void SparseMatrix<T>::NonZeroRowIndices(std::set<unsigned int>& row_index_set, const T& epsilon) { row_index_set.clear(); // save indices of rows with values > epsilon for (unsigned int s=0; s<size_; ++s) { T val = data_[s]; if (std::abs(val) > epsilon) { unsigned int row = row_indices_[s]; row_index_set.insert(row); } } }
void MeshBase::subdomain_ids (std::set<subdomain_id_type> &ids) const { // This requires an inspection on every processor parallel_object_only(); ids.clear(); const_element_iterator el = this->active_elements_begin(); const const_element_iterator end = this->active_elements_end(); for (; el!=end; ++el) ids.insert((*el)->subdomain_id()); // Some subdomains may only live on other processors this->comm().set_union(ids); }
static BOOL WINAPI MyFreeLibrary(HMODULE hModule) { if (VERBOSITY >= 2) { debugPrintf("inject: intercepting %s(0x%p)\n", __FUNCTION__, hModule); } BOOL bRet = FreeLibrary(hModule); EnterCriticalSection(&Mutex); // TODO: Only clear the modules that have been freed g_hHookedModules.clear(); LeaveCriticalSection(&Mutex); return bRet; }
bool ARPScanner::scanLocalNetwork(std::set<std::string>& foundMACAddresses) { FILE *fp; int status; char line[128]; std::vector<std::string> lines; foundMACAddresses.clear(); // execute arp-scan fp = popen(m_commandString.c_str(), "r"); if (fp == NULL) { m_lastErrorString = "cannot execute arp-scan"; return false; } // parse arp-scan output // address information should start on line 3, ignore first 2 fgets(line, 128, fp); fgets(line, 128, fp); // go through rest of the output line by line while (fgets(line, 128, fp) != NULL) { // line's second token should be MAC address std::istringstream ss(line); std::string MACAddress; ss >> MACAddress; ss >> MACAddress; // after address info there comes some other lines, time to quit if (MACAddress == "") break; foundMACAddresses.insert(MACAddress); } status = pclose(fp); if (status == -1 || WEXITSTATUS(status) != 0) { m_lastErrorString = "cannot execute arp-scan"; return false; } m_lastErrorString = ""; return true; }
void Node::showNode(const std::string &id) { static std::set<std::string> cache; auto node = nodeTypeMap[id]; if (id == "root") cache.clear(); else { if (!cache.count(id)) { cache.insert(id); std::cout << "ID: " << id << " Runname: " << node->runname << std::endl; std::cout << "Specs: " << std::endl; std::cout << "\tParallel level: " << node->paraLevel << std::endl; std::cout << "\tChildrens: "; for (auto child : node->children) { std::cout << " " << child.first <<"("; switch(child.second) { case SHUFFLE: { std::cout << "ShuffleGrouping"; break; } case DEFAULT: { std::cout << "DefaultGrouping"; break; } default: { std::cout << "Unknown"; break; } } std::cout << ")"; } std::cout << std::endl << std::endl; } } for (auto child : node->children) { showNode(child.first); } }
void Initialize() { memset(&encounter, 0, sizeof(encounter)); PumpkinShrineGUID = 0; HorsemanGUID = 0; HeadGUID = 0; HorsemanAdds.clear(); MograineGUID = 0; WhitemaneGUID = 0; VorrelGUID = 0; DoorHighInquisitorGUID = 0; _KelDoor = 0; _AsmDoor = 0; }
void RegEx::Move(char c, std::set<State*> input, std::set<State*>& output) { output.clear(); set<State*>::iterator it; for(it= input.begin();it!= input.end();it++) { State* u = *it; vector<State*> states; u->getTransition(c,states); for(int i = 0;i<states.size();i++) { output.insert(states[i]); } } }
/* Privileges */ static void read_privileges(lua_State *L, int index, std::set<std::string> &result) { result.clear(); lua_pushnil(L); if(index < 0) index -= 1; while(lua_next(L, index) != 0){ // key at index -2 and value at index -1 std::string key = luaL_checkstring(L, -2); bool value = lua_toboolean(L, -1); if(value) result.insert(key); // removes value, keeps key for next iteration lua_pop(L, 1); } }
void split ( std::set<std::string>& results, const std::string& input, const char delimiter) { results.clear (); std::string::size_type start = 0; std::string::size_type i; while ((i = input.find (delimiter, start)) != std::string::npos) { results.insert (input.substr (start, i - start)); start = i + 1; } if (input.length ()) results.insert (input.substr (start)); }
void init() { fillRace(raceData[RaceIDs::Zerg], "Zerg", UnitTypeIDs::Zerg_Drone, UnitTypeIDs::Zerg_Hatchery, UnitTypeIDs::Zerg_Extractor, UnitTypeIDs::Zerg_Overlord, UnitTypeIDs::Zerg_Overlord); fillRace(raceData[RaceIDs::Terran], "Terran", UnitTypeIDs::Terran_SCV, UnitTypeIDs::Terran_Command_Center, UnitTypeIDs::Terran_Refinery, UnitTypeIDs::Terran_Dropship, UnitTypeIDs::Terran_Supply_Depot); fillRace(raceData[RaceIDs::Protoss], "Protoss", UnitTypeIDs::Protoss_Probe, UnitTypeIDs::Protoss_Nexus, UnitTypeIDs::Protoss_Assimilator, UnitTypeIDs::Protoss_Shuttle, UnitTypeIDs::Protoss_Pylon); raceSet.clear(); raceSet.insert(RaceIDs::Zerg); raceSet.insert(RaceIDs::Terran); raceSet.insert(RaceIDs::Protoss); raceMap.clear(); for(std::set<RaceID>::iterator i = raceSet.begin(); i != raceSet.end(); i++) { raceMap.insert(std::make_pair(std::string(raceData[*i].name), *i)); } }
void Reset() { reseting = true; StartCombat = false; HasKilledAkamaAndReseting = false; GridSearcherSucceeded = false; Sorcerers.clear(); summons.DespawnAll();//despawn all adds Channelers.clear(); if (Creature* Akama = Unit::GetCreature(*me, AkamaGUID)) { Akama->SetFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_GOSSIP);//turn gossip on so players can restart the event if (Akama->isDead()) { Akama->Respawn();//respawn akama if dead Akama->AI()->EnterEvadeMode(); } } SorcererCount = 0; DeathCount = 0; SummonTimer = 10000; ReduceHealthTimer = 0; ResetTimer = 60000; DefenderTimer = 15000; IsBanished = true; HasKilledAkama = false; me->SetVisible(true); me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE); me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE); //me->GetMotionMaster()->Clear(); //me->GetMotionMaster()->MoveIdle(); me->SetUInt32Value(UNIT_NPC_EMOTESTATE, EMOTE_STATE_STUN); if (pInstance && me->IsAlive()) pInstance->SetData(DATA_SHADEOFAKAMAEVENT, NOT_STARTED); reseting = false; me->setActive(true); }
YK_BOOL CForGantt::GetWorkList(YK_ID resId,YK_TM stTime, YK_TM etTime, std::set<YK_ID>& workLst) { workLst.clear(); CResCapacitySPtr resCapPtr = g_Application.Get<CResCapacityMap>()->GetResCap(resId); if (resCapPtr.ValidObj()) { std::list<YK_ID> tempList; resCapPtr->GetAllWorkListInArea(stTime, etTime, tempList); for(std::list<YK_ID>::iterator iter = tempList.begin(); iter != tempList.end();iter++) { workLst.insert(*iter); } return true; } return false; }
void disconnectall() { std::set<signal_base*>::iterator it = senders.begin(); std::set<signal_base*>::iterator end = senders.end(); std::set<signal_base*>::iterator next; while( it != end ) { next = it; ++next; (*it)->disconnect(this); it = next; } senders.clear(); }
CondensationOut build_condensation() { std::vector< Vertex > top_sort = topological_sort(); in_sort.clear(); out_sort.clear(); used.clear(); cond.clear(); for (auto v = top_sort.rbegin(); v != top_sort.rend(); ++v) { if (used.find(v) == used.end()) { this->dfs< Transposed >(v); cond.push_back(vSet(in_sort.begin(), in_sort.end())); in_sort.clear(); } } return cond; }
/* * Search object in database using its key * \param key is the 64 bits row key to search through all tables */ bool CDatabase::searchObjectIndex(uint64 key, std::set<RY_PDS::CObjectIndex>& indexes) const { indexes.clear(); uint i; for (i=0; i<_Tables.size(); ++i) { if (_Tables[i] == NULL || !_Tables[i]->initialised() || !_Tables[i]->isMapped()) continue; RY_PDS::CObjectIndex index = _Tables[i]->getMappedRow(key); if (index.isValid()) indexes.insert(index); } return !indexes.empty(); }
void Reset() { uiCrystalfireBreathTimer = 14*IN_MILLISECONDS; uiCrystalChainsCrystalizeTimer = DUNGEON_MODE(30*IN_MILLISECONDS,11*IN_MILLISECONDS); uiTailSweepTimer = 5*IN_MILLISECONDS; bEnrage = false; uiCheckIntenseColdTimer = 2*IN_MILLISECONDS; //bMoreThanTwoIntenseCold = false; lMoreThanTwoIntenseCold.clear(); me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_STUNNED); RemovePrison(CheckContainmentSpheres()); if (pInstance) pInstance->SetData(DATA_KERISTRASZA_EVENT, NOT_STARTED); }
static void ParseExtensionsString(const std::string& str, std::set<std::string> &output) { output.clear(); size_t next = 0; for (size_t pos = 0, len = str.length(); pos < len; ++pos) { if (str[pos] == ' ') { output.insert(str.substr(next, pos - next)); // Skip the delimiter itself. next = pos + 1; } } if (next == 0 && str.length() != 0) { output.insert(str); } else if (next < str.length()) { output.insert(str.substr(next)); } }
void NTriangulation::maximalForestInSkeleton(std::set<NEdge*>& edgeSet, bool canJoinBoundaries) const { ensureSkeleton(); std::set<NVertex*> vertexSet; std::set<NVertex*> thisBranch; if (canJoinBoundaries) edgeSet.clear(); else maximalForestInBoundary(edgeSet, vertexSet); for (NVertex* v : vertices()) if (! (vertexSet.count(v))) { stretchForestFromVertex(v, edgeSet, vertexSet, thisBranch); thisBranch.clear(); } }
void ZTBSpec::GetPropNames(std::set<std::string>& oPropNames) const { oPropNames.clear(); if (!fRep) return; for (CriterionUnion::const_iterator outer = fRep->fCriterionUnion.begin(), outerEnd = fRep->fCriterionUnion.end(); outer != outerEnd; ++outer) { for (CriterionSect::const_iterator inner = (*outer).begin(), innerEnd = (*outer).end(); inner != innerEnd; ++inner) { oPropNames.insert((*inner).GetPropName().AsString()); } } }
void ZTBSpec::GetPropNames(std::set<ZTuplePropName>& oPropNames) const { oPropNames.clear(); if (!fRep) return; for (CriterionUnion::const_iterator outer = fRep->fCriterionUnion.begin(), outerEnd = fRep->fCriterionUnion.end(); outer != outerEnd; ++outer) { for (CriterionSect::const_iterator inner = outer->begin(), innerEnd = outer->end(); inner != innerEnd; ++inner) { oPropNames.insert(inner->GetPropName()); } } }
bool ReadSubcriberFile(const std::string& dir, const std::string& filename, std::set<uint16_t>& subscribers) { subscribers.clear(); TextFile file(dir, filename, "rt"); if (!file.IsOpen()) { return false; } string line; while (file.ReadLine(&line)) { StringTrim(&line); uint16_t s = StringToUnsignedShort(line); if (s > 0) { subscribers.insert(s); } } return true; }
void IKeyState::KeyInfo::split(const char* screens, std::set<String>& dst) { dst.clear(); if (isDefault(screens)) { return; } if (screens[0] == '*') { dst.insert("*"); return; } const char* i = screens + 1; while (*i != '\0') { const char* j = strchr(i, ':'); dst.insert(String(i, j - i)); i = j + 1; } }
void new_code_line (string_pos n, std::string& new_code) { if (new_instanciations.size() > 0) { for (std::set<std::string>::iterator i = new_instanciations.begin(); i != new_instanciations.end(); ++i) { new_code_lines.push_back (*i); } } new_code_lines.push_back (new_code); new_code = ""; previous_line_start = n; if (n > 0) n--; new_instanciations.clear(); }
void Data<Annotation>::set_union( std::set<Data<Annotation> *> & result_, const std::set<Data<Annotation> *> & datas_ ) { // FIXME currently: same symbol => same data std::vector<Data<Annotation> *> datas(datas_.begin(), datas_.end()); std::vector<Data<Annotation> *> result_in (result_.begin(), result_.end()); std::vector<Data<Annotation> *> result_out(result_.size() + datas.size()); std::sort(result_in.begin(), result_in.end(), less); std::sort(datas.begin(), datas.end(), less); typename std::vector<Data<Annotation> *>::iterator it_result_begin = result_out.begin(); typename std::vector<Data<Annotation> *>::iterator it_result_end = std::set_union(result_in.begin(), result_in.end(), datas.begin(), datas.end(), it_result_begin, less); result_.clear(); result_.insert(it_result_begin, it_result_end); }
inline void computeStrongNeighbors(const double delta, const std::vector<double>& max_aff, const SpMat& C, std::set<size_t>& strongNeighbors) { strongNeighbors.clear(); for (size_t u = 0; u < C.rows(); u++) { for (SpMat::ConstIterator v = C.begin(u); v != C.end(u); v++) { if (v->index() <= u) //guardo solo il triangolo superiore, senza diagonale continue; //v->value() è c_uv //max_aff[u] è max{s!=u} c_us //max_aff[v->index()] è max{s!=v} c_sv //Quindi se c_uv >= delta*max{ max{s!=u} c_us, max{s!=v} c_sv} if (v->value() >= delta * max(max_aff[u], max_aff[v->index()])) { // u e v sono strong neighbors, li metto nel set strongNeighbors.insert(u); strongNeighbors.insert(v->index()); } } } }
void writeNodeIconSection(std::ostream& out, NodeSet& ns, Config& config) { iconNames.clear(); NodeSet::iterator it = ns.begin(); while (it != ns.end()) { EntityTypeStruct type = (*it)->entity->entityType; const std::string& icon = (*it)->getIconName(); if (!icon.empty()) { std::string filename = config.getFileName(icon); out << "[" << (*it)->NodeId << "] NODE-ICON"; out << "\t\ticons" << config.dirSep << filename << std::endl; iconNames.insert(icon); } it++; } out << std::endl; }
bool CTrieMaker::parseLine(char* buf, char* word_buf, unsigned& id, std::set<TUnitInfo>& unitset) { unitset.clear(); /* ignore the empty lines and comment lines */ if (*buf == '\n' || *buf == '#') return 0; char* p = (char*)skipSpace(buf); char* t = (char*)skipNonSpace(p); while (p < t) *word_buf++ = *p++; *word_buf = 0; p = (char*)skipSpace(p); t = (char*)skipNonSpace(p); if (*t) *t++ = 0; id = atoi(p); p = (char*)skipSpace(t); while (*p) { const char* s = p; t = (char*)skipNonSpace(p); if (*t) *t++ = 0; while ((*p >= 'a' && *p <= 'z') || (*p == '\'')) ++p; if ((p > s) && ((*p == 0) || (*p == ':'))) { int cost = 0; if (*p == ':') { *p++ = 0; cost = -log2(atof(p)/100); } unitset.insert(TUnitInfo(s, cost)); } p = (char*)skipSpace(t); } return unitset.size() > 0; }