Saves a bit over 2.5KiB in text size on optimized GCC 4.9 Linux
AMD64 builds.
Change-Id: I18a635d65a3c20c4bf5ec2cbfa4ed81a8153cab3
Reviewed-by: Lars Knoll <lars.knoll@theqtcompany.com>
Saves just shy of 4KiB in text size on optimized GCC 4.9 Linux
AMD64 builds, iow: ~0.07% of the total QtCore library size.
Change-Id: I87fdcc8ee25c6bb5dabddb9a694ab4496b1538fa
Reviewed-by: David Faure <david.faure@kdab.com>
Reviewed-by: Olivier Goffart (Woboq GmbH) <ogoffart@woboq.com>
Saves just shy of 6KiB in text size on optimized GCC 4.9 Linux
AMD64 builds, iow: ~0.1% of the total QtCore library size.
Change-Id: I087e1e34a64944affb1211e16371e314012c4b2c
Reviewed-by: David Faure <david.faure@kdab.com>
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Not many left. Still 344b saved in text size on optimized
GCC 4.9 Linux AMD64 builds.
Change-Id: I51ba49fe065854f84e26d25d7da5e26427ea2c0b
Reviewed-by: Laszlo Agocs <laszlo.agocs@theqtcompany.com>
Reviewed-by: Sean Harmer <sean.harmer@kdab.com>
Saves 327b in text size, but done mainly because such
functions shouldn't be inline in the first place.
Change-Id: Ieea97f13620e4411dc01cb0d390bd668c13cfa7a
Reviewed-by: Lars Knoll <lars.knoll@theqtcompany.com>
...to turn mutable lvalues into const lvalues.
Like the proposed std::as_const, it should not apply to
rvalues to avoid lifetime issues in code like
for (auto x : qAsConst(someFunc()))
// dangling
At a more basic level, qAsConst isn't useful for rvalues,
because one can always store them in an lvalue first, with
no loss in performance (the object is created by the
compiler silently anyway). So the correct way to write the
above is:
const auto funcResult = someFunc();
for (auto e : funcResult)
To fail compilation when passing rvalues, I used the
const-&& pattern also employed by std::cref(), and the
proposed std::as_const.
Intended as internal API, but not put into the QtPrivate
namespace to make it simpler to use.
We could wait for std::as_const, but that is far, far
away (just entered the current C++17 draft as of this
writing), and the Qt containers with their tendency to
detach are a problem _now_.
Change-Id: I8824a59d2274de5c5cd642f117212322e4648025
Reviewed-by: Lars Knoll <lars.knoll@theqtcompany.com>
It makes tst_QMutex::contendedQMutex with no msleep 8 times faster
Change-Id: Ic300e7618b4467e4e08b30f0213bd23c06d4d90a
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
The 'itemList' is a QList and is not maintained in sorted order.
Change-Id: I8f221281803ff0e9caa054007bee3058214f2f30
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
The old code re-used a QFileInfo object, repeatedly
setting new file names with QFileInfo::setFile(QString).
But QFileInfo::setFile() simply assigns itself a
new QFileInfo object:
*this = QFileInfo(...)
so it's just as efficient to re-create a new QFIleInfo
object for every file name under test.
To avoid extra {} for object lifetime scoping, factor
the repeated evaluation of isReadable() && isFile()
into a small helper function, which also creates and
destroys the QFileInfo object.
The deeper significance of this change is that it
avoids implicit sharing of 'realname', which is
permanently modified. A later patch will make
changes that make 'realname' re-use its capacity
through the lifetime of the find_translation()
function, and sharing the variable implicitly will
nip any auch attempts in the bud.
Force the compiler to not inline the new function.
There's really no point in spending ~0.5KiB in text
size on inlining the code; the miniscule speed
improvement is dwarfed by the memory allocation of
the QFileInfo ctor, anyway.
As a consequence, this change even saves 96b in text
size on optimized GCC 4.9 Linux AMD64 builds, even
though that wasn't even the goal.
Change-Id: I08c5cbb7b6f1ba59440a1597e28d962ce63a7c65
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
... and remove misleading comments (these are overloads, not specializations).
The QList overloads do nothing different from the generic container
overloads. Remove them.
Only leave the QVariantList overload, because that converts to
QDBusVariant before serializing. Which means that this should
probably be templated on the container type, otherwise you get
different behavior for QList<QVariant> and, say, QVector<QVariant>,
which is surely wrong.
Change-Id: I215ba9891235b51304c2ed4041d3dbd003d69581
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
- populate the widget with addItems(QStringList) instead of
looping over addItem(QString)
- Use findText() instead of looping over itemText(int).
QComboBox::findText() delegates searching to the model
(via QAbstractItemModel::match()), so is potentially
much faster. I say potentially, because match() isn't
properly reimplemented in most models, yet. But that is
something to fix in the models.
Change-Id: I6e52cf5af810ab7869c0270504a241868a5ca281
Reviewed-by: Olivier Goffart (Woboq GmbH) <ogoffart@woboq.com>
- Instead of QString::split()-ing the path, just to inspect the
first item in the list returned, simply find the location of
the first separator and work with that.
-> saves creating a QList, and its QString elements
-> saves attempted detaches of that list when calling
first()
- When extracting the user name, don't do it in a QString, do
it in a QStringRef.
- When constructing the result, don't use QString::replace(),
use QStringBuilder with a QStringRef into the original string.
- Eradicate the out parameter, it is easily calculated from the
return value.
- Don't calculate userName on VXWORKS and INTEGRITY, where it
is not used. Requires a different #ifdef sequence. Fixed
preprocessor directives' indention as a drive-by.
Costs 84b in text size on optimized GCC 4.9 Linux AMD64 builds.
Change-Id: I61f1e8d558db7fb0c5c1170bdfd6f5ac1f1a9e62
Reviewed-by: Olivier Goffart (Woboq GmbH) <ogoffart@woboq.com>
In setStretchLastSection we restore a default section size
if we no longer use stretch. That size was however not
sufficient - we should restore the actual size.
Furthermore we should also always stretch the last section
(last visible index) - and not leave a section with a
huge size and stretch another.
This patch refactors stretch handling and keeps track
of the last section and its size in eg. moveSection,
swapSection, hideSection, showSection etc.
There is an auto test showing and guarding its behavior.
[ChangeLog][QtWidgets][QHeaderView] Fixed some issues
(e.g QTBUG-39010) with restoring of section size after
a section is no longer the last visible section
(in stretchLastSection mode).
Task-number: QTBUG-39010
Change-Id: Id47075b5a9dfeb250027374ecbd10eb8babbf9ef
Reviewed-by: David Faure <david.faure@kdab.com>
Both 'configuration' and 'pendingErrorStates' are
QSet<QAbstractState*>, so we can use QSet::operator-=
to subtract one from the other. No need to loop
over QSet::remove() here.
Nevermind that QSet::operator-= is really poorly
implemented atm. That needs to be fixed in QSet.
Change-Id: I3f3172ce9a485c4c2abf7d19b831fb0dc1ea61b1
Reviewed-by: Olivier Goffart (Woboq GmbH) <ogoffart@woboq.com>
These functions have no business being inline.
Change-Id: Ib565fb4870f886be133e9360155bd514935e5e72
Reviewed-by: Olivier Goffart (Woboq GmbH) <ogoffart@woboq.com>
A QStringList is almost as efficient as a QVector<QString>.
More importantly, the QStringList case can share code with
the myriad of other QStringList users, in particular
because std::stack is but the thinnest of wrappers around
its underlying container.
Saves more than 1KiB in text size on optimized GCC 4.9
Linux AMD64 builds.
Change-Id: Ia9c1f8b8c6d3b619f587a0cc0f662462d1b6bdc5
Reviewed-by: David Faure <david.faure@kdab.com>
This is especially necessary for the GHS toolchain which otherwise
chokes on the lack of some local definitions made by the
Q_DECLARE_SHARED macro.
Change-Id: Ie4e355226e4a66e1589e1d422d3a622b11bd9aef
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Reviewed-by: Olivier Goffart (Woboq GmbH) <ogoffart@woboq.com>
Reviewed-by: Jędrzej Nowacki <jedrzej.nowacki@theqtcompany.com>
In a non-const function, if (d), d being a QSharedDataPointer,
will resolve to if(d.data()), which detaches and returns a
pointer to an unshared copy of the data. Thus, the test if (d)
is always true.
Fix by explicit use of constData(), as in other QUrlQuery
functions.
Change-Id: Ib926abdcdb069d69e34c3202c4cf451b7fc6a329
Reviewed-by: Olivier Goffart (Woboq GmbH) <ogoffart@woboq.com>
A QByteArrayList is almost as efficient as a QVector<QByteArray>.
More importantly, the QByteArrayList case can share code with
the myriad of other QByteArrayList users, in particular
because std::stack is but the thinnest of wrappers around
its underlying container.
For moc, saves almost 1KiB in text size on optimized GCC 4.9
Linux AMD64 builds.
For qdbuscpp2xml, which re-uses moc code, saves ~1.6KiB.
Change-Id: I861e92b3c79e47e0ce892ccf54c9041182aaf212
Reviewed-by: Olivier Goffart (Woboq GmbH) <ogoffart@woboq.com>
Receiving the QStringList return value through RVO instead of
move-assigning it saves 48b in text size on optimized GCC 4.9
Linux AMD 64 builds.
Marking the QStringList const saves another 112b because the
following first() doesn't need to attempt a detach.
Change-Id: If6f25399e80de12114ce41c557bff6ee8c24938b
Reviewed-by: Olivier Goffart (Woboq GmbH) <ogoffart@woboq.com>
We already include <utility> in <qglobal.h>, so we might
as well provide a qHash() overload for std::pair.
[ChangeLog][QtCore] Added qHash(std::pair), defined in
<QHashFunctions>.
Change-Id: I0f61c513e82e05ce9d2e56bcf18f3be9e2da4da9
Reviewed-by: Olivier Goffart (Woboq GmbH) <ogoffart@woboq.com>
- Don't detach QCoreApplication::arguments() by calling first(),
call constFirst()
- Use
QString foo;
foo += initial;
instead of
QString foo = initial;
where 'foo' receives more appends later (does not force an
initial capacity that is known to be too small).
- Use QStringBuilder more
- Don't use QStringLiteral in QStringBuilder expressions
- Reserve optionNameList. Its max. size is known ahead of time.
- Don't create optionNameStrings for hidden options.
The result was never used, they just served as placeholders
for the lock-step iteration that followed and wrapped the text.
- Don't create a QStringList to join(), append to the result
string directly.
- Cache the return value of option.valueName().
Not only is this faster, it also saves more than 2KiB in text
size on optimized GCC 4.9 Linux AMD64 builds.
Change-Id: Id1d88f3c36a521ac71f3a7436810ed31319077ae
Reviewed-by: David Faure <david.faure@kdab.com>
... iterate over the hash directly.
Prevents hash lookups and the creation of a temporary QList.
Saves over 376b in text size on optimized GCC 4.9 Linux
AMD64 builds.
Change-Id: I7f1a22da33b94bc91bec89f62c471f8279a5d702
Reviewed-by: Sérgio Martins <iamsergio@gmail.com>
All but one of the callers sorted the list in at least one
code path, with code paths that use the list unsorted looking
suspiciously non-deterministic. The one caller that doesn't
sort the list doesn't use it at all (but uses the out parameter,
which none of the other callers do, suggesting that the function
be split into two at some point).
Change-Id: I178c1476919e4877ef4f4a3cc8934dbd04bd7a58
Reviewed-by: David Faure <david.faure@kdab.com>
... but use the new key_iterators instead.
Saves creating a temporary QList just to iterate over it
and ~1.3KiB in text size on optimized GCC 4.9 Linux AMD64
builds.
Change-Id: Id5223fc5fcb4a4e7c012718c1bb2674b8ea0439d
Reviewed-by: Sérgio Martins <iamsergio@gmail.com>
This will be used in QTextStream to speed up padding processing.
[ChangeLog][QtCore][QString] Added resize(int, QChar) overload.
Change-Id: Id51f8cdacb167310157100b05cacf20e9a5d2716
Reviewed-by: Topi Reiniö <topi.reinio@theqtcompany.com>
Reviewed-by: Olivier Goffart (Woboq GmbH) <ogoffart@woboq.com>
Calling QVector::erase(it) in a loop consitutes quadratic
behavior (O(N) function called O(N) times).
Fix by using std::remove_if(), which is linear.
Change-Id: I39c11231d604bc2d9506427bc3411b71d71b5569
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
resetTty() already does close the fd.
Fixes coverity CID89074.
Change-Id: I2d5fe9bf40b03ed5c249713c64f1dc2ae58ea84b
Reviewed-by: Laszlo Agocs <laszlo.agocs@theqtcompany.com>
d->programGuard and its ID don't change when calling a
GL function, so check them only once, before entering
the loop, instead of once per iteration.
Cache d->programGuard->id().
Change-Id: I398da7a76823b2eb854b7b9d5af512adf9969fc9
Reviewed-by: Laszlo Agocs <laszlo.agocs@theqtcompany.com>
Saves more than 2KiB in text size on optimized GCC 4.9 Linux
AMD64 builds, iow: ~0.5% of the total library size.
Change-Id: I84e1dc208da13eefdf1573c9b7ac7c9d76a7f5c7
Reviewed-by: Olivier Goffart (Woboq GmbH) <ogoffart@woboq.com>
This needs to be handled a bit carefully, because Qt containers
will detach upon being iterated over using range-for.
In the cases of this patch, that cannot happen, because all
containers are local and marked as const (either by this patch
or before).
Separate patches will deal with other situations.
Range-for loops are much more efficient than foreach loops.
This patch shaves ~1.8KiB of text size off an optimized Linux
AMD64 GCC 4.9 build.
Change-Id: I5c58658937ac4323594161bf94a2fce3c5667914
Reviewed-by: Olivier Goffart (Woboq GmbH) <ogoffart@woboq.com>
This needs to be handled a bit carefully, because Qt containers
will detach upon being iterated over using range-for.
In the cases of this patch, that trivially cannot happen, because
all containers are marked as const when being assigned the rvalues
previously found on the rhs of the Q_FOREACH. The new code thus
does exactly what the old code did: take a const copy, then iterate
over it.
Separate patches will deal with other situations.
Range-for loops are much more efficient than foreach loops.
This patch shaves almost 4K of text size off an optimized Linux
AMD64 GCC 4.9 build.
Change-Id: Ida868b77d078cbfa0516d17e98e6f0a86fcdb7a3
Reviewed-by: Olivier Goffart (Woboq GmbH) <ogoffart@woboq.com>
Also marking the error path as unlikely while I am
on it.
Fixes coverity CID154482.
Change-Id: I069fa7753e364ff1b8a4449b7008dfa8aee73de5
Reviewed-by: Marc Mutz <marc.mutz@kdab.com>
Reviewed-by: Robin Burchell <robin.burchell@viroteck.net>
If ev.isAccepted(), since list is gestures.toList(), the
first foreach loop would clear 'gestures', one item at
a time. The second foreach loop would then not execute
at all.
Make this case clearer by not executing either loop if
ev.isAccepted().
Make it more performant by not iterating twice, but once,
simply skipping those gestures in the second (remaining)
loop which would have been removed by the first one.
Also iterate over the equivalent QList instead of the QSet,
because the former is way more efficient.
Text size savings are present, but minimal. The runtime
savings are signficant, of course.
Change-Id: I3d5bfe99c5d3fcbe4c98816577846551c632f315
Reviewed-by: Olivier Goffart (Woboq GmbH) <ogoffart@woboq.com>
The old code dealt with a lot of special cases, probably to
avoid detaching. But the only case where deep copies are
avoided is if
a) there're no freeItemIndexes
b) there're no unindexedItems
c) the sort order is neither AcendingOrder nor DescendingOrder,
which is funny, since those are the only two values for
Qt::SortOrder. The code checks for SortOrder(-1), but
nowhere in Qt is such a sort order created.
Ergo, the deep copy was _never_ avoided.
So simplify the code by always building the result list from
the two input lists by copying all non-null items.
Saves over 2KiB in text size on optimized GCC 4.9 Linux AMD64
builds.
Change-Id: I8e739fb78896b2ad0bec45d05e86a76fe1ede04a
Reviewed-by: Olivier Goffart (Woboq GmbH) <ogoffart@woboq.com>
Iterate over the original list instead.
Change-Id: I7be154c0e19074033df6f6e01f68d21a8904d2ee
Reviewed-by: Andreas Aardal Hanssen <andreas@hanssen.name>
QTouchEvent::touchPoints() returns a const-&, but the old
code took a copy, over which it then iterated, modifying
the touch points, causing (necessary) detaches of both the
list and the touch points.
Befriend QTouchEvent and modify the list in-place, avoiding
all detaches in the likely case that QTouchPoint contains the
only copy of the touch point list.
This is all the more important as the function is called once
for every item-under-mouse in sendTouchBeginEvent().
Port to C++11 range-for as a drive-by.
Change-Id: I2f74d19845711d97e3566886123b5d18d55db74c
Reviewed-by: Andreas Aardal Hanssen <andreas@hanssen.name>
Helps pinning the vtable to a single TU, which can
prevent false negative RTTI (incl. dynamic_cast and
catch()).
But mostly because it's rather pointless to have dtors
of polymophic function inline. Most of the time, the
code will be called through the vtable indirection,
anyway (which also means that an out-of-line copy of
the code needs to exist in any case). The inline
method will only be used when the compiler can prove
the dynamic type of an object.
Saves ~1.5KiB in text size on optimized GCC 4.9 Linux
AMD64 builds.
Change-Id: Ic4ce96da559252c8abc29d880530c84035db2306
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
The QMap<QByteArray, QString> was only used to hold key/value pairs
until they were serialized into a QString at the end of the function.
Serialize into QString directly instead, dropping the temporary QMap.
The problem is that we'd like to keep the line formatting central
while at the same time harnessing the power of QStringBuilder.
This is possible with a templated function with an input/output
parameter:
format_attr(QString &result, const char *key, T &&value)
format_attr(result, text-foo, str + str2 + str3);
Or with return type deduction:
formatted(const char *key, T &&value) -> decltype((expr)) { return expr; }
result += formatted(text-foo, str + str2 + str3);
I don't like out parameters, and we can't rely on auto return
type deduction, yet, so I opted for a miniature expression
template solution that can only match the expression
attr[key] = value;
where 'key' is a const char* and 'value' can be anything that
QStringBuilder supports. This allows to keep the syntax of a map
while at the same time serializing to QString immediately.
The only behavioral difference to the old code is that the
attributes are no longer sorted, but order doesn't matter.
Saves more than 10KiB in text size on optimized GCC 4.9 Linux
AMD64 builds.
Change-Id: I7b3bec0466ef24156c693adaa95f0316007e0bfe
Reviewed-by: Olivier Goffart (Woboq GmbH) <ogoffart@woboq.com>
