KMime

kmime_headers.h
Go to the documentation of this file.
1 /* -*- c++ -*-
2  kmime_headers.h
3 
4  KMime, the KDE Internet mail/usenet news message library.
5  SPDX-FileCopyrightText: 2001-2002 the KMime authors.
6  See file AUTHORS for details
7  SPDX-FileCopyrightText: 2006 Volker Krause <[email protected]>
8 
9  SPDX-License-Identifier: LGPL-2.0-or-later
10 */
27 #ifndef __KMIME_HEADERS_H__
28 #define __KMIME_HEADERS_H__
29 
30 #include "kmime_export.h"
31 #include "kmime_header_parsing.h"
32 
33 #include <QString>
34 #include <QStringList>
35 #include <QDateTime>
36 #include <QVector>
37 #include <QByteArray>
38 #include <QMetaType>
39 
40 namespace KMime
41 {
42 
43 class Content;
44 
45 namespace Headers
46 {
47 
48 class BasePrivate;
49 
50 enum contentCategory {
51  CCsingle,
52  CCcontainer,
53  CCmixedPart,
54  CCalternativePart
55 };
56 
67 };
68 
77 };
78 
79 //@cond PRIVATE
80 // internal macro to generate default constructors
81 #define kmime_mk_trivial_ctor( subclass ) \
82  public: \
83  subclass(); \
84  ~subclass() override;
85 
86 #define kmime_mk_dptr_ctor( subclass ) \
87  protected: \
88  explicit subclass( subclass##Private *d );
89 
90 #define kmime_mk_trivial_ctor_with_name( subclass ) \
91  kmime_mk_trivial_ctor( subclass ) \
92  const char *type() const override; \
93  static const char *staticType();
94 //@endcond
95 
96 //
97 //
98 // HEADER'S BASE CLASS. DEFINES THE COMMON INTERFACE
99 //
100 //
101 
104 class KMIME_EXPORT Base
105 {
106 public:
111 
115  Base();
116 
120  virtual ~Base();
121 
126  virtual void from7BitString(const char *s, size_t len);
127  virtual void from7BitString(const QByteArray &s) = 0;
128 
133  Q_REQUIRED_RESULT virtual QByteArray as7BitString(bool withHeaderType = true) const = 0;
134 
138  Q_REQUIRED_RESULT QByteArray rfc2047Charset() const;
139 
144  void setRFC2047Charset(const QByteArray &cs);
145 
151  virtual void fromUnicodeString(const QString &s, const QByteArray &b) = 0;
152 
160  virtual QString asUnicodeString() const = 0;
161 
165  virtual void clear() = 0;
166 
170  virtual bool isEmpty() const = 0;
171 
175  virtual const char *type() const;
176 
180  Q_REQUIRED_RESULT bool is(const char *t) const;
181 
185  Q_REQUIRED_RESULT bool isMimeHeader() const;
186 
187 protected:
191  QByteArray typeIntro() const;
192 
193  //@cond PRIVATE
194  BasePrivate *d_ptr;
195  kmime_mk_dptr_ctor(Base)
196  //@endcond
197 
198 private:
199  Q_DECLARE_PRIVATE(Base)
200  Q_DISABLE_COPY(Base)
201 };
202 
203 //
204 //
205 // GENERIC BASE CLASSES FOR DIFFERENT TYPES OF FIELDS
206 //
207 //
208 
209 namespace Generics
210 {
211 
212 class UnstructuredPrivate;
213 
224 // known issues:
225 // - uses old decodeRFC2047String function, instead of our own...
226 
227 class KMIME_EXPORT Unstructured : public Base
228 {
229  //@cond PRIVATE
230  kmime_mk_dptr_ctor(Unstructured)
231  //@endcond
232 public:
233  Unstructured();
234  ~Unstructured() override;
235 
236  using Base::from7BitString;
237  void from7BitString(const QByteArray &s) override;
238  QByteArray as7BitString(bool withHeaderType = true) const override;
239 
240  void fromUnicodeString(const QString &s, const QByteArray &b) override;
241  QString asUnicodeString() const override;
242 
243  void clear() override;
244 
245  bool isEmpty() const override;
246 
247 private:
248  Q_DECLARE_PRIVATE(Unstructured)
249 };
250 
251 class StructuredPrivate;
252 
283 class KMIME_EXPORT Structured : public Base
284 {
285 public:
286  Structured();
287  ~Structured() override;
288 
289  void from7BitString(const char *s, size_t len) override;
290  void from7BitString(const QByteArray &s) override;
291  QString asUnicodeString() const override;
292  void fromUnicodeString(const QString &s, const QByteArray &b) override;
293 
294 protected:
303  virtual bool parse(const char *&scursor, const char *const send,
304  bool isCRLF = false) = 0;
305 
306  //@cond PRIVATE
307  kmime_mk_dptr_ctor(Structured)
308  //@endcond
309 
310 private:
311  Q_DECLARE_PRIVATE(Structured)
312 };
313 
314 class AddressPrivate;
315 
319 class KMIME_EXPORT Address : public Structured
320 {
321 public:
322  Address();
323  ~Address() override;
324 protected:
325  //@cond PRIVATE
326  kmime_mk_dptr_ctor(Address)
327  //@endcond
328 private:
329  Q_DECLARE_PRIVATE(Address)
330 };
331 
332 class MailboxListPrivate;
333 
340 class KMIME_EXPORT MailboxList : public Address
341 {
342  //@cond PRIVATE
343  kmime_mk_trivial_ctor(MailboxList)
344  kmime_mk_dptr_ctor(MailboxList)
345  //@endcond
346 public:
347  QByteArray as7BitString(bool withHeaderType = true) const override;
348  void fromUnicodeString(const QString &s, const QByteArray &b) override;
349  QString asUnicodeString() const override;
350 
351  void clear() override;
352  bool isEmpty() const override;
353 
359  void addAddress(const Types::Mailbox &mbox);
360 
366  void addAddress(const QByteArray &address,
367  const QString &displayName = QString());
368 
372  QVector<QByteArray> addresses() const;
373 
379  QStringList displayNames() const;
380 
386  QString displayString() const;
387 
391  Types::Mailbox::List mailboxes() const;
392 
393 protected:
394  bool parse(const char *&scursor, const char *const send, bool isCRLF = false) override;
395 
396 private:
397  Q_DECLARE_PRIVATE(MailboxList)
398 };
399 
400 class SingleMailboxPrivate;
401 
406 class KMIME_EXPORT SingleMailbox : public MailboxList
407 {
408  //@cond PRIVATE
409  kmime_mk_trivial_ctor(SingleMailbox)
410  //@endcond
411 protected:
412  bool parse(const char *&scursor, const char *const send, bool isCRLF = false) override;
413 private:
414  Q_DECLARE_PRIVATE(SingleMailbox)
415 };
416 
417 class AddressListPrivate;
418 
430 class KMIME_EXPORT AddressList : public Address
431 {
432  //@cond PRIVATE
433  kmime_mk_trivial_ctor(AddressList)
434  kmime_mk_dptr_ctor(AddressList)
435  //@endcond
436 public:
437  QByteArray as7BitString(bool withHeaderType = true) const override;
438  void fromUnicodeString(const QString &s, const QByteArray &b) override;
439  QString asUnicodeString() const override;
440 
441  void clear() override;
442  bool isEmpty() const override;
443 
449  void addAddress(const Types::Mailbox &mbox);
450 
456  void addAddress(const QByteArray &address, const QString &displayName = QString());
457 
461  QVector<QByteArray> addresses() const;
462 
467  QStringList displayNames() const;
468 
474  QString displayString() const;
475 
479  Types::Mailbox::List mailboxes() const;
480 
481 protected:
482  bool parse(const char *&scursor, const char *const send, bool isCRLF = false) override;
483 
484 private:
485  Q_DECLARE_PRIVATE(AddressList)
486 };
487 
488 class IdentPrivate;
489 
495 class KMIME_EXPORT Ident : public Address
496 {
497  //@cond PRIVATE
498  kmime_mk_trivial_ctor(Ident)
499  kmime_mk_dptr_ctor(Ident)
500  //@endcond
501 public:
502  QByteArray as7BitString(bool withHeaderType = true) const override;
503  void clear() override;
504  bool isEmpty() const override;
505 
509  void fromIdent(const Ident* ident);
510 
517  QVector<QByteArray> identifiers() const;
518 
523  void appendIdentifier(const QByteArray &id);
524 
525 protected:
526  bool parse(const char *&scursor, const char *const send, bool isCRLF = false) override;
527 
528 private:
529  Q_DECLARE_PRIVATE(Ident)
530 };
531 
532 class SingleIdentPrivate;
533 
539 class KMIME_EXPORT SingleIdent : public Ident
540 {
541  //@cond PRIVATE
542  kmime_mk_trivial_ctor(SingleIdent)
543  kmime_mk_dptr_ctor(SingleIdent)
544  //@endcond
545 public:
550  QByteArray identifier() const;
551 
556  void setIdentifier(const QByteArray &id);
557 
558 protected:
559  bool parse(const char *&scursor, const char *const send, bool isCRLF = false) override;
560 
561 private:
562  Q_DECLARE_PRIVATE(SingleIdent)
563 };
564 
565 class TokenPrivate;
566 
570 class KMIME_EXPORT Token : public Structured
571 {
572  //@cond PRIVATE
573  kmime_mk_trivial_ctor(Token)
574  kmime_mk_dptr_ctor(Token)
575  //@endcond
576 public:
577  QByteArray as7BitString(bool withHeaderType = true) const override;
578  void clear() override;
579  bool isEmpty() const override;
580 
584  QByteArray token() const;
585 
589  void setToken(const QByteArray &t);
590 
591 protected:
592  bool parse(const char *&scursor, const char *const send, bool isCRLF = false) override;
593 
594 private:
595  Q_DECLARE_PRIVATE(Token)
596 };
597 
598 class PhraseListPrivate;
599 
603 class KMIME_EXPORT PhraseList : public Structured
604 {
605  //@cond PRIVATE
606  kmime_mk_trivial_ctor(PhraseList)
607  //@endcond
608 public:
609  QByteArray as7BitString(bool withHeaderType = true) const override;
610  QString asUnicodeString() const override;
611  void clear() override;
612  bool isEmpty() const override;
613 
617  QStringList phrases() const;
618 
619 protected:
620  bool parse(const char *&scursor, const char *const send, bool isCRLF = false) override;
621 
622 private:
623  Q_DECLARE_PRIVATE(PhraseList)
624 };
625 
626 class DotAtomPrivate;
627 
631 class KMIME_EXPORT DotAtom : public Structured
632 {
633  //@cond PRIVATE
634  kmime_mk_trivial_ctor(DotAtom)
635  //@endcond
636 public:
637  QByteArray as7BitString(bool withHeaderType = true) const override;
638  QString asUnicodeString() const override;
639  void clear() override;
640  bool isEmpty() const override;
641 
642 protected:
643  bool parse(const char *&scursor, const char *const send, bool isCRLF = false) override;
644 
645 private:
646  Q_DECLARE_PRIVATE(DotAtom)
647 };
648 
649 class ParametrizedPrivate;
650 
654 class KMIME_EXPORT Parametrized : public Structured
655 {
656  //@cond PRIVATE
657  kmime_mk_trivial_ctor(Parametrized)
658  kmime_mk_dptr_ctor(Parametrized)
659  //@endcond
660 public:
661  QByteArray as7BitString(bool withHeaderType = true) const override;
662 
663  bool isEmpty() const override;
664  void clear() override;
665 
666  //FIXME: Shouldn't the parameter keys be QByteArray and not QStrings? Only the values can be
667  // non-ascii!
668 
673  QString parameter(const QString &key) const;
674 
680  bool hasParameter(const QString &key) const;
681 
687  void setParameter(const QString &key, const QString &value);
688 
689 protected:
690  bool parse(const char *&scursor, const char *const send, bool isCRLF = false) override;
691 
692 private:
693  Q_DECLARE_PRIVATE(Parametrized)
694 };
695 
696 } // namespace Generics
697 
698 //
699 //
700 // INCOMPATIBLE, GSTRUCTURED-BASED FIELDS:
701 //
702 //
703 
704 class ReturnPathPrivate;
705 
711 class KMIME_EXPORT ReturnPath : public Generics::Address
712 {
713  //@cond PRIVATE
714  kmime_mk_trivial_ctor_with_name(ReturnPath)
715  //@endcond
716 public:
717  QByteArray as7BitString(bool withHeaderType = true) const override;
718  void clear() override;
719  bool isEmpty() const override;
720 
721 protected:
722  bool parse(const char *&scursor, const char *const send, bool isCRLF = false) override;
723 
724 private:
725  Q_DECLARE_PRIVATE(ReturnPath)
726 };
727 
728 // Address et al.:
729 
730 // rfc(2)822 headers:
736 class KMIME_EXPORT From : public Generics::MailboxList
737 {
738  kmime_mk_trivial_ctor_with_name(From)
739 };
740 
746 class KMIME_EXPORT Sender : public Generics::SingleMailbox
747 {
748  kmime_mk_trivial_ctor_with_name(Sender)
749 };
750 
756 class KMIME_EXPORT To : public Generics::AddressList
757 {
758  kmime_mk_trivial_ctor_with_name(To)
759 };
760 
766 class KMIME_EXPORT Cc : public Generics::AddressList
767 {
768  kmime_mk_trivial_ctor_with_name(Cc)
769 };
770 
776 class KMIME_EXPORT Bcc : public Generics::AddressList
777 {
778  kmime_mk_trivial_ctor_with_name(Bcc)
779 };
780 
786 class KMIME_EXPORT ReplyTo : public Generics::AddressList
787 {
788  kmime_mk_trivial_ctor_with_name(ReplyTo)
789 };
790 
791 class MailCopiesToPrivate;
792 
798 class KMIME_EXPORT MailCopiesTo : public Generics::AddressList
799 {
800  //@cond PRIVATE
801  kmime_mk_trivial_ctor_with_name(MailCopiesTo)
802  //@endcond
803 public:
804  QByteArray as7BitString(bool withHeaderType = true) const override;
805  QString asUnicodeString() const override;
806 
807  void clear() override;
808  bool isEmpty() const override;
809 
813  bool alwaysCopy() const;
814 
818  void setAlwaysCopy();
819 
823  bool neverCopy() const;
824 
828  void setNeverCopy();
829 
830 protected:
831  bool parse(const char *&scursor, const char *const send, bool isCRLF = false) override;
832 
833 private:
834  Q_DECLARE_PRIVATE(MailCopiesTo)
835 };
836 
837 class ContentTransferEncodingPrivate;
838 
844 class KMIME_EXPORT ContentTransferEncoding : public Generics::Token
845 {
846  //@cond PRIVATE
847  kmime_mk_trivial_ctor_with_name(ContentTransferEncoding)
848  //@endcond
849 public:
850  void clear() override;
851 
855  contentEncoding encoding() const;
856 
860  void setEncoding(contentEncoding e);
861 
865  bool isDecoded() const;
866 
873  void setDecoded(bool isDecoded = true);
874 
879  bool needToEncode() const;
880 
881 protected:
882  bool parse(const char *&scursor, const char *const send, bool isCRLF = false) override;
883 
884 private:
885  Q_DECLARE_PRIVATE(ContentTransferEncoding)
886 };
887 
893 class KMIME_EXPORT Keywords : public Generics::PhraseList
894 {
895  kmime_mk_trivial_ctor_with_name(Keywords)
896 };
897 
898 // DotAtom:
899 
905 class KMIME_EXPORT MIMEVersion : public Generics::DotAtom
906 {
907  kmime_mk_trivial_ctor_with_name(MIMEVersion)
908 };
909 
910 // Ident:
911 
917 class KMIME_EXPORT MessageID : public Generics::SingleIdent
918 {
919  //@cond PRIVATE
920  kmime_mk_trivial_ctor_with_name(MessageID)
921  //@endcond
922 public:
927  void generate(const QByteArray &fqdn);
928 };
929 
930 class ContentIDPrivate;
931 
935 class KMIME_EXPORT ContentID : public Generics::SingleIdent
936 {
937  //@cond PRIVATE
938  kmime_mk_trivial_ctor_with_name(ContentID)
939  kmime_mk_dptr_ctor(ContentID)
940  //@endcond
941 
942 protected:
943  bool parse(const char *&scursor, const char *const send, bool isCRLF = false) override;
944 private:
945  Q_DECLARE_PRIVATE(ContentID)
946 };
947 
951 class KMIME_EXPORT Supersedes : public Generics::SingleIdent
952 {
953  kmime_mk_trivial_ctor_with_name(Supersedes)
954 };
955 
961 class KMIME_EXPORT InReplyTo : public Generics::Ident
962 {
963  kmime_mk_trivial_ctor_with_name(InReplyTo)
964 };
965 
971 class KMIME_EXPORT References : public Generics::Ident
972 {
973  kmime_mk_trivial_ctor_with_name(References)
974 };
975 
976 class ContentTypePrivate;
977 
983 class KMIME_EXPORT ContentType : public Generics::Parametrized
984 {
985  //@cond PRIVATE
986  kmime_mk_trivial_ctor_with_name(ContentType)
987  //@endcond
988 public:
989  QByteArray as7BitString(bool withHeaderType = true) const override;
990  void clear() override;
991  bool isEmpty() const override;
992 
996  QByteArray mimeType() const;
997 
1002  QByteArray mediaType() const;
1003 
1007  QByteArray subType() const;
1008 
1013  void setMimeType(const QByteArray &mimeType);
1014 
1018  bool isMediatype(const char *mediatype) const;
1019 
1023  bool isSubtype(const char *subtype) const;
1024 
1028  bool isMimeType(const char *mimeType) const;
1029 
1033  bool isText() const;
1034 
1038  bool isPlainText() const;
1039 
1043  bool isHTMLText() const;
1044 
1048  bool isImage() const;
1049 
1053  bool isMultipart() const;
1054 
1059  bool isPartial() const;
1060 
1064  QByteArray charset() const;
1065 
1069  void setCharset(const QByteArray &s);
1070 
1074  QByteArray boundary() const;
1075 
1079  void setBoundary(const QByteArray &s);
1080 
1084  QString name() const;
1085 
1089  void setName(const QString &s, const QByteArray &cs);
1090 
1094  QByteArray id() const;
1095 
1099  void setId(const QByteArray &s);
1100 
1105  int partialNumber() const;
1106 
1111  int partialCount() const;
1112 
1118  void setPartialParams(int total, int number);
1119 
1120  // TODO: document
1121  contentCategory category() const;
1122 
1123  void setCategory(contentCategory c);
1124 
1125 protected:
1126  bool parse(const char *&scursor, const char *const send, bool isCRLF = false) override;
1127 
1128 private:
1129  Q_DECLARE_PRIVATE(ContentType)
1130 };
1131 
1132 class ContentDispositionPrivate;
1133 
1139 class KMIME_EXPORT ContentDisposition : public Generics::Parametrized
1140 {
1141  //@cond PRIVATE
1142  kmime_mk_trivial_ctor_with_name(ContentDisposition)
1143  //@endcond
1144 public:
1145  QByteArray as7BitString(bool withHeaderType = true) const override;
1146  bool isEmpty() const override;
1147  void clear() override;
1148 
1152  contentDisposition disposition() const;
1153 
1158  void setDisposition(contentDisposition disp);
1159 
1165  QString filename() const;
1166 
1173  void setFilename(const QString &filename);
1174 
1175 protected:
1176  bool parse(const char *&scursor, const char *const send, bool isCRLF = false) override;
1177 
1178 private:
1179  Q_DECLARE_PRIVATE(ContentDisposition)
1180 };
1181 
1182 //
1183 //
1184 // COMPATIBLE GUNSTRUCTURED-BASED FIELDS:
1185 //
1186 //
1187 
1188 class GenericPrivate;
1189 
1195 class KMIME_EXPORT Generic : public Generics::Unstructured
1196 {
1197 public:
1198  Generic();
1199  Generic(const char *t, int len = -1);
1200  ~Generic() override;
1201 
1202  void clear() override;
1203 
1204  bool isEmpty() const override;
1205 
1206  const char *type() const override;
1207 
1208  void setType(const char *type, int len = -1);
1209 
1210 private:
1211  Q_DECLARE_PRIVATE(Generic)
1212 };
1213 
1219 class KMIME_EXPORT Subject : public Generics::Unstructured
1220 {
1221  //@cond PRIVATE
1222  kmime_mk_trivial_ctor_with_name(Subject)
1223  //@endcond
1224 };
1225 
1229 class KMIME_EXPORT Organization : public Generics::Unstructured
1230 {
1231  kmime_mk_trivial_ctor_with_name(Organization)
1232 };
1233 
1237 class KMIME_EXPORT ContentDescription : public Generics::Unstructured
1238 {
1239  kmime_mk_trivial_ctor_with_name(ContentDescription)
1240 };
1241 
1246 class KMIME_EXPORT ContentLocation : public Generics::Unstructured
1247 {
1248  kmime_mk_trivial_ctor_with_name(ContentLocation)
1249 };
1250 
1251 class ControlPrivate;
1252 
1258 class KMIME_EXPORT Control : public Generics::Structured
1259 {
1260  //@cond PRIVATE
1261  kmime_mk_trivial_ctor_with_name(Control)
1262  //@endcond
1263 public:
1264  QByteArray as7BitString(bool withHeaderType = true) const override;
1265  void clear() override;
1266  bool isEmpty() const override;
1267 
1271  QByteArray controlType() const;
1272 
1276  QByteArray parameter() const;
1277 
1282  bool isCancel() const;
1283 
1288  void setCancel(const QByteArray &msgid);
1289 
1290 protected:
1291  bool parse(const char *&scursor, const char *const send, bool isCRLF = false) override;
1292 
1293 private:
1294  Q_DECLARE_PRIVATE(Control)
1295 };
1296 
1297 class DatePrivate;
1298 
1304 class KMIME_EXPORT Date : public Generics::Structured
1305 {
1306  //@cond PRIVATE
1307  kmime_mk_trivial_ctor_with_name(Date)
1308  //@endcond
1309 public:
1310  QByteArray as7BitString(bool withHeaderType = true) const override;
1311  void clear() override;
1312  bool isEmpty() const override;
1313 
1317  QDateTime dateTime() const;
1318 
1322  void setDateTime(const QDateTime &dt);
1323 
1327  int ageInDays() const;
1328 
1329 protected:
1330  bool parse(const char *&scursor, const char *const send, bool isCRLF = false) override;
1331 
1332 private:
1333  Q_DECLARE_PRIVATE(Date)
1334 };
1335 
1336 class NewsgroupsPrivate;
1337 
1343 class KMIME_EXPORT Newsgroups : public Generics::Structured
1344 {
1345  //@cond PRIVATE
1346  kmime_mk_trivial_ctor_with_name(Newsgroups)
1347  //@endcond
1348 public:
1349  QByteArray as7BitString(bool withHeaderType = true) const override;
1350  void fromUnicodeString(const QString &s, const QByteArray &b) override;
1351  QString asUnicodeString() const override;
1352  void clear() override;
1353  bool isEmpty() const override;
1354 
1358  QVector<QByteArray> groups() const;
1359 
1363  void setGroups(const QVector<QByteArray> &groups);
1364 
1369  bool isCrossposted() const;
1370 
1371 protected:
1372  bool parse(const char *&scursor, const char *const send, bool isCRLF = false) override;
1373 
1374 private:
1375  Q_DECLARE_PRIVATE(Newsgroups)
1376 };
1377 
1383 class KMIME_EXPORT FollowUpTo : public Newsgroups
1384 {
1385  //@cond PRIVATE
1386  kmime_mk_trivial_ctor_with_name(FollowUpTo)
1387  //@endcond
1388 };
1389 
1390 class LinesPrivate;
1391 
1397 class KMIME_EXPORT Lines : public Generics::Structured
1398 {
1399  //@cond PRIVATE
1400  kmime_mk_trivial_ctor_with_name(Lines)
1401  //@endcond
1402 public:
1403  QByteArray as7BitString(bool withHeaderType = true) const override;
1404  QString asUnicodeString() const override;
1405  void clear() override;
1406  bool isEmpty() const override;
1407 
1411  int numberOfLines() const;
1412 
1416  void setNumberOfLines(int lines);
1417 
1418 protected:
1419  bool parse(const char *&scursor, const char *const send, bool isCRLF = false) override;
1420 
1421 private:
1422  Q_DECLARE_PRIVATE(Lines)
1423 };
1424 
1428 class KMIME_EXPORT UserAgent : public Generics::Unstructured
1429 {
1430  kmime_mk_trivial_ctor_with_name(UserAgent)
1431 };
1432 
1435 KMIME_EXPORT Base *createHeader(const QByteArray &type);
1436 
1437 } //namespace Headers
1438 
1439 } //namespace KMime
1440 
1441 // undefine code generation macros again
1442 #undef kmime_mk_trivial_ctor
1443 #undef kmime_mk_dptr_ctor
1444 #undef kmime_mk_trivial_ctor_with_name
1445 
1446 Q_DECLARE_METATYPE(KMime::Headers::To*)
1447 Q_DECLARE_METATYPE(KMime::Headers::Cc*)
1448 Q_DECLARE_METATYPE(KMime::Headers::Bcc*)
1449 
1450 #endif // __KMIME_HEADERS_H__
Base class for headers that deal with exactly one mailbox (e.g.
Represents a "Message-ID" header.
Represents a "Content-Disposition" header.
Represents a "Date" header.
Represents an (email address, display name) pair according RFC 2822, section 3.4. ...
Definition: kmime_types.h:38
Represents a "References" header.
Base class for headers that deal with (possibly multiple) addresses, but don&#39;t allow groups...
Represents a "Mail-Copies-To" header.
Represents a "Cc" header.
Represents a "To" header.
virtual void from7BitString(const char *s, size_t len)
Parses the given string.
parallel (invalid, do not use)
Definition: kmime_headers.h:76
Represents a "Followup-To" header.
Represents a "Control" header.
Base class for all address related headers.
Represents a "Content-ID" header.
Base class for headers that deal with (possibly multiple) addresses, allowing groups.
contentDisposition
Various possible values for the "Content-Disposition" header.
Definition: kmime_headers.h:72
Represents an arbitrary header, that can contain any header-field.
Represents a "MIME-Version" header.
Represents the Return-Path header field.
Default, invalid value.
Definition: kmime_headers.h:73
Base class for headers containing a parameter list such as "Content-Type".
Base class for headers containing a dot atom.
Represent a "From" header.
Baseclass of all header-classes.
Base class for headers containing a list of phrases.
Represents a "ReplyTo" header.
quoted-printable
Definition: kmime_headers.h:63
Represents a "Content-Location" header.
Represents a "Lines" header.
Represents a "Keywords" header.
Represents a "Content-Description" header.
Represents a "Newsgroups" header.
Represents a "In-Reply-To" header.
Represents a "Supersedes" header.
Represents a "Subject" header.
Base class for headers which deal with a single msg-id.
Represents a "Organization" header.
Abstract base class for unstructured header fields (e.g.
Base class for headers which deal with a list of msg-id&#39;s.
Represents a "User-Agent" header.
Represents a "Content-Transfer-Encoding" header.
Base class for structured header fields.
QVector< KMime::Headers::Base * > List
A vector of headers.
Base class for headers which deal with a single atom.
Represents a "Content-Type" header.
Base * createHeader(const QByteArray &type)
Creates a header based on.
Represents a "Bcc" header.
contentEncoding
Various possible values for the "Content-Transfer-Encoding" header.
Definition: kmime_headers.h:60
Represents a "Sender" header.
This file is part of the KDE documentation.
Documentation copyright © 1996-2021 The KDE developers.
Generated on Tue Jan 19 2021 23:16:18 by doxygen 1.8.11 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.