QList<QString> QgsGraduatedSymbolRendererV2::usedAttributes()
{
QSet<QString> attributes;
// mAttrName can contain either attribute name or an expression.
// Sometimes it is not possible to distinguish between those two,
// e.g. "a - b" can be both a valid attribute name or expression.
// Since we do not have access to fields here, try both options.
attributes << mAttrName;
QgsExpression testExpr( mAttrName );
if ( !testExpr.hasParserError() )
attributes.unite( testExpr.referencedColumns().toSet() );
if ( mRotation.data() ) attributes.unite( mRotation->referencedColumns().toSet() );
if ( mSizeScale.data() ) attributes.unite( mSizeScale->referencedColumns().toSet() );
QgsRangeList::const_iterator range_it = mRanges.constBegin();
for ( ; range_it != mRanges.constEnd(); ++range_it )
{
QgsSymbolV2* symbol = range_it->symbol();
if ( symbol )
{
attributes.unite( symbol->usedAttributes() );
}
}
return attributes.toList();
}
void ServerModeReader::generateProjectTree(CMakeListsNode *root,
const QList<const FileNode *> &allFiles)
{
// Split up cmake inputs into useful chunks:
QList<FileNode *> cmakeFilesSource;
QList<FileNode *> cmakeFilesBuild;
QList<FileNode *> cmakeFilesOther;
QList<FileNode *> cmakeLists;
foreach (FileNode *fn, m_cmakeInputsFileNodes) {
const FileName path = fn->filePath();
if (path.fileName().compare("CMakeLists.txt", HostOsInfo::fileNameCaseSensitivity()) == 0)
cmakeLists.append(fn);
else if (path.isChildOf(m_parameters.sourceDirectory))
cmakeFilesSource.append(fn);
else if (path.isChildOf(m_parameters.buildDirectory))
cmakeFilesBuild.append(fn);
else
cmakeFilesOther.append(fn);
}
m_cmakeInputsFileNodes.clear(); // Clean out, they are not going to be used anymore!
if (!m_projects.isEmpty())
root->setDisplayName(m_projects.at(0)->name);
QSet<Node *> usedNodes;
usedNodes.insert(updateCMakeInputs(root, m_parameters.sourceDirectory, m_parameters.buildDirectory,
cmakeFilesSource, cmakeFilesBuild, cmakeFilesOther));
usedNodes.unite(updateCMakeLists(root, cmakeLists));
usedNodes.unite(updateProjects(root, m_projects, allFiles));
// Trim out unused nodes:
root->trim(usedNodes);
}
void TcpPortsGathererPrivate::updateWin()
{
#ifdef Q_OS_WIN
QSet<int> ports;
if (protocol == QAbstractSocket::IPv4Protocol) {
ports.unite(usedTcpPorts<MIB_TCPTABLE>(GetTcpTable));
} else {
//Dynamically load symbol for GetTcp6Table for systems that dont have support for IPV6,
//eg Windows XP
typedef ULONG (__stdcall *GetTcp6TablePtr)(PMIB_TCP6TABLE, PULONG, BOOL);
static GetTcp6TablePtr getTcp6TablePtr = 0;
if (!getTcp6TablePtr)
getTcp6TablePtr = (GetTcp6TablePtr)QLibrary::resolve(QLatin1String("Iphlpapi.dll"),
"GetTcp6Table");
if (getTcp6TablePtr && (protocol == QAbstractSocket::IPv6Protocol)) {
ports.unite(usedTcpPorts<MIB_TCP6TABLE>(getTcp6TablePtr));
} else if (protocol == QAbstractSocket::UnknownNetworkLayerProtocol) {
ports.unite(usedTcpPorts<MIB_TCPTABLE>(GetTcpTable));
if (getTcp6TablePtr)
ports.unite(usedTcpPorts<MIB_TCP6TABLE>(getTcp6TablePtr));
}
}
foreach (int port, ports)
usedPorts.insert(port);
#endif
Q_UNUSED(protocol);
}
void TcpPortsGathererPrivate::updateWin(TcpPortsGatherer::ProtocolFlags protocolFlags)
{
#ifdef Q_OS_WIN
QSet<int> ports;
if (protocolFlags & TcpPortsGatherer::IPv4Protocol)
ports.unite(usedTcpPorts<MIB_TCPTABLE>(GetTcpTable));
//Dynamically load symbol for GetTcp6Table for systems that dont have support for IPV6,
//eg Windows XP
typedef ULONG (__stdcall *GetTcp6TablePtr)(PMIB_TCP6TABLE, PULONG, BOOL);
static GetTcp6TablePtr getTcp6TablePtr = 0;
if (!getTcp6TablePtr)
getTcp6TablePtr = (GetTcp6TablePtr)QLibrary::resolve(QLatin1String("Iphlpapi.dll"),
"GetTcp6Table");
if (getTcp6TablePtr && (protocolFlags & TcpPortsGatherer::IPv6Protocol))
ports.unite(usedTcpPorts<MIB_TCP6TABLE>(getTcp6TablePtr));
foreach (int port, ports) {
if (!usedPorts.contains(port))
usedPorts.addPort(port);
}
#endif
Q_UNUSED(protocolFlags);
}
QSet<XsdElement::Ptr> collectAllElements(const XsdSchema::Ptr &schema)
{
QSet<XsdElement::Ptr> elements;
// collect global elements
const XsdElement::List elementList = schema->elements();
for (int i = 0; i < elementList.count(); ++i)
elements.insert(elementList.at(i));
// collect all elements from global groups
const XsdModelGroup::List groupList = schema->elementGroups();
for (int i = 0; i < groupList.count(); ++i) {
const XsdModelGroup::Ptr group(groupList.at(i));
for (int j = 0; j < group->particles().count(); ++j)
elements.unite(collectAllElements(group->particles().at(j)));
}
// collect all elements from complex type definitions
SchemaType::List types;
types << schema->types() << schema->anonymousTypes();
for (int i = 0; i < types.count(); ++i) {
if (types.at(i)->isComplexType() && types.at(i)->isDefinedBySchema()) {
const XsdComplexType::Ptr complexType(types.at(i));
if (complexType->contentType()->particle())
elements.unite(collectAllElements(complexType->contentType()->particle()));
}
}
return elements;
}
QList<QString> QgsSingleSymbolRendererV2::usedAttributes()
{
QSet<QString> attributes;
if ( mSymbol.data() ) attributes.unite( mSymbol->usedAttributes() );
if ( mRotation.data() ) attributes.unite( mRotation->referencedColumns().toSet() );
if ( mSizeScale.data() ) attributes.unite( mSizeScale->referencedColumns().toSet() );
return attributes.toList();
}
void AutoProfileWatcher::clearProfileAssignments()
{
QSet<AutoProfileInfo*> terminateProfiles;
QListIterator<QList<AutoProfileInfo*> > iterDelete(appProfileAssignments.values());
while (iterDelete.hasNext())
{
QList<AutoProfileInfo*> templist = iterDelete.next();
terminateProfiles.unite(templist.toSet());
}
appProfileAssignments.clear();
QListIterator<QList<AutoProfileInfo*> > iterClassDelete(windowClassProfileAssignments.values());
while (iterClassDelete.hasNext())
{
QList<AutoProfileInfo*> templist = iterClassDelete.next();
terminateProfiles.unite(templist.toSet());
}
windowClassProfileAssignments.clear();
QListIterator<QList<AutoProfileInfo*> > iterNameDelete(windowNameProfileAssignments.values());
while (iterNameDelete.hasNext())
{
QList<AutoProfileInfo*> templist = iterNameDelete.next();
terminateProfiles.unite(templist.toSet());
}
windowNameProfileAssignments.clear();
QSetIterator<AutoProfileInfo*> iterTerminate(terminateProfiles);
while (iterTerminate.hasNext())
{
AutoProfileInfo *info = iterTerminate.next();
if (info)
{
delete info;
info = 0;
}
}
QListIterator<AutoProfileInfo*> iterDefaultsDelete(defaultProfileAssignments.values());
while (iterDefaultsDelete.hasNext())
{
AutoProfileInfo *info = iterDefaultsDelete.next();
if (info)
{
delete info;
info = 0;
}
}
defaultProfileAssignments.clear();
allDefaultInfo = 0;
guidSet.clear();
}
QList<QString> QgsRuleBasedRendererV2::usedAttributes()
{
QSet<QString> attrs;
for ( QList<Rule>::iterator it = mRules.begin(); it != mRules.end(); ++it )
{
Rule& rule = *it;
attrs.unite( rule.needsFields().toSet() );
if ( rule.symbol() )
{
attrs.unite( rule.symbol()->usedAttributes() );
}
}
return attrs.values();
}
QSet<QString> QgsPointClusterRenderer::usedAttributes() const
{
QSet<QString> attr = QgsPointDistanceRenderer::usedAttributes();
if ( mClusterSymbol )
attr.unite( mClusterSymbol->usedAttributes() );
return attr;
}
void WordMatchSearchImpl::query(const QString &req, QVector<Service::Item *> *res) const
{
QSet<Service::Item*>* resSet = nullptr;
QStringList words = req.split(' ', QString::SkipEmptyParts);
// Quit if there are no words in query
if (words.empty())
return;
for (QString &w : words)
{
InvertedIndex::const_iterator lb, ub;
lb = std::lower_bound (_invertedIndex.cbegin(), _invertedIndex.cend(), w, CaseInsensitiveCompare());
ub = std::upper_bound (_invertedIndex.cbegin(), _invertedIndex.cend(), w, CaseInsensitiveComparePrefix());
QSet<Service::Item*> tmpSet;
while (lb!=ub)
tmpSet.unite(lb++->second);
if (resSet == nullptr)
resSet = new QSet<Service::Item*>(tmpSet);
else
resSet->intersect(tmpSet);
}
if (resSet != nullptr) {
for (Service::Item *s : *resSet)
res->append(s);
delete resSet;
}
}
QSet<QString> QgsSingleSymbolRenderer::usedAttributes( const QgsRenderContext &context ) const
{
QSet<QString> attributes;
if ( mSymbol )
attributes.unite( mSymbol->usedAttributes( context ) );
return attributes;
}
QSet<QString> QgsPointDisplacementRenderer::usedAttributes( const QgsRenderContext &context ) const
{
QSet<QString> attr = QgsPointDistanceRenderer::usedAttributes( context );
if ( mCenterSymbol )
attr.unite( mCenterSymbol->usedAttributes( context ) );
return attr;
}
bool QgsVectorLayerDiagramProvider::prepare( const QgsRenderContext& context, QSet<QString>& attributeNames )
{
QgsDiagramLayerSettings& s2 = mSettings;
const QgsMapSettings& mapSettings = mEngine->mapSettings();
if ( mapSettings.hasCrsTransformEnabled() )
{
if ( context.coordinateTransform().isValid() )
// this is context for layer rendering - use its CT as it includes correct datum transform
s2.setCoordinateTransform( context.coordinateTransform() );
else
// otherwise fall back to creating our own CT - this one may not have the correct datum transform!
s2.setCoordinateTransform( QgsCoordinateTransform( mLayerCrs, mapSettings.destinationCrs() ) );
}
else
{
s2.setCoordinateTransform( QgsCoordinateTransform() );
}
s2.setRenderer( mDiagRenderer );
//add attributes needed by the diagram renderer
attributeNames.unite( s2.referencedFields( context.expressionContext(), mFields ) );
return true;
}
QSet<Core::Id> ServerModeReader::updateCodeModel(CppTools::ProjectPartBuilder &ppBuilder)
{
QSet<Core::Id> languages;
int counter = 0;
foreach (const FileGroup *fg, m_fileGroups) {
++counter;
const QString defineArg
= transform(fg->defines, [](const QString &s) -> QString {
QString result = QString::fromLatin1("#define ") + s;
int assignIndex = result.indexOf('=');
if (assignIndex != -1)
result[assignIndex] = ' ';
return result;
}).join('\n');
const QStringList flags = QtcProcess::splitArgs(fg->compileFlags);
const QStringList includes = transform(fg->includePaths, [](const IncludePath *ip) {
return ip->path.toString();
});
ppBuilder.setProjectFile(fg->target->sourceDirectory.toString());
ppBuilder.setDisplayName(fg->target->name + QString::number(counter));
ppBuilder.setDefines(defineArg.toUtf8());
ppBuilder.setIncludePaths(includes);
ppBuilder.setCFlags(flags);
ppBuilder.setCxxFlags(flags);
languages.unite(QSet<Core::Id>::fromList(ppBuilder.createProjectPartsForFiles(transform(fg->sources, &FileName::toString))));
}
QSet<RPropertyTypeId> RBlockReferenceEntity::getPropertyTypeIds() const {
QSet<RPropertyTypeId> ret;
// TODO: move to RObject?
// add attribute tag / values as properties of the block reference:
const RDocument* doc = getDocument();
if (doc!=NULL) {
QSet<REntity::Id> childIds = doc->queryChildEntities(getId(), RS::EntityAttribute);
QSet<REntity::Id>::iterator it;
for (it=childIds.begin(); it!=childIds.end(); it++) {
REntity::Id childId = *it;
QSharedPointer<REntity> child = doc->queryEntityDirect(childId);
if (child.isNull()) {
continue;
}
QSet<RPropertyTypeId> childProperties = child->getPropertyTypeIds();
QSet<RPropertyTypeId>::iterator it2;
for (it2=childProperties.begin(); it2!=childProperties.end(); it2++) {
RPropertyTypeId pid = *it2;
QPair<QVariant, RPropertyAttributes> p = child->getProperty(pid);
if (p.second.isVisibleToParent()) {
pid.setId(RPropertyTypeId::INVALID_ID);
ret.insert(pid);
//qDebug() << pid.getCustomPropertyTitle() << " / " << pid.getCustomPropertyName();
//qDebug() << p.first.toString();
}
}
}
}
ret.unite(REntity::getPropertyTypeIds());
return ret;
}
QSet<QString> allKnownSet()
{
QSet<QString> set;
set << "WantHelp" << "Help+" << "HelpHidden" << "FirstTimeForInst";
set.unite(availPublicSet());
return set;
}
QSet<QString> QgsMarkerLineSymbolLayerV2::usedAttributes() const
{
QSet<QString> attr = QgsLineSymbolLayerV2::usedAttributes();
if ( mMarker )
attr.unite( mMarker->usedAttributes() );
return attr;
}
QList<QString> QgsGraduatedSymbolRendererV2::usedAttributes()
{
QSet<QString> attributes;
attributes.insert( mAttrName );
if ( !mRotationField.isEmpty() )
{
attributes.insert( mRotationField );
}
if ( !mSizeScaleField.isEmpty() )
{
attributes.insert( mSizeScaleField );
}
QgsSymbolV2* symbol = 0;
QgsRangeList::const_iterator range_it = mRanges.constBegin();
for ( ; range_it != mRanges.constEnd(); ++range_it )
{
symbol = range_it->symbol();
if ( symbol )
{
attributes.unite( symbol->usedAttributes() );
}
}
return attributes.toList();
}
void DataVizAdapter::updateLabels()
{
// Generate rows and row labels (use minute resolution)
QSet<qint64> rowKeys;
for ( const auto& tvm : qAsConst(_tvms) )
rowKeys.unite(QSet<qint64>::fromList(tvm->getMap().keys()));
updateLabels( rowKeys );
}
QSet<QString> QgsArrowSymbolLayer::usedAttributes() const
{
QSet<QString> attributes = QgsLineSymbolLayerV2::usedAttributes();
attributes.unite( mSymbol->usedAttributes() );
return attributes;
}
QList<kint> VertexBuffer::mergeVerticesIndices(const QList<kint>& v1, const QList<kint>& v2) const
{
QSet<kint> set = QSet<kint>::fromList(v1);
set.unite(QSet<kint>::fromList(v2));
QList<kint> result = set.values();
qSort(result);
return result;
}
QSet<QString> Tag::allFiles() {
int childQuantity = this->children_.size();
QSet<QString> uniqueFiles = this->files_;
for(int i = 0; i < childQuantity; ++i) {
uniqueFiles = uniqueFiles.unite(this->children_[i]->allFiles());
}
return uniqueFiles;
}
QStringList QbsProject::files(Project::FilesMode fileMode) const
{
Q_UNUSED(fileMode);
if (!m_qbsProject.isValid() || isParsing())
return QStringList();
QSet<QString> result;
collectFilesForProject(m_projectData, result);
result.unite(m_qbsProject.buildSystemFiles());
return result.toList();
}
QSet<QString> KateHlKeyword::allKeywords() const
{
QSet<QString> result;
foreach (const QSet<QString>* v, dict) {
if (!v) {
continue;
}
result.unite(*v);
}
return result;
}
QSet<QString> suffixesForMimeTypes(const QStringList &mimeTypes)
{
initializeFormatForMimeType();
QSet<QString> formats;
foreach (const QString &mimeType, mimeTypes)
formats.unite(formatForMimeType.value(mimeType));
if (mimeTypes.count() && mimeTypes.at(0).startsWith("audio/")) {
// TWEAK: Supported audio formats that are not reported as such:
formats.insert("wav");
}
return formats;
}
/**
* Fills up the parent sync file with all the content of folders in the folder action group.
* Recursively calls itself when finds a folder.
*/
void SyncAction::createSyncFileFromFolders(SyncFile * parent, FolderActionGroup * f*g)
{
QSet<QString> entries;
for (int i = 0; i < f*g->count(); ++i) {
//Creating a set of all file names ---------------------------------
QDir sync_dir(f*g->at(i));
if (!sync_dir.exists()) continue;
entries.unite(sync_dir.entryList(exception_bundle->filters(), static_cast<QDir::Filter>(dir_filters), (QDir::Name | QDir::DirsFirst | QDir::IgnoreCase)).toSet());
}
QFileInfo fi;
FolderActionGroup * child_dirs_fag = NULL;
SyncFile * sf = NULL;
foreach (QString entry, entries) {
if (exception_bundle->cdAndCheck(entry)) { // +++ Blacklisted +++
skipped_count++;
}
else { // +++ Not in blacklist +++
sf = parent->addChild(entry);
for (int n = 0; n < f*g->count(); ++n) {
// Obtaining absolute paths for the file names ---------------------
fi.setFile(QDir(f*g->at(n)).absoluteFilePath(entry));
if (fi.exists()) {
if (fi.isDir()) {
sf->setDir(true);
if (!child_dirs_fag) child_dirs_fag = new FolderActionGroup;
child_dirs_fag->insert(f*g->idAt(n), fi.absoluteFilePath());
}
sf->addFolder(f*g->idAt(n));
}
}
//sf->setBlacklisted(exception_bundle->isInBlacklist());
if (child_dirs_fag) {
createSyncFileFromFolders(sf, child_dirs_fag);
delete child_dirs_fag; child_dirs_fag = NULL;
}
}
exception_bundle->cdUp();
}
f*g = NULL;
}
QStringList QbsProject::files(Project::FilesMode fileMode) const
{
Q_UNUSED(fileMode);
qCDebug(qbsPmLog) << Q_FUNC_INFO << m_qbsProject.isValid() << isParsing();
if (!m_qbsProject.isValid() || isParsing())
return QStringList();
QSet<QString> result;
collectFilesForProject(m_projectData, result);
result.unite(m_qbsProject.buildSystemFiles());
qCDebug(qbsPmLog) << "file count:" << result.count();
return result.toList();
}
void QGeoCameraTilesPrivate::updateGeometry(double viewExpansion)
{
// Find the frustum from the camera / screen / viewport information
// The larger frustum when stationary is a form of prefetching
Frustum f = frustum(viewExpansion);
// Find the polygon where the frustum intersects the plane of the map
Polygon footprint = frustumFootprint(f);
// Clip the polygon to the map, split it up if it cross the dateline
QPair<Polygon, Polygon> polygons = clipFootprintToMap(footprint);
if (!polygons.first.isEmpty()) {
QSet<QGeoTileSpec> tilesLeft = tilesFromPolygon(polygons.first);
tiles_.unite(tilesLeft);
}
if (!polygons.second.isEmpty()) {
QSet<QGeoTileSpec> tilesRight = tilesFromPolygon(polygons.second);
tiles_.unite(tilesRight);
}
}
QSet<QString> QgsSymbolV2::usedAttributes() const
{
QSet<QString> attributes;
QgsSymbolLayerV2List::const_iterator sIt = mLayers.constBegin();
for ( ; sIt != mLayers.constEnd(); ++sIt )
{
if ( *sIt )
{
attributes.unite(( *sIt )->usedAttributes() );
}
}
return attributes;
}
void EntitySimulation::updateEntities(QSet<EntityItem*>& entitiesToDelete) {
quint64 now = usecTimestampNow();
// these methods may accumulate entries in _entitiesToBeDeleted
expireMortalEntities(now);
callUpdateOnEntitiesThatNeedIt(now);
updateEntitiesInternal(now);
sortEntitiesThatMoved();
// at this point we harvest _entitiesToBeDeleted
entitiesToDelete.unite(_entitiesToDelete);
_entitiesToDelete.clear();
}
