summaryrefslogtreecommitdiffstats
path: root/libkmime/kmime_headers.h
diff options
context:
space:
mode:
Diffstat (limited to 'libkmime/kmime_headers.h')
-rw-r--r--libkmime/kmime_headers.h861
1 files changed, 861 insertions, 0 deletions
diff --git a/libkmime/kmime_headers.h b/libkmime/kmime_headers.h
new file mode 100644
index 000000000..779cd341a
--- /dev/null
+++ b/libkmime/kmime_headers.h
@@ -0,0 +1,861 @@
+/* -*- c++ -*
+ kmime_headers.h
+
+ KMime, the KDE internet mail/usenet news message library.
+ Copyright (c) 2001-2002 the KMime authors.
+ See file AUTHORS for details
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License version 2.0 as
+ published by the Free Software Foundation.
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, US
+*/
+#ifndef __KMIME_HEADERS_H__
+#define __KMIME_HEADERS_H__
+
+// Content:
+//
+// - header's base class defining the common interface
+// - generic base classes for different types of fields
+// - incompatible, GStructured-based field classes
+// - compatible, GUnstructured-based field classes
+
+#include "kmime_header_parsing.h"
+
+#include <qstring.h>
+#include <qstrlist.h>
+#include <qstringlist.h>
+#include <qregexp.h>
+#include <qdatetime.h>
+#include <qasciidict.h>
+#include <qmap.h>
+#include <qptrlist.h>
+
+#include <time.h>
+
+#include <kdepimmacros.h>
+
+namespace KMime {
+
+//forward declaration
+class Content;
+
+namespace Headers {
+
+
+enum contentCategory { CCsingle,
+ CCcontainer,
+ CCmixedPart,
+ CCalternativePart };
+
+enum contentEncoding { CE7Bit,
+ CE8Bit,
+ CEquPr,
+ CEbase64,
+ CEuuenc,
+ CEbinary };
+
+enum contentDisposition { CDinline,
+ CDattachment,
+ CDparallel };
+
+//often used charset
+static const QCString Latin1("ISO-8859-1");
+
+#define mk_trivial_subclass_with_name( subclass, subclassName, baseclass ) \
+class subclass : public Generics::baseclass { \
+public: \
+ subclass() : Generics::baseclass() {} \
+ subclass( Content * p ) : Generics::baseclass( p ) {} \
+ subclass( Content * p, const QCString & s ) \
+ : Generics::baseclass( p ) { from7BitString( s ); } \
+ subclass( Content * p, const QString & s, const QCString & cs ) \
+ : Generics::baseclass( p ) { fromUnicodeString( s, cs ); } \
+ ~subclass() {} \
+ \
+ const char * type() const { return #subclassName; } \
+}
+
+#define mk_trivial_subclass( subclass, baseclass ) \
+mk_trivial_subclass_with_name( subclass, subclass, baseclass )
+
+#define mk_parsing_subclass_with_name( subclass, subclassName, baseclass ) \
+class subclass : public Generics::baseclass { \
+public: \
+ subclass() : Generics::baseclass() {} \
+ subclass( Content * p ) : Generics::baseclass( p ) {} \
+ subclass( Content * p, const QCString & s ) \
+ : Generics::baseclass( p ) { from7BitString( s ); } \
+ subclass( Content * p, const QString & s, const QCString & cs ) \
+ : Generics::baseclass( p ) { fromUnicodeString( s, cs ); } \
+ ~subclass() {} \
+ \
+ const char * type() const { return #subclassName; } \
+protected: \
+ bool parse( const char* & scursor, const char * const send, bool isCRLF=false ); \
+}
+
+#define mk_parsing_subclass( subclass, baseclass ) \
+mk_parsing_subclass_with_name( subclass, subclass, baseclass )
+
+//
+//
+// HEADER'S BASE CLASS. DEFINES THE COMMON INTERFACE
+//
+//
+
+/** Baseclass of all header-classes. It represents a
+ header-field as described in RFC-822. */
+class KDE_EXPORT Base {
+
+ public:
+ typedef QPtrList<Base> List;
+
+ /** Create an empty header. */
+ Base() : e_ncCS(0), p_arent(0) {}
+
+ /** Create an empty header with a parent-content. */
+ Base(KMime::Content *parent) : e_ncCS(0), p_arent(parent) {}
+
+ /** Destructor */
+ virtual ~Base() {}
+
+ /** Return the parent of this header. */
+ KMime::Content* parent() { return p_arent; }
+
+ /** Set the parent for this header. */
+ void setParent(KMime::Content *p) { p_arent=p; }
+
+ /** Parse the given string. Take care of RFC2047-encoded
+ strings. A default charset is given. If the last parameter
+ is true the default charset is used in any case */
+ virtual void from7BitString(const QCString&) {}
+
+ /** Return the encoded header. The parameter specifies
+ whether the header-type should be included. */
+ virtual QCString as7BitString(bool=true) { return QCString(); }
+
+ /** Return the charset that is used for RFC2047-encoding */
+ QCString rfc2047Charset();
+
+ /** Set the charset for RFC2047-encoding */
+ void setRFC2047Charset(const QCString &cs);
+
+ /** Return the default charset */
+ QCString defaultCS();
+
+ /** Return if the default charset is mandatory */
+ bool forceCS();
+
+ /** Parse the given string and set the charset. */
+ virtual void fromUnicodeString(const QString&, const QCString&) {}
+
+ /** Return the decoded content of the header without
+ the header-type. */
+ virtual QString asUnicodeString() { return QString(); }
+
+ /** Delete */
+ virtual void clear() {}
+
+ /** Do we have data? */
+ virtual bool isEmpty() { return false; }
+
+ /** Return the type of this header (e.g. "From") */
+ virtual const char* type() { return ""; }
+
+ /** Check if this header is of type t. */
+ bool is(const char* t) { return (strcasecmp(t, type())==0); }
+
+ /** Check if this header is a MIME header */
+ bool isMimeHeader() { return (strncasecmp(type(), "Content-", 8)==0); }
+
+ /** Check if this header is a X-Header */
+ bool isXHeader() { return (strncmp(type(), "X-", 2)==0); }
+
+ protected:
+ QCString typeIntro() { return (QCString(type())+": "); }
+
+ const char *e_ncCS;
+ Content *p_arent;
+
+};
+
+
+//
+//
+// GENERIC BASE CLASSES FOR DIFFERENT TYPES OF FIELDS
+//
+//
+
+namespace Generics {
+
+/** Abstract base class for unstructured header fields
+ (e.g. "Subject", "Comment", "Content-description").
+
+ Features: Decodes the header according to RFC2047, incl. RFC2231
+ extensions to encoded-words.
+
+ Subclasses need only re-implement @p const @p char* @p type().
+
+ A macro to automate this is named
+\code
+ MK_TRIVIAL_GUnstructured_SUBCLASS(classname,headername);
+\endcode
+
+ The ContentDescription class then reads:
+\code
+ MK_TRIVIAL_GUnstructured_SUBCLASS(ContentDescription,Content-Description);
+\endcode
+*/
+
+ // known issues:
+ // - uses old decodeRFC2047String function, instead of our own...
+
+class KDE_EXPORT GUnstructured : public Base {
+
+public:
+ GUnstructured() : Base() {}
+ GUnstructured( Content * p ) : Base( p ) {}
+ GUnstructured( Content * p, const QCString & s )
+ : Base( p ) { from7BitString(s); }
+ GUnstructured( Content * p, const QString & s, const QCString & cs )
+ : Base( p ) { fromUnicodeString( s, cs ); }
+ ~GUnstructured() {}
+
+ virtual void from7BitString( const QCString& str );
+ virtual QCString as7BitString( bool withHeaderType=true );
+
+ virtual void fromUnicodeString( const QString & str,
+ const QCString & suggestedCharset);
+ virtual QString asUnicodeString();
+
+ virtual void clear() { d_ecoded.truncate(0); }
+ virtual bool isEmpty() { return (d_ecoded.isEmpty()); }
+
+private:
+ QString d_ecoded;
+};
+
+/** This is the base class for all structured header fields. It
+ contains parsing methods for all basic token types found in
+ rfc2822.
+
+ @section Parsing
+
+ At the basic level, there are tokens & tspecials (rfc2045),
+ atoms & specials, quoted-strings, domain-literals (all rfc822) and
+ encoded-words (rfc2047).
+
+ As a special token, we have the comment. It is one of the basic
+ tokens defined in rfc822, but it's parsing relies in part on the
+ basic token parsers (e.g. comments may contain encoded-words).
+ Also, most upper-level parsers (notably those for phrase and
+ dot-atom) choose to ignore any comment when parsing.
+
+ Then there are the real composite tokens, which are made up of one
+ or more of the basic tokens (and semantically invisible comments):
+ phrases (rfc822 with rfc2047) and dot-atoms (rfc2822).
+
+ This finishes the list of supported token types. Subclasses will
+ provide support for more higher-level tokens, where necessary,
+ using these parsers.
+
+ @short Base class for structured header fields.
+ @author Marc Mutz <mutz@kde.org>
+*/
+
+class KDE_EXPORT GStructured : public Base {
+public:
+ GStructured() : Base() {}
+ GStructured( Content * p ) : Base( p ) {}
+ GStructured( Content * p, const QCString & s )
+ : Base( p ) { from7BitString(s); }
+ GStructured( Content * p, const QString & s, const QCString & cs )
+ : Base( p ) { fromUnicodeString( s, cs ); }
+ ~GStructured() {}
+
+
+protected:
+#if 0
+ // the assembly squad:
+
+ bool writeAtom( char* & dcursor, const char * const dend, const QString & input );
+ bool writeAtom( char* & dcursor, const char * const dend,
+ const QPair<const char*,int> & input );
+ bool writeToken( char* & dcursor, const char * const dend, const QString & input );
+ bool writeToken( char* & dcursor, const char * const dend,
+ const QPair<const char*int> & input );
+
+ bool writeGenericQuotedString( char* & dcursor, const char * const dend,
+ const QString & input, bool withCRLF=false );
+ bool writeComment( char* & dcursor, const char * const dend,
+ const QString & input, bool withCRLF=false );
+ bool writePhrase( char* & dcursor, const char * const dend,
+ const QString & input, bool withCRLF=false );
+ bool writeDotAtom( char* & dcursor, const char * const dend,
+ const QString & input, bool withCRLF=false );
+#endif
+};
+
+
+class KDE_EXPORT GAddress : public GStructured {
+public:
+ GAddress() : GStructured() {}
+ GAddress( Content * p ) : GStructured( p ) {}
+ GAddress( Content * p, const QCString & s )
+ : GStructured( p ) { from7BitString(s); }
+ GAddress( Content * p, const QString & s, const QCString & cs )
+ : GStructured( p ) { fromUnicodeString( s, cs ); }
+ ~GAddress() {}
+
+protected:
+};
+
+
+/** Base class for headers that deal with (possibly multiple)
+ addresses, but don't allow groups: */
+class KDE_EXPORT MailboxList : public GAddress {
+public:
+ MailboxList() : GAddress() {}
+ MailboxList( Content * p ) : GAddress( p ) {}
+ MailboxList( Content * p, const QCString & s )
+ : GAddress( p ) { from7BitString(s); }
+ MailboxList( Content * p, const QString & s, const QCString & cs )
+ : GAddress( p ) { fromUnicodeString( s, cs ); }
+ ~MailboxList() {}
+
+protected:
+ bool parse( const char* & scursor, const char * const send, bool isCRLF=false );
+
+ /** The list of mailboxes */
+ QValueList<Types::Mailbox> mMailboxList;
+};
+
+
+/** Base class for headers that deal with exactly one mailbox
+ (e.g. Sender) */
+mk_parsing_subclass(SingleMailbox,MailboxList);
+
+/** Base class for headers that deal with (possibly multiple)
+ addresses, allowing groups. */
+class KDE_EXPORT AddressList : public GAddress {
+public:
+ AddressList() : GAddress() {}
+ AddressList( Content * p ) : GAddress( p ) {}
+ AddressList( Content * p, const QCString & s )
+ : GAddress( p ) { from7BitString(s); }
+ AddressList( Content * p, const QString & s, const QCString & cs )
+ : GAddress( p ) { fromUnicodeString( s, cs ); }
+ ~AddressList() {}
+
+protected:
+ bool parse( const char* & scursor, const char * const send, bool isCRLF=false );
+
+ /** The list of addresses */
+ QValueList<Types::Address> mAddressList;
+};
+
+/** Base class for headers which deal with a list of msg-id's */
+class KDE_EXPORT GIdent : public GAddress {
+public:
+ GIdent() : GAddress() {}
+ GIdent( Content * p ) : GAddress( p ) {}
+ GIdent( Content * p, const QCString & s )
+ : GAddress( p ) { from7BitString(s); }
+ GIdent( Content * p, const QString & s, const QCString & cs )
+ : GAddress( p ) { fromUnicodeString( s, cs ); }
+ ~GIdent() {}
+
+protected:
+ bool parse( const char* & scursor, const char * const send, bool isCRLF=false );
+
+ /** The list of msg-id's */
+ QValueList<Types::AddrSpec> mMsgIdList;
+};
+
+/** Base class for headers which deal with a list of msg-id's */
+mk_parsing_subclass(GSingleIdent,GIdent);
+
+/** Base class for headers which deal with a single atom. */
+class KDE_EXPORT GToken : public GStructured {
+public:
+ GToken() : GStructured() {}
+ GToken( Content * p ) : GStructured( p ) {}
+ GToken( Content * p, const QCString & s )
+ : GStructured( p ) { from7BitString(s); }
+ GToken( Content * p, const QString & s, const QCString & cs )
+ : GStructured( p ) { fromUnicodeString( s, cs ); }
+ ~GToken() {}
+
+protected:
+ bool parse( const char* & scursor, const char * const send, bool isCRLF=false );
+
+ QCString mToken;
+};
+
+
+class KDE_EXPORT GPhraseList : public GStructured {
+public:
+ GPhraseList() : GStructured() {}
+ GPhraseList( Content * p ) : GStructured( p ) {}
+ GPhraseList( Content * p, const QCString & s )
+ : GStructured( p ) { from7BitString(s); }
+ GPhraseList( Content * p, const QString & s, const QCString & cs )
+ : GStructured( p ) { fromUnicodeString( s, cs ); }
+ ~GPhraseList() {}
+
+protected:
+ bool parse( const char* & scursor, const char * const send, bool isCRLF=false );
+
+ QStringList mPhraseList;
+};
+
+class KDE_EXPORT GDotAtom : public GStructured {
+public:
+ GDotAtom() : GStructured() {}
+ GDotAtom( Content * p ) : GStructured( p ) {}
+ GDotAtom( Content * p, const QCString & s )
+ : GStructured( p ) { from7BitString(s); }
+ GDotAtom( Content * p, const QString & s, const QCString & cs )
+ : GStructured( p ) { fromUnicodeString( s, cs ); }
+ ~GDotAtom() {}
+
+protected:
+ bool parse( const char* & scursor, const char * const send, bool isCRLF=false );
+
+ QString mDotAtom;
+};
+
+class KDE_EXPORT GParametrized : public GStructured {
+public:
+ GParametrized() : GStructured() {}
+ GParametrized( Content * p ) : GStructured( p ) {}
+ GParametrized( Content * p, const QCString & s )
+ : GStructured( p ) { from7BitString(s); }
+ GParametrized( Content * p, const QString & s, const QCString & cs )
+ : GStructured( p ) { fromUnicodeString( s, cs ); }
+ ~GParametrized() {}
+
+protected:
+ QMap<QString,QString> mParameterHash;
+
+private:
+};
+
+class KDE_EXPORT GContentType : public GParametrized {
+public:
+ GContentType() : GParametrized() {}
+ GContentType( Content * p ) : GParametrized( p ) {}
+ GContentType( Content * p, const QCString & s )
+ : GParametrized( p ) { from7BitString(s); }
+ GContentType( Content * p, const QString & s, const QCString & cs )
+ : GParametrized( p ) { fromUnicodeString( s, cs ); }
+ ~GContentType() {}
+
+protected:
+ bool parse( const char* & scursor, const char * const send, bool isCRLF=false );
+
+ QCString mMimeType;
+ QCString mMimeSubType;
+};
+
+
+class KDE_EXPORT GCISTokenWithParameterList : public GParametrized {
+public:
+ GCISTokenWithParameterList() : GParametrized() {}
+ GCISTokenWithParameterList( Content * p ) : GParametrized( p ) {}
+ GCISTokenWithParameterList( Content * p, const QCString & s )
+ : GParametrized( p ) { from7BitString(s); }
+ GCISTokenWithParameterList( Content * p, const QString & s, const QCString & cs )
+ : GParametrized( p ) { fromUnicodeString( s, cs ); }
+ ~GCISTokenWithParameterList() {}
+
+protected:
+ bool parse( const char* & scursor, const char * const send, bool isCRLF=false );
+
+ QCString mToken;
+};
+
+
+} // namespace Generics
+
+//
+//
+// INCOMPATIBLE, GSTRUCTURED-BASED FIELDS:
+//
+//
+
+
+/** Represents the Return-Path header field. */
+class KDE_EXPORT ReturnPath : public Generics::GAddress {
+public:
+ ReturnPath() : Generics::GAddress() {}
+ ReturnPath( Content * p ) : Generics::GAddress( p ) {}
+ ReturnPath( Content * p, const QCString & s )
+ : Generics::GAddress( p ) { from7BitString(s); }
+ ReturnPath( Content * p, const QString & s, const QCString & cs )
+ : Generics::GAddress( p ) { fromUnicodeString( s, cs ); }
+ ~ReturnPath() {}
+
+ const char * type() const { return "Return-Path"; }
+
+protected:
+ bool parse( const char* & scursor, const char * const send, bool isCRLF=false );
+};
+
+#if defined(KMIME_NEW_STYLE_CLASSTREE)
+// classes whose names collide with earlier ones:
+
+// GAddress et al.:
+
+// rfc(2)822 headers:
+mk_trivial_subclass(From,MailboxList);
+mk_trivial_subclass(Sender,SingleMailbox);
+mk_trivial_subclass_with_name(ReplyTo,Reply-To,AddressList);
+mk_trivial_subclass(Cc,AddressList);
+mk_trivial_subclass(Bcc,AddressList);
+// usefor headers:
+mk_trivial_subclass_with_name(MailCopiesTo,Mail-Copies-To,AddressList);
+
+// GToken:
+
+mk_trivial_subclass_with_name(ContentTransferEncoding,
+ Content-Transfer-Encoding,GToken);
+
+// GPhraseList:
+
+mk_trivial_subclass(Keywords,GPhraseList);
+
+// GDotAtom:
+
+mk_trivial_subclass_with_name(MIMEVersion,MIME-Version,GDotAtom);
+
+// GIdent:
+
+mk_trivial_subclass_with_name(MessageID,Message-ID,GSingleIdent);
+mk_trivial_subclass_with_name(ContentID,Content-ID,GSingleIdent);
+mk_trivial_subclass(Supersedes,GSingleIdent);
+mk_trivial_subclass_with_name(InReplyTo,In-Reply-To,GIdent);
+mk_trivial_subclass(References,GIdent);
+
+// GContentType:
+
+mk_trivial_subclass_with_name(ContentType,ContentType,GContentType);
+
+// GCISTokenWithParameterList:
+
+mk_trivial_subclass_with_name(ContentDisposition,Content-Disposition,
+ GCISTokenWithParameterList);
+
+
+#endif
+
+
+//
+//
+// COMPATIBLE GUNSTRUCTURED-BASED FIELDS:
+//
+//
+
+
+/** Represents an arbitrary header, that can contain
+ any header-field.
+ Adds a type over GUnstructured.
+ @see GUnstructured
+*/
+class KDE_EXPORT Generic : public Generics::GUnstructured {
+
+ public:
+ Generic() : Generics::GUnstructured(), t_ype(0) {}
+ Generic(const char *t)
+ : Generics::GUnstructured(), t_ype(0) { setType(t); }
+ Generic(const char *t, Content *p)
+ : Generics::GUnstructured( p ), t_ype(0) { setType(t); }
+ Generic(const char *t, Content *p, const QCString &s)
+ : Generics::GUnstructured( p, s ), t_ype(0) { setType(t); }
+ Generic(const char *t, Content *p, const QString &s, const QCString &cs)
+ : Generics::GUnstructured( p, s, cs ), t_ype(0) { setType(t); }
+ ~Generic() { delete[] t_ype; }
+
+ virtual void clear() { delete[] t_ype; GUnstructured::clear(); }
+ virtual bool isEmpty() { return (t_ype==0 || GUnstructured::isEmpty()); }
+ virtual const char* type() { return t_ype; }
+ void setType(const char *type);
+
+ protected:
+ char *t_ype;
+
+};
+
+
+/** Represents a "Subject" header */
+class KDE_EXPORT Subject : public Generics::GUnstructured {
+
+ public:
+ Subject() : Generics::GUnstructured() {}
+ Subject( Content * p ) : Generics::GUnstructured( p ) {}
+ Subject( Content * p, const QCString & s )
+ : Generics::GUnstructured( p, s ) {}
+ Subject( Content * p, const QString & s, const QCString & cs )
+ : Generics::GUnstructured( p, s, cs ) {}
+ ~Subject() {}
+
+ virtual const char* type() { return "Subject"; }
+
+ bool isReply() {
+ return ( asUnicodeString().find( QString("Re:"), 0, false ) == 0 );
+ }
+};
+
+/** Represents a "Organization" header */
+class KDE_EXPORT Organization : public Generics::GUnstructured {
+
+ public:
+ Organization() : Generics::GUnstructured() {}
+ Organization( Content * p ) : Generics::GUnstructured( p ) {}
+ Organization( Content * p, const QCString & s )
+ : Generics::GUnstructured( p, s ) {};
+ Organization( Content * p, const QString & s, const QCString & cs)
+ : Generics::GUnstructured( p, s, cs ) {}
+ ~Organization() {}
+
+ virtual const char* type() { return "Organization"; }
+
+};
+
+//
+//
+// NOT YET CONVERTED STUFF BELOW:
+//
+//
+
+
+
+/** Represents a "Control" header */
+class KDE_EXPORT Control : public Base {
+
+ public:
+ Control() : Base() {}
+ Control(Content *p) : Base(p) {}
+ Control(Content *p, const QCString &s) : Base(p) { from7BitString(s); }
+ Control(Content *p, const QString &s) : Base(p) { fromUnicodeString(s, Latin1); }
+ ~Control() {}
+
+ virtual void from7BitString(const QCString &s);
+ virtual QCString as7BitString(bool incType=true);
+ virtual void fromUnicodeString(const QString &s, const QCString&);
+ virtual QString asUnicodeString();
+ virtual void clear() { c_trlMsg.truncate(0); }
+ virtual bool isEmpty() { return (c_trlMsg.isEmpty()); }
+ virtual const char* type() { return "Control"; }
+
+ bool isCancel() { return (c_trlMsg.find("cancel", 0, false)!=-1); }
+
+ protected:
+ QCString c_trlMsg;
+
+};
+
+/** Represents a "Date" header */
+class KDE_EXPORT Date : public Base {
+
+ public:
+ Date() : Base(), t_ime(0) {}
+ Date(Content *p) : Base(p), t_ime(0) {}
+ Date(Content *p, time_t t) : Base(p), t_ime(t) {}
+ Date(Content *p, const QCString &s) : Base(p) { from7BitString(s); }
+ Date(Content *p, const QString &s) : Base(p) { fromUnicodeString(s, Latin1); }
+ ~Date() {}
+
+ virtual void from7BitString(const QCString &s);
+ virtual QCString as7BitString(bool incType=true);
+ virtual void fromUnicodeString(const QString &s, const QCString&);
+ virtual QString asUnicodeString();
+ virtual void clear() { t_ime=0; }
+ virtual bool isEmpty() { return (t_ime==0); }
+ virtual const char* type() { return "Date"; }
+
+ time_t unixTime() { return t_ime; }
+ void setUnixTime(time_t t) { t_ime=t; }
+ void setUnixTime() { t_ime=time(0); }
+ QDateTime qdt();
+ int ageInDays();
+
+ protected:
+ time_t t_ime;
+
+};
+
+
+/** Represents a "Newsgroups" header */
+class KDE_EXPORT Newsgroups : public Base {
+
+ public:
+ Newsgroups() : Base() {}
+ Newsgroups(Content *p) : Base(p) {}
+ Newsgroups(Content *p, const QCString &s) : Base(p) { from7BitString(s); }
+ Newsgroups(Content *p, const QString &s) : Base(p) { fromUnicodeString(s, Latin1); }
+ ~Newsgroups() {}
+
+ virtual void from7BitString(const QCString &s);
+ virtual QCString as7BitString(bool incType=true);
+ virtual void fromUnicodeString(const QString &s, const QCString&);
+ virtual QString asUnicodeString();
+ virtual void clear() { g_roups.resize(0); }
+ virtual bool isEmpty() { return g_roups.isEmpty(); }
+ virtual const char* type() { return "Newsgroups"; }
+
+ QCString firstGroup();
+ bool isCrossposted() { return ( g_roups.find(',')>-1 ); }
+ QStringList getGroups();
+
+ protected:
+ QCString g_roups;
+
+};
+
+
+/** Represents a "Followup-To" header */
+class KDE_EXPORT FollowUpTo : public Newsgroups {
+
+ public:
+ FollowUpTo() : Newsgroups() {}
+ FollowUpTo(Content *p) : Newsgroups(p) {}
+ FollowUpTo(Content *p, const QCString &s) : Newsgroups(p,s) {}
+ FollowUpTo(Content *p, const QString &s) : Newsgroups(p,s) {}
+ ~FollowUpTo() {}
+
+ virtual const char* type() { return "Followup-To"; }
+
+};
+
+
+/** Represents a "Lines" header */
+class KDE_EXPORT Lines : public Base {
+
+ public:
+ Lines() : Base(),l_ines(-1) {}
+ Lines(Content *p) : Base(p),l_ines(-1) {}
+ Lines(Content *p, unsigned int i) : Base(p),l_ines(i) {}
+ Lines(Content *p, const QCString &s) : Base(p) { from7BitString(s); }
+ Lines(Content *p, const QString &s) : Base(p) { fromUnicodeString(s, Latin1); }
+ ~Lines() {}
+
+ virtual void from7BitString(const QCString &s);
+ virtual QCString as7BitString(bool incType=true);
+ virtual void fromUnicodeString(const QString &s, const QCString&);
+ virtual QString asUnicodeString();
+ virtual void clear() { l_ines=-1; }
+ virtual bool isEmpty() { return (l_ines==-1); }
+ virtual const char* type() { return "Lines"; }
+
+ int numberOfLines() { return l_ines; }
+ void setNumberOfLines(int i) { l_ines=i; }
+
+ protected:
+ int l_ines;
+
+};
+
+
+
+/** Represents a "User-Agent" header */
+class KDE_EXPORT UserAgent : public Base {
+
+ public:
+ UserAgent() : Base() {}
+ UserAgent(Content *p) : Base(p) {}
+ UserAgent(Content *p, const QCString &s) : Base(p) { from7BitString(s); }
+ UserAgent(Content *p, const QString &s) : Base(p) { fromUnicodeString(s, Latin1); }
+ ~UserAgent() {}
+
+ virtual void from7BitString(const QCString &s);
+ virtual QCString as7BitString(bool incType=true);
+ virtual void fromUnicodeString(const QString &s, const QCString&);
+ virtual QString asUnicodeString();
+ virtual void clear() { u_agent.resize(0); }
+ virtual bool isEmpty() { return (u_agent.isEmpty()); }
+ virtual const char* type() { return "User-Agent"; }
+
+ protected:
+ QCString u_agent;
+
+};
+
+
+#if !defined(KMIME_NEW_STYLE_CLASSTREE)
+#include "kmime_headers_obs.h"
+#endif
+} //namespace Headers
+
+#if 0
+typedef Headers::Base* (*headerCreator)(void);
+
+/** This is a factory for KMime::Headers. You can create new header
+ objects by type with @ref create and @ref upgrade an existing
+ @ref Headers::Generic to a specialized header object.
+
+ If you are a header class author, you can register your class
+ (let's call it Foo) so:
+ <pre>
+
+ </pre>
+
+ @short Factory for KMime::Headers
+ @author Marc Mutz <mutz@kde.org>
+ @see KMime::Headers::Base KMime::Headers::Generic
+*/
+
+class HeaderFactory : public QAsciiDict<headerCreator>
+{
+private:
+ HeaderFactory();
+ ~HeaderFactory() {}
+ static QAsciiDict
+
+public:
+ /** Create a new header object of type @p aType, or a fitting
+ generic substitute, if available and known
+ */
+ static Headers::Base* create( const char* aType )
+ {
+ if (!s_elf)
+ s_elf = new HeaderFactory;
+ headerCreator * hc = (*s_elf)[aType];
+ if ( !hc )
+ return 0;
+ else
+ return (*hc)();
+ }
+
+ /** This is a wrapper around the above function, provided for
+ convenience. It differs from the above only in what arguments it
+ takes.
+ */
+ static Headers::Base* create( const QCString& aType )
+ {
+ return create( aType.data() );
+ }
+
+ /** Consume @p aType and build a header object that corresponds to
+ the type that @p aType->type() returns.
+ @param aType generic header to upgrade. This will be deleted
+ if necessary, so don't use references to it after
+ calling this function.
+ @return A corresponding header object (if available), or a generic
+ object for this kind of header (if known), or @p aType (else).
+ @see Headers::Generic create
+ */
+ static Headers::Base* upgrade( Headers::Generic* aType ) { (void)aType; return new Headers::Base; }
+
+};
+
+#endif
+
+} //namespace KMime
+
+
+#endif // __KMIME_HEADERS_H__
+