See METHODS in Mail::Reporter
Create a copy of this message. Returned is a Mail::Message
object.
The head and body, the log and trace levels are taken. Labels are
copied with the message, but the delete and modified flags are not.
BE WARNED: the clone of any kind of message (or a message part) will always be a
Mail::Message
object. For example, a
Mail::Box::Message's clone is detached from the folder of its original.
When you use Mail::Box::addMessage() with the cloned message at hand,
then the clone will automatically be coerced into the right message type
to be added.
See also Mail::Box::Message::copyTo() and Mail::Box::Message::moveTo().
Option | Default |
---|---|
shallow | <false> |
shallow_body | <false> |
shallow_head | <false> |
$copy = $msg->clone;
Option | Defined in | Default |
---|---|---|
body | undef | |
body_type | ||
deleted | <false> | |
field_type | undef | |
head | undef | |
head_type | ||
labels | {} | |
log | Mail::Reporter |
|
messageId | undef | |
modified | <false> | |
trace | Mail::Reporter |
|
trusted | <false> |
If the message is a part of another message, container
returns the
reference to the containing body.
my Mail::Message $msg = ... return unless $msg->body->isMultipart; my $part = $msg->body->part(2); return unless $part->body->isMultipart; my $nested = $part->body->part(3); $nested->container; # returns $msg->body $nested->toplevel; # returns $msg $msg->container; # returns undef $msg->toplevel; # returns $msg $msg->isPart; # returns false $part->isPart; # returns true
Dummy messages are used to fill holes in linked-list and such, where only a message-id is known, but not the place of the header of body data.
This method is also available for Mail::Message::Dummy objects,
where this will return true
. On any extension of Mail::Message
,
this will return false
.
Returns true if the message is a part of another message. This is
the case for Mail::Message::Part extensions of Mail::Message
.
Retrieve the message's id. Every message has a unique message-id. This id is used mainly for recognizing discussion threads.
Print the message to the FILE-HANDLE, which defaults to the selected filehandle, without the encapsulation sometimes required by a folder type, like write() does.
$message->print(\*STDERR); # to the error output $message->print; # to the selected file my $out = IO::File->new('out', 'w'); $message->print($out); # no encapsulation: no folder $message->write($out); # with encapsulation: is folder.
Transmit the message to anything outside this Perl program. MAILER is a Mail::Transport::Send object. When the MAILER is not specified, one will be created, and kept as default for the next messages as well.
The OPTIONS are mailer specific, and a mixture of what is usable for the creation of the mailer object and the sending itself. Therefore, see for possible options Mail::Transport::Send::new() and Mail::Transport::Send::send().
$message->send;
is short (but little less flexibile) for
my $mailer = Mail::Transport::SMTP->new(@smtpopts); $mailer->send($message, @sendopts);
See examples/send.pl in the distribution of Mail::Box.
$message->send(via => 'sendmail')
The message send() mechanism had not enough information to automatically
find a mail transfer agent to sent this message. Specify a mailer
explicitly using the via
options.
Returns an estimated size of the whole message in bytes. In many occasions, the functions which process the message further, for instance send() or print() will need to add/change header lines or add CR characters, so the size is only an estimate with a few percent margin of the real result.
The computation assumes that each line ending is represented by one character (like UNIX, MacOS, and sometimes Cygwin), and not two characters (like Windows and sometimes Cygwin). If you write the message to file on a system which uses CR and LF to end a single line (all Windows versions), the result in that file will be at least nrLines() larger than this method returns.
Returns a reference to the main message, which will be the current message if the message is not part of another message.
Write the message to the FILE-HANDLE, which defaults to the selected FILEHANDLE, with all surrounding information which is needed to put it correctly in a folder file.
In most cases, the result of write
will be the same as with print().
The main exception is for Mbox folder messages, which will get printed
with their leading 'From ' line and a trailing blank. Each line of
their body which starts with 'From ' will have an '>' added in front.
Returns the addresses which are specified on the Bcc
header line (or lines)
A list of Mail::Address objects is returned.
Bcc
stands for Blind Carbon Copy: destinations of the message which are
not listed in the messages actually sent. So, this field will be empty
for received messages, but may be present in messages you construct yourself.
Returns the addresses which are specified on the Cc
header line (or lines)
A list of Mail::Address objects is returned. Cc
stands for
Carbon Copy; the people addressed on this line receive the message
informational, and are usually not expected to reply on its content.
Method has been removed for reasons of consistency. Use timestamp()
or < $msg->head->get('Date')
>.
Returns a list of Mail::Address objects which contains the combined
info of active To
, Cc
, and Bcc
addresses. Double addresses are
removed if detectable.
Returns the addresses from the senders. It is possible to have more than
one address specified in the From
field of the message, according
to the specification. Therefore a list of Mail::Address objects is
returned, which usually has length 1.
If you need only one address from a sender, for instance to create a "original message by" line in constructed forwarded message body, then use sender().
my @from = $message->from;
Returns the value which is stored in the header field with the specified name. The FIELDNAME is case insensitive. The unfolded body of the field is returned, stripped from any attributes. See Mail::Message::Field::body().
If the field has multiple appearances in the header, only the last instance is returned. If you need more complex handing of fields, then call Mail::Message::Head::get() yourself. See study() when you want to be smart, doing the better (but slower) job.
print $msg->get('Content-Type'), "\n";
Is equivalent to:
print $msg->head->get('Content-Type')->body, "\n";
Return an estimate on the time this message was sent. The data is
derived from the header, where it can be derived from the date
and
received
lines. For MBox-like folders you may get the date from
the from-line as well.
This method may return undef
if the header is not parsed or only
partially known. If you require a time, then use the timestamp()
method, described below.
print "Receipt ", ($message->timestamp || 'unknown'), "\n";
Return (optionally after setting) the HEAD of this message. The head must be an (sub-)class of Mail::Message::Head. When the head is added, status information is taken from it and transformed into labels. More labels can be added by the LABELS hash. They are added later.
my $header = Mail::Message::Head->new; $msg->head($header); # set my $head = $msg->head; # get
Returns the number of lines used for the whole message.
Returns exactly one address, which is the originator of this message.
The returned Mail::Address object is taken from the Sender
header
field, unless that field does not exists, in which case the first
address from the From
field is taken. If none of both provide
an address, undef
is returned.
my $sender = $message->sender; print "Reply to: ", $sender->format, "\n" if defined $sender;
Study the content of a field, like get() does, with as main difference
that a Mail::Message::Field::Full object is returned. These objects
stringify to an utf8 decoded representation of the data contained in
the field, where get() does not decode. When the field does not exist,
then undef
is returned. See Mail::Message::Field::study().
print $msg->study('to'), "\n";
Is equivalent to:
print $msg->head->study('to'), "\n"; # and print $msg->head->get('to')->study, "\n";
or better:
if(my $to = $msg->study('to')) { print "$to\n" } if(my $to = $msg->get('to')) { print $to->study, "\n" }
Get a good timestamp for the message, doesn't matter how much work it is. The value returned is compatible with the platform dependent result of function time().
In these days, the timestamp as supplied by the message (in the Date
field) is not trustable at all: many spammers produce illegal or
unreal dates to influence their location in the displayed folder.
To start, the received headers are tried for a date (see
Mail::Message::Head::Complete::recvstamp()) and only then the Date
field. In very rare cases, only with some locally produced messages,
no stamp can be found.
Returns the addresses which are specified on the To
header line (or lines).
A list of Mail::Address objects is returned. The people addressed
here are the targets of the content, and should read it contents
carefully.
my @to = $message->to;
Return the body of this message. BE WARNED that this returns you an object which may be encoded: use decoded() to get a body with usable data.
With options, a new BODY is set for this message. This is not for normal use unless you understand the consequences: you change the message content without changing the message-ID. The right way to go is via
$message = Mail::Message->buildFromBody($body); # or $message = Mail::Message->build($body); # or $message = $origmsg->forward(body => $body);
The BODY must be an (sub-)class of Mail::Message::Body. In this case, information from the specified body will be copied into the header. The body object will be encoded if needed, because messages written to file or transmitted shall not contain binary data. The converted body is returned.
When BODY is undef
, the current message body will be dissected from
the message. All relation will be cut. The body is returned, and
can be connected to a different message.
my $body = $msg->body; my @encoded = $msg->body->lines; my $new = Mail::Message::Body->new(mime_type => 'text/html'); my $converted = $msg->body($new);
Returns the content type header line, or text/plain
if it is not
defined. The parameters will be stripped off.
Decodes the body of this message, and returns it as a body object. If there was no encoding, the body object as read from file is passed on, however, some more work will be needed when a serious encoding is encountered. The OPTIONS control how the conversion takes place.
Option | Default |
---|---|
charset |
|
result_type | <type of body> |
$message->decoded->print(\*OUT); $message->decoded->print;
Encode the message to a certain format. Read the details in the dedicated manual page Mail::Message::Body::Encode. The OPTIONS which can be specified here are those of the Mail::Message::Body::encode() method.
Check whether this message is a multipart message (has attachments). To find this out, we need at least the header of the message; there is no need to read the body of the message to detect this.
Returns true
for message/rfc822
messages and message parts.
Returns the parts of this message. Usually, the term part is used
with multipart messages: messages which are encapsulated in the body
of a message. To abstract this concept: this method will return you
all header-body combinations which are stored within this message
except the multipart and message/rfc822 wrappers.
Objects returned are Mail::Message
's and Mail::Message::Part's.
The option default to 'ALL', which will return the message itself for single-parts, the nested content of a message/rfc822 object, respectively the parts of a multipart without recursion. In case of 'RECURSE', the parts of multiparts will be collected recursively. This option cannot be combined with the other options, which you may want: it that case you have to test yourself.
'ACTIVE' and 'DELETED' check for the deleted flag on messages and
message parts. The FILTER is a code reference, which is called for
each part of the message; each part as RECURSE
would return.
my @parts = $msg->parts; # $msg not multipart: returns ($msg) my $parts = $msg->parts('ACTIVE'); # returns ($msg) $msg->delete; my @parts = $msg->parts; # returns ($msg) my $parts = $msg->parts('ACTIVE'); # returns ()
Flag the message to be deleted, which is a shortcut for
$msg->label(deleted => time);The real deletion only takes place on a synchronization of the folder. See deleted() as well.
The time stamp of the moment of deletion is stored as value, but that is not always preserved in the folder (depends on the implementation). When the same message is deleted more than once, the first time stamp will stay.
$message->delete; $message->deleted(1); # exactly the same $message->label(deleted => 1); delete $message;
Set the delete flag for this message. Without argument, the method returns the same as isDeleted(), which is prefered. When a true value is given, delete() is called.
$message->deleted(1); # delete $message->delete; # delete (prefered) $message->deleted(0); # undelete if($message->deleted) {...} # check if($message->isDeleted) {...} # check (prefered)
Returns whether this message is flagged as being modified. Modifications are changes in header lines, when a new body is set to the message (dangerous), or when labels change.
Return the value of the LABEL, optionally after setting some values. In case of setting values, you specify key-value PAIRS.
Labels are used to store knowledge about handling of the message within the folder. Flags about whether a message was read, replied to, or scheduled for deletion.
Some labels are taken from the header's Status
and X-Status
lines.
Folder types like MH define a separate label file, and Maildir adds
letters to the message filename. But the MailBox labels are always the
same.
print $message->label('seen'); if($message->label('seen')) {...}; $message->label(seen => 1); $message->label(deleted => 1); # same as $message->delete
Returns all known labels. In SCALAR context, it returns the knowledge
as reference to a hash. This is a reference to the original data, but
you shall *not* change that data directly: call label
for
changes!
In LIST context, you get a list of names which are defined. Be warned that they will not all evaluate to true, although most of them will.
When the labels were changed, that may effect the Status
and/or
X-Status
header lines of mbox messages. Read about the relation
between these fields and the labels in the DETAILS chapter.
The method will carefully only affect the result of modified() when there is a real change of flags, so not for each call to label().
Returns (optionally after setting) whether this message is flagged as being modified. See isModified().
Update the labels according the status lines in the header. See the description in the DETAILS chapter.
Returns the MESSAGE which is the source of this message, which was created by a clone() operation.
Coerce a MESSAGE into a Mail::Message. In some occasions, for instance where you add a message to a folder, this coercion is automatically called to ensure that the correct message type is stored.
The coerced message is returned on success, otherwise undef
. The
coerced message may be a reblessed version of the original message
or a new object. In case the message has to be specialized, for
instance from a general Mail::Message into a Mail::Box::Mbox::Message,
no copy is needed. However, to coerce a Mail::Internet object into
a Mail::Message, a lot of copying and converting will take place.
Valid MESSAGEs which can be coerced into Mail::Message objects are of type
Mail::Message::Part's, which are extensions of Mail::Message
's,
can also be coerced directly from a Mail::Message::Body.
my $folder = Mail::Box::Mbox->new; my $message = Mail::Message->build(...); my $coerced = Mail::Box::Mbox::Message->coerce($message); $folder->addMessage($coerced);
Simpler replacement for the previous two lines:
my $coerced = $folder->addMessage($message);
Check whether the message is delayed (not yet read from file). Returns true or false, dependent on the body type.
Read a body of a message. The PARSER is the access to the folder's file, and the HEAD is already read. Information from the HEAD is used to create expectations about the message's length, but also to determine the mime-type and encodings of the body data.
The BODYTYPE determines which kind of body will be made and defaults to the value specified by new(body_type). BODYTYPE may be the name of a body class, or a reference to a routine which returns the body's class when passed the HEAD as only argument.
Read one message from file. The PARSER is opened on the file. First readHead() is called, and the head is stored in the message. Then readBody() is called, to produce a body. Also the body is added to the message without decodings being done.
The optional BODYTYPE may be a body class or a reference to a code which returns a body-class based on the header.
Read a head into an object of the specified CLASS. The CLASS defaults to new(head_type). The PARSER is the access to the folder's file.
Take the message-id from the STRING, or create one when the undef
is specified. If not STRING nor undef
is given, the current header
of the message is requested for the value of the 'Message-ID'
field.
Angles (if present) are removed from the id.
Convert the message header to a short string (without trailing newline), representing the most important facts (for debugging purposes only). For now, it only reports size and subject.
When a message is to accessible anymore by any user's reference, Perl will call DESTROY for final clean-up. In this case, the head and body are released, and de-registered for the folder. You shall not call this yourself!
Remove the information contained in the message object. This will be
ignored when more than one reference to the same message object exists,
because the method has the same effect as assigning undef
to the
variable which contains the reference. Normal garbage collection will
call DESTROY() when possible.
This method is only provided to hide differences with messages which are located in folders: their Mail::Box::Message::destruct() works quite differently.
my $msg = Mail::Message->read; $msg->destruct; $msg = undef; # same