## javax.mail.internet
Class MimeMultipart

    java.lang.Object
      |
      +--javax.mail.Multipart
            |
            +--javax.mail.internet.MimeMultipart

public class MimeMultipart
extends Multipart

The MimeMultipart class is an implementation of the abstract Multipart class that uses MIME conventions for the multipart data.

A MimeMultipart is obtained from a MimePart whose primary type is "multipart" (by invoking the part's `getContent()` method) or it can be created by a client as part of creating a new MimeMessage.

The default multipart subtype is "mixed". The other multipart subtypes, such as "alternative", "related", and so on, can be implemented as subclasses of MimeMultipart with additional methods to implement the additional semantics of that type of multipart content. The intent is that service providers, mail JavaBean writers and mail clients will write many such subclasses and their Command Beans, and will install them into the JavaBeans Activation Framework, so that any JavaMail implementation and its clients can transparently find and use these classes. Thus, a MIME multipart handler is treated just like any other type handler, thereby decoupling the process of providing multipart handlers from the JavaMail API. Lacking these additional MimeMultipart subclasses, all subtypes of MIME multipart data appear as MimeMultipart objects.

An application can directly construct a MIME multipart object of any subtype by using the `MimeMultipart(String subtype)` constructor. For example, to create a "multipart/alternative" object, use `new MimeMultipart("alternative")`.

In the current implementation, the `mail.mime.multipart.ignoremissingendboundary` System property may be set to `false` to cause a `MessagingException` to be thrown if the multipart data does not end with the required end boundary line. If this property is set to `true` or not set, missing end boundaries are not considered an error and the final body part ends at the end of the data.

Also in the current implementation, the `mail.mime.multipart.ignoremissingboundaryparameter` System property may be set to `false` to cause a `MessagingException` to be thrown if the Content-Type of the MimeMultipart does not include a `boundary` parameter. If this property is set to `true` or not set, the multipart parsing code will look for a line that looks like a bounary line and use that as the boundary separating the parts.

Field Summary
`protected javax.activation.DataSource` `ds` The DataSource supplying our InputStream.
`protected boolean` `parsed` Have we parsed the data from our InputStream yet? Defaults to true; set to false when our constructor is given a DataSource with an InputStream that we need to parse.

Fields inherited from class javax.mail.Multipart
`contentType, parent, parts`

Constructor Summary
`MimeMultipart()` Default constructor.
`MimeMultipart(javax.activation.DataSource ds)` Constructs a MimeMultipart object and its bodyparts from the given DataSource.
`MimeMultipart(java.lang.String subtype)` Construct a MimeMultipart object of the given subtype.

Method Summary
`protected InternetHeaders` `createInternetHeaders(java.io.InputStream is)` Create and return an InternetHeaders object that loads the headers from the given InputStream.
`protected MimeBodyPart` `createMimeBodyPart(java.io.InputStream is)` Create and return a MimeBodyPart object to represent a body part parsed from the InputStream.
`protected MimeBodyPart` `createMimeBodyPart(InternetHeaders headers, byte[] content)` Create and return a MimeBodyPart object to represent a body part parsed from the InputStream.
`BodyPart` `getBodyPart(int index)` Get the specified BodyPart.
`BodyPart` `getBodyPart(java.lang.String CID)` Get the MimeBodyPart referred to by the given ContentID (CID).
`int` `getCount()` Return the number of enclosed BodyPart objects.
`protected void` `parse()` Parse the InputStream from our DataSource, constructing the appropriate MimeBodyParts.
`void` `setSubType(java.lang.String subtype)` Set the subtype.
`protected void` `updateHeaders()` Update headers.
`void` `writeTo(java.io.OutputStream os)` Iterates through all the parts and outputs each Mime part separated by a boundary.

Methods inherited from class javax.mail.Multipart
`addBodyPart, addBodyPart, getContentType, getParent, removeBodyPart, removeBodyPart, setMultipartDataSource, setParent`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### ds

    protected javax.activation.DataSource ds

  The DataSource supplying our InputStream.

### parsed

    protected boolean parsed

  Have we parsed the data from our InputStream yet? Defaults to true; set to false when our constructor is given a DataSource with an InputStream that we need to parse.

Constructor Detail

### MimeMultipart

    public MimeMultipart()

  Default constructor. An empty MimeMultipart object is created. Its content type is set to "multipart/mixed". A unique boundary string is generated and this string is setup as the "boundary" parameter for the `contentType` field.

  MimeBodyParts may be added later.

### MimeMultipart

    public MimeMultipart(java.lang.String subtype)

  Construct a MimeMultipart object of the given subtype. A unique boundary string is generated and this string is setup as the "boundary" parameter for the `contentType` field.

  MimeBodyParts may be added later.

### MimeMultipart

    public MimeMultipart(javax.activation.DataSource ds)
                  throws MessagingException

  Constructs a MimeMultipart object and its bodyparts from the given DataSource.

  This constructor handles as a special case the situation where the given DataSource is a MultipartDataSource object. In this case, this method just invokes the superclass (i.e., Multipart) constructor that takes a MultipartDataSource object.

  Otherwise, the DataSource is assumed to provide a MIME multipart byte stream. The `parsed` flag is set to false. When the data for the body parts are needed, the parser extracts the "boundary" parameter from the content type of this DataSource, skips the 'preamble' and reads bytes till the terminating boundary and creates MimeBodyParts for each part of the stream.

  Parameters:
    `ds` - DataSource, can be a MultipartDataSource

Method Detail

### setSubType

    public void setSubType(java.lang.String subtype)
                    throws MessagingException

  Set the subtype. This method should be invoked only on a new MimeMultipart object created by the client. The default subtype of such a multipart object is "mixed".

  Parameters:
    `subtype` - Subtype

### getCount

    public int getCount()
                 throws MessagingException

  Return the number of enclosed BodyPart objects.
  Overrides:
    `getCount` in class `Multipart`
  Returns:
    number of parts

### getBodyPart

    public BodyPart getBodyPart(int index)
                         throws MessagingException

  Get the specified BodyPart. BodyParts are numbered starting at 0.
  Overrides:
    `getBodyPart` in class `Multipart`
  Parameters:
    `index` - the index of the desired BodyPart
  Returns:
    the Part
  Throws:
    `MessagingException` - if no such BodyPart exists

### getBodyPart

    public BodyPart getBodyPart(java.lang.String CID)
                         throws MessagingException

  Get the MimeBodyPart referred to by the given ContentID (CID). Returns null if the part is not found.
  Parameters:
    `CID` - the ContentID of the desired part
  Returns:
    the Part

### updateHeaders

    protected void updateHeaders()
                          throws MessagingException

  Update headers. The default implementation here just calls the `updateHeaders` method on each of its children BodyParts.

  Note that the boundary parameter is already set up when a new and empty MimeMultipart object is created.

  This method is called when the `saveChanges` method is invoked on the Message object containing this Multipart. This is typically done as part of the Message send process, however note that a client is free to call it any number of times. So if the header updating process is expensive for a specific MimeMultipart subclass, then it might itself want to track whether its internal state actually did change, and do the header updating only if necessary.

### writeTo

    public void writeTo(java.io.OutputStream os)
                 throws java.io.IOException,
                        MessagingException

  Iterates through all the parts and outputs each Mime part separated by a boundary.
  Overrides:
    `writeTo` in class `Multipart`
  Following copied from class: `javax.mail.Multipart`
  Throws:
    `java.io.IOException` - if an IO related exception occurs
    `MessagingException` -

### parse

    protected void parse()
                  throws MessagingException

  Parse the InputStream from our DataSource, constructing the appropriate MimeBodyParts. The `parsed` flag is set to true, and if true on entry nothing is done. This method is called by all other methods that need data for the body parts, to make sure the data has been parsed.
  Since:
    JavaMail 1.2

### createInternetHeaders

    protected InternetHeaders createInternetHeaders(java.io.InputStream is)
                                             throws MessagingException

  Create and return an InternetHeaders object that loads the headers from the given InputStream. Subclasses can override this method to return a subclass of InternetHeaders, if necessary. This implementation simply constructs and returns an InternetHeaders object.
  Parameters:
    `is` - the InputStream to read the headers from
  Throws:
    `MessagingException` -
  Since:
    JavaMail 1.2

### createMimeBodyPart

    protected MimeBodyPart createMimeBodyPart(InternetHeaders headers,
                                              byte[] content)
                                       throws MessagingException

  Create and return a MimeBodyPart object to represent a body part parsed from the InputStream. Subclasses can override this method to return a subclass of MimeBodyPart, if necessary. This implementation simply constructs and returns a MimeBodyPart object.
  Parameters:
    `headers` - the headers for the body part
    `content` - the content of the body part
  Throws:
    `MessagingException` -
  Since:
    JavaMail 1.2

### createMimeBodyPart

    protected MimeBodyPart createMimeBodyPart(java.io.InputStream is)
                                       throws MessagingException

  Create and return a MimeBodyPart object to represent a body part parsed from the InputStream. Subclasses can override this method to return a subclass of MimeBodyPart, if necessary. This implementation simply constructs and returns a MimeBodyPart object.
  Parameters:
    `is` - InputStream containing the body part
  Throws:
    `MessagingException` -
  Since:
    JavaMail 1.2