
=head1 NAME

Mail::Reporter - base-class and error reporter for Mail::Box


=head1 INHERITANCE

 Mail::Reporter is extended by
   Mail::Box
   Mail::Box::Locker
   Mail::Box::MH::Index
   Mail::Box::MH::Labels
   Mail::Box::Manager
   Mail::Box::Parser
   Mail::Box::Search
   Mail::Box::Thread::Manager
   Mail::Box::Thread::Node
   Mail::Message
   Mail::Message::Body
   Mail::Message::Body::Delayed
   Mail::Message::Convert
   Mail::Message::Field
   Mail::Message::Field::AddrGroup
   Mail::Message::Field::Address
   Mail::Message::Head
   Mail::Message::Head::ResentGroup
   Mail::Message::TransferEnc
   Mail::Transport


=head1 SYNOPSIS

 $folder->log(WARNING => 'go away');
 print $folder->trace;        # current level
 $folder->trace('PROGRESS');  # set level
 print $folder->errors;
 print $folder->report('PROGRESS');


=head1 DESCRIPTION

The C<Mail::Reporter> class is the base class for all classes, except
L<Mail::Message::Field::Fast|Mail::Message::Field::Fast> because it would become slow...  This
base class is used during initiation of the objects, and for configuring
and logging error messages.



=head1 METHODS

The C<Mail::Reporter> class is the base for nearly all other
objects.  It can store and report problems, and contains the general
constructor L<new()|"Constructors">.

=head2 Constructors


Mail::Reporter-E<gt>B<new>(OPTIONS)

=over 4

This error container is also the base constructor for all modules, (as long
as there is no need for an other base object)  The constructor always accepts
the following OPTIONS related to error reports.

 Option  Defined in       Default      
 log                      C<'WARNINGS'>
 trace                    C<'WARNINGS'>

. log LEVEL

=over 4

Log messages which have a priority higher or equal to the specified
level are stored internally and can be retrieved later.  The global
default for this option can be changed with L<defaultTrace()|"Error handling">.

Known levels are C<INTERNAL>, C<ERRORS>, C<WARNINGS>, C<PROGRESS>,
C<NOTICES> C<DEBUG>, and C<NONE>.  The C<PROGRESS> level relates to
the reading and writing of folders.  C<NONE> will cause only C<INTERNAL>
errors to be logged.
By the way: C<ERROR> is an alias for C<ERRORS>, as C<WARNING> is an alias
for C<WARNINGS>, and C<NOTICE> for C<NOTICES>.

=back

. trace LEVEL

=over 4

Trace messages which have a level higher or equal to the specified level
are directly printed using warn.  The global default for this option can
be changed with L<defaultTrace()|"Error handling">.

=back

=back

=head2 Error handling


$obj-E<gt>B<AUTOLOAD>

=over 4

By default, produce a nice warning if the sub-classes cannot resolve
a method.

=back

$obj-E<gt>B<defaultTrace>([LEVEL, [LEVEL])

Mail::Reporter-E<gt>B<defaultTrace>([LEVEL, [LEVEL])

=over 4

Reports the default trace and log LEVEL which is used for object as list
of two elements.  When not explicitly set, both are set to C<WARNINGS>.
Two values are returned: the first is the log level, the second represents
the trace level.  Both are special variables: in numeric context they
deliver a value (the internally used value), and in string context the
string name.  Be warned that the string is always singular!

You may specify one or two arguments.  In case of one argument, the
default log and trace levels will both be set to that value.  When two
levels are specified, the first represent the default log-level and
the second the default trace level.

I<Example:> 

 my ($loglevel, $tracelevel) = Mail::Reporter->defaultTrace;
 Mail::Reporter->defaultTrace('NOTICES');

 my ($l, $t) = Mail::Reporter->defaultTrace('WARNINGS', 'DEBUG');
 print $l;     # prints "WARNING"  (no S!)
 print $l+0;   # prints "4"

=back

$obj-E<gt>B<errors>

=over 4

Equivalent to

 $folder->report('ERRORS')

=back

$obj-E<gt>B<log>([LEVEL [,STRINGS]])

Mail::Reporter-E<gt>B<log>([LEVEL [,STRINGS]])

=over 4

As instance method this function has three different purposes.  Without
any argument, it returns one scalar containing the number which is internally
used to represent the current log level, and the textual representation of
the string at the same time. See Scalar::Util method C<dualvar> for
an explanation.

With one argument, a new level of logging detail is set (specify a number
of one of the predefined strings).  With more arguments, it is a report
which may need to be logged or traced.

As class method, only a message can be passed.  The global configuration
value set with L<defaultTrace()|"Error handling"> is used to decide whether the message is
shown or ignored.

Each log-entry has a LEVEL and a text string which will
be constructed by joining the STRINGS.  If there is no newline, it will
be added.

I<Example:> 

 print $message->log;      # may print "NOTICE"
 print $message->log +0;   # may print "3"
 $message->log('ERRORS');  # sets a new level, returns the numeric value

 $message->log(WARNING => "This message is too large.");
 $folder ->log(NOTICE  => "Cannot read from file $filename.");
 $manager->log(DEBUG   => "Hi there!", reverse sort @l);

 Mail::Message->log(ERROR => 'Unknown');

=back

$obj-E<gt>B<logPriority>(LEVEL)

Mail::Reporter-E<gt>B<logPriority>(LEVEL)

=over 4

One error level (log or trace) has more than one representation: a
numeric value and one or more strings.  For instance, C<4>, C<'WARNING'>,
and C<'WARNINGS'> are all the same.  You can specify any of these,
and in return you get a dualvar (see Scalar::Util method C<dualvar>)
back, which contains the number and the singular form.

The higher the number, the more important the message.
Only messages about C<INTERNAL> problems are more important than C<NONE>.

I<Example:> 

 my $r = Mail::Reporter->logPriority('WARNINGS');
 my $r = Mail::Reporter->logPriority('WARNING');    # same
 my $r = Mail::Reporter->logPriority(4);            # same, deprecated
 print $r;      # prints 'WARNING'  (no S!)
 print $r + 0;  # prints 4
 if($r < Mail::Reporter->logPriority('ERROR')) {..} # true

=back

$obj-E<gt>B<logSettings>

=over 4

Returns a list of C<(key => value)> pairs which can be used to initiate
a new object with the same log-settings as this one.

I<Example:> 

 $head->new($folder->logSettings);

=back

$obj-E<gt>B<notImplemented>

=over 4

A special case of L<log()|"Error handling">, which logs a C<INTERNAL>-error
and then croaks.  This is used by extension writers.

=back

$obj-E<gt>B<report>([LEVEL])

=over 4

Get logged reports, as list of strings.  If a LEVEL is specified, the log
for that level is returned.

In case no LEVEL is specified, you get all messages each as reference
to a tuple with level and message.

I<Example:> 

 my @warns = $message->report('WARNINGS');
   # previous indirectly callable with
   my @warns = $msg->warnings;

 print $folder->report('ERRORS');

 if($folder->report('DEBUG')) {...}

 my @reports = $folder->report;
 foreach (@reports) {
    my ($level, $text) = @$_;
    print "$level report: $text";
 }

=back

$obj-E<gt>B<reportAll>([LEVEL])

=over 4

Report all messages which were produced by this object and all the objects
which are maintained by this object.  This will return a list of triplets,
each containing a reference to the object which caught the report, the
level of the report, and the message.

I<Example:> 

 my $folder = Mail::Box::Manager->new->open(folder => 'inbox');
 my @reports = $folder->reportAll;
 foreach (@reports) {
    my ($object, $level, $text) = @$_;

    if($object->isa('Mail::Box')) {
       print "Folder $object: $level: $message";
    } elsif($object->isa('Mail::Message') {
       print "Message ".$object->seqnr.": $level: $message";
    }
 }

=back

$obj-E<gt>B<trace>([LEVEL])

=over 4

Change the trace LEVEL of the object. When no arguments are specified, the
current level is returned only.  It will be returned in one scalar which
contains both the number which is internally used to represent the level,
and the string which represents it.  See L<logPriority()|"Error handling">.

=back

$obj-E<gt>B<warnings>

=over 4

Equivalent to

 $folder->report('WARNINGS')

=back

=head2 Cleanup


$obj-E<gt>B<DESTROY>

=over 4

Cleanup the object.

=back

$obj-E<gt>B<inGlobalDestruction>

=over 4

Returns whether the program is breaking down.  This is used in L<DESTROY()|"Cleanup">,
where during global destructions references cannot be used.

=back



=head1 DIAGNOSTICS

I<Error:> Package $package does not implement $method.

Fatal error: the specific package (or one of its superclasses) does not
implement this method where it should. This message means that some other
related classes do implement this method however the class at hand does
not.  Probably you should investigate this and probably inform the author
of the package.






=head1 REFERENCES

See the Mail::Box website at L<http://perl.overmeer.net/mailbox/> for more details.

=head1 COPYRIGHTS

Module version 2.042.
Written by Mark Overmeer (mark@overmeer.net).  See the ChangeLog for
other contributors.

Copyright (c) 2001-2003 by the author(s). All rights reserved.
This program is free software; you can redistribute it and/or modify it
under the same terms as Perl itself.


