libkmime/kmime_headers.h

   1 /*  -*- c++ -*
   2     kmime_headers.h
   3
   4     KMime, the KDE internet mail/usenet news message library.
   5     Copyright (c) 2001-2002 the KMime authors.
   6     See file AUTHORS for details
   7
   8     This program is free software; you can redistribute it and/or modify
   9     it under the terms of the GNU General Public License version 2.0 as
  10     published by the Free Software Foundation.
  11     You should have received a copy of the GNU General Public License
  12     along with this program; if not, write to the Free Software Foundation,
  13     Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, US
  14 */
  15 #ifndef __KMIME_HEADERS_H__
  16 #define __KMIME_HEADERS_H__
  17
  18 // Content:
  19 //
  20 // - header's base class defining the common interface
  21 // - generic base classes for different types of fields
  22 // - incompatible, GStructured-based field classes
  23 // - compatible, GUnstructured-based field classes
  24
  25 #include "kmime_header_parsing.h"
  26
  27 #include <qstring.h>
  28 #include <qstrlist.h>
  29 #include <qstringlist.h>
  30 #include <qregexp.h>
  31 #include <qdatetime.h>
  32 #include <qasciidict.h>
  33 #include <qmap.h>
  34 #include <qptrlist.h>
  35
  36 #include <time.h>
  37
  38 #include <kdepimmacros.h>
  39
  40 namespace KMime {
  41
  42 //forward declaration
  43 class Content;
  44
  45 namespace Headers {
  46
  47
  48 enum contentCategory    { CCsingle,
  49                           CCcontainer,
  50                           CCmixedPart,
  51                           CCalternativePart };
  52
  53 enum contentEncoding    { CE7Bit,
  54                           CE8Bit,
  55                           CEquPr,
  56                           CEbase64,
  57                           CEuuenc,
  58                           CEbinary };
  59
  60 enum contentDisposition { CDinline,
  61                           CDattachment,
  62                           CDparallel };
  63
  64 //often used charset
  65 static const QCString Latin1("ISO-8859-1");
  66
  67 #define mk_trivial_subclass_with_name( subclass, subclassName, baseclass ) \
  68 class subclass : public Generics::baseclass { \
  69 public: \
  70   subclass() : Generics::baseclass() {} \
  71   subclass( Content * p ) : Generics::baseclass( p ) {} \
  72   subclass( Content * p, const QCString & s ) \
  73     : Generics::baseclass( p ) { from7BitString( s ); } \
  74   subclass( Content * p, const QString & s, const QCString & cs ) \
  75     : Generics::baseclass( p ) { fromUnicodeString( s, cs ); } \
  76   ~subclass() {} \
  77   \
  78   const char * type() const { return #subclassName; } \
  79 }
  80
  81 #define mk_trivial_subclass( subclass, baseclass ) \
  82 mk_trivial_subclass_with_name( subclass, subclass, baseclass )
  83
  84 #define mk_parsing_subclass_with_name( subclass, subclassName, baseclass ) \
  85 class subclass : public Generics::baseclass { \
  86 public: \
  87   subclass() : Generics::baseclass() {} \
  88   subclass( Content * p ) : Generics::baseclass( p ) {} \
  89   subclass( Content * p, const QCString & s ) \
  90     : Generics::baseclass( p ) { from7BitString( s ); } \
  91   subclass( Content * p, const QString & s, const QCString & cs ) \
  92     : Generics::baseclass( p ) { fromUnicodeString( s, cs ); } \
  93   ~subclass() {} \
  94   \
  95   const char * type() const { return #subclassName; } \
  96 protected: \
  97   bool parse( const char* & scursor, const char * const send, bool isCRLF=false ); \
  98 }
  99
 100 #define mk_parsing_subclass( subclass, baseclass ) \
 101 mk_parsing_subclass_with_name( subclass, subclass, baseclass )
 102
 103 //
 104 //
 105 // HEADER'S BASE CLASS. DEFINES THE COMMON INTERFACE
 106 //
 107 //
 108
 109 /** Baseclass of all header-classes. It represents a
 110     header-field as described in RFC-822.  */
 111 class KDE_EXPORT Base {
 112
 113   public:
 114     typedef QPtrList<Base> List;
 115
 116     /** Create an empty header. */
 117     Base() : e_ncCS(0), p_arent(0) {}
 118
 119     /** Create an empty header with a parent-content. */
 120     Base(KMime::Content *parent) : e_ncCS(0), p_arent(parent) {}
 121
 122     /** Destructor */
 123     virtual ~Base()  {}
 124
 125     /** Return the parent of this header. */
 126     KMime::Content* parent()  { return p_arent; }
 127
 128     /** Set the parent for this header. */
 129     void setParent(KMime::Content *p)  { p_arent=p; }
 130
 131     /** Parse the given string. Take care of RFC2047-encoded
 132         strings. A default charset is given. If the last parameter
 133         is true the default charset is used in any case */
 134     virtual void from7BitString(const QCString&)  {}
 135
 136     /** Return the encoded header. The parameter specifies
 137         whether the header-type should be included. */
 138     virtual QCString as7BitString(bool=true)  { return QCString(); }
 139
 140     /** Return the charset that is used for RFC2047-encoding */
 141     QCString rfc2047Charset();
 142
 143     /** Set the charset for RFC2047-encoding */
 144     void setRFC2047Charset(const QCString &cs);
 145
 146     /** Return the default charset */
 147     QCString defaultCS();
 148
 149     /** Return if the default charset is mandatory */
 150     bool forceCS();
 151
 152     /** Parse the given string and set the charset. */
 153     virtual void fromUnicodeString(const QString&, const QCString&)  {}
 154
 155     /** Return the decoded content of the header without
 156        the header-type. */
 157     virtual QString asUnicodeString()  { return QString(); }
 158
 159     /** Delete */
 160     virtual void clear()  {}
 161
 162     /** Do we have data? */
 163     virtual bool isEmpty()  { return false; }
 164
 165     /** Return the type of this header (e.g. "From") */
 166     virtual const char* type()  { return ""; }
 167
 168     /** Check if this header is of type t. */
 169     bool is(const char* t)  { return (strcasecmp(t, type())==0); }
 170
 171     /** Check if this header is a MIME header */
 172     bool isMimeHeader()  { return (strncasecmp(type(), "Content-", 8)==0); }
 173
 174     /** Check if this header is a X-Header */
 175     bool isXHeader()  { return (strncmp(type(), "X-", 2)==0); }
 176
 177   protected:
 178     QCString typeIntro()  { return (QCString(type())+": "); }
 179
 180     const char *e_ncCS;
 181     Content *p_arent;
 182
 183 };
 184
 185
 186 //
 187 //
 188 // GENERIC BASE CLASSES FOR DIFFERENT TYPES OF FIELDS
 189 //
 190 //
 191
 192 namespace Generics {
 193
 194 /** Abstract base class for unstructured header fields
 195     (e.g. "Subject", "Comment", "Content-description").
 196
 197     Features: Decodes the header according to RFC2047, incl. RFC2231
 198     extensions to encoded-words.
 199
 200     Subclasses need only re-implement @p const @p char* @p type().
 201
 202     A macro to automate this is named
 203 \code
 204     MK_TRIVIAL_GUnstructured_SUBCLASS(classname,headername);
 205 \endcode
 206
 207     The ContentDescription class then reads:
 208 \code
 209     MK_TRIVIAL_GUnstructured_SUBCLASS(ContentDescription,Content-Description);
 210 \endcode
 211 */
 212
 213   // known issues:
 214   // - uses old decodeRFC2047String function, instead of our own...
 215
 216 class KDE_EXPORT GUnstructured : public Base {
 217
 218 public:
 219   GUnstructured() : Base()  {}
 220   GUnstructured( Content * p ) : Base( p ) {}
 221   GUnstructured( Content * p, const QCString & s )
 222     : Base( p ) { from7BitString(s); }
 223   GUnstructured( Content * p, const QString & s, const QCString & cs )
 224     : Base( p )  { fromUnicodeString( s, cs ); }
 225   ~GUnstructured()  {}
 226
 227   virtual void from7BitString( const QCString& str );
 228   virtual QCString as7BitString( bool withHeaderType=true );
 229
 230   virtual void fromUnicodeString( const QString & str,
 231                                   const QCString & suggestedCharset);
 232   virtual QString asUnicodeString();
 233
 234   virtual void clear()            { d_ecoded.truncate(0); }
 235   virtual bool isEmpty()          { return (d_ecoded.isEmpty()); }
 236
 237 private:
 238   QString d_ecoded;
 239 };
 240
 241 /** This is the base class for all structured header fields. It
 242     contains parsing methods for all basic token types found in
 243     rfc2822.
 244
 245     @section Parsing
 246
 247     At the basic level, there are tokens & tspecials (rfc2045),
 248     atoms & specials, quoted-strings, domain-literals (all rfc822) and
 249     encoded-words (rfc2047).
 250
 251     As a special token, we have the comment. It is one of the basic
 252     tokens defined in rfc822, but it's parsing relies in part on the
 253     basic token parsers (e.g. comments may contain encoded-words).
 254     Also, most upper-level parsers (notably those for phrase and
 255     dot-atom) choose to ignore any comment when parsing.
 256
 257     Then there are the real composite tokens, which are made up of one
 258     or more of the basic tokens (and semantically invisible comments):
 259     phrases (rfc822 with rfc2047) and dot-atoms (rfc2822).
 260
 261     This finishes the list of supported token types. Subclasses will
 262     provide support for more higher-level tokens, where necessary,
 263     using these parsers.
 264
 265     @short Base class for structured header fields.
 266     @author Marc Mutz <mutz@kde.org>
 267 */
 268
 269 class KDE_EXPORT GStructured : public Base {
 270 public:
 271   GStructured() : Base()  {}
 272   GStructured( Content * p ) : Base( p ) {}
 273   GStructured( Content * p, const QCString & s )
 274     : Base( p ) { from7BitString(s); }
 275   GStructured( Content * p, const QString & s, const QCString & cs )
 276     : Base( p )  { fromUnicodeString( s, cs ); }
 277   ~GStructured()  {}
 278
 279
 280 protected:
 281 #if 0
 282   // the assembly squad:
 283
 284   bool writeAtom( char* & dcursor, const char * const dend, const QString & input );
 285   bool writeAtom( char* & dcursor, const char * const dend,
 286                   const QPair<const char*,int> & input );
 287   bool writeToken( char* & dcursor, const char * const dend, const QString & input );
 288   bool writeToken( char* & dcursor, const char * const dend,
 289                    const QPair<const char*int> & input );
 290
 291   bool writeGenericQuotedString( char* & dcursor, const char * const dend,
 292                                  const QString & input, bool withCRLF=false );
 293   bool writeComment( char* & dcursor, const char * const dend,
 294                      const QString & input, bool withCRLF=false );
 295   bool writePhrase( char* & dcursor, const char * const dend,
 296                     const QString & input, bool withCRLF=false );
 297   bool writeDotAtom( char* & dcursor, const char * const dend,
 298                      const QString & input, bool withCRLF=false );
 299 #endif
 300 };
 301
 302
 303 class KDE_EXPORT GAddress : public GStructured {
 304 public:
 305   GAddress() : GStructured()  {}
 306   GAddress( Content * p ) : GStructured( p ) {}
 307   GAddress( Content * p, const QCString & s )
 308     : GStructured( p ) { from7BitString(s); }
 309   GAddress( Content * p, const QString & s, const QCString & cs )
 310     : GStructured( p )  { fromUnicodeString( s, cs ); }
 311   ~GAddress()  {}
 312
 313 protected:
 314 };
 315
 316
 317 /** Base class for headers that deal with (possibly multiple)
 318     addresses, but don't allow groups: */
 319 class KDE_EXPORT MailboxList : public GAddress {
 320 public:
 321   MailboxList() : GAddress()  {}
 322   MailboxList( Content * p ) : GAddress( p ) {}
 323   MailboxList( Content * p, const QCString & s )
 324     : GAddress( p ) { from7BitString(s); }
 325   MailboxList( Content * p, const QString & s, const QCString & cs )
 326     : GAddress( p )  { fromUnicodeString( s, cs ); }
 327   ~MailboxList()  {}
 328
 329 protected:
 330   bool parse( const char* & scursor, const char * const send, bool isCRLF=false );
 331
 332   /** The list of mailboxes */
 333   QValueList<Types::Mailbox> mMailboxList;
 334 };
 335
 336
 337 /** Base class for headers that deal with exactly one mailbox
 338     (e.g. Sender) */
 339 mk_parsing_subclass(SingleMailbox,MailboxList);
 340
 341 /** Base class for headers that deal with (possibly multiple)
 342     addresses, allowing groups. */
 343 class KDE_EXPORT AddressList : public GAddress {
 344 public:
 345   AddressList() : GAddress()  {}
 346   AddressList( Content * p ) : GAddress( p ) {}
 347   AddressList( Content * p, const QCString & s )
 348     : GAddress( p ) { from7BitString(s); }
 349   AddressList( Content * p, const QString & s, const QCString & cs )
 350     : GAddress( p )  { fromUnicodeString( s, cs ); }
 351   ~AddressList()  {}
 352
 353 protected:
 354   bool parse( const char* & scursor, const char * const send, bool isCRLF=false );
 355
 356   /** The list of addresses */
 357   QValueList<Types::Address> mAddressList;
 358 };
 359
 360 /** Base class for headers which deal with a list of msg-id's */
 361 class KDE_EXPORT GIdent : public GAddress {
 362 public:
 363   GIdent() : GAddress()  {}
 364   GIdent( Content * p ) : GAddress( p ) {}
 365   GIdent( Content * p, const QCString & s )
 366     : GAddress( p ) { from7BitString(s); }
 367   GIdent( Content * p, const QString & s, const QCString & cs )
 368     : GAddress( p )  { fromUnicodeString( s, cs ); }
 369   ~GIdent()  {}
 370
 371 protected:
 372   bool parse( const char* & scursor, const char * const send, bool isCRLF=false );
 373
 374   /** The list of msg-id's */
 375   QValueList<Types::AddrSpec> mMsgIdList;
 376 };
 377
 378 /** Base class for headers which deal with a list of msg-id's */
 379 mk_parsing_subclass(GSingleIdent,GIdent);
 380
 381 /** Base class for headers which deal with a single atom. */
 382 class KDE_EXPORT GToken : public GStructured {
 383 public:
 384   GToken() : GStructured()  {}
 385   GToken( Content * p ) : GStructured( p ) {}
 386   GToken( Content * p, const QCString & s )
 387     : GStructured( p ) { from7BitString(s); }
 388   GToken( Content * p, const QString & s, const QCString & cs )
 389     : GStructured( p )  { fromUnicodeString( s, cs ); }
 390   ~GToken()  {}
 391
 392 protected:
 393   bool parse( const char* & scursor, const char * const send, bool isCRLF=false );
 394
 395   QCString mToken;
 396 };
 397
 398
 399 class KDE_EXPORT GPhraseList : public GStructured {
 400 public:
 401   GPhraseList() : GStructured()  {}
 402   GPhraseList( Content * p ) : GStructured( p ) {}
 403   GPhraseList( Content * p, const QCString & s )
 404     : GStructured( p ) { from7BitString(s); }
 405   GPhraseList( Content * p, const QString & s, const QCString & cs )
 406     : GStructured( p )  { fromUnicodeString( s, cs ); }
 407   ~GPhraseList()  {}
 408
 409 protected:
 410   bool parse( const char* & scursor, const char * const send, bool isCRLF=false );
 411
 412   QStringList mPhraseList;
 413 };
 414
 415 class KDE_EXPORT GDotAtom : public GStructured {
 416 public:
 417   GDotAtom() : GStructured()  {}
 418   GDotAtom( Content * p ) : GStructured( p ) {}
 419   GDotAtom( Content * p, const QCString & s )
 420     : GStructured( p ) { from7BitString(s); }
 421   GDotAtom( Content * p, const QString & s, const QCString & cs )
 422     : GStructured( p )  { fromUnicodeString( s, cs ); }
 423   ~GDotAtom()  {}
 424
 425 protected:
 426   bool parse( const char* & scursor, const char * const send, bool isCRLF=false );
 427
 428   QString mDotAtom;
 429 };
 430
 431 class KDE_EXPORT GParametrized : public GStructured {
 432 public:
 433   GParametrized() : GStructured()  {}
 434   GParametrized( Content * p ) : GStructured( p ) {}
 435   GParametrized( Content * p, const QCString & s )
 436     : GStructured( p ) { from7BitString(s); }
 437   GParametrized( Content * p, const QString & s, const QCString & cs )
 438     : GStructured( p )  { fromUnicodeString( s, cs ); }
 439   ~GParametrized()  {}
 440
 441 protected:
 442   QMap<QString,QString> mParameterHash;
 443
 444 private:
 445 };
 446
 447 class KDE_EXPORT GContentType : public GParametrized {
 448 public:
 449   GContentType() : GParametrized()  {}
 450   GContentType( Content * p ) : GParametrized( p ) {}
 451   GContentType( Content * p, const QCString & s )
 452     : GParametrized( p ) { from7BitString(s); }
 453   GContentType( Content * p, const QString & s, const QCString & cs )
 454     : GParametrized( p )  { fromUnicodeString( s, cs ); }
 455   ~GContentType()  {}
 456
 457 protected:
 458   bool parse( const char* & scursor, const char * const send, bool isCRLF=false );
 459
 460   QCString mMimeType;
 461   QCString mMimeSubType;
 462 };
 463
 464
 465 class KDE_EXPORT GCISTokenWithParameterList : public GParametrized {
 466 public:
 467   GCISTokenWithParameterList() : GParametrized()  {}
 468   GCISTokenWithParameterList( Content * p ) : GParametrized( p ) {}
 469   GCISTokenWithParameterList( Content * p, const QCString & s )
 470     : GParametrized( p ) { from7BitString(s); }
 471   GCISTokenWithParameterList( Content * p, const QString & s, const QCString & cs )
 472     : GParametrized( p )  { fromUnicodeString( s, cs ); }
 473   ~GCISTokenWithParameterList()  {}
 474
 475 protected:
 476   bool parse( const char* & scursor, const char * const send, bool isCRLF=false );
 477
 478   QCString mToken;
 479 };
 480
 481
 482 } // namespace Generics
 483
 484 //
 485 //
 486 // INCOMPATIBLE, GSTRUCTURED-BASED FIELDS:
 487 //
 488 //
 489
 490
 491 /** Represents the Return-Path header field. */
 492 class KDE_EXPORT ReturnPath : public Generics::GAddress {
 493 public:
 494   ReturnPath() : Generics::GAddress()  {}
 495   ReturnPath( Content * p ) : Generics::GAddress( p ) {}
 496   ReturnPath( Content * p, const QCString & s )
 497     : Generics::GAddress( p ) { from7BitString(s); }
 498   ReturnPath( Content * p, const QString & s, const QCString & cs )
 499     : Generics::GAddress( p )  { fromUnicodeString( s, cs ); }
 500   ~ReturnPath()  {}
 501
 502   const char * type() const { return "Return-Path"; }
 503
 504 protected:
 505   bool parse( const char* & scursor, const char * const send, bool isCRLF=false );
 506 };
 507
 508 #if defined(KMIME_NEW_STYLE_CLASSTREE)
 509 // classes whose names collide with earlier ones:
 510
 511 // GAddress et al.:
 512
 513 // rfc(2)822 headers:
 514 mk_trivial_subclass(From,MailboxList);
 515 mk_trivial_subclass(Sender,SingleMailbox);
 516 mk_trivial_subclass_with_name(ReplyTo,Reply-To,AddressList);
 517 mk_trivial_subclass(Cc,AddressList);
 518 mk_trivial_subclass(Bcc,AddressList);
 519 // usefor headers:
 520 mk_trivial_subclass_with_name(MailCopiesTo,Mail-Copies-To,AddressList);
 521
 522 // GToken:
 523
 524 mk_trivial_subclass_with_name(ContentTransferEncoding,
 525                               Content-Transfer-Encoding,GToken);
 526
 527 // GPhraseList:
 528
 529 mk_trivial_subclass(Keywords,GPhraseList);
 530
 531 // GDotAtom:
 532
 533 mk_trivial_subclass_with_name(MIMEVersion,MIME-Version,GDotAtom);
 534
 535 // GIdent:
 536
 537 mk_trivial_subclass_with_name(MessageID,Message-ID,GSingleIdent);
 538 mk_trivial_subclass_with_name(ContentID,Content-ID,GSingleIdent);
 539 mk_trivial_subclass(Supersedes,GSingleIdent);
 540 mk_trivial_subclass_with_name(InReplyTo,In-Reply-To,GIdent);
 541 mk_trivial_subclass(References,GIdent);
 542
 543 // GContentType:
 544
 545 mk_trivial_subclass_with_name(ContentType,ContentType,GContentType);
 546
 547 // GCISTokenWithParameterList:
 548
 549 mk_trivial_subclass_with_name(ContentDisposition,Content-Disposition,
 550                               GCISTokenWithParameterList);
 551
 552
 553 #endif
 554
 555
 556 //
 557 //
 558 // COMPATIBLE GUNSTRUCTURED-BASED FIELDS:
 559 //
 560 //
 561
 562
 563 /** Represents an arbitrary header, that can contain
 564     any header-field.
 565     Adds a type over GUnstructured.
 566     @see GUnstructured
 567 */
 568 class KDE_EXPORT Generic : public Generics::GUnstructured {
 569
 570   public:
 571     Generic() : Generics::GUnstructured(), t_ype(0) {}
 572     Generic(const char *t)
 573       : Generics::GUnstructured(), t_ype(0) { setType(t); }
 574     Generic(const char *t, Content *p)
 575       : Generics::GUnstructured( p ), t_ype(0) { setType(t); }
 576     Generic(const char *t, Content *p, const QCString &s)
 577       : Generics::GUnstructured( p, s ), t_ype(0) { setType(t); }
 578     Generic(const char *t, Content *p, const QString &s, const QCString &cs)
 579       : Generics::GUnstructured( p, s, cs ), t_ype(0) { setType(t); }
 580     ~Generic() { delete[] t_ype; }
 581
 582     virtual void clear()            { delete[] t_ype; GUnstructured::clear(); }
 583     virtual bool isEmpty()          { return (t_ype==0 || GUnstructured::isEmpty()); }
 584     virtual const char* type()      { return t_ype; }
 585     void setType(const char *type);
 586
 587   protected:
 588     char *t_ype;
 589
 590 };
 591
 592
 593 /** Represents a "Subject" header */
 594 class KDE_EXPORT Subject : public Generics::GUnstructured {
 595
 596   public:
 597     Subject() : Generics::GUnstructured()  {}
 598     Subject( Content * p ) : Generics::GUnstructured( p )  {}
 599     Subject( Content * p, const QCString & s )
 600       : Generics::GUnstructured( p, s ) {}
 601     Subject( Content * p, const QString & s, const QCString & cs )
 602       : Generics::GUnstructured( p, s, cs ) {}
 603     ~Subject()  {}
 604
 605     virtual const char* type() { return "Subject"; }
 606
 607     bool isReply() {
 608       return ( asUnicodeString().find( QString("Re:"), 0, false ) == 0 );
 609     }
 610 };
 611
 612 /** Represents a "Organization" header */
 613 class KDE_EXPORT Organization : public Generics::GUnstructured {
 614
 615   public:
 616     Organization() : Generics::GUnstructured() {}
 617     Organization( Content * p ) : Generics::GUnstructured( p ) {}
 618     Organization( Content * p, const QCString & s )
 619       : Generics::GUnstructured( p, s ) {};
 620     Organization( Content * p, const QString & s, const QCString & cs)
 621       : Generics::GUnstructured( p, s, cs ) {}
 622     ~Organization()  {}
 623
 624     virtual const char* type()      { return "Organization"; }
 625
 626 };
 627
 628 //
 629 //
 630 // NOT YET CONVERTED STUFF BELOW:
 631 //
 632 //
 633
 634
 635
 636 /** Represents a "Control" header */
 637 class KDE_EXPORT Control : public Base {
 638
 639   public:
 640     Control() : Base()  {}
 641     Control(Content *p) : Base(p)  {}
 642     Control(Content *p, const QCString &s) : Base(p) { from7BitString(s); }
 643     Control(Content *p, const QString &s) : Base(p)  { fromUnicodeString(s, Latin1); }
 644     ~Control()  {}
 645
 646     virtual void from7BitString(const QCString &s);
 647     virtual QCString as7BitString(bool incType=true);
 648     virtual void fromUnicodeString(const QString &s, const QCString&);
 649     virtual QString asUnicodeString();
 650     virtual void clear()            { c_trlMsg.truncate(0); }
 651     virtual bool isEmpty()          { return (c_trlMsg.isEmpty()); }
 652     virtual const char* type()      { return "Control"; }
 653
 654     bool isCancel()                 { return (c_trlMsg.find("cancel", 0, false)!=-1); }
 655
 656   protected:
 657     QCString c_trlMsg;
 658
 659 };
 660
 661 /** Represents a "Date" header */
 662 class KDE_EXPORT Date : public Base {
 663
 664   public:
 665     Date() : Base(), t_ime(0)  {}
 666     Date(Content *p) : Base(p), t_ime(0)  {}
 667     Date(Content *p, time_t t) : Base(p), t_ime(t)  {}
 668     Date(Content *p, const QCString &s) : Base(p)  { from7BitString(s); }
 669     Date(Content *p, const QString &s) : Base(p)  { fromUnicodeString(s, Latin1); }
 670     ~Date()  {}
 671
 672     virtual void from7BitString(const QCString &s);
 673     virtual QCString as7BitString(bool incType=true);
 674     virtual void fromUnicodeString(const QString &s, const QCString&);
 675     virtual QString asUnicodeString();
 676     virtual void clear()            { t_ime=0; }
 677     virtual bool isEmpty()          { return (t_ime==0); }
 678     virtual const char* type()      { return "Date"; }
 679
 680     time_t unixTime()               { return t_ime; }
 681     void setUnixTime(time_t t)      { t_ime=t; }
 682     void setUnixTime()              { t_ime=time(0); }
 683     QDateTime qdt();
 684     int ageInDays();
 685
 686   protected:
 687     time_t t_ime;
 688
 689 };
 690
 691
 692 /** Represents a "Newsgroups" header */
 693 class KDE_EXPORT Newsgroups : public Base {
 694
 695   public:
 696     Newsgroups() : Base()  {}
 697     Newsgroups(Content *p) : Base(p)  {}
 698     Newsgroups(Content *p, const QCString &s) : Base(p)  { from7BitString(s); }
 699     Newsgroups(Content *p, const QString &s) : Base(p)  { fromUnicodeString(s, Latin1); }
 700     ~Newsgroups()  {}
 701
 702     virtual void from7BitString(const QCString &s);
 703     virtual QCString as7BitString(bool incType=true);
 704     virtual void fromUnicodeString(const QString &s, const QCString&);
 705     virtual QString asUnicodeString();
 706     virtual void clear()            { g_roups.resize(0); }
 707     virtual bool isEmpty()          { return g_roups.isEmpty(); }
 708     virtual const char* type()      { return "Newsgroups"; }
 709
 710     QCString firstGroup();
 711     bool isCrossposted()            { return ( g_roups.find(',')>-1 ); }
 712     QStringList getGroups();
 713
 714   protected:
 715     QCString g_roups;
 716
 717 };
 718
 719
 720 /** Represents a "Followup-To" header */
 721 class KDE_EXPORT FollowUpTo : public Newsgroups {
 722
 723   public:
 724     FollowUpTo() : Newsgroups()  {}
 725     FollowUpTo(Content *p) : Newsgroups(p)  {}
 726     FollowUpTo(Content *p, const QCString &s) : Newsgroups(p,s)  {}
 727     FollowUpTo(Content *p, const QString &s) : Newsgroups(p,s)  {}
 728     ~FollowUpTo()  {}
 729
 730     virtual const char* type()        { return "Followup-To"; }
 731
 732 };
 733
 734
 735 /** Represents a "Lines" header */
 736 class KDE_EXPORT Lines : public Base {
 737
 738   public:
 739     Lines() : Base(),l_ines(-1)  {}
 740     Lines(Content *p) : Base(p),l_ines(-1)  {}
 741     Lines(Content *p, unsigned int i) : Base(p),l_ines(i)  {}
 742     Lines(Content *p, const QCString &s) : Base(p)  { from7BitString(s); }
 743     Lines(Content *p, const QString &s) : Base(p)  { fromUnicodeString(s, Latin1); }
 744     ~Lines()                 {}
 745
 746     virtual void from7BitString(const QCString &s);
 747     virtual QCString as7BitString(bool incType=true);
 748     virtual void fromUnicodeString(const QString &s, const QCString&);
 749     virtual QString asUnicodeString();
 750     virtual void clear()            { l_ines=-1; }
 751     virtual bool isEmpty()          { return (l_ines==-1); }
 752     virtual const char* type()      { return "Lines"; }
 753
 754     int numberOfLines()             { return l_ines; }
 755     void setNumberOfLines(int i)    { l_ines=i; }
 756
 757   protected:
 758     int l_ines;
 759
 760 };
 761
 762
 763
 764 /** Represents a "User-Agent" header */
 765 class KDE_EXPORT UserAgent : public Base {
 766
 767   public:
 768     UserAgent() : Base()  {}
 769     UserAgent(Content *p) : Base(p)  {}
 770     UserAgent(Content *p, const QCString &s) : Base(p)  { from7BitString(s); }
 771     UserAgent(Content *p, const QString &s) : Base(p)  { fromUnicodeString(s, Latin1); }
 772     ~UserAgent()  {}
 773
 774     virtual void from7BitString(const QCString &s);
 775     virtual QCString as7BitString(bool incType=true);
 776     virtual void fromUnicodeString(const QString &s, const QCString&);
 777     virtual QString asUnicodeString();
 778     virtual void clear()            { u_agent.resize(0); }
 779     virtual bool isEmpty()          { return (u_agent.isEmpty()); }
 780     virtual const char* type()      { return "User-Agent"; }
 781
 782   protected:
 783     QCString u_agent;
 784
 785 };
 786
 787
 788 #if !defined(KMIME_NEW_STYLE_CLASSTREE)
 789 #include "kmime_headers_obs.h"
 790 #endif
 791 }  //namespace Headers
 792
 793 #if 0
 794 typedef Headers::Base* (*headerCreator)(void);
 795
 796 /** This is a factory for KMime::Headers. You can create new header
 797     objects by type with @ref create and @ref upgrade an existing
 798     @ref Headers::Generic to a specialized header object.
 799
 800     If you are a header class author, you can register your class
 801     (let's call it Foo) so:
 802     <pre>
 803
 804     </pre>
 805
 806     @short Factory for KMime::Headers
 807     @author Marc Mutz <mutz@kde.org>
 808     @see KMime::Headers::Base KMime::Headers::Generic
 809 */
 810
 811 class HeaderFactory : public QAsciiDict<headerCreator>
 812 {
 813 private:
 814   HeaderFactory();
 815   ~HeaderFactory() {}
 816   static QAsciiDict
 817
 818 public:
 819   /** Create a new header object of type @p aType, or a fitting
 820       generic substitute, if available and known
 821   */
 822   static Headers::Base* create( const char* aType )
 823   {
 824     if (!s_elf)
 825       s_elf = new HeaderFactory;
 826     headerCreator * hc = (*s_elf)[aType];
 827     if ( !hc )
 828       return 0;
 829     else
 830       return (*hc)();
 831   }
 832
 833   /** This is a wrapper around the above function, provided for
 834       convenience. It differs from the above only in what arguments it
 835       takes.
 836   */
 837   static Headers::Base* create( const QCString& aType )
 838   {
 839     return create( aType.data() );
 840   }
 841
 842   /** Consume @p aType and build a header object that corresponds to
 843       the type that @p aType->type() returns.
 844       @param  aType    generic header to upgrade. This will be deleted
 845                        if necessary, so don't use references to it after
 846                        calling this function.
 847       @return A corresponding header object (if available), or a generic
 848       object for this kind of header (if known), or @p aType (else).
 849       @see Headers::Generic create
 850   */
 851   static Headers::Base* upgrade( Headers::Generic* aType ) { (void)aType; return new Headers::Base; }
 852
 853 };
 854
 855 #endif
 856
 857 }  //namespace KMime
 858
 859
 860 #endif // __KMIME_HEADERS_H__
 861