/** * @return True if the data should be deleted. */ bool MaskWorkspace::isMasked(const std::set<detid_t> &detectorIDs) const { if (detectorIDs.empty()) { return false; } bool masked(true); for (std::set<detid_t>::const_iterator it = detectorIDs.begin(); it != detectorIDs.end(); ++it) { if (!this->isMasked(*it)) { masked = false; break; // allows space for a debug print statement } } return masked; }
/* * 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 CFileItemHandler::FillDetails(const ISerializable *info, const CFileItemPtr &item, std::set<std::string> &fields, CVariant &result, CThumbLoader *thumbLoader /* = NULL */) { if (info == NULL || fields.empty()) return; CVariant serialization; info->Serialize(serialization); bool fetchedArt = false; std::set<std::string> originalFields = fields; for (std::set<std::string>::const_iterator fieldIt = originalFields.begin(); fieldIt != originalFields.end(); ++fieldIt) { if (GetField(*fieldIt, serialization, item, result, fetchedArt, thumbLoader) && result.isMember(*fieldIt) && !result[*fieldIt].empty()) fields.erase(*fieldIt); } }
std::set<T> MonsterGenerator::get_set_from_tags(std::set<std::string> tags, std::map<std::string, T> conversion_map, T fallback) { std::set<T> ret; if (!tags.empty()){ for (std::set<std::string>::iterator it = tags.begin(); it != tags.end(); ++it){ if (conversion_map.find(*it) != conversion_map.end()){ ret.insert(conversion_map[*it]); } } } if (ret.empty()){ ret.insert(fallback); } return ret; }
std::set<T> MonsterGenerator::get_set_from_tags(std::set<std::string> tags, std::map<std::string, T> conversion_map, T fallback) { std::set<T> ret; if (!tags.empty()) { for( const auto &tag : tags ) { if( conversion_map.find( tag ) != conversion_map.end() ) { ret.insert( conversion_map[tag] ); } } } if (ret.empty()) { ret.insert(fallback); } return ret; }
void HlslLinker::emitLibraryFunctions(const std::set<TOperator>& libFunctions, EShLanguage lang, bool usePrecision) { // library Functions & required extensions std::string shaderLibFunctions; if (!libFunctions.empty()) { for (std::set<TOperator>::const_iterator it = libFunctions.begin(); it != libFunctions.end(); it++) { const std::string &func = getHLSLSupportCode(*it, m_Extensions, lang==EShLangVertex, usePrecision); if (!func.empty()) { shaderLibFunctions += func; shaderLibFunctions += '\n'; } } } shader << shaderLibFunctions; }
void CheckInternal::checkUnknownPattern() { static std::set<std::string> knownPatterns; if (knownPatterns.empty()) { knownPatterns.insert("%any%"); knownPatterns.insert("%var%"); knownPatterns.insert("%type%"); knownPatterns.insert("%num%"); knownPatterns.insert("%bool%"); knownPatterns.insert("%str%"); knownPatterns.insert("%varid%"); knownPatterns.insert("%or%"); knownPatterns.insert("%oror%"); knownPatterns.insert("%op%"); } for (const Token *tok = _tokenizer->tokens(); tok; tok = tok->next()) { if (!Token::simpleMatch(tok, "Token :: Match (") && !Token::simpleMatch(tok, "Token :: findmatch (")) continue; // Get pattern string const Token *pattern_tok = tok->tokAt(4)->nextArgument(); if (!pattern_tok || pattern_tok->type() != Token::eString) continue; const std::string pattern = pattern_tok->strValue(); bool inBrackets = false; for (std::string::size_type i = 0; i < pattern.length()-1; i++) { if (pattern[i] == '[' && (i == 0 || pattern[i-1] == ' ')) inBrackets = true; else if (pattern[i] == ']') inBrackets = false; else if (pattern[i] == '%' && pattern[i+1] != ' ' && pattern[i+1] != '|' && !inBrackets) { std::string::size_type end = pattern.find('%', i+1); if (end != std::string::npos) { std::string s = pattern.substr(i, end-i+1); if (knownPatterns.find(s) == knownPatterns.end()) unknownPatternError(tok, s); } } } } }
ItemStack::ItemStack(const MWWorld::Ptr &base, ItemModel *creator, size_t count) : mType(Type_Normal) , mFlags(0) , mCreator(creator) , mCount(count) , mBase(base) { if (base.getClass().getEnchantment(base) != "") mFlags |= Flag_Enchanted; static std::set<std::string> boundItemIDCache; // If this is empty then we haven't executed the GMST cache logic yet; or there isn't any sMagicBound* GMST's for some reason if (boundItemIDCache.empty()) { // Build a list of known bound item ID's const MWWorld::Store<ESM::GameSetting> &gameSettings = MWBase::Environment::get().getWorld()->getStore().get<ESM::GameSetting>(); for (MWWorld::Store<ESM::GameSetting>::iterator currentIteration = gameSettings.begin(); currentIteration != gameSettings.end(); ++currentIteration) { const ESM::GameSetting ¤tSetting = *currentIteration; std::string currentGMSTID = currentSetting.mId; Misc::StringUtils::toLower(currentGMSTID); // Don't bother checking this GMST if it's not a sMagicBound* one. const std::string& toFind = "smagicbound"; if (currentGMSTID.compare(0, toFind.length(), toFind) != 0) continue; // All sMagicBound* GMST's should be of type string std::string currentGMSTValue = currentSetting.getString(); Misc::StringUtils::toLower(currentGMSTValue); boundItemIDCache.insert(currentGMSTValue); } } // Perform bound item check and assign the Flag_Bound bit if it passes std::string tempItemID = base.getCellRef().getRefId(); Misc::StringUtils::toLower(tempItemID); if (boundItemIDCache.count(tempItemID) != 0) mFlags |= Flag_Bound; }
config vconfig::get_parsed_config() const { // Keeps track of insert_tag variables. static std::set<std::string> vconfig_recursion; config res; BOOST_FOREACH(const config::attribute &i, cfg_->attribute_range()) { res[i.first] = expand(i.first); } BOOST_FOREACH(const config::any_child &child, cfg_->all_children_range()) { if (child.key == "insert_tag") { vconfig insert_cfg(child.cfg); const t_string& name = insert_cfg["name"]; const t_string& vname = insert_cfg["variable"]; if(!vconfig_recursion.insert(vname).second) { throw recursion_error("vconfig::get_parsed_config() infinite recursion detected, aborting"); } try { config::const_child_itors range = as_nonempty_range(vname); BOOST_FOREACH(const config& child, range) { res.add_child(name, vconfig(child).get_parsed_config()); } } catch(const invalid_variablename_exception&) { res.add_child(name); } catch(recursion_error &err) { vconfig_recursion.erase(vname); WRN_NG << err.message << std::endl; if(vconfig_recursion.empty()) { res.add_child("insert_tag", insert_cfg.get_config()); } else { // throw to the top [insert_tag] which started the recursion throw; } } vconfig_recursion.erase(vname); } else {
void XLHighlighter::highlightNames(int index, std::set<text> &names) // ---------------------------------------------------------------------------- // Set the words to highlight as XL names or symbols // ---------------------------------------------------------------------------- { HighlightingRule &nameRule = highlightingRules[index]; if (names.empty()) { nameRule.begin = QRegExp(""); return; } QStringList w; for (std::set<text>::iterator n = names.begin(); n != names.end(); n++) w << QRegExp::escape(+*n); QString exp = w.join("|"); if (index != 1) exp = QString("\\b(%1)\\b").arg(exp); nameRule.begin = QRegExp(exp); }
void DBManager::DeleteItems( std::set<unsigned int> const& ids ) const { if (ids.empty()) { return; } std::list<std::tstring> idStrings; for (std::set<unsigned int>::const_iterator it = ids.begin(); it != ids.end(); ++it) { idStrings.push_back(STREAM2STR(*it)); } std::tstring idList = boost::join(idStrings, _T(",")); std::tstringstream sql; sql << _T("DELETE FROM tItems WHERE itemidx IN(") << idList << _T(")"); m_db->Exec(sql.str()); }
/** * @brief Utility method to get value for specified key. * * Docker supports querying primary columns by prefix. This is preserved when * querying throught OSQuery. * * For example the following should return same result as long as there is only * one container with "id" that starts with "12345678": * SELECT * FROM docker_containers WHERE id = '1234567890abcdef' * SELECT * FROM docker_containers WHERE id = '12345678' * * @param tree Property tree response from docker. * @param set Set that might contain prefix values. * @param key Key to look for in the property tree. */ std::string getValue(const pt::ptree& tree, const std::set<std::string>& set, const std::string& key) { std::string value = tree.get<std::string>(key, ""); if (value.find("sha256:") == 0) { value.erase(0, 7); } if (set.empty()) { return value; // Return value from tree, if set is empty } for (const auto& entry : set) { if (value.find(entry) == 0) { return entry; // If entry from set is prefix of value from tree, return } } return value; }
int SlaveManager::chooseLessReplicaNode(std::set<Address, AddrComp>& loclist, Address& addr) { if (loclist.empty()) return -1; int min_dist = 1024; int64_t min_avail_space = -1; // TODO (sergey) // Remove a node such that the rest has the max-min distance; // When the first rule ties, choose one with least available space. for (set<Address, AddrComp>::iterator i = loclist.begin(); i != loclist.end(); ++ i) { // TODO: optimize this by using ID instead of address. set<Address, AddrComp> tmp = loclist; tmp.erase(*i); int slave_id = m_mAddrList[*i]; SlaveNode sn = m_mSlaveList[slave_id]; if( m_mSlaveList.find( slave_id ) == m_mSlaveList.end() ) log().error << __PRETTY_FUNCTION__ << ": about to add new slave to list " << slave_id << std::endl; int64_t availDiskSpace = sn.m_llAvailDiskSpace; int dist = m_pTopology->min_distance(*i, tmp); if (dist < min_dist) { addr = *i; min_dist = dist; min_avail_space = availDiskSpace; } else if (dist == min_dist) { if (availDiskSpace < min_avail_space) { addr = *i; min_avail_space = sn.m_llAvailDiskSpace; } } } return 0; }
void MatrixArchive::saveMatrices(std::ostream & fout, std::set<std::string> const & validNames) const { matrix_map_t::const_iterator it = m_values.begin(); for( ; it != m_values.end(); it++) { if(validNames.empty() || validNames.count(it->first) > 0) { if(isSystemLittleEndian()) { writeMatrixBlock(fout, it->first, it->second); } else { writeMatrixBlockSwapBytes(fout, it->first, it->second); } SM_ASSERT_TRUE(MatrixArchiveException, fout.good(), "Error while writing matrix " << it->first << " to file."); } } }
void operator()(msgpack::object::with_zone& o, const std::set<T>& v) const { o.type = msgpack::type::ARRAY; if(v.empty()) { o.via.array.ptr = nullptr; o.via.array.size = 0; } else { uint32_t size = checked_get_container_size(v.size()); msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size)); msgpack::object* const pend = p + size; o.via.array.ptr = p; o.via.array.size = size; typename std::set<T>::const_iterator it(v.begin()); do { *p = msgpack::object(*it, o.zone); ++p; ++it; } while(p < pend); } }
bool change_sql_database() { if(new_sql_updates.empty()) return true; printf("+ changing database sql files\n"); // rename the database files, copy their contents back // and change the required update line for(int i = 0; i < NUM_DATABASES; i++) { if(last_sql_update[i][0] == '\0') continue; char old_file[MAX_PATH], tmp_file[MAX_PATH], dummy[MAX_BUF]; snprintf(old_file, MAX_PATH, "%s%s", path_prefix, db_sql_file[i]); snprintf(tmp_file, MAX_PATH, "%s%stmp", path_prefix, db_sql_file[i]); rename(old_file, tmp_file); FILE *fin = fopen( tmp_file, "r" ); if(!fin) return false; FILE *fout = fopen( old_file, "w" ); if(!fout) return false; while(1) { if(!fgets(buffer, MAX_BUF, fin)) return false; if(sscanf(buffer, " `required_%s`", dummy) == 1) break; fputs(buffer, fout); } fprintf(fout, " `required_%s` bit(1) default NULL\n", last_sql_update[i]); while(fgets(buffer, MAX_BUF, fin)) fputs(buffer, fout); fclose(fin); fclose(fout); remove(tmp_file); snprintf(cmd, MAX_CMD, "git add %s", old_file); system_switch_index(cmd); } return true; }
void MergingSearcher::update(ExecutionState *current, const std::set<ExecutionState*> &addedStates, const std::set<ExecutionState*> &removedStates) { if (!removedStates.empty()) { std::set<ExecutionState *> alt = removedStates; for (std::set<ExecutionState*>::const_iterator it = removedStates.begin(), ie = removedStates.end(); it != ie; ++it) { ExecutionState *es = *it; std::set<ExecutionState*>::const_iterator it2 = statesAtMerge.find(es); if (it2 != statesAtMerge.end()) { statesAtMerge.erase(it2); alt.erase(alt.find(es)); } } baseSearcher->update(current, addedStates, alt); } else { baseSearcher->update(current, addedStates, removedStates); } }
TEST_P(FormatWriterTest, PixelTypesByCodec) { const PixelType::value_map_type& pv = PixelType::values(); std::set<ome::xml::model::enums::PixelType> all_pixel_types; for (PixelType::value_map_type::const_iterator i = pv.begin(); i != pv.end(); ++i) all_pixel_types.insert(i->first); std::set<ome::xml::model::enums::PixelType> default_pixel_types; for (PixelType::value_map_type::const_iterator i = pv.begin(); i != pv.end(); ++i) { if (i->first != PixelType::INT16 && i->first != PixelType::DOUBLE && i->first != PixelType::COMPLEXDOUBLE && i->first != PixelType::BIT) default_pixel_types.insert(i->first); } const std::set<ome::xml::model::enums::PixelType> dpt = w.getPixelTypes("default"); EXPECT_EQ(default_pixel_types, dpt); const std::set<ome::xml::model::enums::PixelType> lzw = w.getPixelTypes("lzw"); EXPECT_EQ(all_pixel_types, lzw); std::set<ome::xml::model::enums::PixelType> rle_pixel_types; rle_pixel_types.insert(PixelType::BIT); const std::set<ome::xml::model::enums::PixelType> rle = w.getPixelTypes("rle"); EXPECT_EQ(rle_pixel_types, rle); std::set<ome::xml::model::enums::PixelType> test_8bit_pixel_types; test_8bit_pixel_types.insert(PixelType::INT8); test_8bit_pixel_types.insert(PixelType::UINT8); const std::set<ome::xml::model::enums::PixelType> test_8bit = w.getPixelTypes("test-8bit-only"); EXPECT_EQ(test_8bit_pixel_types, test_8bit); const std::set<ome::xml::model::enums::PixelType> ipt = w.getPixelTypes("invalid"); EXPECT_TRUE(ipt.empty()); }
bool summarize(OTCLI & otCLI) override { if (pruneInpTreesNotSynth) { return true; } assert(synthTree != nullptr && !includedNodes.empty()); std::set<NodeWithSplits *> toPrune; for (auto nd : iter_node(*synthTree)) { const NodeWithSplits * c = const_cast<const NodeWithSplits *>(nd); if ((!contains(includedNodes, c)) && contains(includedNodes, c->getParent())) { toPrune.insert(nd); } } for (auto nd : toPrune) { pruneAndDelete(*synthTree, nd); } writeTreeAsNewick(otCLI.out, *synthTree); otCLI.out << '\n'; return numErrors == 0; }
void Data<Annotation>::set_intersection( std::set<Data<Annotation> *> & result_, const std::set<Data<Annotation> *> & datas_1_, const std::set<Data<Annotation> *> & datas_2_ ) { assert(result_.empty()); // FIXME currently: same symbol => same data std::vector<Data<Annotation> *> datas_1(datas_1_.begin(), datas_1_.end()); std::vector<Data<Annotation> *> datas_2(datas_2_.begin(), datas_2_.end()); std::vector<Data<Annotation> *> result(std::min(datas_1.size(), datas_2.size())); std::sort(datas_1.begin(), datas_1.end(), less); std::sort(datas_2.begin(), datas_2.end(), less); typename std::vector<Data<Annotation> *>::iterator it_result_begin = result.begin(); typename std::vector<Data<Annotation> *>::iterator it_result_end = std::set_intersection(datas_1.begin(), datas_1.end(), datas_2.begin(), datas_2.end(), it_result_begin, less); result_.insert(it_result_begin, it_result_end); }
void SVLocus:: eraseNodes( const std::set<NodeIndexType>& nodes, flyweight_observer_t* obs) { if (nodes.empty()) return; if (size() == nodes.size()) { // if the whole locus is being erased, this is more efficient: clear(obs); return; } // partial deletion must be done in descending order: BOOST_REVERSE_FOREACH(const NodeIndexType nodeIndex, nodes) { eraseNode(nodeIndex, obs); }
///////////////////////////////////////////////////////////////////////////// // methods ///////////////////////////////////////////////////////////////////////////// bool initialize(kdsplit_strategy<value_t> const& split_strategy, std::set<contour_segment_ptr> const& segments) { if (segments.empty()) { root = std::make_shared<kdnode2d<value_t>>(bbox_type(), 0, 0, 0, 0, segments, nullptr, nullptr, nullptr); return false; } else { // gather bbox information bbox = (*segments.begin())->bbox(); for (auto const& segment : segments) { bbox.merge(segment->bbox()); } // create root root = std::make_shared<kdnode2d<value_t>>(bbox, 0, 0, 0, 0, segments, nullptr, nullptr, nullptr); bool success = split_strategy.generate(*this); root->determine_parity(segments); return success; } }
void ExtractAllMaps(std::set<uint32>& mapIds, uint32 threads, bool debug) { DBC* dbc = MPQHandler->GetDBC("Map"); for (std::vector<Record*>::iterator itr = dbc->Records.begin(); itr != dbc->Records.end(); ++itr) { uint32 mapId = (*itr)->Values[0]; // Skip this map if a list of specific maps was provided and this one is not contained in it. if (!mapIds.empty() && mapIds.find(mapId) == mapIds.end()) continue; std::string name = (*itr)->GetString(1); WDT wdt("World\\maps\\" + name + "\\" + name + ".wdt"); if (!wdt.IsValid || wdt.IsGlobalModel) continue; printf("Building %s MapId %u\n", name.c_str(), mapId); ContinentBuilder builder(name, mapId, &wdt, threads); builder.Build(debug); } }
actor_addr remote_actor_impl(std::set<std::string> ifs, std::string host, uint16_t port) { auto mm = get_middleman_actor(); actor_addr result; scoped_actor self; self->sync_send(mm, connect_atom::value, std::move(host), port).await( [&](ok_atom, const node_id&, actor_addr res, std::set<std::string>& xs) { if (!res) throw network_error("no actor published at given port"); if (! (xs.empty() && ifs.empty()) && ! std::includes(xs.begin(), xs.end(), ifs.begin(), ifs.end())) throw network_error("expected signature does not " "comply to found signature"); result = std::move(res); }, [&](error_atom, std::string& msg) { throw network_error(std::move(msg)); } ); return result; }
void AssFile::Sort(EntryList<AssDialogue> &lst, CompFunc comp, std::set<AssDialogue*> const& limit) { if (limit.empty()) { lst.sort(comp); return; } // Sort each selected block separately, leaving everything else untouched for (auto begin = lst.begin(); begin != lst.end(); ++begin) { if (!limit.count(&*begin)) continue; auto end = begin; while (end != lst.end() && limit.count(&*end)) ++end; // sort doesn't support only sorting a sublist, so move them to a temp list EntryList<AssDialogue> tmp; tmp.splice(tmp.begin(), lst, begin, end); tmp.sort(comp); lst.splice(end, tmp); begin = --end; } }
bool CAudioLibrary::CheckForAdditionalProperties(const CVariant &properties, const std::set<std::string> &checkProperties, std::set<std::string> &foundProperties) { if (!properties.isArray() || properties.empty()) return false; std::set<std::string> checkingProperties = checkProperties; for (CVariant::const_iterator_array itr = properties.begin_array(); itr != properties.end_array() && !checkingProperties.empty(); itr++) { if (!itr->isString()) continue; std::string property = itr->asString(); if (checkingProperties.find(property) != checkingProperties.end()) { checkingProperties.erase(property); foundProperties.insert(property); } } return !foundProperties.empty(); }
void MyRecycleThread::run() { while(!isFini()) { checkQueue(); if (!taskSet.empty()) { std::set<MySockTask *>::iterator iter = taskSet.begin(); for (; iter != taskSet.end(); ++iter) { if (NULL != *iter) { MySockTaskManager::getInstance().removeTask(*iter); delete *iter; } } taskSet.clear(); } usleep(10*1000); } }
Glib::ustring SimulOutSetsAdapterModelImpl::getStringListFromStringSet( std::set<std::string> Vect) { Glib::ustring Str = ""; if (!Vect.empty()) Str = *Vect.begin(); if (Vect.size() > 1) { std::set<std::string>::iterator it = Vect.begin(); it++; while (it != Vect.end()) { Str += Glib::ustring::compose(";%1", *it); ++it; } } return Str; }
void Endpoint::OnConfigLoaded(void) { DynamicObject::OnConfigLoaded(); BOOST_FOREACH(const Zone::Ptr& zone, DynamicType::GetObjectsByType<Zone>()) { const std::set<Endpoint::Ptr> members = zone->GetEndpoints(); if (members.empty()) continue; if (members.find(GetSelf()) != members.end()) { if (m_Zone) BOOST_THROW_EXCEPTION(std::runtime_error("Endpoint '" + GetName() + "' is in more than one zone.")); m_Zone = zone; } } if (!m_Zone) BOOST_THROW_EXCEPTION(std::runtime_error("Endpoint '" + GetName() + "' does not belong to a zone.")); }
/** * Performs "give inventory" operations for provided avatars. * * Sends one requests to give all selected inventory items for each passed avatar. * Avatars are represent by two vectors: names and UUIDs which must be sychronized with each other. * * @param avatar_names - avatar names request to be sent. * @param avatar_uuids - avatar names request to be sent. */ static void give_inventory(const uuid_vec_t& avatar_uuids, const std::vector<LLAvatarName> avatar_names) { llassert(avatar_names.size() == avatar_uuids.size()); const std::set<LLUUID> inventory_selected_uuids = LLAvatarActions::getInventorySelectedUUIDs(); if (inventory_selected_uuids.empty()) { return; } std::string residents; LLAvatarActions::buildResidentsString(avatar_names, residents); std::string items; build_items_string(inventory_selected_uuids, items); int folders_count = 0; std::set<LLUUID>::const_iterator it = inventory_selected_uuids.begin(); //traverse through selected inventory items and count folders among them for ( ; it != inventory_selected_uuids.end() && folders_count <=1 ; ++it) { LLViewerInventoryCategory* inv_cat = gInventory.getCategory(*it); if (NULL != inv_cat) { folders_count++; } } // EXP-1599 // In case of sharing multiple folders, make the confirmation // dialog contain a warning that only one folder can be shared at a time. std::string notification = (folders_count > 1) ? "ShareFolderConfirmation" : "ShareItemsConfirmation"; LLSD substitutions; substitutions["RESIDENTS"] = residents; substitutions["ITEMS"] = items; LLShareInfo::instance().mAvatarNames = avatar_names; LLShareInfo::instance().mAvatarUuids = avatar_uuids; LLNotificationsUtil::add(notification, substitutions, LLSD(), &give_inventory_cb); }