About Reactive Objects

Example Reactive Objects

        package Echoer;
        use Moose;
        extends 'Reflex::Base';

        sub ping {
                my ($self, $args) = @_;
                print "Echoer was pinged!\n";
                $self->emit( -name => "pong" );
        }

The next object uses Echoer. It creates an Echoer and pings it to get started. It also reacts to "pong" events by pinging the Echoer again. Reflex::Trait::Watched (via its exported watches() declarative syntax) implicitly watches the object in echoer(), mapping its "pong" event to the on_echoer_pong() method.

        package Pinger;
        use Moose;
        extends 'Reflex::Base';
        use Reflex::Trait::Watched qw(watches);

        watches echoer => (
                isa     => 'Echoer',
                default => sub { Echoer->new() },
        );

        sub BUILD {
                my $self = shift;
                $self->echoer->ping();
        }

        sub on_echoer_pong {
                my $self = shift;
                print "Pinger got echoer's pong!\n";
                $self->echoer->ping();
        }

Then the Pinger would be created and run.

        Pinger->new()->run_all();

A complete, runnable version of this example is in the distribution as eg/eg-37-ping-pong.pl.

Coderef Callbacks

Here we'll start a periodic timer and handle its ticks with a simple callback. The program is still reactive. Every second it prints "timer ticked" in response Reflex::Interval's events.

        my $t = Reflex::Interval->new(
                interval    => 1,
                auto_repeat => 1,
                on_tick     => sub { say "timer ticked" },
        );

        $t->run_all();

A complete, runnable version of the above example is available as eg/eg-36-tiny-coderefs.pl in the distribution.

Promises Instead of Callbacks

It may not be obvious that the same emit() method drives all of Reflex's forms of callback. The same Reflex::Interval class can be used in many different ways.

        use Reflex::Interval;

        my $t = Reflex::Interval->new(
                interval    => 1,
                auto_repeat => 1,
        );

        while (my $event = $t->next()) {
                say "next() returned an event (@$event)";
        }

run_all

        # (Omitted: First you'll need to create some Reflex objects.)

        Reflex->run_all();
        exit;

Core Modules

Reflex - You're reading it!

Reflex::Base - A base class for reactive (aka, event driven) objects.

Reflex::Role - Define a new Reflex parameterized role.

Reflex::Role::Reactive - Add non-blocking reactive behavior to a class.

Callback Adapters

Reflex::Callback - A base class for callback adapters.

Reflex::Callback::CodeRef - Implement plain coderef callbacks.

Reflex::Callback::Method - Implement class and object method callbacks.

Reflex::Callback::Promise - Return events procedurally rather than via callbacks.

Reflex::Callbacks - Convenience functions to creating and use callbacks.

POE Adapters

Reflex::POE::Event - Communicate with POE components that expect command events.

Reflex::POE::Postback - Communicate with POE components that respond via postbacks.

Reflex::POE::Session - Communicate with POE components that expect to talk to POE sessions.

Reflex::POE::Wheel - A generic POE::Wheel adapter to use them in Reflex.

Reflex::POE::Wheel::Run - Adapt POE::Wheel::Run by wrapping it in a Reflex class.

Object Collections

Reflex::Collection - Automatically manage a collection of collectible objects.

Reflex::Role::Collectible - Allow objects to be managed by Reflex::Collection.

Reflex::Sender - API to access the objects an event has passed through.

I/O

Reflex::Acceptor - A non-blocking server (client socket acceptor).

Reflex::Client - A non-blocking socket client.

Reflex::Connector - A non-blocking client socket connector.

Reflex::Role::Accepting - Add non-blocking connection accepting to a role.

Reflex::Role::Connecting - Add non-blocking client connecting to a class.

Reflex::Role::InStreaming - Add non-blocking streaming input behavior to a class.

Reflex::Role::OutStreaming - Add non-blocking streaming output behavior to a class.

Reflex::Role::Readable - Add non-blocking readable-watching behavior to a class.

Reflex::Role::Reading - Add standard non-blocking sysread() behavior to a class.

Reflex::Role::Recving - Add standard non-blocking send/recv behavior to a class.

Reflex::Role::Streaming - Add non-blocking streaming I/O behavior to a class.

Reflex::Role::Writable - Add non-blocking writable-watching behavior to a class.

Reflex::Role::Writing - Add standard non-blocking syswrite() behavior to a class.

Reflex::Stream - A non-blocking, buffered and translated I/O stream.

Reflex::UdpPeer - A base class for non-blocking UDP networking peers.

Signals and Child Processes

Reflex::PID - A non-blocking SIGCHLD watcher for a specific process.

Reflex::Role::PidCatcher - Add non-blocking SIGCHLD watching to a class.

Reflex::Role::SigCatcher - Add non-blocking signal handling behavior to a class.

Reflex::Signal - A non-blocking signal watcher.

Timers

Reflex::Interval - A non-blocking periodic interval timer.

Reflex::Role::Interval - Add non-blocking periodic callbacks to a class.

Reflex::Role::Timeout - Add non-blocking timeout timer behavior to a class.

Reflex::Role::Wakeup - Add non-blocking wakeup alarm behavior to a class.

Reflex::Timeout - A non-blocking single-shot delayed timer.

Reflex::Wakeup - A non-blocking single-shot alarm for a specific time.

Breadboarding Traits

Reflex::Trait::EmitsOnChange - Cause a Moose attribute to emit() an event when it changes.

Reflex::Trait::Observed - (Deprecated. See Reflex::Trait::Watched.)

Reflex::Trait::Watched - Automatically watch a Reactive object stored in a Moose attribute.

CONTRIBUTORS

Chris Fedde, CFEDDE on CPAN

• <https://github.com/rcaputo/reflex>
• <http://gitorious.org/reflex>

Perldoc

  perldoc Reflex

Websites

• MetaCPAN

  A modern, open-source CPAN search engine, useful to view POD in HTML format.

  <http://metacpan.org/release/Reflex>

• Search CPAN

  The default CPAN search engine, useful to view POD in HTML format.

  <http://search.cpan.org/dist/Reflex>

• RT: CPAN's Bug Tracker

  The RT ( Request Tracker ) website is the default bug/issue tracking system for CPAN.

  <https://rt.cpan.org/Public/Dist/Display.html?Name=Reflex>

• AnnoCPAN

  The AnnoCPAN is a website that allows community annotations of Perl module documentation.

  <http://annocpan.org/dist/Reflex>

• CPAN Ratings

  The CPAN Ratings is a website that allows community ratings and reviews of Perl modules.

  <http://cpanratings.perl.org/d/Reflex>

• CPAN Forum

  The CPAN Forum is a web forum for discussing Perl modules.

  <http://cpanforum.com/dist/Reflex>

• CPANTS

  The CPANTS is a website that analyzes the Kwalitee ( code metrics ) of a distribution.

  <http://cpants.cpanauthors.org/dist/Reflex>

• CPAN Testers

  The CPAN Testers is a network of smokers who run automated tests on uploaded CPAN distributions.

  <http://www.cpantesters.org/distro/R/Reflex>

• CPAN Testers Matrix

  The CPAN Testers Matrix is a website that provides a visual overview of the test results for a distribution on various Perls/platforms.

  <http://matrix.cpantesters.org/?dist=Reflex>

• CPAN Testers Dependencies

  The CPAN Testers Dependencies is a website that shows a chart of the test results of all dependencies for a distribution.

  <http://deps.cpantesters.org/?module=Reflex>

Email

Internet Relay Chat

•

irc.perl.org

You can connect to the server at 'irc.perl.org' and join this channel: #reflex to get help.

Bugs / Feature Requests

Source Code

  git clone git://github.com/rcaputo/reflex.git