kabc Library API Documentation

ContentLine.cpp

00001 /*
00002         libvcard - vCard parsing library for vCard version 3.0
00003 
00004         Copyright (C) 1999 Rik Hemsley rik@kde.org
00005         
00006   Permission is hereby granted, free of charge, to any person obtaining a copy
00007   of this software and associated documentation files (the "Software"), to
00008   deal in the Software without restriction, including without limitation the
00009   rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
00010   sell copies of the Software, and to permit persons to whom the Software is
00011   furnished to do so, subject to the following conditions:
00012 
00013   The above copyright notice and this permission notice shall be included in
00014   all copies or substantial portions of the Software.
00015 
00016   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
00017   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
00018   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
00019   AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
00020   ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
00021   WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
00022 */
00023 
00024 #include <qcstring.h>
00025 #include <qstrlist.h>
00026 #include <qregexp.h>
00027 
00028 #include <kdebug.h>
00029 
00030 #include <VCardAdrParam.h>
00031 #include <VCardAgentParam.h>
00032 #include <VCardDateParam.h>
00033 #include <VCardEmailParam.h>
00034 #include <VCardImageParam.h>
00035 #include <VCardSourceParam.h>
00036 #include <VCardTelParam.h>
00037 #include <VCardTextBinParam.h>
00038 #include <VCardTextParam.h>
00039 
00040 #include <VCardAdrValue.h>
00041 #include <VCardAgentValue.h>
00042 #include <VCardDateValue.h>
00043 #include <VCardImageValue.h>
00044 #include <VCardTextValue.h>
00045 #include <VCardTextBinValue.h>
00046 #include <VCardLangValue.h>
00047 #include <VCardNValue.h>
00048 #include <VCardURIValue.h>
00049 #include <VCardSoundValue.h>
00050 #include <VCardClassValue.h>
00051 #include <VCardFloatValue.h>
00052 #include <VCardOrgValue.h>
00053 #include <VCardTelValue.h>
00054 #include <VCardTextListValue.h>
00055 #include <VCardUTCValue.h>
00056 #include <VCardGeoValue.h>
00057 
00058 #include <VCardRToken.h>
00059 #include <VCardContentLine.h>
00060 
00061 #include <VCardEntity.h>
00062 #include <VCardEnum.h>
00063 #include <VCardDefines.h>
00064 
00065 using namespace VCARD;
00066 
00067 ContentLine::ContentLine()
00068         :       Entity(),
00069                 value_(0)
00070 {
00071 }
00072 
00073 ContentLine::ContentLine(const ContentLine & x)
00074         :       Entity(x),
00075                 group_ (x.group_),
00076                 name_ (x.name_),
00077                 paramList_(x.paramList_),
00078                 value_(x.value_->clone())
00079 {
00080 }
00081 
00082 ContentLine::ContentLine(const QCString & s)
00083         :       Entity(s),
00084                 value_(0)
00085 {
00086 }
00087 
00088         ContentLine &
00089 ContentLine::operator = (ContentLine & x)
00090 {
00091         if (*this == x) return *this;
00092         
00093         paramList_ = x.paramList();
00094         value_ = x.value_->clone();
00095 
00096         Entity::operator = (x);
00097         return *this;
00098 }
00099 
00100         ContentLine &
00101 ContentLine::operator = (const QCString & s)
00102 {
00103         Entity::operator = (s);
00104         delete value_;
00105         value_ = 0;
00106         return *this;
00107 }
00108 
00109         bool
00110 ContentLine::operator == (ContentLine & x)
00111 {
00112         x.parse();
00113         
00114         QPtrListIterator<Param> it(x.paramList());
00115         
00116         if (!paramList_.find(it.current()))
00117                 return false;
00118 
00119         return true;
00120 }
00121 
00122 ContentLine::~ContentLine()
00123 {
00124         delete value_;
00125         value_ = 0;
00126 }
00127 
00128         void
00129 ContentLine::_parse()
00130 {
00131         vDebug("parse");
00132         
00133         // Unqote newlines
00134         strRep_ = strRep_.replace( QRegExp( "\\\\n" ), "\n" );
00135         
00136         int split = strRep_.find(':');
00137         
00138         if (split == -1) { // invalid content line
00139                 vDebug("No ':'");
00140                 return;
00141         }
00142         
00143         QCString firstPart(strRep_.left(split));
00144         QCString valuePart(strRep_.mid(split + 1));
00145         
00146         split = firstPart.find('.');
00147         
00148         if (split != -1) {
00149                 group_          = firstPart.left(split);
00150                 firstPart       = firstPart.mid(split + 1);
00151         }
00152         
00153         vDebug("Group == " + group_);
00154         vDebug("firstPart == " + firstPart);
00155         vDebug("valuePart == " + valuePart);
00156         
00157         // Now we have the group, the name and param list together and the value.
00158         
00159         QStrList l;
00160         
00161         RTokenise(firstPart, ";", l);
00162         
00163         if (l.count() == 0) {// invalid - no name !
00164                 vDebug("No name for this content line !");
00165                 return;
00166         }
00167         
00168         name_ = l.at(0);
00169 
00170         // Now we have the name, so the rest of 'l' is the params.
00171         // Remove the name part.
00172         l.remove(0u);
00173         
00174         entityType_     = EntityNameToEntityType(name_);
00175         paramType_      = EntityTypeToParamType(entityType_);
00176         
00177         unsigned int i = 0;
00178         
00179         // For each parameter, create a new parameter of the correct type.
00180 
00181         QStrListIterator it(l);
00182         
00183         for (; it.current(); ++it, i++) {
00184 
00185                 QCString str = *it;
00186 
00187                 split = str.find("=");
00188                 if (split < 0 ) {
00189                         vDebug("No '=' in paramter.");
00190                         continue;
00191                 }
00192                 
00193                 QCString paraName = str.left(split);
00194                 QCString paraValue = str.mid(split + 1);
00195                 
00196                 QStrList paraValues;
00197                 RTokenise(paraValue, ",", paraValues);
00198                 
00199                 QStrListIterator it2( paraValues );
00200                 
00201                 for(; it2.current(); ++it2) {           
00202                 
00203                         Param *p = new Param;
00204                         p->setName( paraName );
00205                         p->setValue( *it2 );
00206         
00207                         paramList_.append(p);
00208                 }
00209         }
00210 
00211         // Create a new value of the correct type.
00212 
00213         valueType_ = EntityTypeToValueType(entityType_);
00214         
00215 //      kdDebug(5710) << "valueType: " << valueType_ << endl;
00216         
00217         switch (valueType_) {
00218                 
00219                 case ValueSound:        value_ = new SoundValue;        break;
00220                 case ValueAgent:        value_ = new AgentValue;        break;
00221                 case ValueAddress:      value_ = new AdrValue;          break;
00222                 case ValueTel:          value_ = new TelValue;          break;
00223                 case ValueTextBin:      value_ = new TextBinValue;      break;
00224                 case ValueOrg:          value_ = new OrgValue;          break;
00225                 case ValueN:            value_ = new NValue;            break;
00226                 case ValueUTC:          value_ = new UTCValue;          break;
00227                 case ValueURI:          value_ = new URIValue;          break;
00228                 case ValueClass:        value_ = new ClassValue;        break;
00229                 case ValueFloat:        value_ = new FloatValue;        break;
00230                 case ValueImage:        value_ = new ImageValue;        break;
00231                 case ValueDate:         value_ = new DateValue;         break;
00232                 case ValueTextList:     value_ = new TextListValue;     break;
00233                 case ValueGeo:          value_ = new GeoValue;          break;
00234                 case ValueText:
00235                 case ValueUnknown:
00236                 default:                value_ = new TextValue;         break;
00237         }
00238         
00239         *value_ = valuePart;
00240 }
00241 
00242         void
00243 ContentLine::_assemble()
00244 {
00245         vDebug("Assemble (argl) - my name is \"" + name_ + "\"");
00246         strRep_.truncate(0);
00247 
00248         QCString line;
00249         
00250         if (!group_.isEmpty())
00251                 line += group_ + '.';
00252         
00253         line += name_;
00254 
00255         vDebug("Adding parameters");
00256         ParamListIterator it(paramList_);
00257         
00258         for (; it.current(); ++it)
00259                 line += ";" + it.current()->asString();
00260         
00261         vDebug("Adding value");
00262         if (value_ != 0)
00263                 line += ":" + value_->asString();
00264         else
00265                 vDebug("No value");
00266 
00267         // Quote newlines
00268         line = line.replace( QRegExp( "\n" ), "\\n" );
00269                 
00270         // Fold lines longer than 72 chars
00271         const int maxLen = 72;
00272         uint cursor = 0;
00273         while( line.length() > ( cursor + 1 ) * maxLen ) {
00274                 strRep_ += line.mid( cursor * maxLen, maxLen );
00275                 strRep_ += "\r\n ";
00276                 ++cursor;
00277         }
00278         strRep_ += line.mid( cursor * maxLen );
00279 }
00280 
00281         void
00282 ContentLine::clear()
00283 {
00284         group_.truncate(0);
00285         name_.truncate(0);
00286         paramList_.clear();
00287         delete value_;
00288         value_ = 0;
00289 }
KDE Logo
This file is part of the documentation for kdelibs Version 3.1.5.
Documentation copyright © 1996-2002 the KDE developers.
Generated on Wed Jan 28 13:29:19 2004 by doxygen 1.3.4 written by Dimitri van Heesch, © 1997-2001