many AB fixes

4 files changed, 15 insertions, 6 deletions

diff --git a/kabc/addressbook.cpp b/kabc/addressbook.cpp
index 8487ff3..4de7da2 100644
--- a/kabc/addressbook.cpp
+++ b/kabc/addressbook.cpp
@@ -827,214 +827,221 @@ void AddressBook::removeAddressee( const Addressee &a )
     if ( a.uid() == (*it).uid() ) {
         found = true;
         it2 = it;
     } else {
         if ( (*it).uid().left( 19 ) == QString("last-syncAddressee-") ) {
             QString name = (*it).uid().mid( 19 );
             Addressee b = a;
             QString id = b.getID( name );
             if ( ! id.isEmpty() ) {
                 QString des = (*it).note();
                 if( des.find( id ) < 0 ) {
                     des +=   id  + ",";
                     (*it).setNote( des );
                 }
             }
         }
         
     }
   }
 
   if ( found )
       removeAddressee( it2 );
       
 }
 
 void AddressBook::removeSyncAddressees( bool removeDeleted )
 {
     Iterator it = begin();
     Iterator it2 ;
     QDateTime dt ( QDate( 2003,1,1) );
     while ( it != end() ) {
         (*it).setRevision( dt );
         if (( *it).IDStr() != "changed" ) { 
             // "changed" is used for tagging changed addressees when syncing with KDE or OL
             (*it).removeCustom( "KADDRESSBOOK", "X-ExternalID" );
             (*it).setIDStr(":");
         }
         if ( ( (*it).tempSyncStat() == SYNC_TEMPSTATE_DELETE && removeDeleted  )|| (*it).uid().left( 19 ) == QString("last-syncAddressee-")) {
             it2 = it;
             //qDebug("removing %s ",(*it).uid().latin1() );
             ++it;
             removeAddressee( it2 );
         } else  {
             //qDebug("skipping %s ",(*it).uid().latin1() );
             if ( removeDeleted ) {
                 // we have no postprocessing in the resource, we have to do it here
                 // we have to compute csum for all, because it could be the first sync
                 (*it).setTempSyncStat( SYNC_TEMPSTATE_NEW_ID );
             }
             ++it;
         }
     }
     deleteRemovedAddressees();
 }
 
 void AddressBook::removeAddressee( const Iterator &it )
 {
   d->mRemovedAddressees.append( (*it) );
   d->mAddressees.remove( it.d->mIt );
 }
 
 AddressBook::Iterator AddressBook::find( const Addressee &a )
 {
   Iterator it;
   for ( it = begin(); it != end(); ++it ) {
     if ( a.uid() == (*it).uid() ) {
       return it;
     }
   }
   return end();
 }
 
 Addressee AddressBook::findByUid( const QString &uid )
 {
   Iterator it;
   for ( it = begin(); it != end(); ++it ) {
     if ( uid == (*it).uid() ) {
       return *it;
     }
   }
   return Addressee();
 }
 void AddressBook::preExternSync( AddressBook* aBook, const QString& csd , bool isSubset )
 {
     //qDebug("AddressBook::preExternSync ");
     AddressBook::Iterator it;  
     for ( it = begin(); it != end(); ++it ) {
         (*it).setID( csd, (*it).externalUID() );
         (*it).computeCsum( csd );
     }
     mergeAB( aBook ,csd, isSubset );  
 }
 void AddressBook::postExternSync( AddressBook* aBook , const QString& csd, bool setID)
 {
     //qDebug("AddressBook::postExternSync ");
     AddressBook::Iterator it;  
+    int foundEmpty = 0;
     for ( it = begin(); it != end(); ++it ) {
         //qDebug("check uid %s ", (*it).uid().latin1() );
         if ( (*it).tempSyncStat() == SYNC_TEMPSTATE_NEW_ID ||
              (*it).tempSyncStat() == SYNC_TEMPSTATE_NEW_CSUM ||
              (*it).tempSyncStat() == SYNC_TEMPSTATE_ADDED_EXTERNAL) {
             Addressee ad = aBook->findByUid( ( (*it).uid() ));
             if ( ad.isEmpty() ) {
-                qDebug("postExternSync:ERROR addressee is empty: %s ", (*it).uid().latin1());
+                ++foundEmpty;
+                //qDebug("postExternSync:addressee is empty: %s ", (*it).uid().latin1());
+                //qDebug("-- formatted name %s ",(*it).formattedName().latin1() );
             } else {
                 (*it).setIDStr(":");
                 if ( setID ) {
                     if ( (*it).tempSyncStat() == SYNC_TEMPSTATE_NEW_ID )
                         ad.setID( csd, (*it).externalUID() );
                 } else
                     ad.setID( csd, (*it).uid() );
                 (*it).computeCsum( csd );
                 ad.setCsum( csd, (*it).getCsum( csd ) );
                 //qDebug("CSUM %s ",(*it).getCsum( csd ).latin1() );
                 aBook->insertAddressee( ad , false);
             }
         }
     }
+    if ( foundEmpty ) {
+        qDebug("postExternSync:%d empty addressees found:\n  probably filtered out by incoming sync filter.",foundEmpty  );
+    }
+        
 }
 
 bool   AddressBook::containsExternalUid( const QString& uid  )
 {
     Iterator it;
     for ( it = begin(); it != end(); ++it ) {
         if ( uid == (*it).externalUID( ) )
             return true;
     }
     return false;
 }
 Addressee   AddressBook::findByExternUid( const QString& uid , const QString& profile  )
 {
     Iterator it;
     for ( it = begin(); it != end(); ++it ) {
         if ( uid == (*it).getID( profile ) )
             return (*it);
     }
     return Addressee();
 }
 void  AddressBook::mergeAB( AddressBook *aBook, const QString& profile , bool isSubset )
 {
     Iterator it;
     Addressee ad;
     for ( it = begin(); it != end(); ++it ) {
         ad = aBook->findByExternUid( (*it).externalUID(), profile );
             if ( !ad.isEmpty() ) {
                 (*it).mergeContact( ad ,isSubset);
             }
     }
 #if 0 
     // test only
     for ( it = begin(); it != end(); ++it ) {
         
         qDebug("uid %s ", (*it).uid().latin1());
     }
 #endif
 }
 
 #if 0
 Addressee::List AddressBook::getExternLastSyncAddressees()
 {
     Addressee::List results;
 
   Iterator it;
   for ( it = begin(); it != end(); ++it ) {
     if ( (*it).uid().left( 19 ) == "last-syncAddressee-"  ) {
         if ( (*it).familyName().left(4) == "!E: " )
             results.append( *it );
     }
   }
 
   return results;
 }
 #endif
 void AddressBook::resetTempSyncStat()
 {
     Iterator it;
   for ( it = begin(); it != end(); ++it ) {
       (*it).setTempSyncStat ( SYNC_TEMPSTATE_INITIAL );
   }
 
 }
  
 QStringList AddressBook:: uidList()
 {
     QStringList results;
     Iterator it;
     for ( it = begin(); it != end(); ++it ) {
         results.append( (*it).uid() );
     }
     return results;
 }
 
 
 Addressee::List AddressBook::allAddressees()
 {
    return d->mAddressees; 
  
 }
 
 Addressee::List AddressBook::findByName( const QString &name )
 {
   Addressee::List results;
 
   Iterator it;
   for ( it = begin(); it != end(); ++it ) {
     if ( name == (*it).realName() ) {
       results.append( *it );
     }
   }
 
   return results;
 }
 
 Addressee::List AddressBook::findByEmail( const QString &email )
diff --git a/kabc/addressee.cpp b/kabc/addressee.cpp
index 568dfc4..d60cd6b 100644
--- a/kabc/addressee.cpp
+++ b/kabc/addressee.cpp
@@ -162,214 +162,216 @@ bool Addressee::operator==( const Addressee &a ) const
   if ( mData->phoneNumbers != a.mData->phoneNumbers ) return false;
   if ( mData->addresses != a.mData->addresses ) return false;
   if ( mData->keys != a.mData->keys ) return false;
   if ( mData->emails != a.mData->emails ) return false;
   if ( mData->categories != a.mData->categories ) return false;
   if ( mData->custom != a.mData->custom ) return false;
 
   return true;
 }
 
 bool Addressee::operator!=( const Addressee &a ) const
 {
   return !( a == *this );
 }
 
 bool Addressee::isEmpty() const
 {
   return mData->empty;
 }
 ulong  Addressee::getCsum4List( const QStringList &  attList)
 {
     int max = attList.count();
     ulong cSum = 0;
     int j,k,i;
     int add;
     for ( i = 0; i < max ; ++i ) {
         QString s = attList[i];
         if ( ! s.isEmpty() ){
             j = s.length();
             for ( k = 0; k < j; ++k ) {
                 int mul = k +1;
                 add = s[k].unicode ();
                 if ( k < 16 )
                     mul = mul * mul;
                 int ii = i+1;
                 add = add * mul *ii*ii*ii;
                 cSum += add;
             }
         }
             
     }
     //QString dump = attList.join(",");
     //qDebug("csum: %d %s", cSum,dump.latin1()); 
     
     return cSum;
 
 }
 void Addressee::computeCsum(const QString &dev)
 {
     QStringList l;
     //if ( !mData->name.isEmpty() ) l.append(mData->name);
     //if ( !mData->formattedName.isEmpty() ) l.append(mData->formattedName  );
     if ( !mData->familyName.isEmpty()  ) l.append( mData->familyName );
     if ( !mData->givenName.isEmpty() ) l.append(mData->givenName  );
     if ( !mData->additionalName.isEmpty()  ) l.append( mData->additionalName );
     if ( !mData->prefix.isEmpty()  ) l.append( mData->prefix );
     if ( !mData->suffix.isEmpty()  ) l.append( mData->suffix );
     if ( !mData->nickName.isEmpty()  ) l.append( mData->nickName );
     if ( mData->birthday.isValid()  ) l.append( mData->birthday.toString() );
     if ( !mData->mailer.isEmpty() ) l.append( mData->mailer );
     if ( mData->timeZone.isValid() ) l.append( mData->timeZone.asString() );
     if ( mData->geo.isValid() ) l.append( mData->geo.asString() );
     if ( !mData->title .isEmpty() ) l.append( mData->title );
     if ( !mData->role.isEmpty() ) l.append( mData->role );
     if ( !mData->organization.isEmpty() ) l.append( mData->organization ); 
     if ( !mData->note.isEmpty() ) l.append( mData->note ); 
     if ( !mData->productId.isEmpty() ) l.append(mData->productId ); 
     if ( !mData->sortString.isEmpty() ) l.append( mData->sortString ); 
     if ( mData->secrecy.isValid() ) l.append( mData->secrecy.asString()); 
     // if ( !mData->logo.isEmpty() ) l.append(  ); 
     //if ( !mData->photo.isEmpty() ) l.append(  );
     //if ( !mData->sound.isEmpty() ) l.append(  );
     //if ( !mData->agent.isEmpty() ) l.append(  ); 
     if (  mData->url.isValid() )
         if ( ! mData->url.path().isEmpty()) l.append( mData->url.path()  ); 
     KABC::PhoneNumber::List phoneNumbers;
     KABC::PhoneNumber::List::Iterator phoneIter;
 
     QStringList t;
     for ( phoneIter = mData->phoneNumbers.begin(); phoneIter != mData->phoneNumbers.end();
           ++phoneIter )
         t.append( ( *phoneIter ).number()+QString::number( ( *phoneIter ).type() ) );
     t.sort();
     uint iii;
     for ( iii = 0; iii < t.count(); ++iii)
         l.append( t[iii]  );
     t = mData->emails;
     t.sort();
     for ( iii = 0; iii < t.count(); ++iii)
         l.append( t[iii]  );
     t = mData->categories;
     t.sort();
     for ( iii = 0; iii < t.count(); ++iii)
         l.append( t[iii]  );
     t = mData->custom;
     t.sort();
-    for ( iii = 0; iii < t.count(); ++iii)
+    for ( iii = 0; iii < t.count(); ++iii) 
         if ( t[iii].left( 25 ) != "KADDRESSBOOK-X-ExternalID" ) {
             int find = t[iii].find (':')+1;
             //qDebug("lennnn %d %d  ", find, t[iii].length());
             if ( find < t[iii].length())
-                 l.append( t[iii]  );
-
+                l.append( t[iii]  );
+            
         }
     KABC::Address::List::Iterator addressIter;
     for ( addressIter = mData->addresses.begin(); addressIter != mData->addresses.end();
           ++addressIter ) {
         t = (*addressIter).asList();
         t.sort();
         for ( iii = 0; iii < t.count(); ++iii)
             l.append( t[iii]  );
     }
     uint cs = getCsum4List(l);
+
 #if 0
     for ( iii = 0; iii < l.count(); ++iii)
         qDebug("%d***%s***",iii,l[iii].latin1());
     qDebug("CSUM computed %d %s %s", cs,QString::number (cs ).latin1(), uid().latin1() );
 #endif
+    
     setCsum( dev, QString::number (cs ));
 }
 
 void Addressee::mergeContact( const Addressee& ad , bool isSubSet) // = false)
 {
 
     detach();
     if ( mData->name.isEmpty() ) mData->name = ad.mData->name;
     if ( mData->formattedName.isEmpty() ) mData->formattedName  = ad.mData->formattedName;
     if ( mData->familyName.isEmpty()  )  mData->familyName  = ad.mData->familyName;
     if ( mData->givenName.isEmpty() ) mData->givenName   = ad.mData->givenName ;
     if ( mData->additionalName )  mData->additionalName  = ad.mData->additionalName;
     if ( mData->prefix.isEmpty() )  mData->prefix  = ad.mData->prefix;
     if ( mData->suffix.isEmpty() )  mData->suffix  = ad.mData->suffix;
     if ( mData->nickName.isEmpty() )  mData->nickName  = ad.mData->nickName;
     if ( !mData->birthday.isValid() ) 
         if ( ad.mData->birthday.isValid()) 
             mData->birthday =  ad.mData->birthday;
     if ( mData->mailer.isEmpty() ) mData->mailer = ad.mData->mailer;
     if ( !mData->timeZone.isValid() ) mData->timeZone = ad.mData->timeZone;
     if ( !mData->geo.isValid() ) mData->geo = ad.mData->geo;
     if ( mData->title .isEmpty() ) mData->title = ad.mData->title  ;
     if ( mData->role.isEmpty() ) mData->role = ad.mData->role ;
     if ( mData->organization.isEmpty() ) mData->organization = ad.mData->organization ; 
     if ( mData->note.isEmpty() ) mData->note = ad.mData->note ; 
     if ( mData->productId.isEmpty() ) mData->productId  = ad.mData->productId; 
     if ( mData->sortString.isEmpty() )  mData->sortString  = ad.mData->sortString; 
     if ( !mData->secrecy.isValid() ) mData->secrecy = ad.mData->secrecy;
     if ( ( !mData->url.isValid() && ad.mData->url.isValid() ) ) mData->url = ad.mData->url ;
     QStringList t;
     QStringList tAD;
     uint iii;
 
     // ********** phone numbers
     PhoneNumber::List phoneAD = ad.phoneNumbers();
     PhoneNumber::List::Iterator phoneItAD;
     for ( phoneItAD = phoneAD.begin(); phoneItAD != phoneAD.end(); ++phoneItAD ) {
         bool found = false;
         PhoneNumber::List::Iterator it;
         for( it = mData->phoneNumbers.begin(); it != mData->phoneNumbers.end(); ++it ) {
             if ( ( *phoneItAD ).contains( (*it)  ) ) {
                 found = true;
                 (*it).setType( ( *phoneItAD ).type() );
                 (*it).setNumber( ( *phoneItAD ).number() );
                 break;
             }
         }
         // if ( isSubSet && ! found ) 
         if (  ! found ) // LR try this one...
             mData->phoneNumbers.append( *phoneItAD );                
     }
     if ( isSubSet ) {
         // ************* emails;
         t = mData->emails;
         tAD = ad.mData->emails;
         for ( iii = 0; iii < tAD.count(); ++iii)
             if ( !t.contains(tAD[iii] ) )
                 mData->emails.append( tAD[iii] );
     }
 
     // ************* categories;
     t = mData->categories;
     tAD = ad.mData->categories;
     for ( iii = 0; iii < tAD.count(); ++iii)
         if ( !t.contains(tAD[iii] ) )
             mData->categories.append( tAD[iii] );
     QStringList::ConstIterator it;
     for( it = ad.mData->custom.begin(); it != ad.mData->custom.end(); ++it ) {
         QString qualifiedName = (*it).left( (*it).find( ":" )); 
         bool found = false;
         QStringList::ConstIterator itL;
         for( itL = mData->custom.begin(); itL != mData->custom.end(); ++itL ) {
             if ( (*itL).startsWith( qualifiedName ) ) {
                 found = true;
                 break;
             }
         }
         if ( ! found ) {
             mData->custom.append( *it );
         }
     }
     if ( mData->logo.undefined() && !ad.mData->logo.undefined() ) mData->logo = ad.mData->logo;
     if ( mData->photo.undefined() && !ad.mData->photo.undefined() ) mData->photo = ad.mData->photo;
     if ( !mData->sound.isIntern() ) {
         if ( mData->sound.url().isEmpty() ) {
             mData->sound = ad.mData->sound;
         }
     }
     if ( !mData->agent.isIntern() ) {
         if ( mData->agent.url().isEmpty() ) {
             mData->agent = ad.mData->agent;
         }
     }
     { 
         Key::List::Iterator itA;
         for( itA = ad.mData->keys.begin(); itA != ad.mData->keys.end(); ++itA ) {
diff --git a/kabc/secrecy.h b/kabc/secrecy.h
index 8f2f736..b2ff565 100644
--- a/kabc/secrecy.h
+++ b/kabc/secrecy.h
@@ -1,102 +1,102 @@
 /*
     This file is part of libkabc.
     Copyright (c) 2002 Tobias Koenig <tokoe@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_SECRECY_H
 #define KABC_SECRECY_H
 
 #include <qvaluelist.h>
 
 namespace KABC {
 
 class Secrecy
 {
     friend QDataStream &operator<<( QDataStream &, const Secrecy & );
     friend QDataStream &operator>>( QDataStream &, Secrecy & );
 
 public:
   typedef QValueList<int> TypeList;  
 
   /**
    * Secrecy types
    *
    * @li Public       - for public access
    * @li Private      - only private access
    * @li Confidential - access for confidential persons
    */
   enum Types {
     Public,
     Private,
     Confidential,
     Invalid
   };
 
   /**
    * Constructor.
    *
    * @param type  The secrecy type, @see Types.
    */
-  Secrecy( int type = Invalid );
+  Secrecy( int type = Public );
 
   bool operator==( const Secrecy & ) const;
   bool operator!=( const Secrecy & ) const;
 
   /**
     Returns if the Secrecy object has a valid value.
   */
   bool isValid() const;
 
   /**
    * Sets the type, @see Types.
    */
   void setType( int type );
 
   /**
    * Returns the type, @see Types.
    */
   int type() const;
 
   /**
    * Returns a list of all available secrecy types.
    */
   static TypeList typeList();
   
   /**
    * Returns a translated label for a given secrecy type.
    */
   static QString typeLabel( int type );
 
   /**
    * For debug.
    */
   QString asString() const;
 
 private:
   int mType;
 };
 
 }
 #endif
diff --git a/kabc/vcard/VCardv.cpp b/kabc/vcard/VCardv.cpp
index 1166aac..bad2ef1 100644
--- a/kabc/vcard/VCardv.cpp
+++ b/kabc/vcard/VCardv.cpp
@@ -79,193 +79,193 @@ VCard::operator = (VCard & x)
 }
 
 	VCard &
 VCard::operator = (const QCString & s)
 {
 	Entity::operator = (s);
 	return *this;
 }
 
 	bool
 VCard::operator == (VCard & x)
 {
 	x.parse();
 	return false;
 }
 
 VCard::~VCard()
 {
 }
 
 	void
 VCard::_parse()
 {
 	
 	QStringList l;
 	QStrList sl;
 
 	RTokenise(strRep_, "\r\n", sl);
 
 	if (sl.count() < 3) { // Invalid VCARD !
         //qDebug("invalid vcard ");
 		return;
 	}
     l = QStringList::fromStrList( sl );
 	// Get the first line
 	QString beginLine = l[0].stripWhiteSpace();
 
 	// Remove extra blank lines
 	while (l.last().isEmpty())
 		l.remove(l.last());
 
 	// Now we know this is the last line
 	QString endLine = l.last();
 
 	// Trash the first and last lines as we have seen them.
 	l.remove(l.begin());
 	l.remove(l.last());
 
 	///////////////////////////////////////////////////////////////
 	// FIRST LINE
 
 	int split = beginLine.find(':');
 
 	if (split == -1) { // invalid, no BEGIN
 		vDebug("No split");
 		return;
 	}
 
 	QString firstPart(beginLine.left(split));
 	QString valuePart(beginLine.mid(split + 1));
 
 	split = firstPart.find('.');
 
 	if (split != -1) {
 		group_		= firstPart.left(split);
 		firstPart	= firstPart.right(firstPart.length() - split - 1);
 	}
 
 	if (firstPart.left(5) != "BEGIN" ) { // No BEGIN !
 		qDebug("no BEGIN in vcard ");
 		return;
 	}
 
 	if (valuePart.left(5) != "VCARD") { // Not a vcard !
 		qDebug("not a VCARD  ");
 		return;
 	}
 
 	///////////////////////////////////////////////////////////////
 	// CONTENT LINES
 	//
 	vDebug("Content lines");
 
 	// Handle folded lines.
 
 	QStringList refolded;
 
 
     QStringList::Iterator it =  l.begin(); 
 
 	QString cur;
 
 	for (; it != l.end(); ++it) {
 		cur = (*it);
 		++it;
 		while ( it!= l.end() && (*it).at(0) == ' '	&& (*it).length()!= 1) {
-			cur += (*it) ;
+			cur += (*it).mid(1) ;
 			++it;
 		}
 		--it;
 		refolded.append(cur);
 	}
     QStringList::Iterator it2 = refolded.begin();
 	for (; it2 != refolded.end(); ++it2) {
 		ContentLine * cl = new ContentLine(QCString((*it2).latin1()));
 		cl->parse();
 		if (cl->value() == 0)
 		{
 		    qDebug("Content line could not be parsed. Discarded: %s", (*it2).latin1());
 		    delete cl;
 		}
 		else
 		  contentLineList_.append(cl);
 	}
 
 	///////////////////////////////////////////////////////////////
 	// LAST LINE
 
 
         // LR: sorry, but the remaining code in this method makes no sense
 
 #if 0
 	split = endLine.find(':');
 
 	if (split == -1) // invalid, no END
 		return;
 
 	firstPart = endLine.left(split);
 	valuePart = endLine.right(firstPart.length() - split - 1);
 
 	split = firstPart.find('.');
 
 	if (split != -1) {
 		group_		= firstPart.left(split);
 		firstPart	= firstPart.right(firstPart.length() - split - 1);
 	}
 
 	if (qstricmp(firstPart, "END") != 0) // No END !
 		return;
 
 	if (qstricmp(valuePart, "VCARD") != 0) // Not a vcard !
 		return;
 #endif
 }
 
 	void
 VCard::_assemble()
 {
 	vDebug("Assembling vcard");
 	strRep_ = "BEGIN:VCARD\r\n";
 	strRep_ += "VERSION:3.0\r\n";
 
 	QPtrListIterator<ContentLine> it(contentLineList_);
 
 	for (; it.current(); ++it)
 		strRep_ += it.current()->asString() + "\r\n";
 
 	strRep_ += "END:VCARD\r\n";
 }
 
 	bool
 VCard::has(EntityType t)
 {
 	parse();
 	return contentLine(t) == 0 ? false : true;
 }
 
 	bool
 VCard::has(const QCString & s)
 {
 	parse();
 	return contentLine(s) == 0 ? false : true;
 }
 
 	void
 VCard::add(const ContentLine & cl)
 {
 	parse();
 	ContentLine * c = new ContentLine(cl);
 	contentLineList_.append(c);
 }
 
 	void
 VCard::add(const QCString & s)
 {
 	parse();
 	ContentLine * c = new ContentLine(s);
 	contentLineList_.append(c);
 }
 
 	ContentLine *
 VCard::contentLine(EntityType t)
 {