performance optimization during vCard loading

2 files changed, 29 insertions, 26 deletions

diff --git a/kabc/vcardformatimpl.cpp b/kabc/vcardformatimpl.cpp
index 3fcaf94..bd9a57b 100644
--- a/kabc/vcardformatimpl.cpp
+++ b/kabc/vcardformatimpl.cpp
@@ -1,223 +1,225 @@
 /*
     This file is part of libkabc.
     Copyright (c) 2001 Cornelius Schumacher <schumacher@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., 59 Temple Place - Suite 330,
     Boston, MA 02111-1307, USA.
 */
 
 /*
 Enhanced Version of the file for platform independent KDE tools.
 Copyright (c) 2004 Ulf Schenk
 
 $Id$
 */
 
 #include <qfile.h>
 #include <qregexp.h>
 
 #include <kdebug.h>
 #include <kmdcodec.h>
 #include <kstandarddirs.h>
 #include <ktempfile.h>
 
 #include <VCard.h>
 
 #include "addressbook.h"
 #include "vcardformatimpl.h"
 
 using namespace KABC;
 using namespace VCARD;
 
 bool VCardFormatImpl::load( Addressee &addressee, QFile *file )
 {
   kdDebug(5700) << "VCardFormat::load()" << endl;
 
   QByteArray fdata = file->readAll();
   QCString data(fdata.data(), fdata.size()+1);
 
   VCardEntity e( data );
 
   VCardListIterator it( e.cardList() );
 
   if ( it.current() ) {
-    VCard v(*it.current());
-    loadAddressee( addressee, v );
+//US    VCard v(*it.current());
+//US    loadAddressee( addressee, v );
+    loadAddressee( addressee, it.current() );
     return true;
   }
 
   return false;
 }
 
 bool VCardFormatImpl::loadAll( AddressBook *addressBook, Resource *resource, QFile *file )
 {
   kdDebug(5700) << "VCardFormat::loadAll()" << endl;
 
   QByteArray fdata = file->readAll();
   QCString data(fdata.data(), fdata.size()+1);
 
   VCardEntity e( data );
 
   VCardListIterator it( e.cardList() );
 
   for (; it.current(); ++it) {
-    VCard v(*it.current());
+//US    VCard v(*it.current());
     Addressee addressee;
-    loadAddressee( addressee, v );
+//US    loadAddressee( addressee, v );
+    loadAddressee( addressee, it.current() );
     addressee.setResource( resource );
     addressBook->insertAddressee( addressee );
   }
 
   return true;
 }
 
 void VCardFormatImpl::save( const Addressee &addressee, QFile *file )
 {
   VCardEntity vcards;
   VCardList vcardlist;
   vcardlist.setAutoDelete( true );
 
   VCard *v = new VCard;
 
   saveAddressee( addressee, v, false );
 
   vcardlist.append( v );
   vcards.setCardList( vcardlist );
 
   QCString vcardData = vcards.asString();
   file->writeBlock( (const char*)vcardData, vcardData.length() );
 }
 
 void VCardFormatImpl::saveAll( AddressBook *ab, Resource *resource, QFile *file )
 {
   VCardEntity vcards;
   VCardList vcardlist;
   vcardlist.setAutoDelete( true );
 
   AddressBook::Iterator it;
   for ( it = ab->begin(); it != ab->end(); ++it ) {
     if ( (*it).resource() == resource ) {
       VCard *v = new VCard;
       saveAddressee( (*it), v, false );
       (*it).setChanged( false );
       vcardlist.append( v );
     }
   }
 
   vcards.setCardList( vcardlist );
 
   QCString vcardData = vcards.asString();
   file->writeBlock( (const char*)vcardData, vcardData.length() );
 }
 
-bool VCardFormatImpl::loadAddressee( Addressee& addressee, VCard &v )
+bool VCardFormatImpl::loadAddressee( Addressee& addressee, VCard *v )
 {
-  QPtrList<ContentLine> contentLines = v.contentLineList();
+  QPtrList<ContentLine> contentLines = v->contentLineList();
   ContentLine *cl;
 
   for( cl = contentLines.first(); cl; cl = contentLines.next() ) {
     QCString n = cl->name();
     if ( n.left( 2 ) == "X-" ) {
       n = n.mid( 2 );
       int posDash = n.find( "-" );
       addressee.insertCustom( QString::fromUtf8( n.left( posDash ) ),
                         QString::fromUtf8( n.mid( posDash + 1 ) ),
                         QString::fromUtf8( cl->value()->asString() ) );
         continue;
     }
 
     EntityType type = cl->entityType();
     switch( type ) {
 
       case EntityUID:
         addressee.setUid( readTextValue( cl ) );
         break;
 
       case EntityEmail:
         addressee.insertEmail( readTextValue( cl ) );
         break;
 
       case EntityName:
         addressee.setName( readTextValue( cl ) );
         break;
 
       case EntityFullName:
         addressee.setFormattedName( readTextValue( cl ) );
         break;
 
       case EntityURL:
         addressee.setUrl( KURL( readTextValue( cl ) ) );
         break;
 
       case EntityNickname:
         addressee.setNickName( readTextValue( cl ) );
         break;
 
       case EntityLabel:
         // not yet supported by kabc
         break;
 
       case EntityMailer:
         addressee.setMailer( readTextValue( cl ) );
         break;
 
       case EntityTitle:
         addressee.setTitle( readTextValue( cl ) );
         break;
 
       case EntityRole:
         addressee.setRole( readTextValue( cl ) );
         break;
 
       case EntityOrganisation:
         addressee.setOrganization( readTextValue( cl ) );
         break;
 
       case EntityNote:
         addressee.setNote( readTextValue( cl ) );
         break;
 
       case EntityProductID:
         addressee.setProductId( readTextValue( cl ) );
         break;
 
       case EntitySortString:
         addressee.setSortString( readTextValue( cl ) );
         break;
 
       case EntityN:
         readNValue( cl, addressee );
         break;
 
       case EntityAddress:
         addressee.insertAddress( readAddressValue( cl ) );
         break;
 
       case EntityTelephone:
         addressee.insertPhoneNumber( readTelephoneValue( cl ) );
         break;
 
       case EntityCategories:
         addressee.setCategories( QStringList::split( ",", readTextValue( cl ) ) );
         break;
 
       case EntityBirthday:
         addressee.setBirthday( readDateValue( cl ) );
         break;
 
       case EntityRevision:
         addressee.setRevision( readDateTimeValue( cl ) );
         break;
 
@@ -691,337 +693,338 @@ Secrecy VCardFormatImpl::readClassValue( ContentLine *cl )
         secrecy.setType( Secrecy::Private );
         break;
       case ClassValue::Confidential:
         secrecy.setType( Secrecy::Confidential );
         break;
     }
 
     return secrecy;
   } else
     return Secrecy();
 }
 
 void VCardFormatImpl::addKeyValue( VCARD::VCard *vcard, const Key &key )
 {
   ContentLine cl;
   cl.setName( EntityTypeToParamName( EntityKey ) );
 
   ParamList params;
   if ( key.isBinary() ) {
     cl.setValue( new TextValue( KCodecs::base64Encode( key.binaryData() ) ) );
     params.append( new Param( "ENCODING", "b" ) );
   } else {
     cl.setValue( new TextValue( key.textData().utf8() ) );
   }
 
   switch ( key.type() ) {
     case Key::X509:
       params.append( new Param( "TYPE", "X509" ) );
       break;
     case Key::PGP:
       params.append( new Param( "TYPE", "PGP" ) );
       break;
     case Key::Custom:
       params.append( new Param( "TYPE", key.customTypeString().utf8() ) );
       break;
   }
 
   cl.setParamList( params );
   vcard->add( cl );
 }
 
 Key VCardFormatImpl::readKeyValue( VCARD::ContentLine *cl )
 {
   Key key;
   bool isBinary = false;
   TextValue *v = (TextValue *)cl->value();
 
   ParamList params = cl->paramList();
   ParamListIterator it( params );
   for( ; it.current(); ++it ) {
     if ( (*it)->name() == "ENCODING" && (*it)->value() == "b" )
       isBinary = true;
     if ( (*it)->name() == "TYPE" ) {
       if ( (*it)->value().isEmpty() )
         continue;
       if ( (*it)->value() == "X509" )
         key.setType( Key::X509 );
       else if ( (*it)->value() == "PGP" )
         key.setType( Key::PGP );
       else {
         key.setType( Key::Custom );
         key.setCustomTypeString( QString::fromUtf8( (*it)->value() ) );
       }
     }
   }
 
 
   if ( isBinary ) {
     QByteArray data;
     KCodecs::base64Decode( v->asString().stripWhiteSpace(), data );
     key.setBinaryData( data );
   } else {
     key.setTextData( QString::fromUtf8( v->asString() ) );
   }
 
   return key;
 }
 
 
 void VCardFormatImpl::addAgentValue( VCARD::VCard *vcard, const Agent &agent )
 {
   if ( agent.isIntern() && !agent.addressee() )
     return;
 
   if ( !agent.isIntern() && agent.url().isEmpty() )
     return;
 
   ContentLine cl;
   cl.setName( EntityTypeToParamName( EntityAgent ) );
 
   ParamList params;
   if ( agent.isIntern() ) {
     QString vstr;
     Addressee *addr = agent.addressee();
     if ( addr ) {
       writeToString( (*addr), vstr );
-      
+
       qDebug("VCardFormatImpl::addAgentValue please verify if replace is correct");
-/*US      
+/*US
       vstr.replace( ":", "\\:" );
       vstr.replace( ",", "\\," );
       vstr.replace( ";", "\\;" );
       vstr.replace( "\r\n", "\\n" );
-*/      
-      vstr.replace( QRegExp(":"), "\\:" );   
-      vstr.replace( QRegExp(","), "\\," );   
-      vstr.replace( QRegExp(";"), "\\;" );   
-      vstr.replace( QRegExp("\r\n"), "\\n" );   
-      
+*/
+      vstr.replace( QRegExp(":"), "\\:" );
+      vstr.replace( QRegExp(","), "\\," );
+      vstr.replace( QRegExp(";"), "\\;" );
+      vstr.replace( QRegExp("\r\n"), "\\n" );
+
       cl.setValue( new TextValue( vstr.utf8() ) );
     } else
       return;
   } else {
     cl.setValue( new TextValue( agent.url().utf8() ) );
     params.append( new Param( "VALUE", "uri" ) );
   }
 
   cl.setParamList( params );
   vcard->add( cl );
 }
 
 Agent VCardFormatImpl::readAgentValue( VCARD::ContentLine *cl )
 {
   Agent agent;
   bool isIntern = true;
   TextValue *v = (TextValue *)cl->value();
 
   ParamList params = cl->paramList();
   ParamListIterator it( params );
   for( ; it.current(); ++it ) {
     if ( (*it)->name() == "VALUE" && (*it)->value() == "uri" )
       isIntern = false;
   }
 
   if ( isIntern ) {
     QString vstr = QString::fromUtf8( v->asString() );
     qDebug("VCardFormatImpl::addAgentValue please verify if replace is correct");
-/*US    
+/*US
     vstr.replace( "\\n", "\r\n" );
     vstr.replace( "\\:", ":" );
     vstr.replace( "\\,", "," );
     vstr.replace( "\\;", ";" );
 */
-    vstr.replace( QRegExp("\\n"), "\r\n" );   
-    vstr.replace( QRegExp("\\:"), ":" );   
-    vstr.replace( QRegExp("\\,"), "," );   
-    vstr.replace( QRegExp("\\;"), ";" );   
-    
+    vstr.replace( QRegExp("\\n"), "\r\n" );
+    vstr.replace( QRegExp("\\:"), ":" );
+    vstr.replace( QRegExp("\\,"), "," );
+    vstr.replace( QRegExp("\\;"), ";" );
+
     Addressee *addr = new Addressee;
     readFromString( vstr, *addr );
     agent.setAddressee( addr );
   } else {
     agent.setUrl( QString::fromUtf8( v->asString() ) );
   }
 
   return agent;
 }
 
 void VCardFormatImpl::addPictureValue( VCARD::VCard *vcard, VCARD::EntityType type, const Picture &pic, const Addressee &addr, bool intern )
 {
   ContentLine cl;
   cl.setName( EntityTypeToParamName( type ) );
 
   if ( pic.isIntern() && pic.data().isNull() )
     return;
 
   if ( !pic.isIntern() && pic.url().isEmpty() )
     return;
 
   ParamList params;
   if ( pic.isIntern() ) {
     QImage img = pic.data();
     if ( intern ) { // only for vCard export we really write the data inline
       QByteArray data;
       QDataStream s( data, IO_WriteOnly );
       s.setVersion( 4 ); // to produce valid png files
       s << img;
       cl.setValue( new TextValue( KCodecs::base64Encode( data ) ) );
-      
+
     } else { // save picture in cache
       QString dir;
       if ( type == EntityPhoto )
         dir = "photos";
       if ( type == EntityLogo )
         dir = "logos";
 
       img.save( locateLocal( "data", "kabc/" + dir + "/" + addr.uid() ), pic.type().utf8() );
       cl.setValue( new TextValue( "<dummy>" ) );
     }
     params.append( new Param( "ENCODING", "b" ) );
     if ( !pic.type().isEmpty() )
       params.append( new Param( "TYPE", pic.type().utf8() ) );
   } else {
-  
+
     cl.setValue( new TextValue( pic.url().utf8() ) );
     params.append( new Param( "VALUE", "uri" ) );
   }
 
   cl.setParamList( params );
   vcard->add( cl );
 }
 
 Picture VCardFormatImpl::readPictureValue( VCARD::ContentLine *cl, VCARD::EntityType type, const Addressee &addr )
 {
   Picture pic;
   bool isInline = false;
   QString picType;
   TextValue *v = (TextValue *)cl->value();
 
   ParamList params = cl->paramList();
   ParamListIterator it( params );
   for( ; it.current(); ++it ) {
     if ( (*it)->name() == "ENCODING" && (*it)->value() == "b" )
       isInline = true;
     if ( (*it)->name() == "TYPE" && !(*it)->value().isEmpty() )
       picType = QString::fromUtf8( (*it)->value() );
   }
 
   if ( isInline ) {
     QImage img;
     if ( v->asString() == "<dummy>" ) { // no picture inline stored => picture is in cache
       QString dir;
       if ( type == EntityPhoto )
         dir = "photos";
       if ( type == EntityLogo )
         dir = "logos";
 
       img.load( locateLocal( "data", "kabc/" + dir + "/" + addr.uid() ) );
     } else {
       QByteArray data;
       KCodecs::base64Decode( v->asString(), data );
       img.loadFromData( data );
     }
     pic.setData( img );
     pic.setType( picType );
   } else {
     pic.setUrl( QString::fromUtf8( v->asString() ) );
   }
 
   return pic;
 }
 
 void VCardFormatImpl::addSoundValue( VCARD::VCard *vcard, const Sound &sound, const Addressee &addr, bool intern )
 {
   ContentLine cl;
   cl.setName( EntityTypeToParamName( EntitySound ) );
 
   if ( sound.isIntern() && sound.data().isNull() )
     return;
 
   if ( !sound.isIntern() && sound.url().isEmpty() )
     return;
 
   ParamList params;
   if ( sound.isIntern() ) {
     QByteArray data = sound.data();
     if ( intern ) { // only for vCard export we really write the data inline
         cl.setValue( new TextValue( KCodecs::base64Encode( data ) ) );
     } else { // save sound in cache
       QFile file( locateLocal( "data", "kabc/sounds/" + addr.uid() ) );
       if ( file.open( IO_WriteOnly ) ) {
         file.writeBlock( data );
       }
       cl.setValue( new TextValue( "<dummy>" ) );
     }
     params.append( new Param( "ENCODING", "b" ) );
   } else {
     cl.setValue( new TextValue( sound.url().utf8() ) );
     params.append( new Param( "VALUE", "uri" ) );
   }
 
   cl.setParamList( params );
   vcard->add( cl );
 }
 
 Sound VCardFormatImpl::readSoundValue( VCARD::ContentLine *cl, const Addressee &addr )
 {
   Sound sound;
   bool isInline = false;
   TextValue *v = (TextValue *)cl->value();
 
   ParamList params = cl->paramList();
   ParamListIterator it( params );
   for( ; it.current(); ++it ) {
     if ( (*it)->name() == "ENCODING" && (*it)->value() == "b" )
       isInline = true;
   }
 
   if ( isInline ) {
     QByteArray data;
     if ( v->asString() == "<dummy>" ) { // no sound inline stored => sound is in cache
       QFile file( locateLocal( "data", "kabc/sounds/" + addr.uid() ) );
       if ( file.open( IO_ReadOnly ) ) {
         data = file.readAll();
         file.close();
       }
     } else {
       KCodecs::base64Decode( v->asString(), data );
     }
     sound.setData( data );
   } else {
     sound.setUrl( QString::fromUtf8( v->asString() ) );
   }
 
   return sound;
 }
 
 bool VCardFormatImpl::readFromString( const QString &vcard, Addressee &addressee )
 {
   VCardEntity e( vcard.utf8() );
   VCardListIterator it( e.cardList() );
 
   if ( it.current() ) {
-    VCard v(*it.current());
-    loadAddressee( addressee, v );
+//US    VCard v(*it.current());
+//US    loadAddressee( addressee, v );
+    loadAddressee( addressee, it.current() );
     return true;
   }
 
   return false;
 }
 
 bool VCardFormatImpl::writeToString( const Addressee &addressee, QString &vcard )
 {
   VCardEntity vcards;
   VCardList vcardlist;
   vcardlist.setAutoDelete( true );
 
   VCard *v = new VCard;
 
   saveAddressee( addressee, v, true );
 
   vcardlist.append( v );
   vcards.setCardList( vcardlist );
   vcard = QString::fromUtf8( vcards.asString() );
 
   return true;
 }
diff --git a/kabc/vcardformatimpl.h b/kabc/vcardformatimpl.h
index 2dd68d9..fa3d55f 100644
--- a/kabc/vcardformatimpl.h
+++ b/kabc/vcardformatimpl.h
@@ -1,112 +1,112 @@
 /*
     This file is part of libkabc.
     Copyright (c) 2001 Cornelius Schumacher <schumacher@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., 59 Temple Place - Suite 330,
     Boston, MA 02111-1307, USA.
 */
 
 /*
 Enhanced Version of the file for platform independent KDE tools.
 Copyright (c) 2004 Ulf Schenk
 
 $Id$
 */
 
 #ifndef KABC_VCARDFORMATIMPL_H
 #define KABC_VCARDFORMATIMPL_H
 
 #include <qstring.h>
 #include <qfile.h>
 
 #include "address.h"
 #include "addressee.h"
 
 #include <VCard.h>
 
 namespace KABC {
 
 class AddressBook;
 
 /**
   @short Implementation of vCard backend for address book.
-  
+
   This class implements reading and writing of address book information using
   the vCard format. It requires the vCard lib from kdepim.
 */
 class VCardFormatImpl
 {
   public:
     bool load( Addressee &, QFile *file );
     bool loadAll( AddressBook *, Resource *, QFile *file );
     void save( const Addressee &, QFile *file );
     void saveAll( AddressBook *, Resource *, QFile *file );
 
     bool readFromString( const QString &vcard, Addressee &addr );
     bool writeToString( const Addressee &addressee, QString &vcard );
 
   protected:
-    bool loadAddressee( Addressee &, VCARD::VCard & );
+    bool loadAddressee( Addressee &, VCARD::VCard * );
     void saveAddressee( const Addressee &, VCARD::VCard *, bool intern );
 
     void addTextValue (VCARD::VCard *, VCARD::EntityType, const QString & );
     QString readTextValue( VCARD::ContentLine * );
 
     void addDateValue( VCARD::VCard *, VCARD::EntityType, const QDate & );
     QDate readDateValue( VCARD::ContentLine * );
 
     void addDateTimeValue( VCARD::VCard *, VCARD::EntityType, const QDateTime & );
     QDateTime readDateTimeValue( VCARD::ContentLine * );
 
     void addAddressValue( VCARD::VCard *, const Address & );
     Address readAddressValue( VCARD::ContentLine * );
 
     void addLabelValue( VCARD::VCard *, const Address & );
 
     void addTelephoneValue( VCARD::VCard *, const PhoneNumber & );
     PhoneNumber readTelephoneValue( VCARD::ContentLine * );
 
     void addNValue( VCARD::VCard *, const Addressee & );
     void readNValue( VCARD::ContentLine *, Addressee & );
 
     void addCustomValue( VCARD::VCard *, const QString & );
 
     void addAddressParam( VCARD::ContentLine *, int );
     int readAddressParam( VCARD::ContentLine * );
 
     void addGeoValue( VCARD::VCard *, const Geo & );
     Geo readGeoValue( VCARD::ContentLine * );
 
     void addUTCValue( VCARD::VCard *, const TimeZone & );
     TimeZone readUTCValue( VCARD::ContentLine * );
 
     void addClassValue( VCARD::VCard *, const Secrecy & );
     Secrecy readClassValue( VCARD::ContentLine * );
 
     void addKeyValue( VCARD::VCard *, const Key & );
     Key readKeyValue( VCARD::ContentLine * );
 
     void addPictureValue( VCARD::VCard *, VCARD::EntityType, const Picture &, const Addressee &, bool );
     Picture readPictureValue( VCARD::ContentLine *, VCARD::EntityType, const Addressee &addr );
 
     void addSoundValue( VCARD::VCard *, const Sound &, const Addressee &, bool );
     Sound readSoundValue( VCARD::ContentLine *, const Addressee &addr );
 
     void addAgentValue( VCARD::VCard *, const Agent & );
     Agent readAgentValue( VCARD::ContentLine * );
 };
 
 }
 #endif