Catalyst::ActionChain(3)

NAME
Catalyst::ActionChain - Chain of Catalyst Actions

SYNOPSIS
See Catalyst::Manual::Intro for more info about Chained actions.

DESCRIPTION
This class represents a chain of Catalyst Actions. It behaves exactly like the action at the *end* of the chain except on dispatch it will execute all the actions in the chain in order.

METHODS

  chain
Accessor for the action chain; will be an arrayref of the Catalyst::Action objects encapsulated by this chain.

  dispatch( $c )
Dispatch this action chain against a context; will dispatch the encapsulated actions in order.

  from_chain( \@actions )
Takes a list of Catalyst::Action objects and constructs and returns a Catalyst::ActionChain object representing a chain of these actions

  number_of_captures
Returns the total number of captures for the entire chain of actions.

  match_captures
Match all the captures that this chain encloses, if any.

  scheme
Any defined scheme for the actionchain

  next ( @args)
Dispatches to the next action in the chain immediately, suspending any remaining code in the action. If there are no more actions in the chain, this is basically a no-op. When the last action in the chain returns, we will return to the last action that called next and continue processing that action's code exactly where it was left off. If more than one action in the chain called "next" then we proceed back up the chain stack in reverse order of calls after the last action completes.

The return value of "next" is the return value of the next action in the chain (that is the action that was called with "next") or whatever $c->state is set to.

Please note that since "state" is a scalar, you cannot return a list of values from an action chain. If you want to return a list you must return an arrayref or hashref. This limitation is due to longstanding code in Catalyst that is not easily changed without breaking backwards compatibility.

You can call "next" in as many actions in a long chain as you want and the chain will correctly return to the last action that called "next" based on order of execution. If there are actions inbetween that didn't call "next", those will be skipped when proceeding back up the call stack. When we've completed walking back up the action call stack the dispatcher will then return to normal processing order (for example processing any "end" action present).

Any arguments you pass to "next" will be passed to the next action in the chain as "$c->request->arguments". You can pass more than one argument. All arguments passed via "next" will be added into the argument list prior to any CaptureArgs or Args that the action itself defines.

Example:

    sub action_a :Chained('/') CaptureArgs(0) {
      my ($self, $ctx) = @_;
      my $abc = $c->action->next('a'); # $abc = "abc";
    }

    sub action_b :Chained('action_a') CaptureArgs(0) {
      my ($self, $ctx, $a) = @_;
      my $abc = $c->action->next("${a}b");
      return $abc;
    }

    sub action_c :Chained('action_b') Args(0) {
      my ($self, $ctx, $ab) = @_;
      return "${ab}c";
    }

  meta
Provided by Moose

AUTHORS
Catalyst Contributors, see Catalyst.pm

COPYRIGHT
This library is free software. You can redistribute it and/or modify it under the same terms as Perl itself.