diff --git a/akonadi/collectionfetchjob.cpp b/akonadi/collectionfetchjob.cpp
index 01c4efba4..d941c9403 100644
--- a/akonadi/collectionfetchjob.cpp
+++ b/akonadi/collectionfetchjob.cpp
@@ -1,262 +1,262 @@
 /*
     Copyright (c) 2006 - 2007 Volker Krause <vkrause@kde.org>
 
     This library is free software; you can redistribute it and/or modify it
     under the terms of the GNU Library General Public License as published by
     the Free Software Foundation; either version 2 of the License, or (at your
     option) any later version.
 
     This library is distributed in the hope that it will be useful, but WITHOUT
     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
     License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to the
     Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     02110-1301, USA.
 */
 
 #include "collectionfetchjob.h"
 
 #include "imapparser_p.h"
 #include "job_p.h"
 #include "protocol_p.h"
 #include "protocolhelper_p.h"
 #include "entity_p.h"
 #include "collectionfetchscope.h"
 
 #include <kdebug.h>
 
 #include <QtCore/QHash>
 #include <QtCore/QStringList>
 #include <QtCore/QTimer>
 
 using namespace Akonadi;
 
 class Akonadi::CollectionFetchJobPrivate : public JobPrivate
 {
   public:
     CollectionFetchJobPrivate( CollectionFetchJob *parent )
       : JobPrivate( parent )
     {
     }
 
     Q_DECLARE_PUBLIC( CollectionFetchJob )
 
     CollectionFetchJob::Type mType;
     Collection mBase;
     Collection::List mBaseList;
     Collection::List mCollections;
     CollectionFetchScope mScope;
     Collection::List mPendingCollections;
     QTimer *mEmitTimer;
 
     void timeout()
     {
       Q_Q( CollectionFetchJob );
 
       mEmitTimer->stop(); // in case we are called by result()
       if ( !mPendingCollections.isEmpty() ) {
         emit q->collectionsReceived( mPendingCollections );
         mPendingCollections.clear();
       }
     }
 };
 
 CollectionFetchJob::CollectionFetchJob( const Collection &collection, Type type, QObject *parent )
   : Job( new CollectionFetchJobPrivate( this ), parent )
 {
   Q_D( CollectionFetchJob );
 
   d->mBase = collection;
   d->mType = type;
 
   d->mEmitTimer = new QTimer( this );
   d->mEmitTimer->setSingleShot( true );
   d->mEmitTimer->setInterval( 100 );
   connect( d->mEmitTimer, SIGNAL(timeout()), this, SLOT(timeout()) );
   connect( this, SIGNAL(result(KJob*)), this, SLOT(timeout()) );
 }
 
 CollectionFetchJob::CollectionFetchJob( const Collection::List & cols, QObject * parent )
   : Job( new CollectionFetchJobPrivate( this ), parent )
 {
   Q_D( CollectionFetchJob );
 
   Q_ASSERT( !cols.isEmpty() );
   if ( cols.size() == 1 ) {
     d->mBase = cols.first();
     d->mType = CollectionFetchJob::Base;
   } else {
     d->mBaseList = cols;
   }
 
   d->mEmitTimer = new QTimer( this );
   d->mEmitTimer->setSingleShot( true );
   d->mEmitTimer->setInterval( 100 );
   connect( d->mEmitTimer, SIGNAL(timeout()), this, SLOT(timeout()) );
   connect( this, SIGNAL(result(KJob*)), this, SLOT(timeout()) );
 }
 
 CollectionFetchJob::~CollectionFetchJob()
 {
 }
 
 Collection::List CollectionFetchJob::collections() const
 {
   Q_D( const CollectionFetchJob );
 
   return d->mCollections;
 }
 
 void CollectionFetchJob::doStart()
 {
   Q_D( CollectionFetchJob );
 
   if ( !d->mBaseList.isEmpty() ) {
     foreach ( const Collection &col, d->mBaseList ) {
       new CollectionFetchJob( col, CollectionFetchJob::Base, this );
     }
     return;
   }
 
   if ( !d->mBase.isValid() && d->mBase.remoteId().isEmpty() ) {
     setError( Unknown );
     setErrorText( QLatin1String( "Invalid collection given." ) );
     emitResult();
     return;
   }
 
   QByteArray command = d->newTag();
   if ( !d->mBase.isValid() )
     command += " " AKONADI_CMD_RID;
   if ( d->mScope.includeUnubscribed() )
     command += " LIST ";
   else
     command += " LSUB ";
   if ( d->mBase.isValid() )
     command += QByteArray::number( d->mBase.id() );
   else
     command += ImapParser::quote( d->mBase.remoteId().toUtf8() );
   command += ' ';
   switch ( d->mType ) {
     case Base:
       command += "0 (";
       break;
     case FirstLevel:
       command += "1 (";
       break;
     case Recursive:
       command += "INF (";
       break;
     default:
       Q_ASSERT( false );
   }
 
   QList<QByteArray> filter;
   if ( !d->mScope.resource().isEmpty() ) {
     filter.append( "RESOURCE" );
     filter.append( d->mScope.resource().toUtf8() );
   }
 
   if ( !d->mScope.contentMimeTypes().isEmpty() ) {
     filter.append( "MIMETYPE" );
     QList<QByteArray> mts;
     foreach ( const QString &mt, d->mScope.contentMimeTypes() )
       mts.append( mt.toUtf8() );
-    filter.append( "(" + ImapParser::join( mts, " " ) + ")" );
+    filter.append( "(" + ImapParser::join( mts, " " ) + ')' );
   }
 
   QList<QByteArray> options;
   if ( d->mScope.includeStatistics() ) {
     options.append( "STATISTICS" );
     options.append( "true" );
   }
   if ( d->mScope.ancestorRetrieval() != CollectionFetchScope::None ) {
     options.append( "ANCESTORS" );
     switch ( d->mScope.ancestorRetrieval() ) {
       case CollectionFetchScope::None:
         options.append( "0" );
         break;
       case CollectionFetchScope::Parent:
         options.append( "1" );
         break;
       case CollectionFetchScope::All:
         options.append( "INF" );
         break;
       default:
         Q_ASSERT( false );
     }
   }
 
   command += ImapParser::join( filter, " " ) + ") (" + ImapParser::join( options, " " ) + ")\n";
   d->writeData( command );
 }
 
 void CollectionFetchJob::doHandleResponse( const QByteArray & tag, const QByteArray & data )
 {
   Q_D( CollectionFetchJob );
 
   if ( tag == "*" ) {
     Collection collection;
     ProtocolHelper::parseCollection( data, collection );
     if ( !collection.isValid() )
       return;
 
     collection.d_ptr->resetChangeLog();
     d->mCollections.append( collection );
     d->mPendingCollections.append( collection );
     if ( !d->mEmitTimer->isActive() )
       d->mEmitTimer->start();
     return;
   }
   kDebug() << "Unhandled server response" << tag << data;
 }
 
 void CollectionFetchJob::setResource(const QString & resource)
 {
   Q_D( CollectionFetchJob );
 
   d->mScope.setResource( resource );
 }
 
 void CollectionFetchJob::slotResult(KJob * job)
 {
   Q_D( CollectionFetchJob );
 
   CollectionFetchJob *list = dynamic_cast<CollectionFetchJob*>( job );
   Q_ASSERT( job );
   d->mCollections += list->collections();
   Job::slotResult( job );
   if ( !job->error() && !hasSubjobs() )
     emitResult();
 }
 
 void CollectionFetchJob::includeUnsubscribed(bool include)
 {
   Q_D( CollectionFetchJob );
 
   d->mScope.setIncludeUnsubscribed( include );
 }
 
 void CollectionFetchJob::includeStatistics(bool include)
 {
   Q_D( CollectionFetchJob );
 
   d->mScope.setIncludeStatistics( include );
 }
 
 void CollectionFetchJob::setFetchScope( const CollectionFetchScope &scope )
 {
   Q_D( CollectionFetchJob );
   d->mScope = scope;
 }
 
 CollectionFetchScope& CollectionFetchJob::fetchScope()
 {
   Q_D( CollectionFetchJob );
   return d->mScope;
 }
 
 #include "collectionfetchjob.moc"
diff --git a/akonadi/protocolhelper.cpp b/akonadi/protocolhelper.cpp
index cdd334b0e..29ab112a0 100644
--- a/akonadi/protocolhelper.cpp
+++ b/akonadi/protocolhelper.cpp
@@ -1,248 +1,248 @@
 /*
     Copyright (c) 2008 Volker Krause <vkrause@kde.org>
 
     This library is free software; you can redistribute it and/or modify it
     under the terms of the GNU Library General Public License as published by
     the Free Software Foundation; either version 2 of the License, or (at your
     option) any later version.
 
     This library is distributed in the hope that it will be useful, but WITHOUT
     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
     License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to the
     Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     02110-1301, USA.
 */
 
 #include "protocolhelper_p.h"
 
 #include "attributefactory.h"
 #include "collectionstatistics.h"
 #include "exception.h"
 #include <akonadi/private/imapparser_p.h>
 #include <akonadi/private/protocol_p.h>
 
 #include <QtCore/QVarLengthArray>
 
 #include <kdebug.h>
 #include <klocale.h>
 
 #include <boost/bind.hpp>
 #include <algorithm>
 
 using namespace Akonadi;
 
 int ProtocolHelper::parseCachePolicy(const QByteArray & data, CachePolicy & policy, int start)
 {
   QVarLengthArray<QByteArray,16> params;
   int end = Akonadi::ImapParser::parseParenthesizedList( data, params, start );
   for ( int i = 0; i < params.count() - 1; i += 2 ) {
     const QByteArray key = params[i];
     const QByteArray value = params[i + 1];
 
     if ( key == "INHERIT" )
       policy.setInheritFromParent( value == "true" );
     else if ( key == "INTERVAL" )
       policy.setIntervalCheckTime( value.toInt() );
     else if ( key == "CACHETIMEOUT" )
       policy.setCacheTimeout( value.toInt() );
     else if ( key == "SYNCONDEMAND" )
       policy.setSyncOnDemand( value == "true" );
     else if ( key == "LOCALPARTS" ) {
       QVarLengthArray<QByteArray,16> tmp;
       QStringList parts;
       Akonadi::ImapParser::parseParenthesizedList( value, tmp );
       for ( int j=0; j<tmp.size(); j++ )
         parts << QString::fromLatin1( tmp[j] );
       policy.setLocalParts( parts );
     }
   }
   return end;
 }
 
 QByteArray ProtocolHelper::cachePolicyToByteArray(const CachePolicy & policy)
 {
   QByteArray rv = "CACHEPOLICY (";
   if ( policy.inheritFromParent() ) {
     rv += "INHERIT true";
   } else {
     rv += "INHERIT false";
     rv += " INTERVAL " + QByteArray::number( policy.intervalCheckTime() );
     rv += " CACHETIMEOUT " + QByteArray::number( policy.cacheTimeout() );
     rv += " SYNCONDEMAND " + ( policy.syncOnDemand() ? QByteArray("true") : QByteArray("false") );
     rv += " LOCALPARTS (" + policy.localParts().join( QLatin1String(" ") ).toLatin1() + ')';
   }
   rv += ')';
   return rv;
 }
 
 int ProtocolHelper::parseCollection(const QByteArray & data, Collection & collection, int start)
 {
   int pos = start;
 
   // collection and parent id
   Collection::Id colId = -1;
   bool ok = false;
   pos = ImapParser::parseNumber( data, colId, &ok, pos );
   if ( !ok || colId <= 0 ) {
     kDebug() << "Could not parse collection id from response:" << data;
     return start;
   }
 
   Collection::Id parentId = -1;
   pos = ImapParser::parseNumber( data, parentId, &ok, pos );
   if ( !ok || parentId < 0 ) {
     kDebug() << "Could not parse parent id from response:" << data;
     return start;
   }
 
   collection = Collection( colId );
   collection.setParentCollection( Collection( parentId ) );
 
   // attributes
   QVarLengthArray<QByteArray,16> attributes;
   pos = ImapParser::parseParenthesizedList( data, attributes, pos );
 
   for ( int i = 0; i < attributes.count() - 1; i += 2 ) {
     const QByteArray key = attributes[i];
     const QByteArray value = attributes[i + 1];
 
     if ( key == "NAME" ) {
       collection.setName( QString::fromUtf8( value ) );
     } else if ( key == "REMOTEID" ) {
       collection.setRemoteId( QString::fromUtf8( value ) );
     } else if ( key == "RESOURCE" ) {
       collection.setResource( QString::fromUtf8( value ) );
     } else if ( key == "MIMETYPE" ) {
       QVarLengthArray<QByteArray,16> ct;
       ImapParser::parseParenthesizedList( value, ct );
       QStringList ct2;
       for ( int j = 0; j < ct.size(); j++ )
         ct2 << QString::fromLatin1( ct[j] );
       collection.setContentMimeTypes( ct2 );
     } else if ( key == "MESSAGES" ) {
       CollectionStatistics s = collection.statistics();
       s.setCount( value.toLongLong() );
       collection.setStatistics( s );
     } else if ( key == "UNSEEN" ) {
       CollectionStatistics s = collection.statistics();
       s.setUnreadCount( value.toLongLong() );
       collection.setStatistics( s );
     } else if ( key == "SIZE" ) {
       CollectionStatistics s = collection.statistics();
       s.setSize( value.toLongLong() );
       collection.setStatistics( s );
     } else if ( key == "CACHEPOLICY" ) {
       CachePolicy policy;
       ProtocolHelper::parseCachePolicy( value, policy );
       collection.setCachePolicy( policy );
     } else if ( key == "ANCESTORS" ) {
       QList<QByteArray> ancestors;
       ImapParser::parseParenthesizedList( value, ancestors );
       Collection* currentCol = &collection;
-      foreach ( const QByteArray uidRidPair, ancestors ) {
+      foreach ( const QByteArray &uidRidPair, ancestors ) {
         QList<QByteArray> parentIds;
         ImapParser::parseParenthesizedList( uidRidPair, parentIds );
         if ( parentIds.size() != 2 )
           break;
         const Collection::Id uid = parentIds.at( 0 ).toLongLong();
         const QString rid = QString::fromUtf8( parentIds.at( 1 ) );
         if ( uid == Collection::root().id() ) {
           currentCol->setParentCollection( Collection::root() );
           break;
         }
         currentCol->parentCollection().setId( uid );
         currentCol->parentCollection().setRemoteId( rid );
         currentCol = &currentCol->parentCollection();
       }
     } else {
       Attribute* attr = AttributeFactory::createAttribute( key );
       Q_ASSERT( attr );
       attr->deserialize( value );
       collection.addAttribute( attr );
     }
   }
 
   return pos;
 }
 
 QByteArray ProtocolHelper::attributesToByteArray(const Entity & entity, bool ns )
 {
   QList<QByteArray> l;
   foreach ( const Attribute *attr, entity.attributes() ) {
     l << encodePartIdentifier( ns ? PartAttribute : PartGlobal, attr->type() );
     l << ImapParser::quote( attr->serialized() );
   }
   return ImapParser::join( l, " " );
 }
 
 QByteArray ProtocolHelper::encodePartIdentifier(PartNamespace ns, const QByteArray & label, int version )
 {
   const QByteArray versionString( version != 0 ? '[' + QByteArray::number( version ) + ']' : "" );
   switch ( ns ) {
     case PartGlobal:
       return label + versionString;
     case PartPayload:
       return "PLD:" + label + versionString;
     case PartAttribute:
       return "ATR:" + label + versionString;
     default:
       Q_ASSERT( false );
   }
   return QByteArray();
 }
 
 QByteArray ProtocolHelper::decodePartIdentifier( const QByteArray &data, PartNamespace & ns )
 {
   if ( data.startsWith( "PLD:" ) ) { //krazy:exclude=strings
     ns = PartPayload;
     return data.mid( 4 );
   } else if ( data.startsWith( "ATR:" ) ) { //krazy:exclude=strings
     ns = PartAttribute;
     return data.mid( 4 );
   } else {
     ns = PartGlobal;
     return data;
   }
 }
 
 QByteArray ProtocolHelper::itemSetToByteArray( const Item::List &_items, const QByteArray &command )
 {
   if ( _items.isEmpty() )
     throw Exception( "No items specified" );
 
   Item::List items( _items );
 
   QByteArray rv;
   std::sort( items.begin(), items.end(), boost::bind( &Item::id, _1 ) < boost::bind( &Item::id, _2 ) );
   if ( items.first().isValid() ) {
     // all items have a uid set
     rv += " " AKONADI_CMD_UID " ";
     rv += command;
     rv += ' ';
     QList<Item::Id>  uids;
     foreach ( const Item &item, items )
       uids << item.id();
     ImapSet set;
     set.add( uids );
     rv += set.toImapSequenceSet();
   } else {
     // check if all items have a remote id
     QList<QByteArray> rids;
     foreach ( const Item &item, items ) {
       if ( item.remoteId().isEmpty() )
         throw Exception( i18n( "No remote identifier specified" ) );
       rids << ImapParser::quote( item.remoteId().toUtf8() );
     }
 
     rv += " " AKONADI_CMD_RID " ";
     rv += command;
     rv += " (";
     rv += ImapParser::join( rids, " " );
     rv += ')';
   }
   return rv;
 }