From cf5b3e797421e7dbf2c0d7b1efff91fc07277652 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Sandro=20Knau=C3=9F?= <sknauss@kde.org>
Date: Wed, 20 Jul 2016 17:35:29 +0200
Subject: new thoughts for interface

---
 framework/domain/mimetreeparser/interface.cpp | 165 +++++++++++++++-----------
 1 file changed, 97 insertions(+), 68 deletions(-)

(limited to 'framework/domain/mimetreeparser/interface.cpp')

diff --git a/framework/domain/mimetreeparser/interface.cpp b/framework/domain/mimetreeparser/interface.cpp
index e34ffda7..aa7e3911 100644
--- a/framework/domain/mimetreeparser/interface.cpp
+++ b/framework/domain/mimetreeparser/interface.cpp
@@ -89,6 +89,16 @@ QByteArray Part::type() const
     return "Part";
 }
 
+QVector<QByteArray> Part::availableContents() const
+{
+    return QVector<QByteArray>();
+}
+
+QVector<Content::Ptr> Part::content() const
+{
+    return QVector<Content::Ptr>();
+}
+
 QVector<Encryption> Part::encryptions() const
 {
     auto parent = d->parent();
@@ -118,7 +128,7 @@ public:
     Content *q;
 };
 
-Content::Content(const QByteArray& content, ContentPart *parent)
+Content::Content(const QByteArray& content, Part *parent)
     : d(std::unique_ptr<ContentPrivate>(new ContentPrivate))
 {
     d->q = this;
@@ -157,113 +167,141 @@ QByteArray Content::charset() const
     return d->mCodec;
 }
 
-class ContentPartPrivate
+class AlternativePartPrivate
 {
 public:
-    void fillFrom(MimeTreeParser::TextMessagePart::Ptr part);
-    void fillFrom(MimeTreeParser::HtmlMessagePart::Ptr part);
     void fillFrom(MimeTreeParser::AlternativeMessagePart::Ptr part);
 
-    QVector<Content::Ptr> content(ContentPart::Type ct) const;
+    QVector<Content::Ptr> content(const QByteArray &ct) const;
 
-    ContentPart *q;
+    AlternativePart *q;
 
-    ContentPart::Types types() const;
+    QVector<QByteArray> types() const;
 
 private:
-    QMap<ContentPart::Type, QVector<Content::Ptr>> mContent;
-    ContentPart::Types mTypes;
+    QMap<QByteArray, QVector<Content::Ptr>> mContent;
+    QVector<QByteArray> mTypes;
 };
 
-void ContentPartPrivate::fillFrom(MimeTreeParser::TextMessagePart::Ptr part)
+void AlternativePartPrivate::fillFrom(MimeTreeParser::AlternativeMessagePart::Ptr part)
 {
-    qDebug() << "jepp";
-    mTypes = ContentPart::PlainText;
-    foreach (const auto &mp, part->subParts()) {
-        auto content = std::make_shared<Content>(mp->text().toLocal8Bit(), q);
-        mContent[ContentPart::PlainText].append(content);
-    }
+    mTypes = QVector<QByteArray>() << "html" << "plaintext";
+
+    auto content = std::make_shared<HtmlContent>(part->htmlContent().toLocal8Bit(), q);
+    mContent["html"].append(content);
+    content = std::make_shared<PlainTextContent>(part->plaintextContent().toLocal8Bit(), q);
+    mContent["plaintext"].append(content);
 }
 
-void ContentPartPrivate::fillFrom(MimeTreeParser::HtmlMessagePart::Ptr part)
+QVector<QByteArray> AlternativePartPrivate::types() const
 {
-    mTypes = ContentPart::Html;
-    auto content = std::make_shared<Content>(part->text().toLocal8Bit(), q);
-    mContent[ContentPart::Html].append(content);
+    return mTypes;
 }
 
-void ContentPartPrivate::fillFrom(MimeTreeParser::AlternativeMessagePart::Ptr part)
+QVector<Content::Ptr> AlternativePartPrivate::content(const QByteArray& ct) const
 {
-    mTypes = ContentPart::Html | ContentPart::PlainText;
+    return mContent[ct];
+}
 
-    auto content = std::make_shared<Content>(part->htmlContent().toLocal8Bit(), q);
-    mContent[ContentPart::Html].append(content);
-    content = std::make_shared<Content>(part->plaintextContent().toLocal8Bit(), q);
-    mContent[ContentPart::PlainText].append(content);
+AlternativePart::AlternativePart()
+    : d(std::unique_ptr<AlternativePartPrivate>(new AlternativePartPrivate))
+{
+    d->q = this;
 }
 
-ContentPart::Types ContentPartPrivate::types() const
+AlternativePart::~AlternativePart()
 {
-    return mTypes;
+
 }
 
-QVector<Content::Ptr> ContentPartPrivate::content(ContentPart::Type ct) const
+QByteArray AlternativePart::type() const
 {
-    return mContent[ct];
+    return "AlternativePart";
 }
 
-QVector<Content::Ptr> ContentPart::content(ContentPart::Type ct) const
+QVector<QByteArray> AlternativePart::availableContents() const
 {
-    return d->content(ct);
+    return d->types();
 }
 
+QVector<Content::Ptr> AlternativePart::content() const
+{
+    return d->content(availableContents().first());
+}
 
-ContentPart::ContentPart()
-    : d(std::unique_ptr<ContentPartPrivate>(new ContentPartPrivate))
+QVector<Content::Ptr> AlternativePart::content(const QByteArray& ct) const
 {
-    d->q = this;
+    return d->content(ct);
 }
 
-ContentPart::~ContentPart()
+class SinglePartPrivate
 {
+public:
+    void fillFrom(MimeTreeParser::TextMessagePart::Ptr part);
+    void fillFrom(MimeTreeParser::HtmlMessagePart::Ptr part);
+    void fillFrom(MimeTreeParser::AttachmentMessagePart::Ptr part);
+    SinglePart *q;
+
+    QVector<Content::Ptr> mContent;
+    QByteArray mType;
+};
 
+void SinglePartPrivate::fillFrom(MimeTreeParser::TextMessagePart::Ptr part)
+{
+    mType = "plaintext";
+    mContent.clear();
+    foreach (const auto &mp, part->subParts()) {
+        mContent.append(std::make_shared<PlainTextContent>(mp->text().toLocal8Bit(), q));
+    }
 }
 
-QByteArray ContentPart::type() const
+void SinglePartPrivate::fillFrom(MimeTreeParser::HtmlMessagePart::Ptr part)
 {
-    return "ContentPart";
+    mType = "html";
+    mContent.clear();
+    mContent.append(std::make_shared<HtmlContent>(part->text().toLocal8Bit(), q));
 }
 
-ContentPart::Types ContentPart::availableContents() const
+void SinglePartPrivate::fillFrom(MimeTreeParser::AttachmentMessagePart::Ptr part)
 {
-    return d->types();
+
 }
 
-class MimePartPrivate
+SinglePart::SinglePart()
+    : d(std::unique_ptr<SinglePartPrivate>(new SinglePartPrivate))
 {
-public:
-    void fillFrom(MimeTreeParser::MessagePart::Ptr part);
-};
+    d->q = this;
+}
 
-QByteArray MimePart::type() const
+SinglePart::~SinglePart()
 {
-    return "MimePart";
+
 }
 
-class AttachmentPartPrivate
+QVector<QByteArray> SinglePart::availableContents() const
 {
-public:
-    void fillFrom(MimeTreeParser::AttachmentMessagePart::Ptr part);
-};
+    return QVector<QByteArray>() << d->mType;
+}
 
-void AttachmentPartPrivate::fillFrom(MimeTreeParser::AttachmentMessagePart::Ptr part)
+QVector< Content::Ptr > SinglePart::content() const
 {
+    return d->mContent;
+}
 
+QByteArray SinglePart::type() const
+{
+    return "SinglePart";
 }
 
-QByteArray AttachmentPart::type() const
+class MimePartPrivate
+{
+public:
+    void fillFrom(MimeTreeParser::MessagePart::Ptr part);
+};
+
+QByteArray MimePart::type() const
 {
-    return "AttachmentPart";
+    return "MimePart";
 }
 
 ParserPrivate::ParserPrivate(Parser* parser)
@@ -309,15 +347,15 @@ void ParserPrivate::createTree(const MimeTreeParser::MessagePart::Ptr &start, co
             part->d->fillFrom(attachment);
             mTree->d->appendSubPart(part);
          } else if (text) {
-            auto part = std::make_shared<ContentPart>();
+            auto part = std::make_shared<SinglePart>();
             part->d->fillFrom(text);
             mTree->d->appendSubPart(part);
         } else if (alternative) {
-            auto part = std::make_shared<ContentPart>();
+            auto part = std::make_shared<AlternativePart>();
             part->d->fillFrom(alternative);
             mTree->d->appendSubPart(part);
         } else if (html) {
-            auto part = std::make_shared<ContentPart>();
+            auto part = std::make_shared<SinglePart>();
             part->d->fillFrom(html);
             mTree->d->appendSubPart(part);
         } else {
@@ -336,18 +374,9 @@ Parser::~Parser()
 {
 }
 
-ContentPart::Ptr Parser::collectContentPart(const Part::Ptr &start) const
+QVector<Part::Ptr> Parser::collectContentParts() const
 {
-    const auto ret = collect<ContentPart>(start, [](const Part::Ptr &p){return p->type() == "ContentPart";}, [](const ContentPart::Ptr &p){return true;});
-    if (ret.size() > 0) {
-        return ret[0];
-    };
-    return ContentPart::Ptr();
-}
-
-ContentPart::Ptr Parser::collectContentPart() const
-{
-    return collectContentPart(d->mTree);
+    return collect<Part>(d->mTree, [](const Part::Ptr &p){return p->availableContents().indexOf("html") > -1 || p->availableContents().indexOf("text") > -1;}, [](const Part::Ptr &p){return true;});
 }
 
 template <typename T>
@@ -364,4 +393,4 @@ QVector<typename T::Ptr> Parser::collect(const Part::Ptr &start, std::function<b
         }
     }
     return ret;
-}
+}
\ No newline at end of file
-- 
cgit v1.2.3