This affects mostly iterators.
currentIds += CoreAccountSettings().bufferViewOverlay();
QSet<int>::const_iterator iter;
- for (iter = currentIds.constBegin(); iter != currentIds.constEnd(); iter++) {
+ for (iter = currentIds.constBegin(); iter != currentIds.constEnd(); ++iter) {
addView(*iter);
}
}
else {
if (!config->isInitialized())
_uninitializedViewCount++;
- viewIter++;
+ ++viewIter;
}
}
if (Client::bufferViewManager()) {
BufferViewConfig *config = 0;
QSet<int>::const_iterator viewIter;
- for (viewIter = _bufferViewIds.constBegin(); viewIter != _bufferViewIds.constEnd(); viewIter++) {
+ for (viewIter = _bufferViewIds.constBegin(); viewIter != _bufferViewIds.constEnd(); ++viewIter) {
config = Client::bufferViewManager()->bufferViewConfig(*viewIter);
if (!config)
continue;
break;
}
else {
- netIter++;
+ ++netIter;
}
}
}
QVariantList channelVar = iter->toList();
ChannelDescription channelDescription(channelVar[0].toString(), channelVar[1].toUInt(), channelVar[2].toString());
channelList << channelDescription;
- iter++;
+ ++iter;
}
emit channelListReceived(netId, channelFilters, channelList);
{
QSet<int> viewIds;
QVariantList variants = accountValue("BufferViewOverlay").toList();
- for (QVariantList::const_iterator iter = variants.constBegin(); iter != variants.constEnd(); iter++) {
+ for (QVariantList::const_iterator iter = variants.constBegin(); iter != variants.constEnd(); ++iter) {
viewIds << iter->toInt();
}
return viewIds;
while (idIter != _validBuffers.constEnd()) {
if (Client::networkModel()->bufferType(*idIter) == BufferInfo::StatusBuffer)
return true;
- idIter++;
+ ++idIter;
}
}
QSet<BufferId>::const_iterator bufferIdIter = _validBuffers.constBegin();
while (bufferIdIter != _validBuffers.constEnd()) {
Client::messageModel()->requestBacklog(*bufferIdIter);
- bufferIdIter++;
+ ++bufferIdIter;
}
}
QList<Message>::const_iterator iter;
if (inOrder) {
iter = msglist.constEnd();
- iter--; // this op is safe as we've allready passed an empty check
+ --iter; // this op is safe as we've allready passed an empty check
}
else {
iter = msglist.constBegin();
}
if (!inOrder)
- iter++;
+ ++iter;
if (inOrder) {
while (iter != msglist.constBegin()) {
- iter--;
+ --iter;
if (!fastForward && (*iter).msgId() <= minId)
break;
dupeId = (*iter).msgId();
grouplist.prepend(*iter);
}
- iter++;
+ ++iter;
}
}
QHash<UserCategoryItem *, QList<IrcUser *> >::const_iterator catIter = categories.constBegin();
while (catIter != categories.constEnd()) {
catIter.key()->addUsers(catIter.value());
- catIter++;
+ ++catIter;
}
}
iter = _selectionModels.erase(iter);
}
else {
- iter++;
+ ++iter;
}
}
}
QSet<QItemSelectionModel *>::iterator iter = _selectionModels.begin();
while (iter != _selectionModels.end()) {
(*iter)->setCurrentIndex(mapFromSource(current, (*iter)), QItemSelectionModel::Current);
- iter++;
+ ++iter;
}
_changeCurrentEnabled = true;
}
QSet<QItemSelectionModel *>::iterator iter = _selectionModels.begin();
while (iter != _selectionModels.end()) {
(*iter)->select(mapSelectionFromSource(currentSelection(), (*iter)), QItemSelectionModel::ClearAndSelect);
- iter++;
+ ++iter;
}
_changeSelectionEnabled = true;
}
child = *childIter;
child->setTreeItemFlags(0); // disable self deletion, as this would only fuck up consitency and the child gets deleted anyways
child->removeAllChilds();
- childIter++;
+ ++childIter;
}
emit beginRemoveChilds(0, numChilds - 1);
while (childIter != _childItems.constEnd()) {
child = *childIter;
qDebug() << "Row:" << child->row() << child << child->data(0, Qt::DisplayRole);
- childIter++;
+ ++childIter;
}
}
qDebug() << "==== End Of Childlist ====";
BufferViewConfigHash::const_iterator iterEnd = _bufferViewConfigs.constEnd();
while (iter != iterEnd) {
bufferViewIds << (*iter)->bufferViewId();
- iter++;
+ ++iter;
}
return bufferViewIds;
}
QVariantList::const_iterator iterEnd = bufferViewIds.constEnd();
while (iter != iterEnd) {
newBufferViewConfig((*iter).value<int>());
- iter++;
+ ++iter;
}
}
else value = currentArg->toLocal8Bit();
name = currentArg->mid(1).toLatin1().at(0);
// we took one argument as argument to an option so skip it next time
- if (skipNext) currentArg++;
+ if (skipNext) ++currentArg;
if (!addShortArg(CliParserArg::CliArgOption, name, value)) return false;
}
}
QHash<IrcUser *, QString>::const_iterator iter = _userModes.constBegin();
while (iter != _userModes.constEnd()) {
usermodes[iter.key()->nick()] = iter.value();
- iter++;
+ ++iter;
}
return usermodes;
}
while (iter != usermodes.constEnd()) {
users << network()->newIrcUser(iter.key());
modes << iter.value().toString();
- iter++;
+ ++iter;
}
joinIrcUsers(users, modes);
}
QHash<QChar, QStringList>::const_iterator A_iter = _A_channelModes.constBegin();
while (A_iter != _A_channelModes.constEnd()) {
A_modes[A_iter.key()] = A_iter.value();
- A_iter++;
+ ++A_iter;
}
channelModes["A"] = A_modes;
QHash<QChar, QString>::const_iterator B_iter = _B_channelModes.constBegin();
while (B_iter != _B_channelModes.constEnd()) {
B_modes[B_iter.key()] = B_iter.value();
- B_iter++;
+ ++B_iter;
}
channelModes["B"] = B_modes;
QHash<QChar, QString>::const_iterator C_iter = _C_channelModes.constBegin();
while (C_iter != _C_channelModes.constEnd()) {
C_modes[C_iter.key()] = C_iter.value();
- C_iter++;
+ ++C_iter;
}
channelModes["C"] = C_modes;
QSet<QChar>::const_iterator D_iter = _D_channelModes.constBegin();
while (D_iter != _D_channelModes.constEnd()) {
D_modes += *D_iter;
- D_iter++;
+ ++D_iter;
}
channelModes["D"] = D_modes;
QVariantMap::const_iterator iterEnd = channelModes["A"].toMap().constEnd();
while (iter != iterEnd) {
_A_channelModes[iter.key()[0]] = iter.value().toStringList();
- iter++;
+ ++iter;
}
iter = channelModes["B"].toMap().constBegin();
iterEnd = channelModes["B"].toMap().constEnd();
while (iter != iterEnd) {
_B_channelModes[iter.key()[0]] = iter.value().toString();
- iter++;
+ ++iter;
}
iter = channelModes["C"].toMap().constBegin();
iterEnd = channelModes["C"].toMap().constEnd();
while (iter != iterEnd) {
_C_channelModes[iter.key()[0]] = iter.value().toString();
- iter++;
+ ++iter;
}
QString D_modes = channelModes["D"].toString();
QSet<QChar>::const_iterator D_iter = _D_channelModes.constBegin();
while (D_iter != _D_channelModes.constEnd()) {
modeString += *D_iter;
- D_iter++;
+ ++D_iter;
}
QHash<QChar, QString>::const_iterator BC_iter = _C_channelModes.constBegin();
while (BC_iter != _C_channelModes.constEnd()) {
modeString += BC_iter.key();
params << BC_iter.value();
- BC_iter++;
+ ++BC_iter;
}
BC_iter = _B_channelModes.constBegin();
while (BC_iter != _B_channelModes.constEnd()) {
modeString += BC_iter.key();
params << BC_iter.value();
- BC_iter++;
+ ++BC_iter;
}
if (modeString.isEmpty())
return modeString;
break;
}
else {
- slotIter++;
+ ++slotIter;
}
}
}
objIter = classIter->erase(objIter);
obj->stopSynchronize(this);
}
- classIter++;
+ ++classIter;
}
_syncSlave.clear();
slotIter = _attachedSlots.erase(slotIter);
}
else
- slotIter++;
+ ++slotIter;
}
}
classIter->remove(obj->objectName());
break;
}
- classIter++;
+ ++classIter;
}
obj->stopSynchronize(this);
}
while (iterator != properties.constEnd()) {
propName = iterator.key();
if (propName == "objectName") {
- iterator++;
+ ++iterator;
continue;
}
else
setProperty(propName.toLatin1(), iterator.value());
// qDebug() << "<<< SYNC:" << name << iterator.value();
- iterator++;
+ ++iterator;
}
}
{
// disconnect the connections, so their deletion is no longer interessting for us
QHash<QThread *, Connection *>::iterator conIter;
- for (conIter = _connectionPool.begin(); conIter != _connectionPool.end(); conIter++) {
+ for (conIter = _connectionPool.begin(); conIter != _connectionPool.end(); ++conIter) {
QSqlDatabase::removeDatabase(conIter.value()->name());
disconnect(conIter.value(), 0, this, 0);
}
QVariantMap boundValues = query.boundValues();
QStringList valueStrings;
QVariantMap::const_iterator iter;
- for (iter = boundValues.constBegin(); iter != boundValues.constEnd(); iter++) {
+ for (iter = boundValues.constBegin(); iter != boundValues.constEnd(); ++iter) {
QString value;
QSqlField field;
if (query.driver()) {
QList<Message>::const_iterator msgListEnd = msgList.constEnd();
while (msgIter != msgListEnd) {
backlog << qVariantFromValue(*msgIter);
- msgIter++;
+ ++msgIter;
}
if (additional && limit != 0) {
msgListEnd = msgList.constEnd();
while (msgIter != msgListEnd) {
backlog << qVariantFromValue(*msgIter);
- msgIter++;
+ ++msgIter;
}
}
}
QList<Message>::const_iterator msgListEnd = msgList.constEnd();
while (msgIter != msgListEnd) {
backlog << qVariantFromValue(*msgIter);
- msgIter++;
+ ++msgIter;
}
if (additional) {
msgListEnd = msgList.constEnd();
while (msgIter != msgListEnd) {
backlog << qVariantFromValue(*msgIter);
- msgIter++;
+ ++msgIter;
}
}
while (iter != iterEnd) {
config = new CoreBufferViewConfig(iter.key().toInt(), iter.value().toMap(), this);
addBufferViewConfig(config);
- iter++;
+ ++iter;
}
}
BufferViewConfigHash::const_iterator iterEnd = bufferViewConfigHash().constEnd();
while (iter != iterEnd) {
views[QString::number((*iter)->bufferViewId())] = (*iter)->toVariantMap();
- iter++;
+ ++iter;
}
Core::setUserSetting(_coreSession->user(), "BufferViews", views);
if ((*iter)->bufferViewId() > maxId)
maxId = (*iter)->bufferViewId();
- iter++;
+ ++iter;
}
maxId++;
QVariantList::const_iterator iterEnd = properties.constEnd();
while (iter != iterEnd) {
requestCreateBufferView((*iter).toMap());
- iter++;
+ ++iter;
}
}
networkIter = networkInfos.erase(networkIter);
}
else {
- networkIter++;
+ ++networkIter;
}
}
s.removeIdentity(id);
messageIter = _messageQueue.erase(messageIter);
}
else {
- messageIter++;
+ ++messageIter;
}
}
// remove buffers from syncer
IrcUser *me = 0;
while (netIter != _networks.end()) {
net = *netIter;
- netIter++;
+ ++netIter;
if (!net->isConnected())
continue;
QString awayReason;
while (netIter != _networks.end()) {
net = *netIter;
- netIter++;
+ ++netIter;
if (!net->isConnected())
continue;
CoreNetwork *net = 0;
while (netIter != _networks.end()) {
net = *netIter;
- netIter++;
+ ++netIter;
if (!net->isConnected())
continue;
QHash<QByteArray, QByteArray>::const_iterator quoteIter = quoteHash.constBegin();
while (quoteIter != quoteHash.constEnd()) {
quotedMessage.replace(quoteIter.value(), quoteIter.key());
- quoteIter++;
+ ++quoteIter;
}
return quotedMessage;
}
QHash<QByteArray, QByteArray>::const_iterator quoteIter = _ctcpXDelimDequoteHash.constBegin();
while (quoteIter != _ctcpXDelimDequoteHash.constEnd()) {
quotedMessage.replace(quoteIter.value(), quoteIter.key());
- quoteIter++;
+ ++quoteIter;
}
return quotedMessage;
}
<< Sequence("quasseluser", "userid")
<< Sequence("sender", "senderid");
QList<Sequence>::const_iterator iter;
- for (iter = sequences.constBegin(); iter != sequences.constEnd(); iter++) {
+ for (iter = sequences.constBegin(); iter != sequences.constEnd(); ++iter) {
resetQuery();
newQuery(QString("SELECT setval('%1_%2_seq', max(%2)) FROM %1").arg(iter->table, iter->field), db);
if (!exec())
QPointF senderPos(firstColumnHandle()->sceneRight(), 0);
while (lineIter != lineIterBegin) {
- lineIter--;
+ --lineIter;
(*lineIter)->setFirstColumn(timestampWidth, senderWidth, senderPos);
}
//setItemIndexMethod(QGraphicsScene::BspTreeIndex);
qreal contentsWidth = _sceneRect.width() - secondColumnHandle()->sceneRight();
QPointF contentsPos(secondColumnHandle()->sceneRight(), 0);
while (lineIter != lineIterBegin) {
- lineIter--;
+ --lineIter;
(*lineIter)->setSecondColumn(senderWidth, contentsWidth, contentsPos, linePos);
}
//setItemIndexMethod(QGraphicsScene::BspTreeIndex);
while (msgIter != msgIterEnd) {
checkForHighlight(*msgIter);
preProcess(*msgIter);
- msgIter++;
+ ++msgIter;
}
Client::messageModel()->insertMessages(msgs);
return;
rule["CS"].toBool() ? Qt::CaseSensitive : Qt::CaseInsensitive,
rule["RegEx"].toBool(),
rule["Channel"].toString());
- iter++;
+ ++iter;
}
}
break;
}
else {
- iter++;
+ ++iter;
}
}
delete config;
}
else {
changed = true;
- iter++;
+ ++iter;
}
}
return changed;
_editSsl = true;
QHash<IdentityId, CertIdentity *>::iterator idIter;
- for (idIter = identities.begin(); idIter != identities.end(); idIter++) {
+ for (idIter = identities.begin(); idIter != identities.end(); ++idIter) {
idIter.value()->enableEditSsl();
}
if (enable == false) {
addBuffers(QList<BufferId>::fromSet(_toAdd));
QSet<BufferId>::const_iterator iter;
- for (iter = _toTempRemove.constBegin(); iter != _toTempRemove.constEnd(); iter++) {
+ for (iter = _toTempRemove.constBegin(); iter != _toTempRemove.constEnd(); ++iter) {
if (config()->temporarilyRemovedBuffers().contains(*iter))
continue;
config()->requestRemoveBuffer(*iter);
}
- for (iter = _toRemove.constBegin(); iter != _toRemove.constEnd(); iter++) {
+ for (iter = _toRemove.constBegin(); iter != _toRemove.constEnd(); ++iter) {
if (config()->removedBuffers().contains(*iter))
continue;
config()->requestRemoveBufferPermanently(*iter);
ignoreMenu->addAction(act);
}
counter++;
- ruleIter++;
+ ++ruleIter;
}
if (counter)
ignoreMenu->addSeparator();