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