## com.sun.mail.imap
Class IMAPMessage

    java.lang.Object
      javax.mail.Message
          javax.mail.internet.MimeMessage
              com.sun.mail.imap.IMAPMessage

All Implemented Interfaces:
  MimePart, Part

    public class IMAPMessage

extends MimeMessage

This class implements an IMAPMessage object.

An IMAPMessage object starts out as a light-weight object. It gets filled-in incrementally when a request is made for some item. Or when a prefetch is done using the FetchProfile.

An IMAPMessage has a messageNumber and a sequenceNumber. The messageNumber is its index into its containing folder's messageCache. The sequenceNumber is its IMAP sequence-number.

Nested Class Summary

Nested classes/interfaces inherited from class javax.mail.internet.MimeMessage
`MimeMessage.RecipientType`

Field Summary
`protected com.sun.mail.imap.protocol.BODYSTRUCTURE` `bs`
`protected com.sun.mail.imap.protocol.ENVELOPE` `envelope`
`protected String` `sectionId`

Fields inherited from class javax.mail.internet.MimeMessage
`content, contentStream, dh, flags, headers, modified, saved`

Fields inherited from class javax.mail.Message
`expunged, folder, msgnum, session`

Fields inherited from interface javax.mail.Part
`ATTACHMENT, INLINE`

Constructor Summary
`protected` `IMAPMessage(IMAPFolder folder, int msgnum)` Constructor.
`protected` `IMAPMessage(Session session)` Constructor, for use by IMAPNestedMessage.

Method Summary
`void` `addFrom(Address[] addresses)` Add the specified addresses to the existing "From" field.
`void` `addHeader(String name, String value)` Add this value to the existing values for this header_name.
`void` `addHeaderLine(String line)` Add a raw RFC 822 header-line.
`void` `addRecipients(Message.RecipientType type, Address[] addresses)` Add the given addresses to the specified recipient type.
`protected void` `checkExpunged()`
`protected void` `forceCheckExpunged()` Do a NOOP to force any untagged EXPUNGE responses and then check if this message is expunged.
`Enumeration` `getAllHeaderLines()` Get all header-lines.
`Enumeration` `getAllHeaders()` Get all headers.
`String` `getContentID()` Get the Content-ID.
`String[]` `getContentLanguage()` Get the content language.
`String` `getContentMD5()` Get the Content-MD5.
`protected InputStream` `getContentStream()` Get all the bytes for this message.
`String` `getContentType()` Get the Content-Type.
`DataHandler` `getDataHandler()` Get the DataHandler object for this message.
`String` `getDescription()` Get the decoded Content-Description.
`String` `getDisposition()` Get the Content-Disposition.
`String` `getEncoding()` Get the Content-Transfer-Encoding.
`protected int` `getFetchBlockSize()`
`String` `getFileName()` Get the "filename" Disposition parameter.
`Flags` `getFlags()` Get the Flags for this message.
`Address[]` `getFrom()` Get the "From" attribute.
`String[]` `getHeader(String name)` Get the named header.
`String` `getHeader(String name, String delimiter)` Get the named header.
`String` `getInReplyTo()` Get the In-Reply-To header.
`int` `getLineCount()` Get the total number of lines.
`Enumeration` `getMatchingHeaderLines(String[] names)` Get all matching header-lines.
`Enumeration` `getMatchingHeaders(String[] names)` Get matching headers.
`protected Object` `getMessageCacheLock()` Get the messageCacheLock, associated with this Message's Folder.
`String` `getMessageID()` Get the Message-ID.
`Enumeration` `getNonMatchingHeaderLines(String[] names)` Get all non-matching headerlines.
`Enumeration` `getNonMatchingHeaders(String[] names)` Get non-matching headers.
`boolean` `getPeek()` Get whether or not to use the PEEK variant of FETCH when fetching message content.
`protected com.sun.mail.imap.protocol.IMAPProtocol` `getProtocol()` Get this message's folder's protocol connection.
`Date` `getReceivedDate()` Get the recieved date (INTERNALDATE)
`Address[]` `getRecipients(Message.RecipientType type)` Get the desired Recipient type.
`Address[]` `getReplyTo()` Get the ReplyTo addresses.
`Address` `getSender()` Get the "Sender" attribute.
`Date` `getSentDate()` Get the SentDate.
`protected int` `getSequenceNumber()` Get this message's IMAP sequence number.
`int` `getSize()` Get the message size.
`String` `getSubject()` Get the decoded subject.
`protected long` `getUID()`
`void` `invalidateHeaders()` Invalidate cached header and envelope information for this message.
`protected boolean` `isREV1()`
`boolean` `isSet(Flags.Flag flag)` Test if the given Flags are set in this message.
`void` `removeHeader(String name)` Remove all headers with this name.
`void` `setContentID(String cid)` Set the "Content-ID" header field of this Message.
`void` `setContentLanguage(String[] languages)` Set the "Content-Language" header of this MimePart.
`void` `setContentMD5(String md5)` Set the "Content-MD5" header field of this Message.
`void` `setDataHandler(DataHandler content)` This method provides the mechanism to set this part's content.
`void` `setDescription(String description, String charset)` Set the "Content-Description" header field for this Message.
`void` `setDisposition(String disposition)` Set the "Content-Disposition" header field of this Message.
`protected void` `setExpunged(boolean set)` Sets the expunged flag for this Message.
`void` `setFileName(String filename)` Set the filename associated with this part, if possible.
`void` `setFlags(Flags flag, boolean set)` Set/Unset the given flags in this message.
`void` `setFrom(Address address)` Set the RFC 822 "From" header field.
`void` `setHeader(String name, String value)` Set the value for this header_name.
`protected void` `setMessageNumber(int msgnum)` Wrapper around the protected method Message.setMessageNumber() to make that method accessible to IMAPFolder.
`void` `setPeek(boolean peek)` Set whether or not to use the PEEK variant of FETCH when fetching message content.
`void` `setRecipients(Message.RecipientType type, Address[] addresses)` Set the specified recipient type to the given addresses.
`void` `setReplyTo(Address[] addresses)` Set the RFC 822 "Reply-To" header field.
`void` `setSender(Address address)` Set the RFC 822 "Sender" header field.
`void` `setSentDate(Date d)` Set the RFC 822 "Date" header field.
`void` `setSubject(String subject, String charset)` Set the "Subject" header field.
`protected void` `setUID(long uid)`
`void` `writeTo(OutputStream os)` Write out the bytes into the given outputstream.

Methods inherited from class javax.mail.internet.MimeMessage
`addRecipients, createInternetHeaders, createMimeMessage, getAllRecipients, getContent, getInputStream, getRawInputStream, isMimeType, parse, reply, saveChanges, setContent, setContent, setDescription, setFrom, setRecipients, setSubject, setText, setText, setText, updateHeaders, updateMessageID, writeTo`

Methods inherited from class javax.mail.Message
`addRecipient, getFolder, getMessageNumber, isExpunged, match, setFlag, setRecipient`

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

Field Detail

### bs

    protected com.sun.mail.imap.protocol.BODYSTRUCTURE bs

### envelope

    protected com.sun.mail.imap.protocol.ENVELOPE envelope

### sectionId

    protected String sectionId

Constructor Detail

### IMAPMessage

    protected IMAPMessage(IMAPFolder folder,
                          int msgnum)

  Constructor.

### IMAPMessage

    protected IMAPMessage(Session session)

  Constructor, for use by IMAPNestedMessage.

Method Detail

### getProtocol

    protected com.sun.mail.imap.protocol.IMAPProtocol getProtocol()
                                                           throws com.sun.mail.iap.ProtocolException,
                                                                  FolderClosedException

  Get this message's folder's protocol connection. Throws FolderClosedException, if the protocol connection is not available. ASSERT: Must hold the messageCacheLock.

  Throws:
    `com.sun.mail.iap.ProtocolException`
    `FolderClosedException`

### isREV1

    protected boolean isREV1()
                      throws FolderClosedException

  Throws:
    `FolderClosedException`

### getMessageCacheLock

    protected Object getMessageCacheLock()

  Get the messageCacheLock, associated with this Message's Folder.

### getSequenceNumber

    protected int getSequenceNumber()

  Get this message's IMAP sequence number. ASSERT: This method must be called only when holding the messageCacheLock.

### setMessageNumber

    protected void setMessageNumber(int msgnum)

  Wrapper around the protected method Message.setMessageNumber() to make that method accessible to IMAPFolder.

  Overrides:
    `setMessageNumber` in class `Message`

### getUID

    protected long getUID()

### setUID

    protected void setUID(long uid)

### setExpunged

    protected void setExpunged(boolean set)

  Description copied from class: `Message`
  Sets the expunged flag for this Message. This method is to be used only by the implementation classes.

  Overrides:
    `setExpunged` in class `Message`
  Parameters:
    `set` - the expunged flag

### checkExpunged

    protected void checkExpunged()
                          throws MessageRemovedException

  Throws:
    `MessageRemovedException`

### forceCheckExpunged

    protected void forceCheckExpunged()
                               throws MessageRemovedException,
                                      FolderClosedException

  Do a NOOP to force any untagged EXPUNGE responses and then check if this message is expunged.

  Throws:
    `MessageRemovedException`
    `FolderClosedException`

### getFetchBlockSize

    protected int getFetchBlockSize()

### getFrom

    public Address[] getFrom()
                      throws MessagingException

  Get the "From" attribute.

  Overrides:
    `getFrom` in class `MimeMessage`
  Returns:
    Address object
  Throws:
    `MessagingException`
  See Also:
    `MimeMessage.headers`

### setFrom

    public void setFrom(Address address)
                 throws MessagingException

  Description copied from class: `MimeMessage`
  Set the RFC 822 "From" header field. Any existing values are replaced with the given address. If address is `null`, this header is removed.

  Overrides:
    `setFrom` in class `MimeMessage`
  Parameters:
    `address` - the sender of this message
  Throws:
    `MessagingException`
    `IllegalWriteException` - if the underlying implementation does not support modification of existing values

### addFrom

    public void addFrom(Address[] addresses)
                 throws MessagingException

  Description copied from class: `MimeMessage`
  Add the specified addresses to the existing "From" field. If the "From" field does not already exist, it is created.

  Overrides:
    `addFrom` in class `MimeMessage`
  Parameters:
    `addresses` - the senders of this message
  Throws:
    `IllegalWriteException` - if the underlying implementation does not support modification of existing values
    `MessagingException`

### getSender

    public Address getSender()
                      throws MessagingException

  Get the "Sender" attribute.

  Overrides:
    `getSender` in class `MimeMessage`
  Returns:
    Address object
  Throws:
    `MessagingException`
  See Also:
    `MimeMessage.headers`

### setSender

    public void setSender(Address address)
                   throws MessagingException

  Description copied from class: `MimeMessage`
  Set the RFC 822 "Sender" header field. Any existing values are replaced with the given address. If address is `null`, this header is removed.

  Overrides:
    `setSender` in class `MimeMessage`
  Parameters:
    `address` - the sender of this message
  Throws:
    `IllegalWriteException` - if the underlying implementation does not support modification of existing values
    `MessagingException`

### getRecipients

    public Address[] getRecipients(Message.RecipientType type)
                            throws MessagingException

  Get the desired Recipient type.

  Overrides:
    `getRecipients` in class `MimeMessage`
  Parameters:
    `type` - Type of recepient
  Returns:
    array of Address objects
  Throws:
    `MessagingException` - if header could not be retrieved
    `AddressException` - if the header is misformatted
  See Also:
    `MimeMessage.headers`, `Message.RecipientType.TO`, `Message.RecipientType.CC`, `Message.RecipientType.BCC`, `MimeMessage.RecipientType.NEWSGROUPS`

### setRecipients

    public void setRecipients(Message.RecipientType type,
                              Address[] addresses)
                       throws MessagingException

  Description copied from class: `MimeMessage`
  Set the specified recipient type to the given addresses. If the address parameter is `null`, the corresponding recipient field is removed.

  Overrides:
    `setRecipients` in class `MimeMessage`
  Parameters:
    `type` - Recipient type
    `addresses` - Addresses
  Throws:
    `MessagingException`
    `IllegalWriteException` - if the underlying implementation does not support modification of existing values
  See Also:
    `MimeMessage.getRecipients(javax.mail.Message.RecipientType)`

### addRecipients

    public void addRecipients(Message.RecipientType type,
                              Address[] addresses)
                       throws MessagingException

  Description copied from class: `MimeMessage`
  Add the given addresses to the specified recipient type.

  Overrides:
    `addRecipients` in class `MimeMessage`
  Parameters:
    `type` - Recipient type
    `addresses` - Addresses
  Throws:
    `MessagingException`
    `IllegalWriteException` - if the underlying implementation does not support modification of existing values

### getReplyTo

    public Address[] getReplyTo()
                         throws MessagingException

  Get the ReplyTo addresses.

  Overrides:
    `getReplyTo` in class `MimeMessage`
  Returns:
    addresses to which replies should be directed
  Throws:
    `MessagingException`
  See Also:
    `MimeMessage.headers`

### setReplyTo

    public void setReplyTo(Address[] addresses)
                    throws MessagingException

  Description copied from class: `MimeMessage`
  Set the RFC 822 "Reply-To" header field. If the address parameter is `null`, this header is removed.

  Overrides:
    `setReplyTo` in class `MimeMessage`
  Parameters:
    `addresses` - addresses to which replies should be directed
  Throws:
    `MessagingException`
    `IllegalWriteException` - if the underlying implementation does not support modification of existing values
    `MethodNotSupportedException` - if the underlying implementation does not support setting this attribute

### getSubject

    public String getSubject()
                      throws MessagingException

  Get the decoded subject.

  Overrides:
    `getSubject` in class `MimeMessage`
  Returns:
    Subject
  Throws:
    `MessagingException`
  See Also:
    `MimeMessage.headers`

### setSubject

    public void setSubject(String subject,
                           String charset)
                    throws MessagingException

  Description copied from class: `MimeMessage`
  Set the "Subject" header field. If the subject contains non US-ASCII characters, it will be encoded using the specified charset. If the subject contains only US-ASCII characters, no encoding is done and it is used as-is. If the subject is null, the existing "Subject" header field is removed.

  The application must ensure that the subject does not contain any line breaks.

  Note that if the charset encoding process fails, a MessagingException is thrown, and an UnsupportedEncodingException is included in the chain of nested exceptions within the MessagingException.

  Overrides:
    `setSubject` in class `MimeMessage`
  Parameters:
    `subject` - The subject
    `charset` - The charset
  Throws:
    `IllegalWriteException` - if the underlying implementation does not support modification of existing values
    `MessagingException`

### getSentDate

    public Date getSentDate()
                     throws MessagingException

  Get the SentDate.

  Overrides:
    `getSentDate` in class `MimeMessage`
  Returns:
    The sent Date
  Throws:
    `MessagingException`

### setSentDate

    public void setSentDate(Date d)
                     throws MessagingException

  Description copied from class: `MimeMessage`
  Set the RFC 822 "Date" header field. This is the date on which the creator of the message indicates that the message is complete and ready for delivery. If the date parameter is `null`, the existing "Date" field is removed.

  Overrides:
    `setSentDate` in class `MimeMessage`
  Parameters:
    `d` - the sent date of this message
  Throws:
    `MessagingException`
    `IllegalWriteException` - if the underlying implementation does not support modification of existing values

### getReceivedDate

    public Date getReceivedDate()
                         throws MessagingException

  Get the recieved date (INTERNALDATE)

  Overrides:
    `getReceivedDate` in class `MimeMessage`
  Returns:
    the date this message was received
  Throws:
    `MessagingException`

### getSize

    public int getSize()
                throws MessagingException

  Get the message size.

  Note that this returns RFC822.SIZE. That is, it's the size of the whole message, header and body included.

  Specified by:
    `getSize` in interface `Part`
  Overrides:
    `getSize` in class `MimeMessage`
  Returns:
    size of content in bytes
  Throws:
    `MessagingException`

### getLineCount

    public int getLineCount()
                     throws MessagingException

  Get the total number of lines.

  Returns the "body_fld_lines" field from the BODYSTRUCTURE. Note that this field is available only for text/plain and message/rfc822 types

  Specified by:
    `getLineCount` in interface `Part`
  Overrides:
    `getLineCount` in class `MimeMessage`
  Returns:
    number of lines in the content.
  Throws:
    `MessagingException`

### getContentLanguage

    public String[] getContentLanguage()
                                throws MessagingException

  Get the content language.

  Specified by:
    `getContentLanguage` in interface `MimePart`
  Overrides:
    `getContentLanguage` in class `MimeMessage`
  Returns:
    value of content-language header.
  Throws:
    `MessagingException`

### setContentLanguage

    public void setContentLanguage(String[] languages)
                            throws MessagingException

  Description copied from class: `MimeMessage`
  Set the "Content-Language" header of this MimePart. The Content-Language header is defined by RFC 1766.

  Specified by:
    `setContentLanguage` in interface `MimePart`
  Overrides:
    `setContentLanguage` in class `MimeMessage`
  Parameters:
    `languages` - array of language tags
  Throws:
    `IllegalWriteException` - if the underlying implementation does not support modification
    `MessagingException`

### getInReplyTo

    public String getInReplyTo()
                        throws MessagingException

  Get the In-Reply-To header.

  Throws:
    `MessagingException`
  Since:
    JavaMail 1.3.3

### getContentType

    public String getContentType()
                          throws MessagingException

  Get the Content-Type. Generate this header from the BODYSTRUCTURE. Append parameters as well.

  Specified by:
    `getContentType` in interface `Part`
  Overrides:
    `getContentType` in class `MimeMessage`
  Returns:
    The ContentType of this part
  Throws:
    `MessagingException`
  See Also:
    `DataHandler`

### getDisposition

    public String getDisposition()
                          throws MessagingException

  Get the Content-Disposition.

  Specified by:
    `getDisposition` in interface `Part`
  Overrides:
    `getDisposition` in class `MimeMessage`
  Returns:
    disposition of this part, or null if unknown
  Throws:
    `MessagingException`
  See Also:
    `Part.ATTACHMENT`, `Part.INLINE`, `Part.getFileName()`

### setDisposition

    public void setDisposition(String disposition)
                        throws MessagingException

  Description copied from class: `MimeMessage`
  Set the "Content-Disposition" header field of this Message. If `disposition` is null, any existing "Content-Disposition" header field is removed.

  Specified by:
    `setDisposition` in interface `Part`
  Overrides:
    `setDisposition` in class `MimeMessage`
  Parameters:
    `disposition` - disposition of this part
  Throws:
    `MessagingException`
    `IllegalWriteException` - if the underlying implementation does not support modification of this header
  See Also:
    `Part.ATTACHMENT`, `Part.INLINE`, `Part.setFileName(java.lang.String)`

### getEncoding

    public String getEncoding()
                       throws MessagingException

  Get the Content-Transfer-Encoding.

  Specified by:
    `getEncoding` in interface `MimePart`
  Overrides:
    `getEncoding` in class `MimeMessage`
  Returns:
    content-transfer-encoding
  Throws:
    `MessagingException`

### getContentID

    public String getContentID()
                        throws MessagingException

  Get the Content-ID.

  Specified by:
    `getContentID` in interface `MimePart`
  Overrides:
    `getContentID` in class `MimeMessage`
  Returns:
    content-ID
  Throws:
    `MessagingException`

### setContentID

    public void setContentID(String cid)
                      throws MessagingException

  Description copied from class: `MimeMessage`
  Set the "Content-ID" header field of this Message. If the `cid` parameter is null, any existing "Content-ID" is removed.

  Overrides:
    `setContentID` in class `MimeMessage`
  Throws:
    `IllegalWriteException` - if the underlying implementation does not support modification
    `MessagingException`

### getContentMD5

    public String getContentMD5()
                         throws MessagingException

  Get the Content-MD5.

  Specified by:
    `getContentMD5` in interface `MimePart`
  Overrides:
    `getContentMD5` in class `MimeMessage`
  Returns:
    content-MD5
  Throws:
    `MessagingException`

### setContentMD5

    public void setContentMD5(String md5)
                       throws MessagingException

  Description copied from class: `MimeMessage`
  Set the "Content-MD5" header field of this Message.

  Specified by:
    `setContentMD5` in interface `MimePart`
  Overrides:
    `setContentMD5` in class `MimeMessage`
  Parameters:
    `md5` - the MD5 value
  Throws:
    `IllegalWriteException` - if the underlying implementation does not support modification
    `MessagingException`

### getDescription

    public String getDescription()
                          throws MessagingException

  Get the decoded Content-Description.

  Specified by:
    `getDescription` in interface `Part`
  Overrides:
    `getDescription` in class `MimeMessage`
  Returns:
    content-description
  Throws:
    `MessagingException`

### setDescription

    public void setDescription(String description,
                               String charset)
                        throws MessagingException

  Description copied from class: `MimeMessage`
  Set the "Content-Description" header field for this Message. If the description parameter is `null`, then any existing "Content-Description" fields are removed.

  If the description contains non US-ASCII characters, it will be encoded using the specified charset. If the description contains only US-ASCII characters, no encoding is done and it is used as-is.

  Note that if the charset encoding process fails, a MessagingException is thrown, and an UnsupportedEncodingException is included in the chain of nested exceptions within the MessagingException.

  Overrides:
    `setDescription` in class `MimeMessage`
  Parameters:
    `description` - Description
    `charset` - Charset for encoding
  Throws:
    `IllegalWriteException` - if the underlying implementation does not support modification
    `MessagingException`

### getMessageID

    public String getMessageID()
                        throws MessagingException

  Get the Message-ID.

  Overrides:
    `getMessageID` in class `MimeMessage`
  Returns:
    Message-ID
  Throws:
    `MessagingException` - if the retrieval of this field causes any exception.
  See Also:
    `MessageIDTerm`

### getFileName

    public String getFileName()
                       throws MessagingException

  Get the "filename" Disposition parameter. (Only available in IMAP4rev1). If thats not available, get the "name" ContentType parameter.

  Specified by:
    `getFileName` in interface `Part`
  Overrides:
    `getFileName` in class `MimeMessage`
  Returns:
    filename
  Throws:
    `MessagingException`

### setFileName

    public void setFileName(String filename)
                     throws MessagingException

  Description copied from class: `MimeMessage`
  Set the filename associated with this part, if possible.

  Sets the "filename" parameter of the "Content-Disposition" header field of this message.

  If the `mail.mime.encodefilename` System property is set to true, the `MimeUtility.encodeText` method will be used to encode the filename. While such encoding is not supported by the MIME spec, many mailers use this technique to support non-ASCII characters in filenames. The default value of this property is false.

  Specified by:
    `setFileName` in interface `Part`
  Overrides:
    `setFileName` in class `MimeMessage`
  Parameters:
    `filename` - Filename to associate with this part
  Throws:
    `IllegalWriteException` - if the underlying implementation does not support modification of this header
    `MessagingException`

### getContentStream

    protected InputStream getContentStream()
                                    throws MessagingException

  Get all the bytes for this message. Overrides getContentStream() in MimeMessage. This method is ultimately used by the DataHandler to obtain the input stream for this message.

  Overrides:
    `getContentStream` in class `MimeMessage`
  Throws:
    `MessagingException`
  See Also:
    `MimeMessage.getContentStream()`

### getDataHandler

    public DataHandler getDataHandler()
                               throws MessagingException

  Get the DataHandler object for this message.

  Specified by:
    `getDataHandler` in interface `Part`
  Overrides:
    `getDataHandler` in class `MimeMessage`
  Returns:
    DataHandler for the content
  Throws:
    `MessagingException`

### setDataHandler

    public void setDataHandler(DataHandler content)
                        throws MessagingException

  Description copied from class: `MimeMessage`
  This method provides the mechanism to set this part's content. The given DataHandler object should wrap the actual content.

  Specified by:
    `setDataHandler` in interface `Part`
  Overrides:
    `setDataHandler` in class `MimeMessage`
  Parameters:
    `content` - The DataHandler for the content.
  Throws:
    `MessagingException`
    `IllegalWriteException` - if the underlying implementation does not support modification of existing values

### writeTo

    public void writeTo(OutputStream os)
                 throws IOException,
                        MessagingException

  Write out the bytes into the given outputstream.

  Specified by:
    `writeTo` in interface `Part`
  Overrides:
    `writeTo` in class `MimeMessage`
  Throws:
    `IOException` - if an error occurs writing to the stream or if an error is generated by the javax.activation layer.
    `MessagingException` - if an error occurs fetching the data to be written
  See Also:
    `DataHandler.writeTo(java.io.OutputStream)`

### getHeader

    public String[] getHeader(String name)
                       throws MessagingException

  Get the named header.

  Specified by:
    `getHeader` in interface `Part`
  Overrides:
    `getHeader` in class `MimeMessage`
  Parameters:
    `name` - name of header
  Returns:
    array of headers
  Throws:
    `MessagingException`
  See Also:
    `MimeUtility`

### getHeader

    public String getHeader(String name,
                            String delimiter)
                     throws MessagingException

  Get the named header.

  Specified by:
    `getHeader` in interface `MimePart`
  Overrides:
    `getHeader` in class `MimeMessage`
  Parameters:
    `name` - the name of this header
    `delimiter` - separator between values
  Returns:
    the value fields for all headers with this name
  Throws:
    `MessagingException`

### setHeader

    public void setHeader(String name,
                          String value)
                   throws MessagingException

  Description copied from class: `MimeMessage`
  Set the value for this header_name. Replaces all existing header values with this new value. Note that RFC 822 headers must contain only US-ASCII characters, so a header that contains non US-ASCII characters must have been encoded by the caller as per the rules of RFC 2047.

  Specified by:
    `setHeader` in interface `Part`
  Overrides:
    `setHeader` in class `MimeMessage`
  Parameters:
    `name` - header name
    `value` - header value
  Throws:
    `MessagingException`
    `IllegalWriteException` - if the underlying implementation does not support modification of existing values
  See Also:
    `MimeUtility`

### addHeader

    public void addHeader(String name,
                          String value)
                   throws MessagingException

  Description copied from class: `MimeMessage`
  Add this value to the existing values for this header_name. Note that RFC 822 headers must contain only US-ASCII characters, so a header that contains non US-ASCII characters must have been encoded as per the rules of RFC 2047.

  Specified by:
    `addHeader` in interface `Part`
  Overrides:
    `addHeader` in class `MimeMessage`
  Parameters:
    `name` - header name
    `value` - header value
  Throws:
    `MessagingException`
    `IllegalWriteException` - if the underlying implementation does not support modification of existing values
  See Also:
    `MimeUtility`

### removeHeader

    public void removeHeader(String name)
                      throws MessagingException

  Description copied from class: `MimeMessage`
  Remove all headers with this name.

  Specified by:
    `removeHeader` in interface `Part`
  Overrides:
    `removeHeader` in class `MimeMessage`
  Parameters:
    `name` - the name of this header
  Throws:
    `MessagingException`
    `IllegalWriteException` - if the underlying implementation does not support modification of existing values

### getAllHeaders

    public Enumeration getAllHeaders()
                              throws MessagingException

  Get all headers.

  Specified by:
    `getAllHeaders` in interface `Part`
  Overrides:
    `getAllHeaders` in class `MimeMessage`
  Returns:
    array of header objects
  Throws:
    `MessagingException`
  See Also:
    `MimeUtility`

### getMatchingHeaders

    public Enumeration getMatchingHeaders(String[] names)
                                   throws MessagingException

  Get matching headers.

  Specified by:
    `getMatchingHeaders` in interface `Part`
  Overrides:
    `getMatchingHeaders` in class `MimeMessage`
  Returns:
    enumeration of Header objects
  Throws:
    `MessagingException`

### getNonMatchingHeaders

    public Enumeration getNonMatchingHeaders(String[] names)
                                      throws MessagingException

  Get non-matching headers.

  Specified by:
    `getNonMatchingHeaders` in interface `Part`
  Overrides:
    `getNonMatchingHeaders` in class `MimeMessage`
  Returns:
    enumeration of Header objects
  Throws:
    `MessagingException`

### addHeaderLine

    public void addHeaderLine(String line)
                       throws MessagingException

  Description copied from class: `MimeMessage`
  Add a raw RFC 822 header-line.

  Specified by:
    `addHeaderLine` in interface `MimePart`
  Overrides:
    `addHeaderLine` in class `MimeMessage`
  Throws:
    `IllegalWriteException` - if the underlying implementation does not support modification
    `MessagingException`

### getAllHeaderLines

    public Enumeration getAllHeaderLines()
                                  throws MessagingException

  Get all header-lines.

  Specified by:
    `getAllHeaderLines` in interface `MimePart`
  Overrides:
    `getAllHeaderLines` in class `MimeMessage`
  Throws:
    `MessagingException`

### getMatchingHeaderLines

    public Enumeration getMatchingHeaderLines(String[] names)
                                       throws MessagingException

  Get all matching header-lines.

  Specified by:
    `getMatchingHeaderLines` in interface `MimePart`
  Overrides:
    `getMatchingHeaderLines` in class `MimeMessage`
  Throws:
    `MessagingException`

### getNonMatchingHeaderLines

    public Enumeration getNonMatchingHeaderLines(String[] names)
                                          throws MessagingException

  Get all non-matching headerlines.

  Specified by:
    `getNonMatchingHeaderLines` in interface `MimePart`
  Overrides:
    `getNonMatchingHeaderLines` in class `MimeMessage`
  Throws:
    `MessagingException`

### getFlags

    public Flags getFlags()
                   throws MessagingException

  Get the Flags for this message.

  Overrides:
    `getFlags` in class `MimeMessage`
  Returns:
    Flags object containing the flags for this message
  Throws:
    `MessagingException`
  See Also:
    `Flags`

### isSet

    public boolean isSet(Flags.Flag flag)
                  throws MessagingException

  Test if the given Flags are set in this message.

  Overrides:
    `isSet` in class `MimeMessage`
  Parameters:
    `flag` - the flag
  Returns:
    value of the specified flag for this message
  Throws:
    `MessagingException`
  See Also:
    `Flags.Flag`, `Flags.Flag.ANSWERED`, `Flags.Flag.DELETED`, `Flags.Flag.DRAFT`, `Flags.Flag.FLAGGED`, `Flags.Flag.RECENT`, `Flags.Flag.SEEN`

### setFlags

    public void setFlags(Flags flag,
                         boolean set)
                  throws MessagingException

  Set/Unset the given flags in this message.

  Overrides:
    `setFlags` in class `MimeMessage`
  Parameters:
    `flag` - Flags object containing the flags to be set
    `set` - the value to be set
  Throws:
    `MessagingException`
    `IllegalWriteException` - if the underlying implementation does not support modification of existing values.
  See Also:
    `MessageChangedEvent`

### setPeek

    public void setPeek(boolean peek)

  Set whether or not to use the PEEK variant of FETCH when fetching message content.

  Since:
    JavaMail 1.3.3

### getPeek

    public boolean getPeek()

  Get whether or not to use the PEEK variant of FETCH when fetching message content.

  Since:
    JavaMail 1.3.3

### invalidateHeaders

    public void invalidateHeaders()

  Invalidate cached header and envelope information for this message. Subsequent accesses of this information will cause it to be fetched from the server.

  Since:
    JavaMail 1.3.3

Copyright © 2009 Sun Microsystems, Inc.. All Rights Reserved.