void tst_QSet::squeeze()
{
QSet<int> set;
int n = set.capacity();
QVERIFY(n == 0);
set.reserve(1000);
QVERIFY(set.capacity() >= 1000);
set.squeeze();
QVERIFY(set.capacity() < 100);
for (int i = 0; i < 500; ++i)
set.insert(i);
QVERIFY(set.capacity() >= 500 && set.capacity() < 10000);
set.reserve(50000);
QVERIFY(set.capacity() >= 50000);
set.squeeze();
QVERIFY(set.capacity() < 500);
set.remove(499);
QVERIFY(set.capacity() < 500);
set.insert(499);
QVERIFY(set.capacity() >= 500);
for (int i = 0; i < 500; ++i)
set.remove(i);
set.squeeze();
QVERIFY(set.capacity() < 100);
}
/*!
Returns the list of classes of this element.
*/
QStringList QWebElement::classes() const
{
if (!hasAttribute(QLatin1String("class")))
return QStringList();
QStringList classes = attribute(QLatin1String("class")).simplified().split(QLatin1Char(' '), QString::SkipEmptyParts);
#if QT_VERSION >= 0x040500
classes.removeDuplicates();
#else
int n = classes.size();
int j = 0;
QSet<QString> seen;
seen.reserve(n);
for (int i = 0; i < n; ++i) {
const QString& s = classes.at(i);
if (seen.contains(s))
continue;
seen.insert(s);
if (j != i)
classes[j] = s;
++j;
}
if (n != j)
classes.erase(classes.begin() + j, classes.end());
#endif
return classes;
}
bool mergeArraysOfStrings(const QJsonArray &arrayFrom, QJsonArray &arrayTo) {
QJsonArray arrayMerged;
QSet<QString> commonValues;
commonValues.reserve(arrayTo.size() + arrayFrom.size());
int i = 0;
int sizeTo = arrayTo.size();
for (i = 0; i < sizeTo; ++i) {
Q_ASSERT(arrayTo[i].type() == QJsonValue::String);
commonValues.insert(arrayTo[i].toString());
}
int sizeFrom = arrayFrom.size();
for (i = 0; i < sizeFrom; ++i) {
Q_ASSERT(arrayFrom[i].type() == QJsonValue::String);
commonValues.insert(arrayFrom[i].toString());
}
QSet<QString>::iterator begin = commonValues.begin();
QSet<QString>::iterator end = commonValues.end();
for (QSet<QString>::iterator it = begin; it != end; ++it) {
arrayMerged.append(*it);
}
arrayTo = arrayMerged;
return true;
}
QSet<REntity::Id> RMemoryStorage::queryAllEntities(bool undone, bool allBlocks) {
QSet<REntity::Id> result;
result.reserve(entityMap.count());
RBlock::Id currentBlock = getCurrentBlockId();
QHash<REntity::Id, QSharedPointer<REntity> >::iterator it;
for (it = entityMap.begin(); it != entityMap.end(); ++it) {
QSharedPointer<REntity> e = *it;
if (e.isNull()) {
continue;
}
if (!undone && e->isUndone()) {
continue;
}
if (!allBlocks && e->getBlockId() != currentBlock) {
continue;
}
// if (!includeFrozenLayers) {
// RLayer::Id layerId = e->getLayerId();
// QSharedPointer<RLayer> layer = queryLayer(layerId);
// if (!layer.isNull()) {
// if (layer->isFrozen()) {
// continue;
// }
// }
// }
// if (!e.isNull() && (undone || !e->isUndone()) && (allBlocks
// || e->getBlockId() == currentBlock)) {
// result.insert(e->getId());
// }
result.insert(e->getId());
}
return result;
}
void ProjectChangesModel::statusReady(KJob* job)
{
VcsJob* status=static_cast<VcsJob*>(job);
QList<QVariant> states = status->fetchResults().toList();
IProject* project = job->property("project").value<KDevelop::IProject*>();
if(!project)
return;
QSet<QUrl> foundUrls;
foundUrls.reserve(states.size());
foreach(const QVariant& state, states) {
const VcsStatusInfo st = state.value<VcsStatusInfo>();
foundUrls += st.url();
updateState(project, st);
}
QStandardItem* itProject = projectItem(project);
IBasicVersionControl::RecursionMode mode = IBasicVersionControl::RecursionMode(job->property("mode").toInt());
QSet<QUrl> uncertainUrls = urls(itProject).toSet().subtract(foundUrls);
QList<QUrl> sourceUrls = job->property("urls").value<QList<QUrl>>();
foreach(const QUrl& url, sourceUrls) {
if(url.isLocalFile() && QDir(url.toLocalFile()).exists()) {
foreach(const QUrl& currentUrl, uncertainUrls) {
if((mode == IBasicVersionControl::NonRecursive && currentUrl.adjusted(QUrl::RemoveFilename | QUrl::StripTrailingSlash) == url.adjusted(QUrl::StripTrailingSlash))
|| (mode == IBasicVersionControl::Recursive && url.isParentOf(currentUrl))
) {
removeUrl(currentUrl);
}
}
}
}
void VConfigManager::readShortcutsFromSettings()
{
const QString group("shortcuts");
m_shortcuts.clear();
m_shortcuts = readShortcutsFromSettings(defaultSettings, group);
// Update default settings according to user settings.
QHash<QString, QString> userShortcuts = readShortcutsFromSettings(userSettings,
group);
QSet<QString> matched;
matched.reserve(m_shortcuts.size());
for (auto it = userShortcuts.begin(); it != userShortcuts.end(); ++it) {
auto defaultIt = m_shortcuts.find(it.key());
if (defaultIt != m_shortcuts.end()) {
QString sequence = it.value().trimmed();
if (sequence != defaultIt.value()) {
if (isValidKeySequence(sequence)) {
matched.insert(it.key());
*defaultIt = sequence;
}
} else {
matched.insert(it.key());
}
}
}
if (matched.size() < m_shortcuts.size()) {
qDebug() << "override user shortcuts settings using default settings";
writeShortcutsToSettings(userSettings, group, m_shortcuts);
}
}
QSet<int> KeyTracker::pressedKeys() const
{
QSet<int> keys;
keys.reserve(d->keys.size());
for (int key : d->keys)
keys << (key + d->modifiers);
return keys;
}
QStringList
ProjectPackager::getAudioFiles()
{
QStringList list;
// get the Composition from the document, so we can iterate through it
Composition *comp = &m_doc->getComposition();
// We don't particularly care about tracks here, so just iterate through the
// entire Composition to find the audio segments and get the associated
// file IDs from which to obtain a list of actual files. This could
// conceivably pick up audio segments that are residing on MIDI tracks and
// wouldn't otherwise be functional, but the important thing is to never
// miss a single file that has any chance of being worth preserving.
for (Composition::iterator i = comp->begin(); i != comp->end(); ++i) {
if ((*i)->getType() == Segment::Audio) {
AudioFileManager *manager = &m_doc->getAudioFileManager();
unsigned int id = (*i)->getAudioFileId();
AudioFile *file = manager->getAudioFile(id);
// some polite sanity checking to avoid possible crashes
if (!file) continue;
list << file->getFilename();
}
}
// QStringList::removeDuplicates() would have been easy, but it's only in Qt
// 4.5.0 and up. So here's the algorithm from Qt 4.5.0, courtesy of (and
// originally Copyright 2009) Nokia
QStringList *that = &list;
int n = that->size();
int j = 0;
QSet<QString> seen;
seen.reserve(n);
for (int i = 0; i < n; ++i) {
const QString &s = that->at(i);
if (seen.contains(s))
continue;
seen.insert(s);
if (j != i)
(*that)[j] = s;
++j;
}
if (n != j)
that->erase(that->begin() + j, that->end());
// return n - j;
return list;
}
static int TWordDiffEntryList_removeDuplicates(TWordDiffEntryList &aList)
{
int n = aList.size();
int j = 0;
QSet<QString> seen;
seen.reserve(n);
for (int i = 0; i < n; ++i) {
const CWordDiffEntry &s = aList.at(i);
if (seen.contains(s.word())) continue;
seen.insert(s.word());
if (j != i) aList[j] = s;
++j;
}
if (n != j) aList.erase(aList.begin() + j, aList.end());
return (n - j);
}
QSet<Edge> DelaunayTriangulation::
findEdgesIncidentToPoint(Point p) {
QSet<Edge> incidentEdges;
incidentEdges.reserve(3);
QSetIterator<Edge> it(edges);
while (it.hasNext()) {
Edge curEdge = it.next();
if (curEdge.getEndPoint() == p || curEdge.getStartPoint() == p) {
incidentEdges.insert(curEdge);
}
}
return incidentEdges;
}
void tst_QScriptValue::isError_data()
{
QTest::addColumn<QScriptValue>("value");
QTest::addColumn<bool>("expected");
if (m_engine)
delete m_engine;
m_engine = new QScriptEngine();
QSet<QString> expectedValue;
expectedValue.reserve(6);
for (uint i = 0; i < 6; ++i)
expectedValue.insert(isError_array[i]);
for (uint i = 0; i < 135; ++i) {
QPair<QString, QScriptValue> testcase = initScriptValues(i);
QTest::newRow(testcase.first.toAscii().constData()) << testcase.second << expectedValue.contains(testcase.first);
}
}
void ProStringList::removeDuplicates()
{
int n = size();
int j = 0;
QSet<ProString> seen;
seen.reserve(n);
for (int i = 0; i < n; ++i) {
const ProString &s = at(i);
if (seen.contains(s))
continue;
seen.insert(s);
if (j != i)
(*this)[j] = s;
++j;
}
if (n != j)
erase(begin() + j, end());
}
/*!
\fn int QStringList::removeDuplicates()
\since 4.5
This function removes duplicate entries from a list.
The entries do not have to be sorted. They will retain their
original order.
Returns the number of removed entries.
*/
int QtPrivate::QStringList_removeDuplicates(QStringList *that)
{
int n = that->size();
int j = 0;
QSet<QString> seen;
seen.reserve(n);
for (int i = 0; i < n; ++i) {
const QString &s = that->at(i);
if (seen.contains(s))
continue;
seen.insert(s);
if (j != i)
(*that)[j] = s;
++j;
}
if (n != j)
that->erase(that->begin() + j, that->end());
return n - j;
}
QSet<QString> ElementAvailableFN::allXSLTInstructions()
{
enum
{
StringSetSize = 27
};
QSet<QString> retval;
retval.reserve(StringSetSize);
/* Alphabetically. */
retval.insert(QLatin1String("analyze-string"));
retval.insert(QLatin1String("apply-imports"));
retval.insert(QLatin1String("apply-templates"));
retval.insert(QLatin1String("attribute"));
retval.insert(QLatin1String("attribute-set"));
retval.insert(QLatin1String("call-template"));
retval.insert(QLatin1String("character-map"));
retval.insert(QLatin1String("choose"));
retval.insert(QLatin1String("comment"));
retval.insert(QLatin1String("copy"));
retval.insert(QLatin1String("copy-of"));
retval.insert(QLatin1String("document"));
retval.insert(QLatin1String("element"));
retval.insert(QLatin1String("fallback"));
retval.insert(QLatin1String("for-each"));
retval.insert(QLatin1String("for-each-group"));
retval.insert(QLatin1String("if"));
retval.insert(QLatin1String("message"));
retval.insert(QLatin1String("namespace"));
retval.insert(QLatin1String("next-match"));
retval.insert(QLatin1String("number"));
retval.insert(QLatin1String("perform-sort"));
retval.insert(QLatin1String("processing-instruction"));
retval.insert(QLatin1String("result-document"));
retval.insert(QLatin1String("sequence"));
retval.insert(QLatin1String("text"));
retval.insert(QLatin1String("variable"));
Q_ASSERT(retval.count() == StringSetSize);
return retval;
}
/*!
\fn int QStringList::removeDuplicates()
\since 4.5
This function removes duplicate entries from a list.
The entries do not have to be sorted. They will retain their
original order.
Returns the number of removed entries.
*/
int QtPrivate::QStringList_removeDuplicates(QStringList *that)
{
int n = that->size();
int j = 0;
QSet<QString> seen;
seen.reserve(n);
int setSize = 0;
for (int i = 0; i < n; ++i) {
const QString &s = that->at(i);
seen.insert(s);
if (setSize == seen.size()) // unchanged size => was already seen
continue;
++setSize;
if (j != i)
that->swap(i, j);
++j;
}
if (n != j)
that->erase(that->begin() + j, that->end());
return n - j;
}
void tst_QSet::reserve()
{
QSet<int> set;
int n = set.capacity();
QVERIFY(n == 0);
set.reserve(1000);
QVERIFY(set.capacity() >= 1000);
for (int i = 0; i < 500; ++i)
set.insert(i);
QVERIFY(set.capacity() >= 1000);
for (int j = 0; j < 500; ++j)
set.remove(j);
QVERIFY(set.capacity() >= 1000);
set.clear();
QVERIFY(set.capacity() == 0);
}
QSet<REntity::Id> RMemoryStorage::queryAllVisibleEntities() {
QSet<REntity::Id> result;
result.reserve(entityMap.count());
RBlock::Id currentBlock = getCurrentBlockId();
QHash<REntity::Id, QSharedPointer<REntity> >::iterator it;
for (it = entityMap.begin(); it != entityMap.end(); ++it) {
QSharedPointer<REntity> e = *it;
if (e.isNull()) {
continue;
}
if (e->isUndone()) {
continue;
}
RBlock::Id blockId = e->getBlockId();
if (blockId != currentBlock) {
continue;
}
QSharedPointer<RBlock> block = queryBlockDirect(blockId);
if (!block.isNull()) {
if (block->isFrozen()) {
continue;
}
}
RLayer::Id layerId = e->getLayerId();
QSharedPointer<RLayer> layer = queryLayerDirect(layerId);
if (!layer.isNull()) {
if (layer->isFrozen()) {
continue;
}
}
result.insert(e->getId());
}
return result;
}
bool BookmarkModel::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent)
{
if (action == Qt::IgnoreAction)
return true;
if (!data->hasFormat(DRAG_MIME))
return false;
// Unpack Selection from MIME data
QList<size_t> rows;
{
QByteArray rawData = data->data(DRAG_MIME);
QDataStream stream(&rawData, QIODevice::ReadOnly);
size_t nrows;
stream.readRawData((char*)&nrows, sizeof(nrows));
QSet<size_t> rowset;
rowset.reserve(nrows);
size_t buf;
for (size_t i=nrows; i; --i)
{
stream.readRawData((char*)&buf, sizeof(buf));
rowset << buf;
}
rows = rowset.toList();
}
// We want it sorted
qSort(rows);
// Qt passes -1 when dragged outside boundaries
if (row < 0 || row > m_bookmarks.size())
row = m_bookmarks.size();
// First, we always copy all rows to the destination
beginInsertRows(QModelIndex(), row, row + rows.size() - 1);
int off = 0;
size_t dst = row;
for (auto src : rows)
{
m_bookmarks.insert(dst, m_bookmarks[src + off]);
if (dst <= src) // since we insert before the read point, the read needs to be offset
++off;
++dst;
}
endInsertRows();
// Now we remove the original ones if a move was requested
if (action == Qt::MoveAction)
{
size_t cur, count;
size_t first = rows[0];
size_t last = first;
size_t next = 1;
while (next <= rows.size())
{
while (next < rows.size() && (cur = rows[next]) == last + 1)
{
last = cur;
++next;
}
count = last - first + 1;
removeRows(first + off, count);
off -= count;
first = last = cur;
++next;
}
}
return true;
}
void Danmaku::append(Record &&record)
{
Q_D(Danmaku);
Record *append = nullptr;
for (Record &r : d->pool) {
if (r.source == record.source) {
append = &r;
break;
}
}
if (append) {
int a = record.danmaku.size();
if (a <= 0) {
return;
}
QSet<CommentPointer> s;
auto &l = append->danmaku;
int c = l.size() + a;
s.reserve(c);
for (const Comment &c : l) {
s.insert(&c);
}
beginResetModel();
l.reserve(c);
for (const Comment &i : record.danmaku) {
l.append(i);
Comment &c = l.last();
c.time += append->delay - record.delay;
int n = s.size();
s.insert(&c);
if (s.size() == n) {
l.removeLast();
}
}
append->full = record.full || append->full;
}
else {
QSet<CommentPointer> s;
auto &l = record.danmaku;
s.reserve(l.size());
auto b = l.begin(), e = l.end();
for (; b != e; ++b) {
int n = s.size();
s.insert(&*b);
if (s.size() == n) {
break;
}
}
auto i = b == e ? e : std::next(b);
for (; i != e; ++i) {
int n = s.size();
*b = *i;
s.insert(&*b);
if (s.size() != n) {
++b;
}
}
l.erase(b, e);
beginResetModel();
d->pool.append(record);
QVector<Comment> t;
l.swap(t);
}
parse(Danmaku::ModelParse | Danmaku::BlockParse);
endResetModel();
if (append) {
emit modelInsert();
}
else {
emit modelAppend();
}
}
QStringList QFontconfigDatabase::fallbacksForFamily(const QString &family, QFont::Style style, QFont::StyleHint styleHint, QChar::Script script) const
{
QStringList fallbackFamilies;
FcPattern *pattern = FcPatternCreate();
if (!pattern)
return fallbackFamilies;
FcValue value;
value.type = FcTypeString;
QByteArray cs = family.toUtf8();
value.u.s = (const FcChar8 *)cs.data();
FcPatternAdd(pattern,FC_FAMILY,value,true);
int slant_value = FC_SLANT_ROMAN;
if (style == QFont::StyleItalic)
slant_value = FC_SLANT_ITALIC;
else if (style == QFont::StyleOblique)
slant_value = FC_SLANT_OBLIQUE;
FcPatternAddInteger(pattern, FC_SLANT, slant_value);
Q_ASSERT(uint(script) < QChar::ScriptCount);
if (*specialLanguages[script] != '\0') {
FcLangSet *ls = FcLangSetCreate();
FcLangSetAdd(ls, (const FcChar8*)specialLanguages[script]);
FcPatternAddLangSet(pattern, FC_LANG, ls);
FcLangSetDestroy(ls);
} else if (!family.isEmpty()) {
// If script is Common or Han, then it may include languages like CJK,
// we should attach system default language set to the pattern
// to obtain correct font fallback list (i.e. if LANG=zh_CN
// then we normally want to use a Chinese font for CJK text;
// while a Japanese font should be used for that if LANG=ja)
FcPattern *dummy = FcPatternCreate();
FcDefaultSubstitute(dummy);
FcChar8 *lang = 0;
FcResult res = FcPatternGetString(dummy, FC_LANG, 0, &lang);
if (res == FcResultMatch)
FcPatternAddString(pattern, FC_LANG, lang);
FcPatternDestroy(dummy);
}
const char *stylehint = getFcFamilyForStyleHint(styleHint);
if (stylehint) {
value.u.s = (const FcChar8 *)stylehint;
FcPatternAddWeak(pattern, FC_FAMILY, value, FcTrue);
}
FcConfigSubstitute(0, pattern, FcMatchPattern);
FcDefaultSubstitute(pattern);
FcResult result = FcResultMatch;
FcFontSet *fontSet = FcFontSort(0,pattern,FcFalse,0,&result);
FcPatternDestroy(pattern);
if (fontSet) {
QSet<QString> duplicates;
duplicates.reserve(fontSet->nfont + 1);
duplicates.insert(family.toCaseFolded());
for (int i = 0; i < fontSet->nfont; i++) {
FcChar8 *value = 0;
if (FcPatternGetString(fontSet->fonts[i], FC_FAMILY, 0, &value) != FcResultMatch)
continue;
// capitalize(value);
const QString familyName = QString::fromUtf8((const char *)value);
const QString familyNameCF = familyName.toCaseFolded();
if (!duplicates.contains(familyNameCF)) {
fallbackFamilies << familyName;
duplicates.insert(familyNameCF);
}
}
FcFontSetDestroy(fontSet);
}
// qDebug() << "fallbackFamilies for:" << family << style << styleHint << script << fallbackFamilies;
return fallbackFamilies;
}
int main(int argc, char **argv) {
Timer t;
quint64 usins, usiter;
int sum;
{
t.restart();
QSet<int> s;
s.reserve(NE);
for (int i=0;i<NE;i++)
s.insert(i);
usins = t.restart();
sum = 0;
for (int j=0;j<SL;j++)
foreach(int v, s)
sum += v;
usiter = t.restart();
}
qWarning("QSet: %lldus insert, %lldus iterate: %d", usins, usiter, sum);
{
t.restart();
QList<int> s;
for (int i=0;i<NE;i++)
s.append(i);
usins = t.restart();
sum = 0;
for (int j=0;j<SL;j++)
foreach(int v, s)
sum += v;
usiter = t.restart();
}
qWarning("QList: %lldus insert, %lldus iterate: %d", usins, usiter, sum);
{
t.restart();
QVector<int> s;
s.reserve(NE);
for (int i=0;i<NE;i++)
s.append(i);
usins = t.restart();
sum = 0;
for (int j=0;j<SL;j++)
foreach(int v, s)
sum += v;
usiter = t.restart();
}
qWarning("QVector: %lldus insert, %lldus iterate: %d", usins, usiter, sum);
{
t.restart();
vector<int> s;
for (int i=0;i<NE;i++)
s.push_back(i);
usins = t.restart();
sum = 0;
int sz = s.size();
for (int j=0;j<SL;j++)
for (int i=0;i<sz;i++)
sum += s[i];
usiter = t.restart();
}
qWarning("std::vector: %lldus insert, %lldus iterate: %d", usins, usiter, sum);
{
t.restart();
int s[NE];
for (int i=0;i<NE;i++)
s[i]=i;
usins = t.restart();
sum = 0;
for (int j=0;j<SL;j++)
for (int i=0;i<NE;i++)
sum += s[i];
usiter = t.restart();
}
qWarning("c99 alloc: %lldus insert, %lldus iterate: %d", usins, usiter, sum);
{
t.restart();
QListSet<int> s;
for (int i=0;i<NE;i++)
s.insert(i);
usins = t.restart();
sum = 0;
for (int j=0;j<SL;j++)
foreach(int v, s.l)
sum += v;
usiter = t.restart();
}
qWarning("QListSet: %lldus insert, %lldus iterate: %d", usins, usiter, sum);
}
