POE: Cookbook - console Input

#!/usr/bin/perl
# This sample shows how POE::Wheel::ReadLine is used to read user
# input from the console.  It is a single-user chat system: It just
# starts a session and lets you talk to yourself.
# Use the tools everyone needs.
use strict;
use warnings;
use POE;                     # The base system.
use POE::Wheel::ReadLine;    # For reading lines from the console.

# Create a session to manage the events we want.  Each "inline_states"
# entry defines the function that will handle a corresponding event.
# Here readline_run() is triggered by the "_start" event.  The
# "got_input" event triggers the got_input_handler() function.
# Finally, readline_stop() is called to handle the "_stop" event.
# The _start and _stop events are supplied by POE to notify you just
# after a session has been created, and just before it will be
# destroyed.  They give you the opportunity to initialize things and
# shut them down.
POE::Session->create(
  inline_states => {
    _start    => \&readline_run,
    got_input => \&got_input_handler,
    _stop     => \&readline_stop,
  }
);

# Let the schizophrenia begin!  Once initial sessions have been
# created, we run them until everything is done.  The rest of this
# program is the functions that handle events.
$poe_kernel->run();
exit 0;

# This subroutine creates our ReadLine module and sends our inital
# Prompt.  ReadLine's "InputEvent" parameter specifies the event that
# will be sent when it has read a line of input or some other user
# generated exception.  As we've seen, it is triggered by POE just
# after the session is created.
sub readline_run {
  my ($heap) = $_[HEAP];
  $heap->{readline_wheel} =
    POE::Wheel::ReadLine->new(InputEvent => 'got_input');
  $heap->{readline_wheel}->get("Say Something: ");
}

# The session is about to stop.  Ensure that the ReadLine object is
# deleted, so it can place your terminal back into a sane mode.  This
# function is triggered by POE's "_stop" event.
sub readline_stop {
  delete $_[HEAP]->{readline_wheel};
}

# The input handler adds user input to an input history, displays what
# the user entered, and prompts for another line.  It also handles the
# "interrupt" exception, which is thrown by POE::Wheel::ReadLine when
# the user presses Ctrl+C.
# If you recall, POE::Session->create() has mapped the "got_input"
# event to the got_input_handler() function.  Looking back, you will
# see that POE::Wheel::ReadLine->new() is used to generate "got_input"
# events for each line of input the user enters.
# ReadLine input handlers take two arguments other than the usual
# KERNEL, HEAP, and so on.  ARG0 contains any input that was entered.
# If ARG0 is undefined, then ARG1 holds a word describing a
# user-generated exception such as "interrupt" (the user pressed
# Ctrl+C) or "cancel" (the user pressed Ctrl+G).
sub got_input_handler {
  my ($heap, $kernel, $input, $exception) = @_[HEAP, KERNEL, ARG0, ARG1];
  if (defined $input) {
    $heap->{readline_wheel}->addhistory($input);
    $heap->{readline_wheel}->put("I heard $input");
  }
  elsif ($exception eq 'interrupt') {
    $heap->{readline_wheel}->put("Goodbye.");
    delete $heap->{readline_wheel};
    return;
  }
  else {
    $heap->{readline_wheel}->put("\tException: $exception");
  }
  $heap->{readline_wheel}->get("Say Something Else: ");
}