1Mail::Message::Field(3)User Contributed Perl DocumentatioMnail::Message::Field(3)
2
6 Mail::Message::Field - one line of a message header
7
9 Mail::Message::Field
10 is a Mail::Reporter
11 Mail::Message::Field is extended by
13 Mail::Message::Field::Fast
14 Mail::Message::Field::Flex
15 Mail::Message::Field::Full
16
18 my $field = Mail::Message::Field->new(From => 'fish@tux.aq');
19 print $field->name;
20 print $field->body;
21 print $field->comment;
22 print $field->content; # body & comment
23 $field->print(\*OUT);
24 print $field->string;
25 print "$field\n";
26 print $field->attribute('charset') || 'us-ascii';
27
29 This implementation follows the guidelines of rfc2822 as close as
30 possible, and may there produce a different output than implementations
31 based on the obsolete rfc822. However, the old output will still be
32 accepted.
33 These objects each store one header line, and facilitates access
35 routines to the information hidden in it. Also, you may want to have a
36 look at the added methods of a message:
37 my @from = $message->from;
39 my $sender = $message->sender;
40 my $subject = $message->subject;
41 my $msgid = $message->messageId;
42 my @to = $message->to;
44 my @cc = $message->cc;
45 my @bcc = $message->bcc;
46 my @dest = $message->destinations;
47 my $other = $message->get('Reply-To');
49 Extends "DESCRIPTION" in Mail::Reporter.
51
53 overload: ""
54 (stringification) produces the unfolded body of the field, which
55 may be what you expect. This is what makes what the field object
56 seems to be a simple string. The string is produced by
57 unfoldedBody().
58 example:
60 print $msg->get('subject'); # via overloading
62 print $msg->get('subject')->unfoldedBody; # same
63 my $subject = $msg->get('subject') || 'your mail';
65 print "Re: $subject\n";
66 overload: 0+
68 (numification) When the field is numeric, the value will be
69 returned. The result is produced by toInt(). If the value is not
70 correct, a 0 is produced, to simplify calculations.
71 overload: <=>
73 (numeric comparison) Compare the integer field contents with
74 something else.
75 example:
77 if($msg->get('Content-Length') > 10000) ...
79 if($msg->size > 10000) ... ; # same, but better
80 overload: bool
82 Always true, to make it possible to say if($field).
83 overload: cmp
85 (string comparison) Compare the unfolded body of a field with
86 another field or a string, using the buildin "cmp".
87
89 Extends "METHODS" in Mail::Reporter.
90 Constructors
92 Extends "Constructors" in Mail::Reporter.
93 $obj->clone()
95 Create a copy of this field object.
96 Mail::Message::Field->new($data)
98 See Mail::Message::Field::Fast::new(),
99 Mail::Message::Field::Flex::new(), and
100 Mail::Message::Field::Full::new(). By default, a "Fast" field is
101 produced.
102 -Option--Defined in --Default
104 log Mail::Reporter 'WARNINGS'
105 trace Mail::Reporter 'WARNINGS'
106 log => LEVEL
108 trace => LEVEL
109 The field
111 $obj->isStructured()
112 Mail::Message::Field->isStructured()
113 Some fields are described in the RFCs as being structured: having a
114 well described syntax. These fields have common ideas about
115 comments and the like, what they do not share with unstructured
116 fields, like the "Subject" field.
117 example:
119 my $field = Mail::Message::Field->new(From => 'me');
121 if($field->isStructured)
122 Mail::Message::Field->isStructured('From');
124 $obj->length()
126 Returns the total length of the field in characters, which includes
127 the field's name, body and folding characters.
128 $obj->nrLines()
130 Returns the number of lines needed to display this header-line.
131 $obj->print( [$fh] )
133 Print the whole header-line to the specified file-handle. One line
134 may result in more than one printed line, because of the folding of
135 long lines. The $fh defaults to the selected handle.
136 $obj->size()
138 Returns the number of bytes needed to display this header-line,
139 Same as length().
140 $obj->string( [$wrap] )
142 Returns the field as string. By default, this returns the same as
143 folded(). However, the optional $wrap will cause to re-fold to take
144 place (without changing the folding stored inside the field).
145 $obj->toDisclose()
147 Returns whether this field can be disclosed to other people, for
148 instance when sending the message to another party. Returns a
149 "true" or "false" condition. See also
150 Mail::Message::Head::Complete::printUndisclosed().
151 Access to the name
153 $obj->Name()
154 Returns the name of this field in original casing. See name() as
155 well.
156 $obj->name()
158 Returns the name of this field, with all characters lower-cased for
159 ease of comparison. See Name() as well.
160 $obj->wellformedName( [STRING] )
162 (Instance method class method) As instance method, the current
163 field's name is correctly formatted and returned. When a STRING is
164 used, that one is formatted.
165 example:
167 print Mail::Message::Field->Name('content-type')
169 # --> Content-Type
170 my $field = $head->get('date');
172 print $field->Name;
173 # --> Date
174 Access to the body
176 $obj->body()
177 This method may be what you want, but usually, the foldedBody() and
178 unfoldedBody() are what you are looking for. This method is
179 cultural heritage, and should be avoided.
180 Returns the body of the field. When this field is structured, it
182 will be stripped from everything what is behind the first semi-
183 color (";"). In any case, the string is unfolded. Whether the
184 field is structured is defined by isStructured().
185 $obj->folded()
187 Returns the folded version of the whole header. When the header is
188 shorter than the wrap length, a list of one line is returned.
189 Otherwise more lines will be returned, all but the first starting
190 with at least one blank. See also foldedBody() to get the same
191 information without the field's name.
192 In scalar context, the lines are delived into one string, which is
194 a little faster because that's the way they are stored
195 internally...
196 example:
198 my @lines = $field->folded;
200 print $field->folded;
201 print scalar $field->folded; # faster
202 $obj->foldedBody( [$body] )
204 Returns the body as a set of lines. In scalar context, this will be
205 one line containing newlines. Be warned about the newlines when
206 you do pattern matching on the result of this method.
207 The optional $body argument changes the field's body. The folding
209 of the argument must be correct.
210 $obj->stripCFWS( [STRING] )
212 Mail::Message::Field->stripCFWS( [STRING] )
213 Remove the comments and folding white spaces from the STRING.
214 Without string and only as instance method, the unfoldedBody() is
215 being stripped and returned.
216 WARNING: This operation is only allowed for structured header
218 fields (which are defined by the various RFCs as being so. You
219 don't want parts within braces which are in the Subject header line
220 to be removed, to give an example.
221 $obj->unfoldedBody( [$body, [$wrap]] )
223 Returns the body as one single line, where all folding information
224 (if available) is removed. This line will also NOT end on a new-
225 line.
226 The optional $body argument changes the field's body. The right
228 folding is performed before assignment. The $wrap may be specified
229 to enforce a folding size.
230 example:
232 my $body = $field->unfoldedBody;
234 print "$field"; # via overloading
235 Access to the content
237 $obj->addresses()
238 Returns a list of Mail::Address objects, which represent the e-mail
239 addresses found in this header line.
240 example:
242 my @addr = $message->head->get('to')->addresses;
244 my @addr = $message->to;
245 $obj->attribute( $name, [$value] )
247 Get the value of an attribute, optionally after setting it to a new
248 value. Attributes are part of some header lines, and hide
249 themselves in the comment field. If the attribute does not exist,
250 then "undef" is returned. The attribute is still encoded.
251 example:
253 my $field = Mail::Message::Field->new(
255 'Content-Type: text/plain; charset="us-ascii"');
256 print $field->attribute('charset');
258 # --> us-ascii
259 print $field->attribute('bitmap') || 'no'
261 # --> no
262 $field->atrribute(filename => '/tmp/xyz');
264 $field->print;
265 # --> Content-Type: text/plain; charset="us-ascii";
266 # filename="/tmp/xyz"
267 # Automatically folded, and no doubles created.
268 $obj->attributes()
270 Returns a list of key-value pairs, where the values are not yet
271 decoded. Keys may appear more than once.
272 example:
274 my @pairs = $head->get('Content-Disposition')->attributes;
276 $obj->comment( [STRING] )
278 Returns the unfolded comment (part after a semi-colon) in a
279 structureed header-line. optionally after setting it to a new
280 STRING first. When "undef" is specified as STRING, the comment is
281 removed. Whether the field is structured is defined by
282 isStructured().
283 The comment part of a header field often contains "attributes".
285 Often it is preferred to use attribute() on them.
286 $obj->study()
288 Study the header field in detail: turn on the full parsing and
289 detailed understanding of the content of the fields.
290 Mail::Message::Field::Fast and Mail::Message::Field::Fast objects
291 will be transformed into any Mail::Message::Field::Full object.
292 example:
294 my $subject = $msg->head->get('subject')->study;
296 my $subject = $msg->head->study('subject'); # same
297 my $subject = $msg->study('subject'); # same
298 $obj->toDate( [$time] )
300 Mail::Message::Field->toDate( [$time] )
301 Convert a timestamp into an rfc2822 compliant date format. This
302 differs from the default output of "localtime" in scalar context.
303 Without argument, the "localtime" is used to get the current time.
304 $time can be specified as one numeric (like the result of time())
305 and as list (like produced by c<localtime()> in list context).
306 Be sure to have your timezone set right, especially when this
308 script runs automatically.
309 example:
311 my $now = time;
313 Mail::Message::Field->toDate($now);
314 Mail::Message::Field->toDate(time);
315 Mail::Message::Field->toDate(localtime);
317 Mail::Message::Field->toDate; # same
318 # returns something like:
319 # Wed, 28 Aug 2002 10:40:25 +0200
320 $obj->toInt()
322 Returns the value which is related to this field as integer. A
323 check is performed whether this is right.
324 Other methods
326 $obj->dateToTimestamp(STRING)
327 Mail::Message::Field->dateToTimestamp(STRING)
328 Convert a STRING which represents and RFC compliant time string
329 into a timestamp like is produced by the "time" function.
330 Internals
332 $obj->consume( $line | <$name,<$body|$objects>> )
333 Accepts a whole field $line, or a pair with the field's $name and
334 $body. In the latter case, the $body data may be specified as array
335 of $objects which are stringified. Returned is a nicely formatted
336 pair of two strings: the field's name and a folded body.
337 This method is called by new(), and usually not by an application
339 program. The details about converting the $objects to a field
340 content are explained in "Specifying field data".
341 $obj->defaultWrapLength( [$length] )
343 Any field from any header for any message will have this default
344 wrapping. This is maintained in one global variable. Without a
345 specified $length, the current value is returned. The default is
346 78.
347 $obj->fold( $name, $body, [$maxchars] )
349 Mail::Message::Field->fold( $name, $body, [$maxchars] )
350 Make the header field with $name fold into multiple lines.
351 Wrapping is performed by inserting newlines before a blanks in the
352 $body, such that no line exceeds the $maxchars and each line is as
353 long as possible.
354 The RFC requests for folding on nice spots, but this request is
356 mainly ignored because it would make folding too slow.
357 $obj->setWrapLength( [$length] )
359 Force the wrapping of this field to the specified $length
360 characters. The wrapping is performed with fold() and the results
361 stored within the field object.
362 example: refolding the field
364 $field->setWrapLength(99);
366 $obj->stringifyData(STRING|ARRAY|$objects)
368 This method implements the translation of user supplied objects
369 into ascii fields. The process is explained in "Specifying field
370 data".
371 $obj->unfold(STRING)
373 The reverse action of fold(): all lines which form the body of a
374 field are joined into one by removing all line terminators (even
375 the last). Possible leading blanks on the first line are removed
376 as well.
377 Error handling
379 Extends "Error handling" in Mail::Reporter.
380 $obj->AUTOLOAD()
382 Inherited, see "Error handling" in Mail::Reporter
383 $obj->addReport($object)
385 Inherited, see "Error handling" in Mail::Reporter
386 $obj->defaultTrace( [$level]|[$loglevel, $tracelevel]|[$level,
388 $callback] )
389 Mail::Message::Field->defaultTrace( [$level]|[$loglevel,
390 $tracelevel]|[$level, $callback] )
391 Inherited, see "Error handling" in Mail::Reporter
392 $obj->errors()
394 Inherited, see "Error handling" in Mail::Reporter
395 $obj->log( [$level, [$strings]] )
397 Mail::Message::Field->log( [$level, [$strings]] )
398 Inherited, see "Error handling" in Mail::Reporter
399 $obj->logPriority($level)
401 Mail::Message::Field->logPriority($level)
402 Inherited, see "Error handling" in Mail::Reporter
403 $obj->logSettings()
405 Inherited, see "Error handling" in Mail::Reporter
406 $obj->notImplemented()
408 Inherited, see "Error handling" in Mail::Reporter
409 $obj->report( [$level] )
411 Inherited, see "Error handling" in Mail::Reporter
412 $obj->reportAll( [$level] )
414 Inherited, see "Error handling" in Mail::Reporter
415 $obj->trace( [$level] )
417 Inherited, see "Error handling" in Mail::Reporter
418 $obj->warnings()
420 Inherited, see "Error handling" in Mail::Reporter
421 Cleanup
423 Extends "Cleanup" in Mail::Reporter.
424 $obj->DESTROY()
426 Inherited, see "Cleanup" in Mail::Reporter
427
429 Field syntax
430 Fields are stored in the header of a message, which are represented by
431 Mail::Message::Head objects. A field is a combination of a name, body,
432 and attributes. Especially the term "body" is cause for confusion:
433 sometimes the attributes are considered to be part of the body.
434 The name of the field is followed by a colon ("":"", not preceded by
436 blanks, but followed by one blank). Each attribute is preceded by a
437 separate semi-colon ("";""). Names of fields are case-insensitive and
438 cannot contain blanks.
439 . Example: of fields
441 Correct fields:
443 Field: hi!
445 Content-Type: text/html; charset=latin1
446 Incorrect fields, but accepted:
448 Field : wrong, blank before colon
450 Field: # wrong, empty
451 Field:not nice, blank preferred after colon
452 One Two: wrong, blank in name
453 Folding fields
455 Fields which are long can be folded to span more than one line. The
457 real limit for lines in messages is only at 998 characters, however
458 such long lines are not easy to read without support of an application.
459 Therefore rfc2822 (which defines the message syntax) specifies
460 explicitly that field lines can be re-formatted into multiple sorter
461 lines without change of meaning, by adding new-line characters to any
462 field before any blank or tab.
463 Usually, the lines are reformatted to create lines which are 78
465 characters maximum. Some applications try harder to fold on nice spots,
466 like before attributes. Especially the "Received" field is often
467 manually folded into some nice layout. In most cases however, it is
468 preferred to produce lines which are as long as possible but max 78.
469 BE WARNED that all fields can be subjected to folding, and that you
471 usually want the unfolded value.
472 . Example: of field folding
474 Subject: this is a short line, and not folded
476 Subject: this subject field is much longer, and therefore
478 folded into multiple
479 lines, although one more than needed.
480 Structured fields
482 The rfc2822 describes a large number of header fields explicitly.
484 These fields have a defined meaning. For some of the fields, like the
485 "Subject" field, the meaning is straight forward the contents itself.
486 These fields are the Unstructured Fields.
487 Other fields have a well defined internal syntax because their content
489 is needed by e-mail applications. For instance, the "To" field contains
490 addresses which must be understood by all applications in the same way.
491 These are the Structured Fields, see isStructured().
492 Comments in fields
494 Stuctured fields can contain comments, which are pieces of text
496 enclosed in parenthesis. These comments can be placed close to
497 anywhere in the line and must be ignored be the application. Not all
498 applications are capable of handling comments correctly in all
499 circumstances.
500 . Example: of field comments
502 To: mailbox (Mail::Box mailinglist) <mailbox@overmeer.net>
504 Date: Thu, 13 Sep 2001 09:40:48 +0200 (CEST)
505 Subject: goodbye (was: hi!)
506 On the first line, the text "Mail::Box mailinglist" is used as comment.
508 Be warned that rfc2822 explicitly states that comments in e-mail
509 address specifications should not be considered to contain any usable
510 information.
511 On the second line, the timezone is specified as comment. The "Date"
513 field format has no way to indicate the timezone of the sender, but
514 only contains the timezone difference to UTC, however one could decide
515 to add this as comment. Application must ignore this data because the
516 "Date" field is structured.
517 The last field is unstructured. The text between parentheses is an
519 integral part of the subject line.
520 Getting a field
522 As many programs as there are handling e-mail, as many variations on
523 accessing the header information are requested. Be careful which way
524 you access the data: read the variations described here and decide
525 which solution suites your needs best.
526 Using get() field
528 The get() interface is copied from other Perl modules which can handle
530 e-mail messages. Many applications which simply replace Mail::Internet
531 objects by Mail::Message objects will work without modification.
532 There is more than one get method. The exact results depend on which
534 get you use. When Mail::Message::get() is called, you will get the
535 unfolded, stripped from comments, stripped from attributes contents of
536 the field as string. Character-set encodings will still be in the
537 string. If the same fieldname appears more than once in the header,
538 only the last value is returned.
539 When Mail::Message::Head::get() is called in scalar context, the last
541 field with the specified name is returned as field object. This object
542 strinigfies into the unfolded contents of the field, including
543 attributes and comments. In list context, all appearances of the field
544 in the header are returned as objects.
545 BE WARNED that some lines seem unique, but are not according to the
547 official rfc. For instance, "To" fields can appear more than once. If
548 your program calls get('to') in scalar context, some information is
549 lost.
550 . Example: of using get()
552 print $msg->get('subject') || 'no subject';
554 print $msg->head->get('subject') || 'no subject';
555 my @to = $msg->head->get('to');
557 Using study() field
559 As the name "study" already implies, this way of accessing the fields
561 is much more thorough but also slower. The "study" of a field is like
562 a "get", but provides easy access to the content of the field and
563 handles character-set decoding correctly.
564 The Mail::Message::study() method will only return the last field with
566 that name as object. Mail::Message::Head::study() and
567 Mail::Message::Field::study() return all fields when used in list
568 context.
569 . Example: of using study()
571 print $msg->study('subject') || 'no subject';
573 my @rec = $msg->head->study('Received');
574 my $from = $msg->head->get('From')->study;
576 my $from = $msg->head->study('From'); # same
577 my @addr = $from->addresses;
578 Using resent groups
580 Some fields belong together in a group of fields. For instance, a set
582 of lines is used to define one step in the mail transport process.
583 Each step adds a "Received" line, and optionally some "Resent-*" lines
584 and "Return-Path". These groups of lines shall stay together and in
585 order when the message header is processed.
586 The "Mail::Message::Head::ResentGroup" object simplifies the access to
588 these related fields. These resent groups can be deleted as a whole,
589 or correctly constructed.
590 . Example: of using resent groups
592 my $rgs = $msg->head->resentGroups;
594 $rgs[0]->delete if @rgs;
595 $msg->head->removeResentGroups;
597 The field's data
599 There are many ways to get the fields info as object, and there are
600 also many ways to process this data within the field.
601 Access to the field
603 • string()
605 Returns the text of the body exactly as will be printed to file
607 when print() is called, so name, main body, and attributes.
608 • foldedBody()
610 Returns the text of the body, like string(), but without the name
612 of the field.
613 • unfoldedBody()
615 Returns the text of the body, like foldedBody(), but then with all
617 new-lines removed. This is the normal way to get the content of
618 unstructured fields. Character-set encodings will still be in
619 place. Fields are stringified into their unfolded representation.
620 • stripCFWS()
622 Returns the text of structured fields, where new-lines and comments
624 are removed from the string. This is a good start for parsing the
625 field, for instance to find e-mail addresses in them.
626 • Mail::Message::Field::Full::decodedBody()
628 Studied fields can produce the unfolded text decoded into utf8
630 strings. This is an expensive process, but the only correct way to
631 get the field's data. More useful for people who are not living in
632 ASCII space.
633 • Studied fields
635 Studied fields have powerful methods to provide ways to access and
637 produce the contents of (structured) fields exactly as the involved
638 rfcs prescribe.
639 Using simplified field access
641 Some fields are accessed that often that there are support methods to
643 provide simplified access. All these methods are called upon a message
644 directly.
645 . Example: of simplified field access
647 print $message->subject;
649 print $message->get('subject') || ''; # same
650 my @from = $message->from; # returns addresses
652 $message->reply->send if $message->sender;
653 The "sender" method will return the address specified in the "Sender"
655 field, or the first named in the "From" field. It will return "undef"
656 in case no address is known.
657 Specifying field data
659 Field data can be anything, strongly dependent on the type of field at
661 hand. If you decide to construct the fields very carefully via some
662 Mail::Message::Field::Full extension (like via
663 Mail::Message::Field::Addresses objects), then you will have protection
664 build-in. However, you can bluntly create any Mail::Message::Field
665 object based on some data.
666 When you create a field, you may specify a string, object, or an array
668 of strings and objects. On the moment, objects are only used to help
669 the construction on e-mail addresses, however you may add some of your
670 own.
671 The following rules (implemented in stringifyData()) are obeyed given
673 the argument is:
674 • a string
676 The string must be following the (complicated) rules of the
678 rfc2822, and is made field content as specified. When the string
679 is not terminated by a new-line ("\n") it will be folded according
680 to the standard rules.
681 • a Mail::Address object
683 The most used Perl object to parse and produce address lines. This
685 object does not understand character set encodings in phrases.
686 • a Mail::Identity object
688 As part of the User::Identity distribution, this object has full
690 understanding of the meaning of one e-mail address, related to a
691 person. All features defined by rfc2822 are implemented.
692 • a User::Identity object
694 A person is specified, which may have more than one
696 Mail::Identity's defined. Some methods, like
697 Mail::Message::reply() and Mail::Message::forward() try to select
698 the right e-mail address smart (see their method descriptions), but
699 in other cases the first e-mail address found is used.
700 • a User::Identity::Collection::Emails object
702 All Mail::Identity objects in the collection will be included in
704 the field as a group carying the name of the collection.
705 • any other object
707 For all other objects, the stringification overload is used to
709 produce the field content.
710 • an ARRAY
712 You may also specify an array with a mixture of any of the above.
714 The elements will be joined as comma-separated list. If you do not
715 want comma's inbetween, you will have to process the array
716 yourself.
717 . Example: specifying simple field data
719 my $f = Mail::Message::Field->new(Subject => 'hi!');
721 my $b = Mail::Message->build(Subject => 'monkey');
722 . Example: s specifying e-mail addresses for a field
724 use Mail::Address;
726 my $fish = Mail::Address->new('Mail::Box', 'fish@tux.aq');
727 print $fish->format; # ==> Mail::Box <fish@tux.aq>
728 my $exa = Mail::Address->new(undef, 'me@example.com');
729 print $exa->format; # ==> me@example.com
730 my $b = $msg->build(To => "you@example.com");
732 my $b = $msg->build(To => $fish);
733 my $b = $msg->build(To => [ $fish, $exa ]);
734 my @all = ($fish, "you@example.com", $exa);
736 my $b = $msg->build(To => \@all);
737 my $b = $msg->build(To => [ "xyz", @all ]);
738 . Example: specifying identities for a field
740 use User::Identity;
742 my $patrik = User::Identity->new
743 ( name => 'patrik'
744 , full_name => "Patrik Fältström" # from rfc
745 , charset => "ISO-8859-1"
746 );
747 $patrik->add
748 ( email => "him@home.net"
749 );
750 my $b = $msg->build(To => $patrik);
752 $b->get('To')->print;
754 # ==> =?ISO-8859-1?Q?Patrik_F=E4ltstr=F6m?=
755 # <him@home.net>
756 Field class implementation
758 For performance reasons only, there are three types of fields: the
759 fast, the flexible, and the full understander:
760 • Mail::Message::Field::Fast
762 "Fast" objects are not derived from a "Mail::Reporter". The
764 consideration is that fields are so often created, and such a small
765 objects at the same time, that setting-up a logging for each of the
766 objects is relatively expensive and not really useful. The fast
767 field implementation uses an array to store the data: that will be
768 faster than using a hash. Fast fields are not easily inheritable,
769 because the object creation and initiation is merged into one
770 method.
771 • Mail::Message::Field::Flex
773 The flexible implementation uses a hash to store the data. The
775 new() and "init" methods are split, so this object is extensible.
776 • Mail::Message::Field::Full
778 With a full implementation of all applicable RFCs (about 5), the
780 best understanding of the fields is reached. However, this comes
781 with a serious memory and performance penalty. These objects are
782 created from fast or flex header fields when study() is called.
783
785 Warning: Field content is not numerical: $content
786 The numeric value of a field is requested (for instance the "Lines"
787 or "Content-Length" fields should be numerical), however the data
788 contains weird characters.
789 Warning: Illegal character in field name $name
791 A new field is being created which does contain characters not
792 permitted by the RFCs. Using this field in messages may break
793 other e-mail clients or transfer agents, and therefore mutulate or
794 extinguish your message.
795 Error: Package $package does not implement $method.
797 Fatal error: the specific package (or one of its superclasses) does
798 not implement this method where it should. This message means that
799 some other related classes do implement this method however the
800 class at hand does not. Probably you should investigate this and
801 probably inform the author of the package.
802
804 This module is part of Mail-Message distribution version 3.013, built
805 on June 24, 2023. Website: http://perl.overmeer.net/CPAN/
806
808 Copyrights 2001-2023 by [Mark Overmeer <markov@cpan.org>]. For other
809 contributors see ChangeLog.
810 This program is free software; you can redistribute it and/or modify it
812 under the same terms as Perl itself. See http://dev.perl.org/licenses/
813perl v5.38.0 2023-07-20 Mail::Message::Field(3)