autodie::exception - phpMan

NAME
    autodie::exception - Exceptions from autodying functions.

SYNOPSIS
        eval {
            use autodie;

            open(my $fh, '<', 'some_file.txt');

            ...
        };

        if (my $E = $@) {
            say "Ooops!  ",$E->caller," had problems: $@";
        }

DESCRIPTION
    When an autodie enabled function fails, it generates an
    "autodie::exception" object. This can be interrogated to determine
    further information about the error that occurred.

    This document is broken into two sections; those methods that are most
    useful to the end-developer, and those methods for anyone wishing to
    subclass or get very familiar with "autodie::exception".

  Common Methods
    These methods are intended to be used in the everyday dealing of
    exceptions.

    The following assume that the error has been copied into a separate
    scalar:

        if ($E = $@) {
            ...
        }

    This is not required, but is recommended in case any code is called
    which may reset or alter $@.

   args
        my $array_ref = $E->args;

    Provides a reference to the arguments passed to the subroutine that
    died.

   function
        my $sub = $E->function;

    The subroutine (including package) that threw the exception.

   file
        my $file = $E->file;

    The file in which the error occurred (eg, "myscript.pl" or "MyTest.pm").

   package
        my $package = $E->package;

    The package from which the exceptional subroutine was called.

   caller
        my $caller = $E->caller;

    The subroutine that *called* the exceptional code.

   line
        my $line = $E->line;

    The line in "$E->file" where the exceptional code was called.

   context
        my $context = $E->context;

    The context in which the subroutine was called by autodie; usually the
    same as the context in which you called the autodying subroutine. This
    can be 'list', 'scalar', or undefined (unknown). It will never be
    'void', as "autodie" always captures the return value in one way or
    another.

    For some core functions that always return a scalar value regardless of
    their context (eg, "chown"), this may be 'scalar', even if you used a
    list context.

   return
        my $return_value = $E->return;

    The value(s) returned by the failed subroutine. When the subroutine was
    called in a list context, this will always be a reference to an array
    containing the results. When the subroutine was called in a scalar
    context, this will be the actual scalar returned.

   errno
        my $errno = $E->errno;

    The value of $! at the time when the exception occurred.

    NOTE: This method will leave the main "autodie::exception" class and
    become part of a role in the future. You should only call "errno" for
    exceptions where $! would reasonably have been set on failure.

   eval_error
        my $old_eval_error = $E->eval_error;

    The contents of $@ immediately after autodie triggered an exception.
    This may be useful when dealing with modules such as Text::Balanced that
    set (but do not throw) $@ on error.

   matches
        if ( $e->matches('open') ) { ... }

        if ( 'open' ~~ $e ) { ... }

    "matches" is used to determine whether a given exception matches a
    particular role.

    An exception is considered to match a string if:

    *   For a string not starting with a colon, the string exactly matches
        the package and subroutine that threw the exception. For example,
        "MyModule::log". If the string does not contain a package name,
        "CORE::" is assumed.

    *   For a string that does start with a colon, if the subroutine
        throwing the exception *does* that behaviour. For example, the
        "CORE::open" subroutine does ":file", ":io" and ":all".

        See "CATEGORIES" in autodie for further information.

        On Perl 5.10 and above, using smart-match ("~~") with an
        "autodie::exception" object will use "matches" underneath. This
        module used to recommend using smart-match with the exception object
        on the left hand side, but in future Perls that is likely to stop
        working. The smart-match facility of this class should only be used
        with the exception object on the right hand side. Having the
        exception object on the right is both future-proof and portable to
        older Perls, back to 5.10. Beware that this facility can only be
        relied upon when it is certain that the exception object actually is
        an "autodie::exception" object; it is no more capable than an
        explicit call to the "matches" method.

  Advanced methods
    The following methods, while usable from anywhere, are primarily
    intended for developers wishing to subclass "autodie::exception", write
    code that registers custom error messages, or otherwise work closely
    with the "autodie::exception" model.

   register
        autodie::exception->register( 'CORE::open' => \&mysub );

    The "register" method allows for the registration of a message handler
    for a given subroutine. The full subroutine name including the package
    should be used.

    Registered message handlers will receive the "autodie::exception" object
    as the first parameter.

   add_file_and_line
        say "Problem occurred",$@->add_file_and_line;

    Returns the string " at %s line %d", where %s is replaced with the
    filename, and %d is replaced with the line number.

    Primarily intended for use by format handlers.

   stringify
        say "The error was: ",$@->stringify;

    Formats the error as a human readable string. Usually there's no reason
    to call this directly, as it is used automatically if an
    "autodie::exception" object is ever used as a string.

    Child classes can override this method to change how they're
    stringified.

   format_default
        my $error_string = $E->format_default;

    This produces the default error string for the given exception, *without
    using any registered message handlers*. It is primarily intended to be
    called from a message handler when they have been passed an exception
    they don't want to format.

    Child classes can override this method to change how default messages
    are formatted.

   new
        my $error = autodie::exception->new(
            args => \@_,
            function => "CORE::open",
            errno => $!,
            context => 'scalar',
            return => undef,
        );

    Creates a new "autodie::exception" object. Normally called directly from
    an autodying function. The "function" argument is required, its the
    function we were trying to call that generated the exception. The "args"
    parameter is optional.

    The "errno" value is optional. In versions of "autodie::exception" 1.99
    and earlier the code would try to automatically use the current value of
    $!, but this was unreliable and is no longer supported.

    Atrributes such as package, file, and caller are determined
    automatically, and cannot be specified.

SEE ALSO
    autodie, autodie::exception::system

LICENSE
    Copyright (C)2008 Paul Fenwick

    This is free software. You may modify and/or redistribute this code
    under the same terms as Perl 5.10 itself, or, at your option, any later
    version of Perl 5.

AUTHOR
    Paul Fenwick <pjf AT perltraining.au>