libkdenetwork Library API Documentation

kmime_headers_obs.h

00001 /*
00002     kmime_headers.h
00003 
00004     KMime, the KDE internet mail/usenet news message library.
00005     Copyright (c) 2001 the KMime authors.
00006     See file AUTHORS for details
00007 
00008     This program is free software; you can redistribute it and/or modify
00009     it under the terms of the GNU General Public License as published by
00010     the Free Software Foundation; either version 2 of the License, or
00011     (at your option) any later version.
00012     You should have received a copy of the GNU General Public License
00013     along with this program; if not, write to the Free Software Foundation,
00014     Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, US
00015 */
00016 #ifndef __KMIME_HEADERS_OBS_H__
00017 #define __KMIME_HEADERS_OBS_H__
00018 
00019 #if defined(KMIME_NEW_STYPE_CLASSTREE)
00020 #error You cannot use this file with the new header classes!
00021 #endif
00022 
00024 class MessageID : public Base {
00025 
00026   public:
00027     MessageID() : Base()  {}
00028     MessageID(Content *p) : Base(p) {}
00029     MessageID(Content *p, const QCString &s) : Base(p) { from7BitString(s); }
00030     MessageID(Content *p, const QString &s) : Base(p)  { fromUnicodeString(s, Latin1); }
00031     ~MessageID()  {}
00032 
00033     virtual void from7BitString(const QCString &s);
00034     virtual QCString as7BitString(bool incType=true);
00035     virtual void fromUnicodeString(const QString &s, const QCString&);
00036     virtual QString asUnicodeString();
00037     virtual void clear()            { m_id.resize(0); }
00038     virtual bool isEmpty()          { return (m_id.isEmpty()); }
00039     virtual const char* type()      { return "Message-Id"; }
00040 
00041     void generate(const QCString &fqdn);
00042 
00043   protected:
00044     QCString m_id;
00045 
00046 };
00047 
00049 class Supersedes : public MessageID {
00050 
00051   public:
00052     Supersedes() : MessageID()  {}
00053     Supersedes(Content *p) : MessageID(p)  {}
00054     Supersedes(Content *p, const QCString &s) : MessageID(p,s)  {}
00055     Supersedes(Content *p, const QString &s)  : MessageID(p,s)  {}
00056     ~Supersedes()                   {}
00057 
00058     virtual const char* type()      { return "Supersedes"; }
00059 
00060 };
00061 
00064 class AddressField : public Base {
00065 
00066   public:
00067     AddressField() : Base()  {}
00068     AddressField(Content *p) : Base(p)  {}
00069     AddressField(Content *p, const QCString &s) : Base(p)  { from7BitString(s); }
00070     AddressField(Content *p, const QString &s, const QCString &cs) : Base(p)  { fromUnicodeString(s, cs); }
00071     AddressField(const AddressField &a):  Base(a.p_arent)  { n_ame=a.n_ame; e_mail=a.e_mail.copy(); e_ncCS=a.e_ncCS; }
00072     ~AddressField()  {}
00073 
00074     AddressField& operator=(const AddressField &a)  { n_ame=a.n_ame; e_mail=a.e_mail.copy(); e_ncCS=a.e_ncCS; return (*this); }
00075 
00076     virtual void from7BitString(const QCString &s);
00077     virtual QCString as7BitString(bool incType=true);
00078     virtual void fromUnicodeString(const QString &s, const QCString &cs);
00079     virtual QString asUnicodeString();
00080     virtual void clear()              { n_ame.truncate(0); e_mail.resize(0); }
00081     virtual bool isEmpty()            { return (e_mail.isEmpty() && n_ame.isEmpty()); }
00082 
00083     bool hasName()                    { return ( !n_ame.isEmpty() ); }
00084     bool hasEmail()                   { return ( !e_mail.isEmpty() ); }
00085     QString name()                    { return n_ame; }
00086     QCString nameAs7Bit();
00087     QCString email()                  { return e_mail; }
00088     void setName(const QString &s)    { n_ame=s; }
00089     void setNameFrom7Bit(const QCString &s);
00090     void setEmail(const QCString &s)  { e_mail=s; }
00091 
00092   protected:
00093     QString n_ame;
00094     QCString e_mail;
00095 };
00096 typedef QPtrList<AddressField> ObsAddressList;
00097 
00099 class From : public AddressField {
00100 
00101   public:
00102     From() : AddressField()  {}
00103     From(Content *p) : AddressField(p)  {}
00104     From(Content *p, const QCString &s) : AddressField(p,s)  {}
00105     From(Content *p, const QString &s, const QCString &cs) : AddressField(p,s,cs)  {}
00106     ~From()  {}
00107 
00108     virtual const char* type()      { return "From"; }
00109 };
00110 
00111 
00113 class ReplyTo : public AddressField {
00114 
00115   public:
00116     ReplyTo() : AddressField()  {}
00117     ReplyTo(Content *p) : AddressField(p)  {}
00118     ReplyTo(Content *p, const QCString &s) : AddressField(p,s)  {}
00119     ReplyTo(Content *p, const QString &s, const QCString &cs) : AddressField(p,s,cs)  {}
00120     ~ReplyTo()  {}
00121 
00122     virtual const char* type()      { return "Reply-To"; }
00123 
00124 };
00125 
00126 
00129 class MailCopiesTo : public AddressField {
00130 
00131   public:
00132     MailCopiesTo() : AddressField()  {}
00133     MailCopiesTo(Content *p) : AddressField(p)  {}
00134     MailCopiesTo(Content *p, const QCString &s) : AddressField(p,s)  {}
00135     MailCopiesTo(Content *p, const QString &s, const QCString &cs) : AddressField(p,s,cs)  {}
00136     ~MailCopiesTo()  {}
00137 
00138     bool isValid();
00139     bool alwaysCopy();
00140     bool neverCopy();
00141 
00142     virtual const char* type()      { return "Mail-Copies-To"; }
00143 
00144 };
00145 
00147 class To : public Base {
00148 
00149   public:
00150     To() : Base(),a_ddrList(0)  {}
00151     To(Content *p) : Base(p),a_ddrList(0)  {}
00152     To(Content *p, const QCString &s) : Base(p),a_ddrList(0)  { from7BitString(s); }
00153     To(Content *p, const QString &s, const QCString &cs) : Base(p),a_ddrList(0)  { fromUnicodeString(s,cs); }
00154     ~To()  { delete a_ddrList; }
00155 
00156     virtual void from7BitString(const QCString &s);
00157     virtual QCString as7BitString(bool incType=true);
00158     virtual void fromUnicodeString(const QString &s, const QCString &cs);
00159     virtual QString asUnicodeString();
00160     virtual void clear()            { delete a_ddrList; a_ddrList=0; }
00161     virtual bool isEmpty()          { return (!a_ddrList || a_ddrList->isEmpty()
00162                                               || a_ddrList->first()->isEmpty()); }
00163     virtual const char* type()      { return "To"; }
00164 
00165     void addAddress(const AddressField &a);
00166     void emails(QStrList *l);
00167 
00168   protected:
00169     ObsAddressList *a_ddrList;
00170 
00171 };
00172 
00173 
00175 class CC : public To {
00176 
00177   public:
00178     CC() : To()  {}
00179     CC(Content *p) : To(p)  {}
00180     CC(Content *p, const QCString &s) : To(p,s)  {}
00181     CC(Content *p, const QString &s, const QCString &cs) : To(p,s,cs)  {}
00182     ~CC()  {}
00183 
00184     virtual const char* type()      { return "CC"; }
00185 
00186 };
00187 
00188 
00190 class BCC : public To {
00191 
00192   public:
00193     BCC() : To()  {}
00194     BCC(Content *p) : To(p)  {}
00195     BCC(Content *p, const QCString &s) : To(p,s)  {}
00196     BCC(Content *p, const QString &s, const QCString &cs) : To(p,s,cs)  {}
00197     ~BCC()  {}
00198 
00199     virtual const char* type()      { return "BCC"; }
00200 
00201 };
00202 
00204 class References : public Base {
00205 
00206   public:
00207     References() : Base(),p_os(-1)  {}
00208     References(Content *p) : Base(p),p_os(-1)  {}
00209     References(Content *p, const QCString &s) : Base(p),p_os(-1)  { from7BitString(s); }
00210     References(Content *p, const QString &s) : Base(p),p_os(-1)  { fromUnicodeString(s, Latin1); }
00211     ~References()                 {}
00212 
00213     virtual void from7BitString(const QCString &s);
00214     virtual QCString as7BitString(bool incType=true);
00215     virtual void fromUnicodeString(const QString &s, const QCString&);
00216     virtual QString asUnicodeString();
00217     virtual void clear()            { r_ef.resize(0); p_os=0; }
00218     virtual bool isEmpty()          { return (r_ef.isEmpty()); }
00219     virtual const char* type()      { return "References"; }
00220 
00221     int count();
00222     QCString first();
00223     QCString next();
00224     QCString at(unsigned int i);
00225     void append(const QCString &s);
00226 
00227   protected:
00228     QCString r_ef;
00229     int p_os;
00230 
00231 };
00232 
00234 class ContentType : public Base {
00235 
00236   public:
00237     ContentType() : Base(),m_imeType("invalid/invalid"),c_ategory(CCsingle)  {}
00238     ContentType(Content *p) : Base(p),m_imeType("invalid/invalid"),c_ategory(CCsingle)  {}
00239     ContentType(Content *p, const QCString &s) : Base(p)  { from7BitString(s); }
00240     ContentType(Content *p, const QString &s) : Base(p)  { fromUnicodeString(s, Latin1); }
00241     ~ContentType()  {}
00242 
00243     virtual void from7BitString(const QCString &s);
00244     virtual QCString as7BitString(bool incType=true);
00245     virtual void fromUnicodeString(const QString &s, const QCString&);
00246     virtual QString asUnicodeString();
00247     virtual void clear()            { m_imeType.resize(0); p_arams.resize(0); }
00248     virtual bool isEmpty()          { return (m_imeType.isEmpty()); }
00249     virtual const char* type()      { return "Content-Type"; }
00250 
00251 
00252     //mime-type handling
00253     QCString mimeType()                     { return m_imeType; }
00254     QCString mediaType();
00255     QCString subType();
00256     void setMimeType(const QCString &s);
00257     bool isMediatype(const char *s);
00258     bool isSubtype(const char *s);
00259     bool isText();
00260     bool isPlainText();
00261     bool isHTMLText();
00262     bool isImage();
00263     bool isMultipart();
00264     bool isPartial();
00265 
00266     //parameter handling
00267     QCString charset();
00268     void setCharset(const QCString &s);
00269     QCString boundary();
00270     void setBoundary(const QCString &s);
00271     QString name();
00272     void setName(const QString &s, const QCString &cs);
00273     QCString id();
00274     void setId(const QCString &s);
00275     int partialNumber();
00276     int partialCount();
00277     void setPartialParams(int total, int number);
00278 
00279     //category
00280     contentCategory category()            { return c_ategory; }
00281     void setCategory(contentCategory c)   { c_ategory=c; }
00282 
00283   protected:
00284     QCString getParameter(const char *name);
00285     void setParameter(const QCString &name, const QCString &value, bool doubleQuotes=false);
00286     QCString m_imeType, p_arams;
00287     contentCategory c_ategory;
00288 
00289 };
00290 
00291 
00293 class CTEncoding : public Base {
00294 
00295   public:
00296     CTEncoding() : Base(),c_te(CE7Bit),d_ecoded(true)  {}
00297     CTEncoding(Content *p) : Base(p),c_te(CE7Bit),d_ecoded(true)  {}
00298     CTEncoding(Content *p, const QCString &s) : Base(p)  { from7BitString(s); }
00299     CTEncoding(Content *p, const QString &s) : Base(p)  { fromUnicodeString(s, Latin1); }
00300     ~CTEncoding()  {}
00301 
00302     virtual void from7BitString(const QCString &s);
00303     virtual QCString as7BitString(bool incType=true);
00304     virtual void fromUnicodeString(const QString &s, const QCString&);
00305     virtual QString asUnicodeString();
00306     virtual void clear()            { d_ecoded=true; c_te=CE7Bit; }
00307     virtual const char* type()      { return "Content-Transfer-Encoding"; }
00308 
00309     contentEncoding cte()                   { return c_te; }
00310     void setCte(contentEncoding e)          { c_te=e; }
00311     bool decoded()                          { return d_ecoded; }
00312     void setDecoded(bool d=true)            { d_ecoded=d; }
00313     bool needToEncode()                     { return (d_ecoded && (c_te==CEquPr || c_te==CEbase64)); }
00314 
00315   protected:
00316     contentEncoding c_te;
00317     bool d_ecoded;
00318 
00319 };
00320 
00321 
00323 class CDisposition : public Base {
00324 
00325   public:
00326     CDisposition() : Base(),d_isp(CDinline)  {}
00327     CDisposition(Content *p) : Base(p),d_isp(CDinline)  {}
00328     CDisposition(Content *p, const QCString &s) : Base(p)  { from7BitString(s); }
00329     CDisposition(Content *p, const QString &s, const QCString &cs) : Base(p)  { fromUnicodeString(s, cs); }
00330     ~CDisposition()  {}
00331 
00332     virtual void from7BitString(const QCString &s);
00333     virtual QCString as7BitString(bool incType=true);
00334     virtual void fromUnicodeString(const QString &s, const QCString &cs);
00335     virtual QString asUnicodeString();
00336     virtual void clear()            { f_ilename.truncate(0); d_isp=CDinline; }
00337     virtual const char* type()      { return "Content-Disposition"; }
00338 
00339     contentDisposition disposition()          { return d_isp; }
00340     void setDisposition(contentDisposition d) { d_isp=d; }
00341     bool isAttachment()                       { return (d_isp==CDattachment); }
00342 
00343     QString filename()                        { return f_ilename; }
00344     void setFilename(const QString &s)        { f_ilename=s; }
00345 
00346   protected:
00347     contentDisposition d_isp;
00348     QString f_ilename;
00349 
00350 };
00351 
00352 
00354 class CDescription : public Generics::GUnstructured {
00355 
00356   public:
00357     CDescription() : Generics::GUnstructured()  {}
00358     CDescription( Content * p ) : Generics::GUnstructured( p )  {}
00359     CDescription( Content * p, const QCString & s )
00360       : Generics::GUnstructured( p, s ) {};
00361     CDescription( Content * p, const QString & s, const QCString & cs )
00362       : Generics::GUnstructured( p, s, cs ) {}
00363     ~CDescription()  {}
00364     
00365     virtual const char* type()      { return "Content-Description"; }
00366 };
00367 
00368 #endif  // __KMIME_HEADERS_OBS_H__
KDE Logo
This file is part of the documentation for libkdenetwork Library Version 3.3.2.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Fri Dec 21 14:21:39 2007 by doxygen 1.4.2 written by Dimitri van Heesch, © 1997-2003