00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015 #ifndef __KMIME_HEADERS_H__
00016 #define __KMIME_HEADERS_H__
00017
00018
00019
00020
00021
00022
00023
00024
00025 #include "kmime_header_parsing.h"
00026
00027 #include <qstring.h>
00028 #include <qstrlist.h>
00029 #include <qstringlist.h>
00030 #include <qregexp.h>
00031 #include <qdatetime.h>
00032 #include <qasciidict.h>
00033 #include <qmap.h>
00034 #include <qptrlist.h>
00035
00036 #include <time.h>
00037
00038 #include <kdepimmacros.h>
00039
00040 namespace KMime {
00041
00042
00043 class Content;
00044
00045 namespace Headers {
00046
00047
00048 enum contentCategory { CCsingle,
00049 CCcontainer,
00050 CCmixedPart,
00051 CCalternativePart };
00052
00053 enum contentEncoding { CE7Bit,
00054 CE8Bit,
00055 CEquPr,
00056 CEbase64,
00057 CEuuenc,
00058 CEbinary };
00059
00060 enum contentDisposition { CDinline,
00061 CDattachment,
00062 CDparallel };
00063
00064
00065 static const QCString Latin1("ISO-8859-1");
00066
00067 #define mk_trivial_subclass_with_name( subclass, subclassName, baseclass ) \
00068 class subclass : public Generics::baseclass { \
00069 public: \
00070 subclass() : Generics::baseclass() {} \
00071 subclass( Content * p ) : Generics::baseclass( p ) {} \
00072 subclass( Content * p, const QCString & s ) \
00073 : Generics::baseclass( p ) { from7BitString( s ); } \
00074 subclass( Content * p, const QString & s, const QCString & cs ) \
00075 : Generics::baseclass( p ) { fromUnicodeString( s, cs ); } \
00076 ~subclass() {} \
00077 \
00078 const char * type() const { return #subclassName; } \
00079 }
00080
00081 #define mk_trivial_subclass( subclass, baseclass ) \
00082 mk_trivial_subclass_with_name( subclass, subclass, baseclass )
00083
00084 #define mk_parsing_subclass_with_name( subclass, subclassName, baseclass ) \
00085 class subclass : public Generics::baseclass { \
00086 public: \
00087 subclass() : Generics::baseclass() {} \
00088 subclass( Content * p ) : Generics::baseclass( p ) {} \
00089 subclass( Content * p, const QCString & s ) \
00090 : Generics::baseclass( p ) { from7BitString( s ); } \
00091 subclass( Content * p, const QString & s, const QCString & cs ) \
00092 : Generics::baseclass( p ) { fromUnicodeString( s, cs ); } \
00093 ~subclass() {} \
00094 \
00095 const char * type() const { return #subclassName; } \
00096 protected: \
00097 bool parse( const char* & scursor, const char * const send, bool isCRLF=false ); \
00098 }
00099
00100 #define mk_parsing_subclass( subclass, baseclass ) \
00101 mk_parsing_subclass_with_name( subclass, subclass, baseclass )
00102
00103
00104
00105
00106
00107
00108
00111 class KDE_EXPORT Base {
00112
00113 public:
00114 typedef QPtrList<Base> List;
00115
00117 Base() : e_ncCS(0), p_arent(0) {}
00118
00120 Base(KMime::Content *parent) : e_ncCS(0), p_arent(parent) {}
00121
00123 virtual ~Base() {}
00124
00126 KMime::Content* parent() { return p_arent; }
00127
00129 void setParent(KMime::Content *p) { p_arent=p; }
00130
00134 virtual void from7BitString(const QCString&) {}
00135
00138 virtual QCString as7BitString(bool=true) { return QCString(); }
00139
00141 QCString rfc2047Charset();
00142
00144 void setRFC2047Charset(const QCString &cs);
00145
00147 QCString defaultCS();
00148
00150 bool forceCS();
00151
00153 virtual void fromUnicodeString(const QString&, const QCString&) {}
00154
00157 virtual QString asUnicodeString() { return QString(); }
00158
00160 virtual void clear() {}
00161
00163 virtual bool isEmpty() { return false; }
00164
00166 virtual const char* type() { return ""; }
00167
00169 bool is(const char* t) { return (strcasecmp(t, type())==0); }
00170
00172 bool isMimeHeader() { return (strncasecmp(type(), "Content-", 8)==0); }
00173
00175 bool isXHeader() { return (strncmp(type(), "X-", 2)==0); }
00176
00177 protected:
00178 QCString typeIntro() { return (QCString(type())+": "); }
00179
00180 const char *e_ncCS;
00181 Content *p_arent;
00182
00183 };
00184
00185
00186
00187
00188
00189
00190
00191
00192 namespace Generics {
00193
00213
00214
00215
00216 class KDE_EXPORT GUnstructured : public Base {
00217
00218 public:
00219 GUnstructured() : Base() {}
00220 GUnstructured( Content * p ) : Base( p ) {}
00221 GUnstructured( Content * p, const QCString & s )
00222 : Base( p ) { from7BitString(s); }
00223 GUnstructured( Content * p, const QString & s, const QCString & cs )
00224 : Base( p ) { fromUnicodeString( s, cs ); }
00225 ~GUnstructured() {}
00226
00227 virtual void from7BitString( const QCString& str );
00228 virtual QCString as7BitString( bool withHeaderType=true );
00229
00230 virtual void fromUnicodeString( const QString & str,
00231 const QCString & suggestedCharset);
00232 virtual QString asUnicodeString();
00233
00234 virtual void clear() { d_ecoded.truncate(0); }
00235 virtual bool isEmpty() { return (d_ecoded.isEmpty()); }
00236
00237 private:
00238 QString d_ecoded;
00239 };
00240
00269 class KDE_EXPORT GStructured : public Base {
00270 public:
00271 GStructured() : Base() {}
00272 GStructured( Content * p ) : Base( p ) {}
00273 GStructured( Content * p, const QCString & s )
00274 : Base( p ) { from7BitString(s); }
00275 GStructured( Content * p, const QString & s, const QCString & cs )
00276 : Base( p ) { fromUnicodeString( s, cs ); }
00277 ~GStructured() {}
00278
00279
00280 protected:
00281 #if 0
00282
00283
00284 bool writeAtom( char* & dcursor, const char * const dend, const QString & input );
00285 bool writeAtom( char* & dcursor, const char * const dend,
00286 const QPair<const char*,int> & input );
00287 bool writeToken( char* & dcursor, const char * const dend, const QString & input );
00288 bool writeToken( char* & dcursor, const char * const dend,
00289 const QPair<const char*int> & input );
00290
00291 bool writeGenericQuotedString( char* & dcursor, const char * const dend,
00292 const QString & input, bool withCRLF=false );
00293 bool writeComment( char* & dcursor, const char * const dend,
00294 const QString & input, bool withCRLF=false );
00295 bool writePhrase( char* & dcursor, const char * const dend,
00296 const QString & input, bool withCRLF=false );
00297 bool writeDotAtom( char* & dcursor, const char * const dend,
00298 const QString & input, bool withCRLF=false );
00299 #endif
00300 };
00301
00302
00303 class KDE_EXPORT GAddress : public GStructured {
00304 public:
00305 GAddress() : GStructured() {}
00306 GAddress( Content * p ) : GStructured( p ) {}
00307 GAddress( Content * p, const QCString & s )
00308 : GStructured( p ) { from7BitString(s); }
00309 GAddress( Content * p, const QString & s, const QCString & cs )
00310 : GStructured( p ) { fromUnicodeString( s, cs ); }
00311 ~GAddress() {}
00312
00313 protected:
00314 };
00315
00316
00319 class KDE_EXPORT MailboxList : public GAddress {
00320 public:
00321 MailboxList() : GAddress() {}
00322 MailboxList( Content * p ) : GAddress( p ) {}
00323 MailboxList( Content * p, const QCString & s )
00324 : GAddress( p ) { from7BitString(s); }
00325 MailboxList( Content * p, const QString & s, const QCString & cs )
00326 : GAddress( p ) { fromUnicodeString( s, cs ); }
00327 ~MailboxList() {}
00328
00329 protected:
00330 bool parse( const char* & scursor, const char * const send, bool isCRLF=false );
00331
00333 QValueList<Types::Mailbox> mMailboxList;
00334 };
00335
00336
00339 mk_parsing_subclass(SingleMailbox,MailboxList);
00340
00343 class KDE_EXPORT AddressList : public GAddress {
00344 public:
00345 AddressList() : GAddress() {}
00346 AddressList( Content * p ) : GAddress( p ) {}
00347 AddressList( Content * p, const QCString & s )
00348 : GAddress( p ) { from7BitString(s); }
00349 AddressList( Content * p, const QString & s, const QCString & cs )
00350 : GAddress( p ) { fromUnicodeString( s, cs ); }
00351 ~AddressList() {}
00352
00353 protected:
00354 bool parse( const char* & scursor, const char * const send, bool isCRLF=false );
00355
00357 QValueList<Types::Address> mAddressList;
00358 };
00359
00361 class KDE_EXPORT GIdent : public GAddress {
00362 public:
00363 GIdent() : GAddress() {}
00364 GIdent( Content * p ) : GAddress( p ) {}
00365 GIdent( Content * p, const QCString & s )
00366 : GAddress( p ) { from7BitString(s); }
00367 GIdent( Content * p, const QString & s, const QCString & cs )
00368 : GAddress( p ) { fromUnicodeString( s, cs ); }
00369 ~GIdent() {}
00370
00371 protected:
00372 bool parse( const char* & scursor, const char * const send, bool isCRLF=false );
00373
00375 QValueList<Types::AddrSpec> mMsgIdList;
00376 };
00377
00379 mk_parsing_subclass(GSingleIdent,GIdent);
00380
00382 class KDE_EXPORT GToken : public GStructured {
00383 public:
00384 GToken() : GStructured() {}
00385 GToken( Content * p ) : GStructured( p ) {}
00386 GToken( Content * p, const QCString & s )
00387 : GStructured( p ) { from7BitString(s); }
00388 GToken( Content * p, const QString & s, const QCString & cs )
00389 : GStructured( p ) { fromUnicodeString( s, cs ); }
00390 ~GToken() {}
00391
00392 protected:
00393 bool parse( const char* & scursor, const char * const send, bool isCRLF=false );
00394
00395 QCString mToken;
00396 };
00397
00398
00399 class KDE_EXPORT GPhraseList : public GStructured {
00400 public:
00401 GPhraseList() : GStructured() {}
00402 GPhraseList( Content * p ) : GStructured( p ) {}
00403 GPhraseList( Content * p, const QCString & s )
00404 : GStructured( p ) { from7BitString(s); }
00405 GPhraseList( Content * p, const QString & s, const QCString & cs )
00406 : GStructured( p ) { fromUnicodeString( s, cs ); }
00407 ~GPhraseList() {}
00408
00409 protected:
00410 bool parse( const char* & scursor, const char * const send, bool isCRLF=false );
00411
00412 QStringList mPhraseList;
00413 };
00414
00415 class KDE_EXPORT GDotAtom : public GStructured {
00416 public:
00417 GDotAtom() : GStructured() {}
00418 GDotAtom( Content * p ) : GStructured( p ) {}
00419 GDotAtom( Content * p, const QCString & s )
00420 : GStructured( p ) { from7BitString(s); }
00421 GDotAtom( Content * p, const QString & s, const QCString & cs )
00422 : GStructured( p ) { fromUnicodeString( s, cs ); }
00423 ~GDotAtom() {}
00424
00425 protected:
00426 bool parse( const char* & scursor, const char * const send, bool isCRLF=false );
00427
00428 QString mDotAtom;
00429 };
00430
00431 class KDE_EXPORT GParametrized : public GStructured {
00432 public:
00433 GParametrized() : GStructured() {}
00434 GParametrized( Content * p ) : GStructured( p ) {}
00435 GParametrized( Content * p, const QCString & s )
00436 : GStructured( p ) { from7BitString(s); }
00437 GParametrized( Content * p, const QString & s, const QCString & cs )
00438 : GStructured( p ) { fromUnicodeString( s, cs ); }
00439 ~GParametrized() {}
00440
00441 protected:
00442 QMap<QString,QString> mParameterHash;
00443
00444 private:
00445 };
00446
00447 class KDE_EXPORT GContentType : public GParametrized {
00448 public:
00449 GContentType() : GParametrized() {}
00450 GContentType( Content * p ) : GParametrized( p ) {}
00451 GContentType( Content * p, const QCString & s )
00452 : GParametrized( p ) { from7BitString(s); }
00453 GContentType( Content * p, const QString & s, const QCString & cs )
00454 : GParametrized( p ) { fromUnicodeString( s, cs ); }
00455 ~GContentType() {}
00456
00457 protected:
00458 bool parse( const char* & scursor, const char * const send, bool isCRLF=false );
00459
00460 QCString mMimeType;
00461 QCString mMimeSubType;
00462 };
00463
00464
00465 class KDE_EXPORT GCISTokenWithParameterList : public GParametrized {
00466 public:
00467 GCISTokenWithParameterList() : GParametrized() {}
00468 GCISTokenWithParameterList( Content * p ) : GParametrized( p ) {}
00469 GCISTokenWithParameterList( Content * p, const QCString & s )
00470 : GParametrized( p ) { from7BitString(s); }
00471 GCISTokenWithParameterList( Content * p, const QString & s, const QCString & cs )
00472 : GParametrized( p ) { fromUnicodeString( s, cs ); }
00473 ~GCISTokenWithParameterList() {}
00474
00475 protected:
00476 bool parse( const char* & scursor, const char * const send, bool isCRLF=false );
00477
00478 QCString mToken;
00479 };
00480
00481
00482 }
00483
00484
00485
00486
00487
00488
00489
00490
00492 class KDE_EXPORT ReturnPath : public Generics::GAddress {
00493 public:
00494 ReturnPath() : Generics::GAddress() {}
00495 ReturnPath( Content * p ) : Generics::GAddress( p ) {}
00496 ReturnPath( Content * p, const QCString & s )
00497 : Generics::GAddress( p ) { from7BitString(s); }
00498 ReturnPath( Content * p, const QString & s, const QCString & cs )
00499 : Generics::GAddress( p ) { fromUnicodeString( s, cs ); }
00500 ~ReturnPath() {}
00501
00502 const char * type() const { return "Return-Path"; }
00503
00504 protected:
00505 bool parse( const char* & scursor, const char * const send, bool isCRLF=false );
00506 };
00507
00508 #if defined(KMIME_NEW_STYLE_CLASSTREE)
00509
00510
00511
00512
00513
00514 mk_trivial_subclass(From,MailboxList);
00515 mk_trivial_subclass(Sender,SingleMailbox);
00516 mk_trivial_subclass_with_name(ReplyTo,Reply-To,AddressList);
00517 mk_trivial_subclass(Cc,AddressList);
00518 mk_trivial_subclass(Bcc,AddressList);
00519
00520 mk_trivial_subclass_with_name(MailCopiesTo,Mail-Copies-To,AddressList);
00521
00522
00523
00524 mk_trivial_subclass_with_name(ContentTransferEncoding,
00525 Content-Transfer-Encoding,GToken);
00526
00527
00528
00529 mk_trivial_subclass(Keywords,GPhraseList);
00530
00531
00532
00533 mk_trivial_subclass_with_name(MIMEVersion,MIME-Version,GDotAtom);
00534
00535
00536
00537 mk_trivial_subclass_with_name(MessageID,Message-ID,GSingleIdent);
00538 mk_trivial_subclass_with_name(ContentID,Content-ID,GSingleIdent);
00539 mk_trivial_subclass(Supersedes,GSingleIdent);
00540 mk_trivial_subclass_with_name(InReplyTo,In-Reply-To,GIdent);
00541 mk_trivial_subclass(References,GIdent);
00542
00543
00544
00545 mk_trivial_subclass_with_name(ContentType,ContentType,GContentType);
00546
00547
00548
00549 mk_trivial_subclass_with_name(ContentDisposition,Content-Disposition,
00550 GCISTokenWithParameterList);
00551
00552
00553 #endif
00554
00555
00556
00557
00558
00559
00560
00561
00562
00568 class KDE_EXPORT Generic : public Generics::GUnstructured {
00569
00570 public:
00571 Generic() : Generics::GUnstructured(), t_ype(0) {}
00572 Generic(const char *t)
00573 : Generics::GUnstructured(), t_ype(0) { setType(t); }
00574 Generic(const char *t, Content *p)
00575 : Generics::GUnstructured( p ), t_ype(0) { setType(t); }
00576 Generic(const char *t, Content *p, const QCString &s)
00577 : Generics::GUnstructured( p, s ), t_ype(0) { setType(t); }
00578 Generic(const char *t, Content *p, const QString &s, const QCString &cs)
00579 : Generics::GUnstructured( p, s, cs ), t_ype(0) { setType(t); }
00580 ~Generic() { delete[] t_ype; }
00581
00582 virtual void clear() { delete[] t_ype; GUnstructured::clear(); }
00583 virtual bool isEmpty() { return (t_ype==0 || GUnstructured::isEmpty()); }
00584 virtual const char* type() { return t_ype; }
00585 void setType(const char *type);
00586
00587 protected:
00588 char *t_ype;
00589
00590 };
00591
00592
00594 class KDE_EXPORT Subject : public Generics::GUnstructured {
00595
00596 public:
00597 Subject() : Generics::GUnstructured() {}
00598 Subject( Content * p ) : Generics::GUnstructured( p ) {}
00599 Subject( Content * p, const QCString & s )
00600 : Generics::GUnstructured( p, s ) {}
00601 Subject( Content * p, const QString & s, const QCString & cs )
00602 : Generics::GUnstructured( p, s, cs ) {}
00603 ~Subject() {}
00604
00605 virtual const char* type() { return "Subject"; }
00606
00607 bool isReply() {
00608 return ( asUnicodeString().find( QString("Re:"), 0, false ) == 0 );
00609 }
00610 };
00611
00613 class KDE_EXPORT Organization : public Generics::GUnstructured {
00614
00615 public:
00616 Organization() : Generics::GUnstructured() {}
00617 Organization( Content * p ) : Generics::GUnstructured( p ) {}
00618 Organization( Content * p, const QCString & s )
00619 : Generics::GUnstructured( p, s ) {};
00620 Organization( Content * p, const QString & s, const QCString & cs)
00621 : Generics::GUnstructured( p, s, cs ) {}
00622 ~Organization() {}
00623
00624 virtual const char* type() { return "Organization"; }
00625
00626 };
00627
00628
00629
00630
00631
00632
00633
00634
00635
00637 class KDE_EXPORT Control : public Base {
00638
00639 public:
00640 Control() : Base() {}
00641 Control(Content *p) : Base(p) {}
00642 Control(Content *p, const QCString &s) : Base(p) { from7BitString(s); }
00643 Control(Content *p, const QString &s) : Base(p) { fromUnicodeString(s, Latin1); }
00644 ~Control() {}
00645
00646 virtual void from7BitString(const QCString &s);
00647 virtual QCString as7BitString(bool incType=true);
00648 virtual void fromUnicodeString(const QString &s, const QCString&);
00649 virtual QString asUnicodeString();
00650 virtual void clear() { c_trlMsg.truncate(0); }
00651 virtual bool isEmpty() { return (c_trlMsg.isEmpty()); }
00652 virtual const char* type() { return "Control"; }
00653
00654 bool isCancel() { return (c_trlMsg.find("cancel", 0, false)!=-1); }
00655
00656 protected:
00657 QCString c_trlMsg;
00658
00659 };
00660
00662 class KDE_EXPORT Date : public Base {
00663
00664 public:
00665 Date() : Base(), t_ime(0) {}
00666 Date(Content *p) : Base(p), t_ime(0) {}
00667 Date(Content *p, time_t t) : Base(p), t_ime(t) {}
00668 Date(Content *p, const QCString &s) : Base(p) { from7BitString(s); }
00669 Date(Content *p, const QString &s) : Base(p) { fromUnicodeString(s, Latin1); }
00670 ~Date() {}
00671
00672 virtual void from7BitString(const QCString &s);
00673 virtual QCString as7BitString(bool incType=true);
00674 virtual void fromUnicodeString(const QString &s, const QCString&);
00675 virtual QString asUnicodeString();
00676 virtual void clear() { t_ime=0; }
00677 virtual bool isEmpty() { return (t_ime==0); }
00678 virtual const char* type() { return "Date"; }
00679
00680 time_t unixTime() { return t_ime; }
00681 void setUnixTime(time_t t) { t_ime=t; }
00682 void setUnixTime() { t_ime=time(0); }
00683 QDateTime qdt();
00684 int ageInDays();
00685
00686 protected:
00687 time_t t_ime;
00688
00689 };
00690
00691
00693 class KDE_EXPORT Newsgroups : public Base {
00694
00695 public:
00696 Newsgroups() : Base() {}
00697 Newsgroups(Content *p) : Base(p) {}
00698 Newsgroups(Content *p, const QCString &s) : Base(p) { from7BitString(s); }
00699 Newsgroups(Content *p, const QString &s) : Base(p) { fromUnicodeString(s, Latin1); }
00700 ~Newsgroups() {}
00701
00702 virtual void from7BitString(const QCString &s);
00703 virtual QCString as7BitString(bool incType=true);
00704 virtual void fromUnicodeString(const QString &s, const QCString&);
00705 virtual QString asUnicodeString();
00706 virtual void clear() { g_roups.resize(0); }
00707 virtual bool isEmpty() { return g_roups.isEmpty(); }
00708 virtual const char* type() { return "Newsgroups"; }
00709
00710 QCString firstGroup();
00711 bool isCrossposted() { return ( g_roups.find(',')>-1 ); }
00712 QStringList getGroups();
00713
00714 protected:
00715 QCString g_roups;
00716
00717 };
00718
00719
00721 class KDE_EXPORT FollowUpTo : public Newsgroups {
00722
00723 public:
00724 FollowUpTo() : Newsgroups() {}
00725 FollowUpTo(Content *p) : Newsgroups(p) {}
00726 FollowUpTo(Content *p, const QCString &s) : Newsgroups(p,s) {}
00727 FollowUpTo(Content *p, const QString &s) : Newsgroups(p,s) {}
00728 ~FollowUpTo() {}
00729
00730 virtual const char* type() { return "Followup-To"; }
00731
00732 };
00733
00734
00736 class KDE_EXPORT Lines : public Base {
00737
00738 public:
00739 Lines() : Base(),l_ines(-1) {}
00740 Lines(Content *p) : Base(p),l_ines(-1) {}
00741 Lines(Content *p, unsigned int i) : Base(p),l_ines(i) {}
00742 Lines(Content *p, const QCString &s) : Base(p) { from7BitString(s); }
00743 Lines(Content *p, const QString &s) : Base(p) { fromUnicodeString(s, Latin1); }
00744 ~Lines() {}
00745
00746 virtual void from7BitString(const QCString &s);
00747 virtual QCString as7BitString(bool incType=true);
00748 virtual void fromUnicodeString(const QString &s, const QCString&);
00749 virtual QString asUnicodeString();
00750 virtual void clear() { l_ines=-1; }
00751 virtual bool isEmpty() { return (l_ines==-1); }
00752 virtual const char* type() { return "Lines"; }
00753
00754 int numberOfLines() { return l_ines; }
00755 void setNumberOfLines(int i) { l_ines=i; }
00756
00757 protected:
00758 int l_ines;
00759
00760 };
00761
00762
00763
00765 class KDE_EXPORT UserAgent : public Base {
00766
00767 public:
00768 UserAgent() : Base() {}
00769 UserAgent(Content *p) : Base(p) {}
00770 UserAgent(Content *p, const QCString &s) : Base(p) { from7BitString(s); }
00771 UserAgent(Content *p, const QString &s) : Base(p) { fromUnicodeString(s, Latin1); }
00772 ~UserAgent() {}
00773
00774 virtual void from7BitString(const QCString &s);
00775 virtual QCString as7BitString(bool incType=true);
00776 virtual void fromUnicodeString(const QString &s, const QCString&);
00777 virtual QString asUnicodeString();
00778 virtual void clear() { u_agent.resize(0); }
00779 virtual bool isEmpty() { return (u_agent.isEmpty()); }
00780 virtual const char* type() { return "User-Agent"; }
00781
00782 protected:
00783 QCString u_agent;
00784
00785 };
00786
00787
00788 #if !defined(KMIME_NEW_STYLE_CLASSTREE)
00789 #include "kmime_headers_obs.h"
00790 #endif
00791 }
00792
00793 #if 0
00794 typedef Headers::Base* (*headerCreator)(void);
00795
00811 class HeaderFactory : public QAsciiDict<headerCreator>
00812 {
00813 private:
00814 HeaderFactory();
00815 ~HeaderFactory() {}
00816 static QAsciiDict
00817
00818 public:
00822 static Headers::Base* create( const char* aType )
00823 {
00824 if (!s_elf)
00825 s_elf = new HeaderFactory;
00826 headerCreator * hc = (*s_elf)[aType];
00827 if ( !hc )
00828 return 0;
00829 else
00830 return (*hc)();
00831 }
00832
00837 static Headers::Base* create( const QCString& aType )
00838 {
00839 return create( aType.data() );
00840 }
00841
00851 static Headers::Base* upgrade( Headers::Generic* aType ) { (void)aType; return new Headers::Base; }
00852
00853 };
00854
00855 #endif
00856
00857 }
00858
00859
00860 #endif // __KMIME_HEADERS_H__
00861