StringVector getDirListing(const std::string& dir) { StringVector tmpList = enumerateFiles(dir); // now filter the list to only keep dirs StringVector list; for (StringVector::iterator it = tmpList.begin(); it != tmpList.end(); ++it) { if (isDirectory(*it)) list.push_back(*it); } return list; }
virtual void GetParams(Session& ses, const string & id) { ServerInstanceInfo inst(Name, id); TeamFortress2Config conf(inst); StringVector maps; GetMaps( inst, maps ); ses.BuildSelect( maps.begin(), maps.end(), "map" ); ses.NewNode( "map", inst.GetParam( "map" ) ); BuildRegionsSelect( ses ); conf.ConfToSes(ses); }
//----------------------------------------------------------------------- void CgProgram::buildArgs(void) { StringVector args; if (!mCompileArgs.empty()) args = StringUtil::split(mCompileArgs); StringVector::const_iterator i; if (mSelectedCgProfile == CG_PROFILE_VS_1_1) { // Need the 'dcls' argument whenever we use this profile // otherwise compilation of the assembler will fail bool dclsFound = false; for (i = args.begin(); i != args.end(); ++i) { if (*i == "dcls") { dclsFound = true; break; } } if (!dclsFound) { args.push_back("-profileopts"); args.push_back("dcls"); } } // Now split args into that god-awful char** that Cg insists on freeCgArgs(); mCgArguments = new char*[args.size() + 1]; int index = 0; for (i = args.begin(); i != args.end(); ++i, ++index) { mCgArguments[index] = new char[i->length() + 1]; strcpy(mCgArguments[index], i->c_str()); } // Null terminate list mCgArguments[index] = 0; }
EStatusCode Type1ToCFFEmbeddedFontWriter::WriteCharStrings(const StringVector& inSubsetGlyphIDs) { /* 1. build the charstrings data, looping the glyphs charstrings and writing a flattened version of each charstring 2. write the charstring index based on offsets inside the data (size should be according to the max) 3. copy the data into the stream */ unsigned long* offsets = new unsigned long[inSubsetGlyphIDs.size() + 1]; MyStringBuf charStringsData; OutputStringBufferStream charStringsDataWriteStream(&charStringsData); Type1ToType2Converter charStringConverter; StringVector::const_iterator itGlyphs = inSubsetGlyphIDs.begin(); EStatusCode status = PDFHummus::eSuccess; do { unsigned short i=0; for(; itGlyphs != inSubsetGlyphIDs.end() && PDFHummus::eSuccess == status; ++itGlyphs,++i) { offsets[i] = (unsigned long)charStringsDataWriteStream.GetCurrentPosition(); status = charStringConverter.WriteConvertedFontProgram(*itGlyphs, &(mType1Input), &charStringsDataWriteStream); } if(status != PDFHummus::eSuccess) break; offsets[i] = (unsigned long)charStringsDataWriteStream.GetCurrentPosition(); charStringsData.pubseekoff(0,std::ios_base::beg); // write index section mCharStringPosition = mFontFileStream.GetCurrentPosition(); Byte sizeOfOffset = GetMostCompressedOffsetSize(offsets[i] + 1); mPrimitivesWriter.WriteCard16((unsigned short)inSubsetGlyphIDs.size()); mPrimitivesWriter.WriteOffSize(sizeOfOffset); mPrimitivesWriter.SetOffSize(sizeOfOffset); for(i=0;i<=inSubsetGlyphIDs.size();++i) mPrimitivesWriter.WriteOffset(offsets[i] + 1); // Write data InputStringBufferStream charStringsDataReadStream(&charStringsData); OutputStreamTraits streamCopier(&mFontFileStream); status = streamCopier.CopyToOutputStream(&charStringsDataReadStream); }while(false); delete[] offsets; return status; }
// Break a contig into a lexicographically ordered set of kmers StringVector MetAssemble::getLexicographicKmers(const std::string& contig) const { StringVector out; for(size_t i = 0; i < contig.size() - m_parameters.kmer + 1; ++i) { std::string ks = contig.substr(i, m_parameters.kmer); std::string rs = reverseComplement(ks); out.push_back(ks < rs ? ks : rs); } std::sort(out.begin(), out.end()); return out; }
//--------------------------------------------------------------------- void FreeImageCodec::startup(void) { FreeImage_Initialise(false); LogManager::getSingleton().logMessage( LML_NORMAL, "FreeImage version: " + String(FreeImage_GetVersion())); LogManager::getSingleton().logMessage( LML_NORMAL, FreeImage_GetCopyrightMessage()); // Register codecs StringUtil::StrStreamType strExt; strExt << "Supported formats: "; bool first = true; for (int i = 0; i < FreeImage_GetFIFCount(); ++i) { // Skip DDS codec since FreeImage does not have the option // to keep DXT data compressed, we'll use our own codec if ((FREE_IMAGE_FORMAT)i == FIF_DDS) continue; String exts(FreeImage_GetFIFExtensionList((FREE_IMAGE_FORMAT)i)); if (!first) { strExt << ","; } first = false; strExt << exts; // Pull off individual formats (separated by comma by FI) StringVector extsVector = StringUtil::split(exts, ","); for (StringVector::iterator v = extsVector.begin(); v != extsVector.end(); ++v) { ImageCodec* codec = OGRE_NEW FreeImageCodec(*v, i); msCodecList.push_back(codec); Codec::registerCodec(codec); } } LogManager::getSingleton().logMessage( LML_NORMAL, strExt.str()); // Set error handler FreeImage_SetOutputMessage(FreeImageErrorHandler); }
/*----------------------------------------------------------------------------- | Initialize the RT Shader system. -----------------------------------------------------------------------------*/ bool OgreApp::initializeRTShaderSystem(SceneManager* sceneMgr) { if (RTShader::ShaderGenerator::initialize()) { mShaderGenerator = RTShader::ShaderGenerator::getSingletonPtr(); mShaderGenerator->addSceneManager(sceneMgr); // Setup core libraries and shader cache path. StringVector groupVector = ResourceGroupManager::getSingleton().getResourceGroups(); StringVector::iterator itGroup = groupVector.begin(); StringVector::iterator itGroupEnd = groupVector.end(); String shaderCoreLibsPath; String shaderCachePath; for (; itGroup != itGroupEnd; ++itGroup) { ResourceGroupManager::LocationList resLocationsList = ResourceGroupManager::getSingleton().getResourceLocationList(*itGroup); ResourceGroupManager::LocationList::iterator it = resLocationsList.begin(); ResourceGroupManager::LocationList::iterator itEnd = resLocationsList.end(); bool coreLibsFound = false; // Try to find the location of the core shader lib functions and use it // as shader cache path as well - this will reduce the number of generated files // when running from different directories. for (; it != itEnd; ++it) { if ((*it)->archive->getName().find("RTShaderLib") != String::npos) { shaderCoreLibsPath = (*it)->archive->getName() + "/"; shaderCachePath = shaderCoreLibsPath; coreLibsFound = true; break; } } // Core libs path found in the current group. if (coreLibsFound) break; } // Core shader libs not found -> shader generating will fail. if (shaderCoreLibsPath.empty()) return false; // Create and register the material manager listener. mMaterialMgrListener = new ShaderGeneratorTechniqueResolverListener(mShaderGenerator); MaterialManager::getSingleton().addListener(mMaterialMgrListener); } return true; }
int main ( ) { PME regex ( ", " ); int i = regex.split ( "very, very2, tired" ); for ( int j = 0; j < i; j++ ) { printf ( "%s\n", regex [ j ].c_str ( ) ); } StringVector sv = regex.GetStringVector ( ); for ( StringVector::iterator i = sv.begin ( ); i != sv.end ( ); i++ ) { printf ( "%s\n", i->c_str ( ) ); } PME match ( "([a-z])([0-9])([A-Z])" ); match.match ( "b2Z" ); sv = match.GetStringVector ( ); for ( StringVector::iterator i = sv.begin ( ); i != sv.end ( ); i++ ) { printf ( "%s\n", i->c_str ( ) ); } }
bool matches(const std::string& s) const { StringVector tokens; boost::split(tokens, s, boost::is_any_of(" ")); StringVector::const_iterator it; for (it = tokens.begin(); it != tokens.end(); ++it) { if (!boost::icontains(title, *it) && !boost::icontains(artist, *it) && !boost::icontains(album, *it)) { return false; } } return true; }
IpAddress::IpAddress(const char* ip_string) { try { int counter = 0; StringVector vector = Helper::split(ip_string, '.'); for (StringVector::iterator itr = vector.begin(); itr != vector.end(); ++itr) part[counter++] = atoi((*itr).c_str()); } catch (int /*e*/) { setNull(); } }
/*! * Detect the character(s) that is used for marking a line as a comment line. * If such a character is found, it is added to LineCommentStart vector. * Since assembly code counter covers multiple assembly languages, there can be * mulitple markers in the same program. * GNU Assembler, for instance, supports # and ; for comment lines * * \param fmap list of file lines * */ void CAssemblyCounter::FindLineCommentMarker(filemap* fmap) { StringVector markerChecklist; // contains line comment markers that need to be checked/tested markerChecklist.push_back("#"); markerChecklist.push_back(";"); markerChecklist.push_back("|"); LineCommentStart.clear(); // remove all existing values just in case it was set unintentionally /* Algorithm: 1. Read each line a. For each comment marker, find position/index of the marker i. If position is 0, a marker is found 1. Save/add the marker: LineCommentStart.push_back() 2. Remove the marker from the check list ii. If position is > 0 && not last index && (position-1) is a space, a marker is found. 1. Save/add the marker: LineCommentStart.push_back() 2. Remove the marker from the check list */ StringVector::iterator nextMarker; string line; size_t position; for (filemap::iterator fit = fmap->begin(); fit != fmap->end(); fit++) { line = fit->line; nextMarker = markerChecklist.begin(); while (nextMarker != markerChecklist.end()) { position = line.find(*nextMarker); if (position == string::npos) { nextMarker++; continue; } else if (position == 0) { LineCommentStart.push_back(*nextMarker); nextMarker = markerChecklist.erase(nextMarker); } else if (position > 0 && position != (line.length() - 1) && line.at(position - 1) == ' ') { LineCommentStart.push_back(*nextMarker); nextMarker = markerChecklist.erase(nextMarker); } else nextMarker++; } } }
void ScriptsVectorController::directoryChanged(const QString &t_path) { StringVector extsToIgnore; extsToIgnore.push_back("osp"); extsToIgnore.push_back("osp-journal"); extsToIgnore.push_back("db"); extsToIgnore.push_back("db-journal"); StringVector::const_iterator extsToIgnoreBegin = extsToIgnore.begin(); StringVector::const_iterator extsToIgnoreEnd = extsToIgnore.end(); openstudio::path path = openstudio::toPath(t_path); if (!m_fswatcher->directories().contains(toQString(m_path)) && boost::filesystem::exists(m_path)) { m_fswatcher->addPath(openstudio::toQString(m_path)); } if (!m_fswatcher->directories().contains(toQString(m_path.parent_path())) && boost::filesystem::exists(m_path.parent_path())) { m_fswatcher->addPath(openstudio::toQString(m_path.parent_path())); } if (path == m_path) { // ooh, it was us. QStringList files = QDir(openstudio::toQString(m_path)).entryList(QDir::Files, QDir::Name); std::vector<OSItemId> items; for (QStringList::const_iterator itr = files.begin(); itr != files.end(); ++itr) { openstudio::path filePath = openstudio::toPath(*itr); std::string ext = getFileExtension(filePath); if (std::find(extsToIgnoreBegin,extsToIgnoreEnd,ext) == extsToIgnoreEnd) { items.push_back(scriptToItemId(m_path / filePath)); } } m_items = items; std::reverse(m_items.begin(), m_items.end()); emit itemIds(m_items); } else { LOG(Debug, "No match for FS Path: " << openstudio::toString(path) << " " << openstudio::toString(m_path)); } }
bool XMLElement::SetStringVector(const StringVector& value) { if (!RemoveChildren("string")) return false; for (auto i = value.begin(); i != value.end(); ++i) { XMLElement stringElem = CreateChild("string"); if (!stringElem) return false; stringElem.SetAttribute("value", *i); } return true; }
//----------------------------------------------------------------------- String StringConverter::toString(const StringVector& val) { StringStream stream; StringVector::const_iterator i, iend, ibegin; ibegin = val.begin(); iend = val.end(); for (i = ibegin; i != iend; ++i) { if (i != ibegin) stream << " "; stream << *i; } return stream.str(); }
void ModuleLinkerPass::deleteAllSymbolsExceptThese( const StringVector& symbolsToKeep) { StringSet keptSymbols(symbolsToKeep.begin(), symbolsToKeep.end()); auto symbols = getAllSymbols(_linkedModule); for(auto symbol = symbols.begin(); symbol != symbols.end(); ++symbol) { if(keptSymbols.count(*symbol) != 0) continue; removeSymbol(_linkedModule, *symbol); } }
void InitThesList (const CThesaurus* Thes, string ConceptStr, StringVector& Vec) { Vec.clear(); vector<int> LowerTermins; Thes->QueryLowerTermins(ConceptStr.c_str(), morphRussian, LowerTermins); long Count = LowerTermins.size(); for (long i=0; i <Count; i++) { const CInnerTermin& T = Thes->m_Termins[LowerTermins[i]]; string TerminStr = T.m_TerminStr; EngRusMakeUpper(TerminStr); Vec.push_back(TerminStr); }; sort(Vec.begin(),Vec.end()); };
static StringVector getOptimizations(const std::string& optimizationList) { StringVector passes = hydrazine::split(optimizationList, ","); StringVector splitPasses; splitPasses.reserve(passes.size()); for(hydrazine::StringVector::iterator pass = passes.begin(); pass != passes.end(); ++pass) { splitPasses.push_back(hydrazine::strip(*pass, " ")); } return splitPasses; }
void CachedResourceLoader::garbageCollectDocumentResources() { typedef Vector<String, 10> StringVector; StringVector resourcesToDelete; for (DocumentResourceMap::iterator it = m_documentResources.begin(); it != m_documentResources.end(); ++it) { if (it->value->hasOneHandle()) { resourcesToDelete.append(it->key); it->value->setOwningCachedResourceLoader(0); } } for (StringVector::const_iterator it = resourcesToDelete.begin(); it != resourcesToDelete.end(); ++it) m_documentResources.remove(*it); }
inline int FindKey(StringVector colNameList, String item) { int index = -1; int found = 0; for (Rcpp::StringVector::iterator it = colNameList.begin(); it != colNameList.end(); ++it) { if (*it == item) { index = found; break; } ++found; } return index; }
StringVector PME::GetStringVector ( ) { StringVector oStringVector; for ( int nCurrentMatch = 0; nCurrentMatch < nMatches; nCurrentMatch++ ) { oStringVector.insert ( oStringVector.end ( ), (*this)[nCurrentMatch] ); } return oStringVector; }
void ConsoleBackend::addText(std::string text, size_t level) { // split the text on newlines, to aid line counting StringVector lines = StringUtil::split(text, "\r\n"); StringVector::iterator it = lines.begin(); for (;it != lines.end(); it++) { mMessages.push_back(std::make_pair(level, *it)); } // if the size is greater the mTextHistory, remove till sufficient while (mMessages.size() > mTextHistory) mMessages.pop_front(); mChanged = true; }
void OSDoubleEdit::bind(model::ModelObject& modelObject, const char* property, const boost::optional<std::string>& isDefaultedProperty, const boost::optional<std::string>& isAutosizedProperty, const boost::optional<std::string>& isAutocalculatedProperty) { m_modelObject = modelObject; m_property = property; m_isDefaultedProperty = isDefaultedProperty; m_isAutosizedProperty = isAutosizedProperty; m_isAutocalculatedProperty = isAutocalculatedProperty; // only let one of autosize/autocalculate if (isAutosizedProperty && isAutocalculatedProperty) { LOG_AND_THROW("A field can only be autosized or autocalculated, it cannot be both."); } // check for attribute existence StringVector attributeNames = modelObject.attributeNames(); StringVector::const_iterator anb(attributeNames.begin()),ane(attributeNames.end()); BOOST_ASSERT(std::find(anb,ane,m_property) != ane); if (m_isDefaultedProperty) { BOOST_ASSERT(std::find(anb,ane,*m_isDefaultedProperty) != ane); } if (m_isAutosizedProperty) { BOOST_ASSERT(std::find(anb,ane,*m_isAutosizedProperty) != ane); } if (m_isAutocalculatedProperty) { BOOST_ASSERT(std::find(anb,ane,*m_isAutocalculatedProperty) != ane); } setEnabled(true); bool isConnected = false; isConnected = connect( this, SIGNAL(editingFinished()), this, SLOT(onEditingFinished()) ); BOOST_ASSERT(isConnected); isConnected = connect( m_modelObject->getImpl<openstudio::model::detail::ModelObject_Impl>().get(),SIGNAL(onChange()), this,SLOT(onModelObjectChange()) ); BOOST_ASSERT(isConnected); isConnected = connect( m_modelObject->getImpl<openstudio::model::detail::ModelObject_Impl>().get(),SIGNAL(onRemoveFromWorkspace(Handle)), this,SLOT(onModelObjectRemove(Handle)) ); BOOST_ASSERT(isConnected); refreshTextAndLabel(); }
void calculateMetric(CSelectionData *selectionData, const std::string &name, rapidjson::Document &results) { ITestSuiteMetricPlugin *metric = kernel.getTestSuiteMetricPluginManager().getPlugin(name); StringVector dependencies = metric->getDependency(); for (StringVector::iterator it = dependencies.begin(); it != dependencies.end(); it++) { if (metricsCalculated.find(*it) == metricsCalculated.end()) { calculateMetric(selectionData, *it, results); } } (std::cerr << "[INFO] Calculating metrics: " << metric->getName() << " ...").flush(); metric->init(selectionData, &clusterList, revision); metric->calculate(results); metricsCalculated.insert(name); (std::cerr << " done." << std::endl).flush(); }
void MeshCombiner::consoleMeshCombiner() { StringVector vec = m_MeshCombinerConfig->getMultiSetting( "Mesh" ); if( vec.empty() ) return; MergeMesh* mm = new MergeMesh(); SkeletonPtr skel = SkeletonPtr(); for( StringVector::iterator it = vec.begin(); it != vec.end(); ++it ) { log( "Loading: " + *it ); try { MeshPtr mesh = MeshManager::getSingleton().load( *it, ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME ); if( !mesh.isNull() ) mm->addMesh( mesh ); } catch( ... ) { } } // save MeshPtr mesh = mm->bake(); MeshSerializer* meshSerializer = new MeshSerializer(); meshSerializer->exportMesh( mesh.getPointer(), "./media/merged.mesh" ); MeshManager::getSingleton().remove( mesh->getHandle() ); // try to load... mesh = MeshManager::getSingleton().load( "merged.mesh", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME ); SceneManager* sm = Root::getSingleton().createSceneManager( ST_GENERIC ); // try to place... sm->getRootSceneNode()->attachObject( sm->createEntity( "test", "merged.mesh" ) ); delete meshSerializer; delete mm; }
// Garbage collecting m_documentResources is a workaround for the // CachedResourceHandles on the RHS being strong references. Ideally this // would be a weak map, however CachedResourceHandles perform additional // bookkeeping on CachedResources, so instead pseudo-GC them -- when the // reference count reaches 1, m_documentResources is the only reference, so // remove it from the map. void CachedResourceLoader::garbageCollectDocumentResourcesTimerFired(Timer<CachedResourceLoader>* timer) { ASSERT_UNUSED(timer, timer == &m_garbageCollectDocumentResourcesTimer); typedef Vector<String, 10> StringVector; StringVector resourcesToDelete; for (DocumentResourceMap::iterator it = m_documentResources.begin(); it != m_documentResources.end(); ++it) { if (it->second->hasOneHandle()) { resourcesToDelete.append(it->first); it->second->setOwningCachedResourceLoader(0); } } for (StringVector::const_iterator it = resourcesToDelete.begin(); it != resourcesToDelete.end(); ++it) m_documentResources.remove(*it); }
void reportingFrequencyGeneralTests(SqlFile& file, const SqlFileTimeSeriesQueryVector& allQueries) { // list of reporting frequencies from file should match .valueDescriptions() from vector StringSet rfStrs; for (const std::string& envPeriod : file.availableEnvPeriods()) { StringVector rfStrsForEnv = file.availableReportingFrequencies(envPeriod); rfStrs.insert(rfStrsForEnv.begin(),rfStrsForEnv.end()); } ReportingFrequencySet rfSetFromVector = reportingFrequencies(allQueries); StringSet rfStrsFromVector; for (const ReportingFrequency& rf : rfSetFromVector) { rfStrsFromVector.insert(rf.valueDescription()); } EXPECT_TRUE(rfStrs.size() >= rfStrsFromVector.size()); for (const std::string& rfStr : rfStrsFromVector) { EXPECT_TRUE(rfStrs.find(rfStr) != rfStrs.end()); } }
TEST_F(IddFixture, IddFile_EpGroups) { StringVector groups = epIddFile.groups(); EXPECT_TRUE(groups.size() > 0); EXPECT_EQ("",groups[0]); std::stringstream ss; // uniqueness for (StringVector::const_iterator it = groups.begin(), itEnd = groups.end(); it != itEnd; ++it) { auto loc = std::find_if(it+1,itEnd,std::bind(istringEqual,*it,std::placeholders::_1)); EXPECT_TRUE(loc == itEnd); if (loc != itEnd) { LOG(Debug,"The group name '" << *it << "' is repeated in epIddFile."); } ss << " " << *it << std::endl; } // log groups LOG(Info,"The current EnergyPlus IddFile contains the following " << groups.size() << " object groups, including the first, unnamed group: " << std::endl << ss.str()); }
void CertificateChain::DisplaySigningChain(const StringVector& aSigningChain) { if(aSigningChain.size()) { std::vector<std::string>::const_iterator chainIter = aSigningChain.begin(); do { cout << "Issued By : " << (*chainIter) << endl; ++chainIter; cout << "Issued To : " << (*chainIter) << endl; ++chainIter; cout << "Valid From : " << (*chainIter) << endl; ++chainIter; cout << "Valid To : " << (*chainIter) << endl << endl; ++chainIter; }while(chainIter != aSigningChain.end()); } }
void ConfigCenter::loadFromDir(const std::string& path) { logMsg(LOG_DEBUG, "config:reading config file fragments from \'%s\'", path.c_str()); StringVector files; Directory::Iterator::Ptr it = Directory::enumerate(path); while(it->moveNext()) { const std::string fileName = it->fullPath(); if (File::isDir(fileName) || (!File::isRegFile(fileName) && !File::isSymLink(path)))//FIXME:Check exact symlink behaviour; continue; if (fileName.length() < 5 || fileName.substr(fileName.length() - 5) != ".conf") continue; files.push_back(fileName); } std::sort(files.begin(), files.end()); for(StringVector::size_type i = 0;i < files.size();i++) loadFromFile(files[i]); }
bool TestOptimizations::doTest() { typedef std::deque<unsigned int> TestSet; StringVector testVector = enumerateTests(getPTXFiles(path), getOptimizations(optimizations)); status << " Enumerated " << testVector.size() << " tests\n"; TestSet tests; for(auto test = testVector.begin(); test != testVector.end(); ++test) { tests.push_back(std::distance(testVector.begin(), test)); } hydrazine::Timer timer; timer.start(); unsigned int count = 0; for(unsigned int i = 0, e = tests.size(); i != e; ++i) { if(timer.seconds() > timeLimit) break; unsigned int index = random() % tests.size(); TestSet::iterator testPosition = tests.begin() + index; std::string test = testVector[*testPosition]; status << " Running test '" << test << "'\n"; if(!runTest(test)) return false; tests.erase(testPosition); ++count; } status << "Finished running " << count << " tests...\n"; return true; }