Mail::Message::Body(3pm)

1Mail::Message::Body(3)User Contributed Perl DocumentationMail::Message::Body(3)
2
3
4

NAME

6       Mail::Message::Body - the data of a body in a message
7

INHERITANCE

9        Mail::Message::Body has extra code in
10          Mail::Message::Body::Construct
11          Mail::Message::Body::Encode
12
13        Mail::Message::Body
14          is a Mail::Reporter
15
16        Mail::Message::Body is extended by
17          Mail::Message::Body::File
18          Mail::Message::Body::Lines
19          Mail::Message::Body::Multipart
20          Mail::Message::Body::Nested
21          Mail::Message::Body::String
22
23        Mail::Message::Body is realized by
24          Mail::Message::Body::Delayed
25

SYNOPSIS

27        my Mail::Message $msg = ...;
28        my $body  = $msg->body;
29        my @text  = $body->lines;
30        my $text  = $body->string;
31        my IO::Handle $file = $body->file;
32        $body->print(\*FILE);
33
34        my $content_type = $body->type;
35        my $transfer_encoding = $body->transferEncoding;
36        my $encoded  = $body->encode(mime_type => 'text/html',
37           charset => 'us-ascii', transfer_encoding => 'none');\n";
38        my $decoded  = $body->decoded;
39

DESCRIPTION

41       The encoding and decoding functionality of a Mail::Message::Body is
42       implemented in the Mail::Message::Body::Encode package.  That package
43       is automatically loaded when encoding and decoding of messages needs to
44       take place.  Methods to simply build an process body objects are imple‐
45       mented in Mail::Message::Body::Construct.
46
47       The body of a message (a Mail::Message object) is stored in one of the
48       many body types.  The functionality of each body type is equivalent,
49       but there are performance differences.  Each body type has its own doc‐
50       umentation with details about its implementation.
51

OVERLOADED

53       overload: ""
54
55           (stringification) Returns the body as string --which will trigger
56           completion-- unless called to produce a string for "Carp".  The
57           latter to avoid deep recursions.
58
59           Example: stringification of body
60
61            print $msg->body;   # implicit by print
62
63            my $body = $msg->body;
64            my $x    = "$body"; # explicit by interpolation
65
66       overload: '==' and '!='
67
68           (numeric comparison) compares if two references point to the same
69           message.  This only produces correct results is both arguments are
70           message references within the same folder.
71
72           Example: use of numeric comparison on a body
73
74            my $skip = $folder->message(3);
75            foreach my $msg (@$folder)
76            {   next if $msg == $skip;
77                $msg->send;
78            }
79
80       overload: @{}
81
82           When a body object is used as being an array reference, the lines
83           of the body are returned.  This is the same as using lines().
84
85           Example: using a body as array
86
87            print $body->lines->[1];  # second line
88            print $body->[1];         # same
89
90            my @lines = $body->lines;
91            my @lines = @$body;       # same
92
93       overload: bool
94
95           Always returns a true value, which is needed to have overloaded
96           objects to be used as in "if($body)".  Otherwise, "if(defined
97           $body)" would be needed to avoid a runtime error.
98

METHODS

100       Constructors
101
102       $obj->clone
103
104           Return a copy of this body, usually to be included in a cloned mes‐
105           sage. Use Mail::Message::clone() for a whole message.
106
107       Mail::Message::Body->new(OPTIONS)
108
109           BE WARNED that, what you specify here are encodings and such which
110           are already in place.  The options will not trigger conversions.
111           When you need conversions, first create a body with options which
112           tell what you've got, and then call encode() for what you need.
113
114            Option           --Defined in     --Default
115            based_on                            undef
116            charset                             'us-ascii'
117            checked                             <false>
118            data                                undef
119            description                         undef
120            disposition                         undef
121            eol                                 'NATIVE'
122            file                                undef
123            log                Mail::Reporter   'WARNINGS'
124            message                             undef
125            mime_type                           'text/plain'
126            modified                            <false>
127            trace              Mail::Reporter   'WARNINGS'
128            transfer_encoding                   'none'
129
130           . based_on BODY
131
132               The information about encodings must be taken from the speci‐
133               fied BODY, unless specified differently.
134
135           . charset STRING
136
137               Defines the character-set which is used in the data.  Only use‐
138               ful in combination with a "mime_type" which refers to "text" in
139               any shape.  This field is case-insensitive.
140
141           . checked BOOLEAN
142
143               Whether the added information has been check not to contain
144               illegal octets with respect to the transfer encoding and mime
145               type.  If not checked, and then set as body for a message, it
146               will be.
147
148           . data ARRAY-OF-LINES ⎪ STRING
149
150               The content of the body.  The only way to set the content of a
151               body is during the creation of the body.  So if you want to
152               modify the content of a message, you need to create a new body
153               with the new content and add that to the body.  The reason
154               behind this, is that correct encodings and body information
155               must be guaranteed.  It avoids your hassle in calculating the
156               number of lines in the body, and checking whether bad charac‐
157               ters are enclosed in text.
158
159               Specify a reference to an ARRAY of lines, each terminated by a
160               newline.  Or one STRING which may contain multiple lines, sepa‐
161               rated and terminated by a newline.
162
163           . description STRING⎪FIELD
164
165               Informal information about the body content.  The data relates
166               to the "Content-Description" field.  Specify a STRING which
167               will become the field content, or a real FIELD.
168
169           . disposition STRING⎪FIELD
170
171               How this message can be decomposed.  The data relates to the
172               "Content-Disposition" field.  Specify a STRING which will
173               become the field content, or a real FIELD.
174
175               The content of this field is specified in RFC 1806.  The body
176               of the field can be "inline", to indicate that the body is
177               intended to be displayed automatically upon display of the mes‐
178               sage. Use "attachment" to indicate that they are separate from
179               the main body of the mail message, and that their display
180               should not be automatic, but contingent upon some further
181               action of the user.
182
183               The "filename" attribute specifies a name to which is suggested
184               to the reader of the message when it is extracted.
185
186           . eol 'CR'⎪'LF'⎪'CRLF'⎪'NATIVE'
187
188               Convert the message into having the specified string as line
189               terminator for all lines in the body.  "NATIVE" is used to rep‐
190               resent the "\n" on the current platform and will be translated
191               in the applicable one.
192
193               BE WARNED that folders with a non-native encoding may appear on
194               your platform, for instance in Windows folders handled from a
195               UNIX system.  The eol encoding has effect on the size of the
196               body!
197
198           . file FILENAME⎪FILEHANDLE⎪IOHANDLE
199
200               Read the data from the specified file, file handle, or object
201               of type "IO::Handle".
202
203           . log LEVEL
204
205           . message MESSAGE
206
207               The message where this body belongs to.
208
209           . mime_type STRING⎪FIELD⎪MIME
210
211               The type of data which is added.  You may specify a content of
212               a header line as STRING, or a FIELD object.  You may also spec‐
213               ify a MIME::Type object.  In any case, it will be kept inter‐
214               nally as a real field (a Mail::Message::Field object).  This
215               relates to the "Content-Type" header field.
216
217               A mime-type specification consists of two parts: a general
218               class ("text", "image", "application", etc) and a specific
219               sub-class.  Examples for specific classes with "text" are
220               "plain", "html", and "xml".  This field is case-insensitive but
221               case preserving.  The default mime-type is "text/plain",
222
223           . modified BOOLEAN
224
225               Whether the body is flagged modified, directly from its cre‐
226               ation.
227
228           . trace LEVEL
229
230           . transfer_encoding STRING⎪FIELD
231
232               The encoding that the data has.  If the data is to be encoded,
233               than you will have to call encode() after the body is created.
234               That will return a new encoded body.  This field is case-insen‐
235               sitive and relates to the "Content-Transfer-Encoding" field in
236               the header.
237
238           Example:
239
240            my $body = Mail::Message::Body::String->new(file => \*IN,
241               mime_type => 'text/html; charset="ISO-8859-1"');
242
243            my $body = Mail::Message::Body::Lines->new(data => ['first', $second],
244               charset => 'ISO-10646', transfer_encoding => 'none');
245
246            my $body = Mail::Message::Body::Lines->new(data => \@lines,
247               transfer_encoding => 'base64');
248
249            my $body = Mail::Message::Body::Lines->new(file => 'picture.gif',
250               mime_type => 'image/gif');
251
252       Constructing a body
253
254       $obj->attach(MESSAGES, OPTIONS)
255
256           See "Constructing a body" in Mail::Message::Body::Construct
257
258       $obj->check
259
260           See "Constructing a body" in Mail::Message::Body::Encode
261
262       $obj->concatenate(COMPONENTS)
263
264           See "Constructing a body" in Mail::Message::Body::Construct
265
266       $obj->decoded(OPTIONS)
267
268           Returns a body, an object which is (a sub-)class of a Mail::Mes‐
269           sage::Body, which contains a simplified representation of textual
270           data.  The returned object may be the object where this is called
271           on, but may also be a new body of any type.
272
273            my $dec = $body->decoded;
274
275           is equivalent with
276
277            my $dec = $body->encode(mime_type => 'text/plain', charset => 'us-ascii',
278               transfer_encoding => 'none');
279
280           The $dec which is returned is a body.  Ask with the mimeType()
281           method what is produced.  This $dec body is not related to a
282           header.
283
284            Option     --Default
285            result_type  <same as current>
286
287           . result_type CLASS
288
289       $obj->encode(OPTIONS)
290
291           See "Constructing a body" in Mail::Message::Body::Encode
292
293       $obj->encoded
294
295           See "Constructing a body" in Mail::Message::Body::Encode
296
297       $obj->eol(['CR'⎪'LF'⎪'CRLF'⎪'NATIVE'])
298
299           Returns the character (or characters) which are used to separate
300           lines within this body.  When a kind of separator is specified, the
301           body is translated to contain the specified line endings.
302
303       $obj->foreachLine(CODE)
304
305           See "Constructing a body" in Mail::Message::Body::Construct
306
307       $obj->stripSignature(OPTIONS)
308
309           See "Constructing a body" in Mail::Message::Body::Construct
310
311       $obj->unify(BODY)
312
313           See "Constructing a body" in Mail::Message::Body::Encode
314
315       The body
316
317       $obj->isDelayed
318
319           Returns a true or false value, depending on whether the body of
320           this message has been read from file.  This can only false for a
321           Mail::Message::Body::Delayed.
322
323       $obj->isMultipart
324
325           Returns whether this message-body contains parts which are messages
326           by themselves.
327
328       $obj->isNested
329
330           Only true for a message body which contains exactly one sub-mes‐
331           sage: the "Mail::Message::Body::Nested" body type.
332
333       $obj->message([MESSAGE])
334
335           Returns the message where this body belongs to, optionally setting
336           it to a new MESSAGE first.  If "undef" is passed, the body will be
337           disconnected from the message.
338
339       About the payload
340
341       $obj->charset
342
343           Returns the character set which is used in the text body as string.
344           This is part of the result of what the "type" method returns.
345
346       $obj->checked([BOOLEAN])
347
348           Returns whether the body encoding has been checked or not (option‐
349           ally after setting the flag to a new value).
350
351       $obj->description([STRING⎪FIELD])
352
353           Returns (optionally after setting) the informal description of the
354           body content.  The related header field is "Content-Description".
355           A Mail::Message::Field object is returned (which stringifies into
356           the field content).  The field content will be "none" if no dispo‐
357           sition was specified.
358
359           The argument can be a STRING (which is converted into a field), or
360           a fully prepared header field.
361
362       $obj->disposition([STRING⎪FIELD])
363
364           Returns (optionally after setting) how the message can be disposed
365           (unpacked).  The related header field is "Content-Disposition".  A
366           Mail::Message::Field object is returned (which stringifies into the
367           field content).  The field content will be "none" if no disposition
368           was specified.
369
370           The argument can be a STRING (which is converted into a field), or
371           a fully prepared header field.
372
373       $obj->dispositionFilename([DIRECTORY])
374
375           See "About the payload" in Mail::Message::Body::Encode
376
377       $obj->isBinary
378
379           See "About the payload" in Mail::Message::Body::Encode
380
381       $obj->isText
382
383           See "About the payload" in Mail::Message::Body::Encode
384
385       $obj->mimeType
386
387           Returns a MIME::Type object which is related to this body's type.
388           This differs from the "type" method, which results in a Mail::Mes‐
389           sage::Field.
390
391           Example:
392
393            if($body->mimeType eq 'text/html') {...}
394            print $body->mimeType->simplified;
395
396       $obj->nrLines
397
398           Returns the number of lines in the message body.  For multi-part
399           messages, this includes the header lines and boundaries of all the
400           parts.
401
402       $obj->size
403
404           The total number of bytes in the message body. The size of the body
405           is computed in the shape it is in. For example, if this is a base64
406           encoded message, the size of the encoded data is returned; you may
407           want to call Mail::Message::decoded() first.
408
409       $obj->transferEncoding([STRING⎪FIELD])
410
411           Returns the transfer-encoding of the data within this body as
412           Mail::Message::Field (which stringifies to its content).  If it
413           needs to be changed, call the encode() or decoded() method.  When
414           no encoding is present, the field contains the text "none".
415
416           The optional STRING or FIELD enforces a new encoding to be set,
417           without the actual required translations.
418
419           Example:
420
421            my $transfer = $msg->decoded->transferEncoding;
422            $transfer->print;   # --> Content-Encoding: base64
423            print $transfer;    # --> base64
424
425            if($msg->body->transferEncoding eq 'none') {...}
426
427       $obj->type([STRING⎪FIELD])
428
429           Returns the type of information the body contains as Mail::Mes‐
430           sage::Field object.  The type is taken from the header field "Con‐
431           tent-Type". If the header did not contain that field, then you will
432           get a default field containing "text/plain".
433
434           You usually can better use mimeType(), because that will return a
435           clever object with type information.
436
437           Example:
438
439            my $msg     = $folder->message(6);
440            $msg->get('Content-Type')->print;
441               # --> Content-Type: text/plain; charset="us-ascii"
442
443            my $content = $msg->decoded;
444            my $type    = $content->type;
445
446            print "This is a $type message\n";
447               # --> This is a text/plain; charset="us-ascii" message
448
449            print "This is a ", $type->body, "message\n";
450               # --> This is a text/plain message
451
452            print "Comment: ", $type->comment, "\n";
453               # --> Comment: charset="us-ascii"
454
455       Access to the payload
456
457       $obj->endsOnNewline
458
459           Returns whether the last line of the body is terminated by a new-
460           line (in transport it will become a CRLF).  An empty body will
461           return true as well: the newline comes from the line before it.
462
463       $obj->file
464
465           Return the content of the body as a file handle.  The returned
466           stream may be a real file, or a simulated file in any form that
467           Perl supports.  While you may not be able to write to the file han‐
468           dle, you can read from it.
469
470           WARNING: Even if the file handle supports writing, do not write to
471           the file handle. If you do, some of the internal values of the
472           Mail::Message::Body may not be updated.
473
474       $obj->lines
475
476           Return the content of the body as a list of lines (in LIST context)
477           or a reference to an array of lines (in SCALAR context).  In scalar
478           context the array of lines is cached to avoid needless copying and
479           therefore provide much faster access for large messages.
480
481           To just get the number of lines in the body, use the nrLines()
482           method, which is usually much more efficient.
483
484           BE WARNED: For some types of bodies the reference will refer to the
485           original data. You must not change the referenced data! If you do,
486           some of the essential internal variables of the Mail::Message::Body
487           may not be updated.
488
489           Example:
490
491            my @lines    = $body->lines;     # copies lines
492            my $line3    = ($body->lines)[3] # only one copy
493            print $lines[0];
494
495            my $linesref = $body->lines;     # reference to originals
496            my $line3    = $body->lines->[3] # only one copy (faster)
497            print $linesref->[0];
498
499            print $body->[0];                # by overloading
500
501       $obj->print([FILEHANDLE])
502
503           Print the body to the specified FILEHANDLE (defaults to the
504           selected handle).  The handle may be a GLOB, an IO::File object,
505           or... any object with a "print()" method will do.  Nothing useful
506           is returned.
507
508       $obj->printEscapedFrom(FILEHANDLE)
509
510           Print the body to the specified FILEHANDLE but all lines which
511           start with 'From ' (optionally already preceded by >'s) will habe
512           an > added in front.  Nothing useful is returned.
513
514       $obj->string
515
516           Return the content of the body as a scalar (a single string).  This
517           is a copy of the internally kept information.
518
519           Example:
520
521            my $text = $body->string;
522            print "Body: $body\n";     # by overloading
523
524       $obj->stripTrailingNewline
525
526           Remove the newline from the last line, or the last line if it does
527           not contain anything else than a newline.
528
529       $obj->write(OPTIONS)
530
531           Write the content of the body to a file.  Be warned that you may
532           want to decode the body before writing it!
533
534            Option  --Default
535            filename  <required>
536
537           . filename FILENAME
538
539           Example: write the data to a file
540
541            use File::Temp;
542            my $fn = tempfile;
543            $message->decoded->write(filename => $fn)
544               or die "Couldn't write to $fn: $!\n";
545
546           Example: using the content-disposition information to write
547
548            use File::Temp;
549            my $dir = tempdir; mkdir $dir or die;
550            my $fn  = $message->body->dispositionFilename($dir);
551            $message->decoded->write(filename => $fn)
552               or die "Couldn't write to $fn: $!\n";
553
554       Internals
555
556       $obj->addTransferEncHandler(NAME, CLASS⎪OBJECT)
557
558       Mail::Message::Body->addTransferEncHandler(NAME, CLASS⎪OBJECT)
559
560           See "Internals" in Mail::Message::Body::Encode
561
562       $obj->contentInfoFrom(HEAD)
563
564           Transfer the body related info from the header into this body.
565
566       $obj->contentInfoTo(HEAD)
567
568           Copy the content information (the "Content-*" fields) into the
569           specified HEAD.  The body was created from raw data without the
570           required information, which must be added.  See also contentIn‐
571           foFrom().
572
573       $obj->fileLocation([BEGIN,END])
574
575           The location of the body in the file.  Returned a list containing
576           begin and end.  The begin is the offsets of the first byte if the
577           folder used for this body.  The end is the offset of the first byte
578           of the next message.
579
580       $obj->getTransferEncHandler(TYPE)
581
582           See "Internals" in Mail::Message::Body::Encode
583
584       $obj->isModified
585
586           Returns whether the body has changed.
587
588       $obj->load
589
590           Be sure that the body is loaded.  This returns the loaded body.
591
592       $obj->modified([BOOLEAN])
593
594           Change the body modification flag.  This will force a re-write of
595           the body to a folder file when it is closed.  It is quite dangerous
596           to change the body: the same body may be shared between messages
597           within your program.
598
599           Especially be warned that you have to change the message-id when
600           you change the body of the message: no two messages should have the
601           same id.
602
603           Without value, the current setting is returned, although you can
604           better use isModified().
605
606       $obj->moveLocation([DISTANCE])
607
608           Move the registration of the message to a new location over DIS‐
609           TANCE.  This is called when the message is written to a new version
610           of the same folder-file.
611
612       $obj->read(PARSER, HEAD, BODYTYPE [,CHARS [,LINES]])
613
614           Read the body with the PARSER from file. The implementation of this
615           method will differ between types of bodies.  The BODYTYPE argument
616           is a class name or a code reference of a routine which can produce
617           a class name, and is used in multipart bodies to determine the type
618           of the body for each part.
619
620           The CHARS argument is the estimated number of bytes in the body, or
621           "undef" when this is not known.  This data can sometimes be derived
622           from the header (the "Content-Length" line) or file-size.
623
624           The second argument is the estimated number of LINES of the body.
625           It is less useful than the CHARS but may be of help determining
626           whether the message separator is trustworthy.  This value may be
627           found in the "Lines" field of the header.
628
629       Error handling
630
631       $obj->AUTOLOAD
632
633           When an unknown method is called on a message body object, this may
634           not be problematic.  For performance reasons, some methods are
635           implemented in separate files, and only demand-loaded.  If this
636           delayed compilation of additional modules does not help, an error
637           will be produced.
638
639       $obj->addReport(OBJECT)
640
641           See "Error handling" in Mail::Reporter
642
643       $obj->defaultTrace([LEVEL]⎪[LOGLEVEL, TRACELEVEL]⎪[LEVEL, CALLBACK])
644
645       Mail::Message::Body->defaultTrace([LEVEL]⎪[LOGLEVEL,
646       TRACELEVEL]⎪[LEVEL, CALLBACK])
647
648           See "Error handling" in Mail::Reporter
649
650       $obj->errors
651
652           See "Error handling" in Mail::Reporter
653
654       $obj->log([LEVEL [,STRINGS]])
655
656       Mail::Message::Body->log([LEVEL [,STRINGS]])
657
658           See "Error handling" in Mail::Reporter
659
660       $obj->logPriority(LEVEL)
661
662       Mail::Message::Body->logPriority(LEVEL)
663
664           See "Error handling" in Mail::Reporter
665
666       $obj->logSettings
667
668           See "Error handling" in Mail::Reporter
669
670       $obj->notImplemented
671
672           See "Error handling" in Mail::Reporter
673
674       $obj->report([LEVEL])
675
676           See "Error handling" in Mail::Reporter
677
678       $obj->reportAll([LEVEL])
679
680           See "Error handling" in Mail::Reporter
681
682       $obj->trace([LEVEL])
683
684           See "Error handling" in Mail::Reporter
685
686       $obj->warnings
687
688           See "Error handling" in Mail::Reporter
689
690       Cleanup
691
692       $obj->DESTROY
693
694           See "Cleanup" in Mail::Reporter
695
696       $obj->inGlobalDestruction
697
698           See "Cleanup" in Mail::Reporter
699

DETAILS

701       Access to the body
702
703       A body can be contained in a message, but may also live without a mes‐
704       sage.  In both cases it stores data, and the same questions can be
705       asked: what type of data it is, how many bytes and lines, what encoding
706       is used.  Any body can be encoded and decoded, returning a new body
707       object.  However, bodies which are part of a message will always be in
708       a shape that they can be written to a file or send to somewhere: they
709       will be encoded if needed.
710
711       Example:
712
713        my $body    = Mail::Message::Body::String->new(mime_type => 'image/gif');
714        $body->print(\*OUT);    # this is binary image data...
715
716        my $encoded = $message->body($body);
717        $encoded->print(\*OUT); # ascii data, encoded image
718
719       Now encoded refers to the body of the $message which is the content of
720       $body in a shape that it can be transmitted.  Usually "base64" encoding
721       is used.
722
723       Body class implementation
724
725       The body of a message can be stored in many ways.  Roughtly, the imple‐
726       mentations can be split in two groups: the data collectors and the com‐
727       plex bodies.  The primer implement various ways to access data, and are
728       full compatible: they only differ in performance and memory footprint
729       under different circumstances.  The latter are created to handle com‐
730       plex multiparts and lazy extraction.
731
732       Data collector bodies
733
734       * Mail::Message::Body::String
735           The whole message body is stored in one scalar.  Small messages can
736           be contained this way without performance penalties.
737
738       * Mail::Message::Body::Lines
739           Each line of the message body is stored as single scalar.  This is
740           a useful representation for a detailed look in the message body,
741           which is usually line-organized.
742
743       * Mail::Message::Body::File
744           The message body is stored in an external temporary file.  This
745           type of storage is especially useful when the body is large, the
746           total folder is large, or memory is limited.
747
748       * Mail::Message::Body::InFolder
749           NOT IMPLEMENTED YET.  The message is kept in the folder, and is
750           only taken out when the content is changed.
751
752       * Mail::Message::Body::External
753           NOT IMPLEMENTED YET.  The message is kept in a separate file, usu‐
754           ally because the message body is large.  The difference with the
755           "::External" object is that this external storage stays this way
756           between closing and opening of a folder. The "::External" object
757           only uses a file when the folder is open.
758
759       Complex bodies
760
761       * Mail::Message::Body::Delayed
762           The message-body is not yet read, but the exact location of the
763           body is known so the message can be read when needed.  This is part
764           of the lazy extraction mechanism.  Once extracted, the object can
765           become any simple or complex body.
766
767       * Mail::Message::Body::Multipart
768           The message body contains a set of sub-messages (which can contain
769           multipart bodies themselves).  Each sub-message is an instance of
770           Mail::Message::Part, which is an extension of Mail::Message.
771
772       * Mail::Message::Body::Nested
773           Nested messages, like "message/rfc822": they contain a message in
774           the body.  For most code, they simply behave like multiparts.
775

DIAGNOSTICS

777       Warning: No decoder defined for transfer encoding $name.
778
779       The data (message body) is encoded in a way which is not currently
780       understood, therefore no decoding (or recoding) can take place.
781
782       Warning: No encoder defined for transfer encoding $name.
783
784       The data (message body) has been decoded, but the required encoding is
785       unknown.  The decoded data is returned.
786
787       Error: Package $package does not implement $method.
788
789       Fatal error: the specific package (or one of its superclasses) does not
790       implement this method where it should. This message means that some
791       other related classes do implement this method however the class at
792       hand does not.  Probably you should investigate this and probably
793       inform the author of the package.
794

LICENSE

800       Copyrights 2001-2007 by Mark Overmeer.For other contributors see
801       ChangeLog.
802
803       This program is free software; you can redistribute it and/or modify it
804       under the same terms as Perl itself.  See
805       http://www.perl.com/perl/misc/Artistic.html
806
807
808
809perl v5.8.8                       2007-03-25            Mail::Message::Body(3)