Renamed 'extra parameters' of MCAttachment to 'content type parameters'

3 files changed, 86 insertions, 80 deletions

diff --git a/src/core/rfc822/MCAttachment.cc b/src/core/rfc822/MCAttachment.cc
index 9369ebe1..925a303a 100644
--- a/src/core/rfc822/MCAttachment.cc
+++ b/src/core/rfc822/MCAttachment.cc
@@ -211,8 +211,8 @@ Attachment * Attachment::attachmentWithText(String * text)
 void Attachment::init()
 {
     mData = NULL;
-    mExtraParameters = NULL;
-    mlcExtraParameters = NULL;
+    mContentTypeParameters = NULL;
+    mlcContentTypeParameters = NULL;
     setMimeType(MCSTR("application/octet-stream"));
 }
 
@@ -225,14 +225,14 @@ Attachment::Attachment(Attachment * other) : AbstractPart(other)
 {
     init();
     MC_SAFE_REPLACE_RETAIN(Data, mData, other->mData);
-    setExtraParameters(other->mExtraParameters);
+    setContentTypeParameters(other->mContentTypeParameters);
 }
 
 Attachment::~Attachment()
 {
     MC_SAFE_RELEASE(mData);
-    MC_SAFE_RELEASE(mExtraParameters);
-    MC_SAFE_RELEASE(mlcExtraParameters);
+    MC_SAFE_RELEASE(mContentTypeParameters);
+    MC_SAFE_RELEASE(mlcContentTypeParameters);
 }
 
 String * Attachment::description()
@@ -261,9 +261,9 @@ String * Attachment::description()
     else {
         result->appendUTF8Format("no data\n");
     }
-    if (mExtraParameters != NULL) {
-        mc_foreachhashmapKeyAndValue(String, header, String, value, mExtraParameters) {
-            result->appendUTF8Format("%s: %s\n", header->UTF8Characters(), value->UTF8Characters());
+    if (mContentTypeParameters != NULL) {
+        mc_foreachhashmapKeyAndValue(String, key, String, value, mContentTypeParameters) {
+            result->appendUTF8Format("%s: %s\n", key->UTF8Characters(), value->UTF8Characters());
         }
     }
     result->appendUTF8Format(">");
@@ -296,54 +296,54 @@ String * Attachment::decodedString()
     }
 }
 
-void Attachment::setExtraParameters(HashMap * parameters)
+void Attachment::setContentTypeParameters(HashMap * parameters)
 {
-    MC_SAFE_REPLACE_COPY(HashMap, mExtraParameters, parameters);
-    MC_SAFE_RELEASE(mlcExtraParameters);
-    if (mExtraParameters != NULL) {
-        mlcExtraParameters = new HashMap();
-        mc_foreachhashmapKeyAndValue(String, key, String, value, mExtraParameters) {
-            mlcExtraParameters->setObjectForKey(key->lowercaseString(), value);
+    MC_SAFE_REPLACE_COPY(HashMap, mContentTypeParameters, parameters);
+    MC_SAFE_RELEASE(mlcContentTypeParameters);
+    if (mContentTypeParameters != NULL) {
+        mlcContentTypeParameters = new HashMap();
+        mc_foreachhashmapKeyAndValue(String, key, String, value, mContentTypeParameters) {
+            mlcContentTypeParameters->setObjectForKey(key->lowercaseString(), value);
         }
     }
 }
 
-Array * Attachment::allExtraParametersNames()
+Array * Attachment::allContentTypeParametersNames()
 {
-    if (mExtraParameters == NULL)
+    if (mContentTypeParameters == NULL)
         return Array::array();
-    return mExtraParameters->allKeys();
+    return mContentTypeParameters->allKeys();
 }
 
-void Attachment::setExtraParameter(String * name, String * object)
+void Attachment::setContentTypeParameter(String * name, String * object)
 {
-    if (mExtraParameters == NULL) {
-        mExtraParameters = new HashMap();
+    if (mContentTypeParameters == NULL) {
+        mContentTypeParameters = new HashMap();
     }
-    if (mlcExtraParameters == NULL) {
-        mlcExtraParameters = new HashMap();
+    if (mlcContentTypeParameters == NULL) {
+        mlcContentTypeParameters = new HashMap();
     }
     if (object == NULL) {
-        removeExtraParameter(name);
+        removeContentTypeParameter(name);
         return;
     }
-    mExtraParameters->setObjectForKey(name, object);
-    mlcExtraParameters->setObjectForKey(name->lowercaseString(), object);
+    mContentTypeParameters->setObjectForKey(name, object);
+    mlcContentTypeParameters->setObjectForKey(name->lowercaseString(), object);
 }
 
-void Attachment::removeExtraParameter(String * name)
+void Attachment::removeContentTypeParameter(String * name)
 {
-    if (mExtraParameters == NULL)
+    if (mContentTypeParameters == NULL)
         return;
-    mExtraParameters->removeObjectForKey(name);
-    mlcExtraParameters->removeObjectForKey(name);
+    mContentTypeParameters->removeObjectForKey(name);
+    mlcContentTypeParameters->removeObjectForKey(name);
 }
 
-String * Attachment::extraParameterValueForName(String * name)
+String * Attachment::contentTypeParameterValueForName(String * name)
 {
-    if (mlcExtraParameters == NULL)
+    if (mlcContentTypeParameters == NULL)
         return NULL;
-    return (String *) mlcExtraParameters->objectForKey(name->lowercaseString());
+    return (String *) mlcContentTypeParameters->objectForKey(name->lowercaseString());
 }
 
 AbstractPart * Attachment::attachmentsWithMIME(struct mailmime * mime)
@@ -610,7 +610,7 @@ Attachment * Attachment::attachmentWithSingleMIME(struct mailmime * mime)
         while (iter != NULL) {
             param = (struct mailmime_parameter *) clist_content(iter);
             if (param != NULL) {
-                result->setExtraParameter(String::stringWithUTF8Characters(param->pa_name), String::stringWithUTF8Characters(param->pa_value));
+                result->setContentTypeParameter(String::stringWithUTF8Characters(param->pa_name), String::stringWithUTF8Characters(param->pa_value));
             }
             iter = clist_next(iter);
         }
diff --git a/src/core/rfc822/MCAttachment.h b/src/core/rfc822/MCAttachment.h
index 33dbf942..069688f2 100644
--- a/src/core/rfc822/MCAttachment.h
+++ b/src/core/rfc822/MCAttachment.h
@@ -29,10 +29,10 @@ namespace mailcore {
         virtual Data * data();
         virtual String * decodedString();
         
-        virtual void setExtraParameter(String * name, String * value);
-        virtual void removeExtraParameter(String * name);
-        virtual String * extraParameterValueForName(String *name);
-        virtual Array * allExtraParametersNames();
+        virtual void setContentTypeParameter(String * name, String * value);
+        virtual void removeContentTypeParameter(String * name);
+        virtual String * contentTypeParameterValueForName(String *name);
+        virtual Array * allContentTypeParametersNames();
         
     public: // subclass behavior
         Attachment(Attachment * other);
@@ -44,8 +44,8 @@ namespace mailcore {
         
     private:
         Data * mData;
-        HashMap * mExtraParameters;
-        HashMap * mlcExtraParameters;
+        HashMap * mContentTypeParameters;
+        HashMap * mlcContentTypeParameters;
         void init();
         static void fillMultipartSubAttachments(AbstractMultipart * multipart, struct mailmime * mime);
         static AbstractPart * attachmentsWithMIMEWithMain(struct mailmime * mime, bool isMain);
@@ -53,7 +53,7 @@ namespace mailcore {
         static MessagePart * attachmentWithMessageMIME(struct mailmime * mime);
         static Encoding encodingForMIMEEncoding(struct mailmime_mechanism * mechanism, int defaultMimeEncoding);
         static HashMap * readMimeTypesFile(String * filename);
-        void setExtraParameters(HashMap * parameters);
+        void setContentTypeParameters(HashMap * parameters);
     };
     
 }
diff --git a/src/core/rfc822/MCMessageBuilder.cc b/src/core/rfc822/MCMessageBuilder.cc
index 390d268b..3e63ce4a 100644
--- a/src/core/rfc822/MCMessageBuilder.cc
+++ b/src/core/rfc822/MCMessageBuilder.cc
@@ -134,7 +134,7 @@ err:
 
 static struct mailmime * get_text_part(const char * mime_type, const char * charset, const char * content_id,
                                 const char * description,
-                                const char * text, size_t length, int encoding_type, Array * extraParameters)
+                                const char * text, size_t length, int encoding_type, clist * contentTypeParameters)
 {
     struct mailmime_fields * mime_fields;
     struct mailmime * mime;
@@ -165,9 +165,8 @@ static struct mailmime * get_text_part(const char * mime_type, const char * char
         param = mailmime_param_new_with_data((char *) "charset", (char *) charset);
     }
     clist_append(content->ct_parameters, param);
-    
-    mc_foreacharray(Value, extraParam, extraParameters) {
-        clist_append(content->ct_parameters, extraParam->pointerValue());
+    if (contentTypeParameters != NULL) {
+        clist_concat(content->ct_parameters, contentTypeParameters);
     }
     
     mime = part_new_empty(content, mime_fields, NULL, 1);
@@ -178,7 +177,7 @@ static struct mailmime * get_text_part(const char * mime_type, const char * char
 
 static struct mailmime * get_plain_text_part(const char * mime_type, const char * charset, const char * content_id,
                                       const char * description,
-                                      const char * text, size_t length, Array * extraParameters)
+                                      const char * text, size_t length, clist * contentTypeParameters)
 {
     bool needsQuotedPrintable;
     int mechanism;
@@ -194,20 +193,20 @@ static struct mailmime * get_plain_text_part(const char * mime_type, const char
     if (needsQuotedPrintable) {
         mechanism = MAILMIME_MECHANISM_QUOTED_PRINTABLE;
     }
-    return get_text_part(mime_type, charset, content_id, description, text, length, mechanism, extraParameters);
+    return get_text_part(mime_type, charset, content_id, description, text, length, mechanism, contentTypeParameters);
 }
 
 static struct mailmime * get_other_text_part(const char * mime_type, const char * charset, const char * content_id,
                                       const char * description,
-                                      const char * text, size_t length, Array * extraParameters)
+                                      const char * text, size_t length, clist * contentTypeParameters)
 {
-    return get_text_part(mime_type, charset, content_id, description, text, length, MAILMIME_MECHANISM_QUOTED_PRINTABLE, extraParameters);
+    return get_text_part(mime_type, charset, content_id, description, text, length, MAILMIME_MECHANISM_QUOTED_PRINTABLE, contentTypeParameters);
 }
 
 static struct mailmime * get_file_part(const char * filename, const char * mime_type, int is_inline,
                                        const char * content_id,
                                        const char * content_description,
-                                       const char * text, size_t length, Array * extraParameters)
+                                       const char * text, size_t length, clist * contentTypeParameters)
 {
     char * disposition_name;
     int encoding_type;
@@ -244,8 +243,8 @@ static struct mailmime * get_file_part(const char * filename, const char * mime_
     mime_fields = mailmime_fields_new_with_data(encoding,
                                                 dup_content_id, dup_content_description, disposition, NULL);
     
-    mc_foreacharray(Value, extraParam, extraParameters) {
-        clist_append(content->ct_parameters, extraParam->pointerValue());
+    if (contentTypeParameters != NULL) {
+        clist_concat(content->ct_parameters, contentTypeParameters);
     }
     
     mime = part_new_empty(content, mime_fields, NULL, 1);
@@ -256,20 +255,21 @@ static struct mailmime * get_file_part(const char * filename, const char * mime_
 
 #define MIME_ENCODED_STR(str) (str != NULL ? str->encodedMIMEHeaderValue()->bytes() : NULL)
 
-static Array * extraParameters_from_attachment(Attachment * att)
+static clist * content_type_parameters_from_attachment(Attachment * att)
 {
-    Array * extraParamters = new Array();
+    clist * contentTypeParameters = NULL;
     struct mailmime_parameter * param;
-    Value * paramValue;
     
-    mc_foreacharray(String, name, att->allExtraParametersNames()) {
-        String * value = att->extraParameterValueForName(name);
+    mc_foreacharray(String, name, att->allContentTypeParametersNames()) {
+        if (contentTypeParameters == NULL) {
+            contentTypeParameters = clist_new();
+        }
+        String * value = att->contentTypeParameterValueForName(name);
         param = mailmime_param_new_with_data((char *)name->UTF8Characters(), (char *)value->UTF8Characters());
-        paramValue = Value::valueWithPointerValue(param);
-        extraParamters->addObject(paramValue);
+        clist_append(contentTypeParameters, param);
     }
 
-    return (Array *)extraParamters->autorelease();
+    return contentTypeParameters;
 }
 
 static struct mailmime * mime_from_attachment(Attachment * att)
@@ -288,27 +288,33 @@ static struct mailmime * mime_from_attachment(Attachment * att)
         if (r != MAILIMF_NO_ERROR)
             return NULL;
     }
-    else if (att->isInlineAttachment() && att->mimeType()->lowercaseString()->isEqual(MCSTR("text/plain"))) {
-        mime = get_plain_text_part(MCUTF8(att->mimeType()), MCUTF8(att->charset()),
-            MCUTF8(att->contentID()),
-            MIME_ENCODED_STR(att->contentDescription()),
-            data->bytes(), data->length(),
-            extraParameters_from_attachment(att));
-    }
-    else if (att->isInlineAttachment() && att->mimeType()->lowercaseString()->hasPrefix(MCSTR("text/"))) {
-        mime = get_other_text_part(MCUTF8(att->mimeType()), MCUTF8(att->charset()),
-            MCUTF8(att->contentID()),
-            MIME_ENCODED_STR(att->contentDescription()),
-            data->bytes(), data->length(),
-            extraParameters_from_attachment(att));
-    }
     else {
-        mime = get_file_part(MIME_ENCODED_STR(att->filename()),
-            MCUTF8(att->mimeType()), att->isInlineAttachment(),
-            MCUTF8(att->contentID()),
-            MIME_ENCODED_STR(att->contentDescription()),
-            data->bytes(), data->length(),
-            extraParameters_from_attachment(att));
+        clist * contentTypeParameters = content_type_parameters_from_attachment(att);
+        if (att->isInlineAttachment() && att->mimeType()->lowercaseString()->isEqual(MCSTR("text/plain"))) {
+            mime = get_plain_text_part(MCUTF8(att->mimeType()), MCUTF8(att->charset()),
+                                       MCUTF8(att->contentID()),
+                                       MIME_ENCODED_STR(att->contentDescription()),
+                                       data->bytes(), data->length(),
+                                       contentTypeParameters);
+        }
+        else if (att->isInlineAttachment() && att->mimeType()->lowercaseString()->hasPrefix(MCSTR("text/"))) {
+            mime = get_other_text_part(MCUTF8(att->mimeType()), MCUTF8(att->charset()),
+                                       MCUTF8(att->contentID()),
+                                       MIME_ENCODED_STR(att->contentDescription()),
+                                       data->bytes(), data->length(),
+                                       contentTypeParameters);
+        }
+        else {
+            mime = get_file_part(MIME_ENCODED_STR(att->filename()),
+                                 MCUTF8(att->mimeType()), att->isInlineAttachment(),
+                                 MCUTF8(att->contentID()),
+                                 MIME_ENCODED_STR(att->contentDescription()),
+                                 data->bytes(), data->length(),
+                                 contentTypeParameters);
+        }
+        if (contentTypeParameters != NULL) {
+            clist_free(contentTypeParameters);
+        }
     }
     return mime;
 }