view release on metacpan or  search on metacpan

lib/HTML/DOM/_TreeBuilder.pm  view on Meta::CPAN

            }

            # end of strict-p block.
        }

       # And now, get busy...
       #----------------------------------------------------------------------
        if ( !$self->{'_implicit_tags'} ) {    # bimskalabim
                                               # do nothing
            print $indent, " * _implicit_tags is off.  doing nothing\n"
                if DEBUG > 1;

 view release on metacpan or  search on metacpan

lib/HTML/Dojo/src.pm  view on Meta::CPAN

		this.name = "VJOURNAL";
		this._ValidProperties = VJournalProperties;
		dojo.cal.iCalendar.Component.call(this, body);
	};
	dojo.inherits(dojo.cal.iCalendar.VJournal, dojo.cal.iCalendar.Component);
	var VFreeBusyProperties = [_P("contact"), _P("dtstart", 1), _P("dtend"), _P("duration"), _P("organizer", 1), _P("dtstamp", 1), _P("uid", 1), _P("url", 1), _P("attendee"), _P("comment"), _P("freebusy"), _P("rstatus")];
	dojo.cal.iCalendar.VFreeBusy = function (body) {
		this.name = "VFREEBUSY";
		this._ValidProperties = VFreeBusyProperties;
		dojo.cal.iCalendar.Component.call(this, body);
	};

lib/HTML/Dojo/src.pm  view on Meta::CPAN

	this.name = "VJOURNAL";
	this._ValidProperties = VJournalProperties;
	dojo.cal.iCalendar.Component.call(this, body);
};
dojo.inherits(dojo.cal.iCalendar.VJournal, dojo.cal.iCalendar.Component);
var VFreeBusyProperties = [_P("contact"), _P("dtstart", 1), _P("dtend"), _P("duration"), _P("organizer", 1), _P("dtstamp", 1), _P("uid", 1), _P("url", 1), _P("attendee"), _P("comment"), _P("freebusy"), _P("rstatus")];
dojo.cal.iCalendar.VFreeBusy = function (body) {
	this.name = "VFREEBUSY";
	this._ValidProperties = VFreeBusyProperties;
	dojo.cal.iCalendar.Component.call(this, body);
};

 view release on metacpan or  search on metacpan

lib/HTML/EntityReference.pm  view on Meta::CPAN

    );


=head1 Functions

The function calls also provide for an easy way to check multiple tables in one go.  They also abstract the way data is actually stored, and provide handling of simple cases, and take care of busy details that you might not have thought of like multi...

=head2 (parameters)

In general, the functions take the thing to be converted as the first parameter, and can take one or two additonal optional arguments.  Only the C<format> function doesn't follow this pattern exactly, taking another parameter first.

 view release on metacpan or  search on metacpan

t/repeatable/list.t  view on Meta::CPAN

   has_field 'tags' => ( type => 'Repeatable' );
   has_field 'tags.contains';

   sub validate_tags_contains {
       my ( $self, $field ) = @_;
       if ( $field->value eq 'busybee' ) {
           $field->add_error('That tag is not allowed');
       }
   }
}

t/repeatable/list.t  view on Meta::CPAN

};
is_deeply( $form->fif, $fif, 'fif is correct' );

is_deeply( $form->values, $params, 'values are correct' );

$params = { name => 'sally', tags => ['busybee', 'sillysally', 'missymim'] };
$form->process($params);
ok( $form->has_errors, 'form has errors' );

done_testing;

 view release on metacpan or  search on metacpan

lib/HTML/Mason/Cache/BaseCache.pm  view on Meta::CPAN

$HTML::Mason::Cache::BaseCache::VERSION = '1.60';
use strict;
use warnings;

#
# Override to handle busy_lock and expire_if.
#
sub get
{
    my ($self, $key, %params) = @_;
    die "must specify key" unless defined($key);

    foreach my $param (keys(%params)) {
        unless ($param =~ /^(busy_lock|expire_if)$/) {
            die "unknown param '$param'";
        }
    }

    $self->_conditionally_auto_purge_on_get();

lib/HTML/Mason/Cache/BaseCache.pm  view on Meta::CPAN

    my $object = $self->get_object($key) or
        return undef;

    if (Cache::BaseCache::Object_Has_Expired($object))
    {
        if ($params{busy_lock}) {
            # If busy_lock value provided, set a new "temporary"
            # expiration time that many seconds forward, and return
            # undef so that this process will start recomputing.
            my $busy_lock_time = Cache::BaseCache::Canonicalize_Expiration_Time($params{busy_lock});
            $object->set_expires_at(time + $busy_lock_time);
            $self->set_object($key, $object);
        } else {
            $self->remove($key);
        }
        return undef;

lib/HTML/Mason/Cache/BaseCache.pm  view on Meta::CPAN

non-existent or expired. This is extended with the following optional
name/value parameters:

=over

=item busy_lock => duration

If the value has expired, set its expiration time to the current time plus
I<duration> (instead of removing it from the cache) before returning undef.
This is used to prevent multiple processes from recomputing the same
expensive value simultaneously. The I<duration> may be of any form acceptable

 view release on metacpan or  search on metacpan

examples/misc/example5.pl  view on Meta::CPAN

			<span class="attendee vcard">
				<span class="cn">Toby Inkster</span>
				<span class="rsvp">true</span>
			</span>
		</p>
		<div class="vfreebusy">
			<span class="freebusy">
				<span class="fbtype">free</span>
				<span class="value">2001-01-01/P6M</span>
				<span class="value"><i class="start">2002-01-01</i> <i class="d">182</i></span>
			</span>
			<span class="summary">freetime</span>

 view release on metacpan or  search on metacpan

t/data/DataFlow.pm.html  view on Meta::CPAN

<h2><a class='u' href='#___top' title='click to go to top of document'
name="Internet_Relay_Chat"
>Internet Relay Chat</a></h2>

<p>You can get live help by using IRC ( Internet Relay Chat ). If you don&#39;t know what IRC is, please read this excellent guide: <a href="http://en.wikipedia.org/wiki/Internet_Relay_Chat" class="podlinkurl"
>http://en.wikipedia.org/wiki/Internet_Relay_Chat</a>. Please be courteous and patient when talking to us, as we might be busy or sleeping! You can join those networks/channels and get help:</p>

<ul>
<li>irc.perl.org
<p>You can connect to the server at &#39;irc.perl.org&#39; and join this channel: #opendata-br to get help.</p>
</li>

 view release on metacpan or  search on metacpan

lib/HTML/TreeBuilder.pm  view on Meta::CPAN

            }

            # end of strict-p block.
        }

       # And now, get busy...
       #----------------------------------------------------------------------
        if ( !$self->{'_implicit_tags'} ) {    # bimskalabim
                                               # do nothing
            print $indent, " * _implicit_tags is off.  doing nothing\n"
                if DEBUG > 1;

 view release on metacpan or  search on metacpan

lib/HTML/Valid/Tagset.pm  view on Meta::CPAN

    'alt' => 'pcdata',
    'archive' => 'urls',
    'aria-activedescendant' => 'pcdata',
    'aria-atomic' => 'pcdata',
    'aria-autocomplete' => 'pcdata',
    'aria-busy' => 'pcdata',
    'aria-checked' => 'pcdata',
    'aria-controls' => 'pcdata',
    'aria-describedby' => 'pcdata',
    'aria-disabled' => 'pcdata',
    'aria-dropeffect' => 'pcdata',

 view release on metacpan or  search on metacpan

lib/HTTP/DownloadLimit.pm  view on Meta::CPAN

	# ÏÐÒÅÄÅÌÉÔØ ÄÏÓÔÕÐ Ë ÆÁÊÌÕ ÄÌÑ ÏÄÎÁÇÏ ÉÌÉ ÎÅÓËÏÌØËÉÈ ËÌÉÅÎÔÏ× ( *Option )
	if( $self->_check_pid && ! $$self{'MULTI'} )
	{
	    print $self->_http_status_403;
	    
	    $self->_logwrite("403 file is busy $$self{'FILE_NAME'}") if $$self{'DEBUG'};
	}
	else
	{
	    ## ÐÒÏ×ÅÒÉÔØ ÓÏÏÔ×ÅÃÔ×ÉÅ ÚÁÐÒÁÛÉ×ÁÅÍÏÇÏ ÆÁÊÌÁ ÄÏÐÕÓÔÉÍÙÍ ÆÏÒÍÁÔÁÍ
	    unless( $self->_permission )

 view release on metacpan or  search on metacpan

lib/HTTP/Proxy/Engine/ScoreBoard.pm  view on Meta::CPAN

        flock $lockfh, LOCK_UN or do {
            $proxy->log( HTTP::Proxy::ERROR, "ERROR", "Cannot unflock: $!" );
            exit;
        };

        5 == syswrite $status_write, pack "NA", $$, "B"    # go busy
          or $proxy->log( HTTP::Proxy::ERROR, "ERROR", "status B: short write");
        $slave->autoflush(1);
        
        $proxy->serve_connections($slave);    # the real work is done here

 view release on metacpan or  search on metacpan

lib/HTTP/Server/Daemon.pm  view on Meta::CPAN

        undef $port;
        undef $quit;

        my $quit = 0;
        my $caller = $0;
        local $SIG{HUP} = sub {$0 = "$caller busy hup"; $quit++; exit 0;};
        while(!$quit and $max_request--)
        {
            my $sock;
            syswrite $pipe_write, "$$ idle\n";
            $0 = "$caller life=$max_request idle";

lib/HTTP/Server/Daemon.pm  view on Meta::CPAN

            {
                local $SIG{HUP} = sub {$0 = "$caller idle hup"; $quit++; die;};
                accept($sock, $server);
            };

            syswrite $pipe_write, "$$ busy\n";
            $0 = "$caller life=$max_request busy";
            &$child_func($sock);

            close $sock;
        }
        close $server;

 view release on metacpan or  search on metacpan

lib/HTTP/Server/Multiplex.pod  view on Meta::CPAN

between processes and very simple caching.  Most importantly: the whole
code is a critical section which avoid the need for locking.  Very fast
and very simple -in concept.

Disadvantages are also plentifold: you have to be careful with any IO
to use the IO::Multiplex select loop, and busy-waits (for reading files,
acquiring locks, database output, hostname lookups, sleep) are blocking
all other clients.  Any bug in your software can break the daemon,
and therewith the whole service.

=head2 Features

 view release on metacpan or  search on metacpan

t/lib/Hailo/Test/TimToady.trn  view on Meta::CPAN

my throng of female groupies I can count on the fingers of one hand, and that's about all I'm allowed to do with 'em. :)
who says mine aren't?
Gloria tends to transcend groupiehood in various ways.
have you seen the Pugs Manifest from Audrey?
we shoulda put a link to it...
I'm busy revising S02 again, and it looks like it's working out very nicely.
Particularly since we still get a shorthand . . that is taken to be equivalent to .#. .
The other comments are naturally defined to make the "extra" newline into the whitespace.
So #... only extends *to* the newline at the end.
and =begin doesn't hide the newline before it.
or actually, ". ." is equivalent to ".#. .." so it still does the "long dot" trick visually.

t/lib/Hailo/Test/TimToady.trn  view on Meta::CPAN

the Internet is a big place
it's possible that there are universes in which Perl 6 is done already, and maybe the Internet leaks between universes.
sorry, he's rocket lee in that universe
it's a strange quirk of english that jets aren't rockets, but rockets use jet propulsion
we'll release as soon as we get up to about 40,000 passing regression tests.
so you'd better get busy :)
to the first approximation, a capture is just a list of generators
some of which are marked as invocant or named, but to begin with they could just live in a list
and the methods could comb them out of the list on demand
well, $ @ % & are essentially just methods too
I don't see why they have to return containers

t/lib/Hailo/Test/TimToady.trn  view on Meta::CPAN

I don't recall every doing a distclean
*ever
testing a fix
that should fix it
so I can understand all the eu folks staying bundled up in their beds, but what's the excuse of all those hardy usians?  all out snowmobiling or somethin'?  :)
maybe they're all too busy hacking to waste time on irc :)
well, taking care of yourself is also important; we're in this for the long haul
the author of elf is a hare rather than a tortoise, and he's been haring off for a while now
only roles
but roles used as classes will attempt to pun themselves into a class
however...

 view release on metacpan or  search on metacpan

lib/Ham/Device/FT950.pm  view on Meta::CPAN

# Returns 0 if OFF
# Return undef is error or don't know
eval {
sub statBSY {
    my $self = shift;
    my ($busy, $result);
    unless ($result = $self->writeCmd('BY;')) { return undef; }
    $busy = $self->readResult();
    $busy =~ /BY(\d+)\;/;
    my $b = $1;
        if ($b == 10) { return 1;
        } else { return 0; }
}
};

lib/Ham/Device/FT950.pm  view on Meta::CPAN

# Returns 2 if Radio TX ON  CAT TX OFF
# Return undef is error or don't know
eval {
sub statTX {
    my $self = shift;
    my ($busy, $result);
    unless ($result = $self->writeCmd('TX;')) { return undef; }
    $busy = $self->readResult();
    $busy =~ /TX(\d)\;/;
    my $b = $1;
        if ($b == 0)      {
            return 1;
        } elsif ($b == 1) {
            return 1;

lib/Ham/Device/FT950.pm  view on Meta::CPAN

# Returns 1 for ON
# Return undef is error or don't know
eval {
sub statFastStep {
    my $self = shift;
    my ($busy, $result);
    unless ($result = $self->writeCmd('FS;')) { return undef; }
    $busy = $self->readResult();
    $busy =~ /FS(\d)\;/;
    my $b = $1;
        if ($b == 0)      {
            return 0;
        } elsif ($b == 1) {
            return 1;

 view release on metacpan or  search on metacpan

lib/Ham/Reference/Qsignals.pm  view on Meta::CPAN

	'qnz' => 'Zero beat your signal with mine.',
	'qrg' => 'Will you tell me my exact frequency?',
	'qrh' => 'Does my frequency vary?',
	'qrj' => 'Are you receiving me badly?',
	'qrk' => 'What is the intelligibility of my signals?',
	'qrl' => 'Are you busy?',
	'qrm' => 'Is my transmission being interfered with?',
	'qrn' => 'Are you troubled by static?',
	'qro' => 'Shall I increase power?',
	'qrp' => 'Shall I decrease power?',
	'qrq' => 'Shall I send faster?',

 view release on metacpan or  search on metacpan

lib/Hardware/Simulator/MIX.pm  view on Meta::CPAN

# Usage: $self->wait_until_device_ready($devnum)
#
# Used only before IN/OUT operations. 
# 
# If the device is busy, that is, the current time - last started < delay,
# increase the current time, so that the device would be ready
sub wait_until_device_ready
{
    my ($self, $devnum) = @_;

    return if $devnum < 0 || $devnum > 19;

    my $devstat = @{$self->{devstat}}[$devnum];
    my $laststarted = $devstat->{laststarted};

    # See whether the device is still busy
    if ($self->{time} - $laststarted < $devstat->{delay})
    {
        # advance the current system time to the point
        # that the device would be ready
        $self->{time} = $laststarted + $devstat->{delay};

lib/Hardware/Simulator/MIX.pm  view on Meta::CPAN

	$self->{message} = "invalid ioc for device(#$f)";
    }
    return 1;
}

# Jump when device busy: always no busy
sub X_JBUS {
    my ($self, $c, $f, $r, $l, $i, $a, $m) = @_;
    return 1;
}

 view release on metacpan or  search on metacpan

Word/adjective.txt  view on Meta::CPAN

brisk,brisker,briskest
broad,broader,broadest
brown,browner,brownest
bulky,bulkier,bulkiest
busty,bustier,bustiest
busy,busier,busiest
calm,calmer,calmest
cheap,cheaper,cheapest
cheeky,cheekier,cheekiest
cheery,cheerier,cheeriest
chief,chiefer,chiefest

 view release on metacpan or  search on metacpan

lib/Hash/Wrap.pm  view on Meta::CPAN

        # do a two-step initialization of the constructor.  If
        # the initialization sub is stored in $recurse_into_hash, and then
        # $recurse_into_hash is set to the actual constructor I worry that
        # Perl may decide to garbage collect the setup subroutine while it's
        # busy setting $recurse_into_hash.  So, store the
        # initialization sub in something other than $recurse_into_hash.

        $dict{recursion_constructor} = <<'END';
our $recurse_into_hash;
our $setup_recurse_into_hash = sub {

 view release on metacpan or  search on metacpan

BCM2835/src/doc/Doxyfile.in  view on Meta::CPAN

# The SYMBOL_CACHE_SIZE determines the size of the internal cache use to
# determine which symbols to keep in memory and which to flush to disk.
# When the cache is full, less often used symbols will be written to disk.
# For small to medium size projects (<1000 input files) the default value is
# probably good enough. For larger projects a too small cache size can cause
# doxygen to be busy swapping symbols to and from disk most of the time
# causing a significant performance penalty.
# If the system has enough physical memory increasing the cache will improve the
# performance by keeping more symbols in memory. Note that the value works on
# a logarithmic scale so increasing the size by one will roughly double the
# memory usage. The cache size is given by this formula:

 view release on metacpan or  search on metacpan

lib/HiPi/Huawei/Errors.pm  view on Meta::CPAN

    
    '400'       => 'error in http request / response',
    
    '100002'    => 'call not supported',
    '100003'    => 'access forbidden in current session context',
    '100004'    => 'system busy',
    '100005'    => 'system system reports request failed',
    '100006'    => 'invalid request parameter',
    '108001'    => 'invalid username',
    '108002'    => 'invalid password',
    '108003'    => 'user already logged in',
    '108006'    => 'invalid username or password',
    '108007'    => 'maximum session login attempts exceeded',
    '120001'    => 'voice busy',
    '125001'    => 'invalid token',
    '125002'    => 'invalid session',
    '125003'    => 'invalid token or session',
    
    '103024'    => 'serial number check failed',

 view release on metacpan or  search on metacpan

share/root/static/yui/assets/yui.css  view on Meta::CPAN

#yui-theater h2 {margin:0 0 10px 0; padding:0; border:none; color:#000;  font-size:122%; font-weight:bold;}
#yui-theater p {margin:7px 0 0 0;}
#yui-theater div {float:right; font-size:85%;}

/*rss reader styles*/
p.loading-content {background-image:url(http://us.i1.yimg.com/us.yimg.com/i/ydn/yuiweb/img/busy_arrow.gif); background-position:top left; background-repeat:no-repeat; height:20px;padding:4px 0 0 25px; margin:0;}
#doc3 ul.yuirssreader {margin:0; padding:0;}
#doc3 ul.yuirssreader li {list-style-type:none;padding:5px 0 0 12px; margin:0;}
#doc3 ul.yuirssreader li p {margin:0; padding:0;}
ul.yuirssreader cite {color:#666666; margin:0;}
span.yuirssreader-date {font-size:77%; color:#E76300;}

 view release on metacpan or  search on metacpan

lib/Hopkins/Config/XML.pm  view on Meta::CPAN

Hopkins::Config::XML - hopkins configuration via XML

=head1 DESCRIPTION

Hopkins::Config encapsulates all of the busywork associated
in the reading and post-processing of the XML configuration
in addition to providing a simple interface to accessing
values when required.

Hopkins::Config::XML will validate your configuration using

 view release on metacpan or  search on metacpan

examples/rss-llq  view on Meta::CPAN

   ll_free_objs($query);
   ll_deallocate($query);

   $title_string = "Jobs: R=$jobs_run, I=$jobs_idle, H=$jobs_held, NQ=$jobs_not_queued";

   $nodes_busy = 0;
   $nodes_idle = 0;
   $nodes_running = 0;
   $nodes_down = 0;

   #

examples/rss-llq  view on Meta::CPAN

      # Get the startd status for each machine
      #

      $sts=ll_get_data($machine,LL_MachineStartdState);

      $nodes_busy++    if ($sts =~ /^Busy/);
      $nodes_idle++    if ($sts =~ /^Idle/);
      $nodes_running++ if ($sts =~ /^Running/);
      $nodes_down++    if ($sts =~ /^Down/);

      $machine=ll_next_obj($query);

examples/rss-llq  view on Meta::CPAN

   ll_free_objs($query);
   ll_deallocate($query);


   $title_string .= ". Nodes: B=$nodes_busy, R=$nodes_running, I=$nodes_idle, D=$nodes_down";

   open (RDF,">/web/htdocs/loadl.rdf");
   print RDF  "<?xml version=\"1.0\"?>\n";
   print RDF  "   <!DOCTYPE rss PUBLIC \"-//Netscape Communications//DTD RSS 0.91//EN\"\n";
   print RDF  "             \"http://my.netscape.com/publish/formats/rss-0.91.dtd\" >\n";

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

		instead of automatically climbing up the tree.

	- be more smart (follow RFC) when filling {*_full} members
		of envelope addresses
	- defined but empty (or 0) disposition should mean `inline'
	- speed up several busy regexen by a factor of 2-5.
	- ->charset will never return mysterious '' or '0' instead
	  of `undef'.

0.96  2005/11/16
	- ->{parts} for singlepart messages is now a '[]'.

 view release on metacpan or  search on metacpan

getCite.pl  view on Meta::CPAN

	print "ERROR!!\n";
	print "Couldn't find the citation in INSPEC databse]--!!\n";
	print "Reasons:\n(1) The citation is too old (i.e older than 1968).\n";
	print "(2) The journal [".$jname."] is not contained in the INSPEC database.\n";
	print "(3) The volume[".$volume."], page number[".$page."], and journal code[".$journal."] were incorrectly specified.\n";
	print "(4) The AXION INPSEC server is down or too busy.  Goto axiom.iop.org/S/ARKAN/search and try a manual search to see.\n";
}

 view release on metacpan or  search on metacpan

AIO.pm  view on Meta::CPAN

                       accept4 tee splice pipe2 pipesize
                       fexecve mount umount memfd_create eventfd
                       timerfd_create timerfd_settime timerfd_gettime
                       pidfd_open pidfd_send_signal pidfd_getfd);

   push @AIO_REQ, qw(aio_busy); # not exported

   @IO::AIO::GRP::ISA = 'IO::AIO::REQ';

   require XSLoader;
   XSLoader::load ("IO::AIO", $VERSION);

AIO.pm  view on Meta::CPAN

phase and still requires a worker thread. Thus, the callback will not
be executed immediately but only after other requests in the queue have
entered their execution phase. This can be used to measure request
latency.

=item IO::AIO::aio_busy $fractional_seconds, $callback->()  *NOT EXPORTED*

Mainly used for debugging and benchmarking, this aio request puts one of
the request workers to sleep for the given time.

While it is theoretically handy to have simple I/O scheduling requests

 view release on metacpan or  search on metacpan

lib/IO/Async/Function.pm  view on Meta::CPAN

               # Shut down atmost one idle worker, starting from the highest
               # ID. Since we search from lowest to assign work, this tries
               # to ensure we'll shut down the least useful ones first,
               # keeping more useful ones in memory (page/cache warmth, etc..)
               foreach my $id ( reverse sort keys %$workers ) {
                  next if $workers->{$id}{busy};

                  $workers->{$id}->stop;
                  last;
               }

lib/IO/Async/Function.pm  view on Meta::CPAN

=head2 call

   @result = await $function->call( %params );

Schedules an invocation of the contained function to be executed on one of the
worker processes. If a non-busy worker is available now, it will be called
immediately. If not, it will be queued and sent to the next free worker that
becomes available.

The request will already have been serialised by the marshaller, so it will be
safe to modify any referenced data structures in the arguments after this call

lib/IO/Async/Function.pm  view on Meta::CPAN

{
   my $self = shift;
   return scalar keys %{ $self->{workers} };
}

=head2 workers_busy

   $count = $function->workers_busy;

Returns the number of worker processes that are currently busy

=cut

sub workers_busy
{
   my $self = shift;
   return scalar grep { $_->{busy} } $self->_worker_objects;
}

=head2 workers_idle

   $count = $function->workers_idle;

lib/IO/Async/Function.pm  view on Meta::CPAN

=cut

sub workers_idle
{
   my $self = shift;
   return scalar grep { !$_->{busy} } $self->_worker_objects;
}

sub _new_worker
{
   my $self = shift;

lib/IO/Async/Function.pm  view on Meta::CPAN

sub _get_worker
{
   my $self = shift;

   foreach ( sort keys %{ $self->{workers} } ) {
      return $self->{workers}{$_} if !$self->{workers}{$_}{busy};
   }

   if( $self->workers < $self->{max_workers} ) {
      return $self->_new_worker;
   }

lib/IO/Async/Function.pm  view on Meta::CPAN

   $ret = $worker->result_future if defined wantarray;

   if( my $function = $worker->parent ) {
      delete $function->{workers}{$worker->id};

      if( $worker->{busy} ) {
         $worker->{remove_on_idle}++;
      }
      else {
         $function->remove_child( $worker );
      }

lib/IO/Async/Function.pm  view on Meta::CPAN

   my $worker = shift;
   my ( $args ) = @_;

   $worker->{arg_channel}->send_encoded( $args );

   $worker->{busy} = 1;
   $worker->{max_calls}--;

   return $worker->{ret_channel}->recv->then(
      # on recv
      $worker->_capture_weakself( sub {

lib/IO/Async/Function.pm  view on Meta::CPAN

         return Future->fail( "closed", "closed" );
      } )
   )->on_ready( $worker->_capture_weakself( sub {
      my ( $worker, $f ) = @_;
      $worker->{busy} = 0;

      my $function = $worker->parent;
      $function->_dispatch_pending if $function;

      $function->remove_child( $worker ) if $function and $worker->{remove_on_idle};

 view release on metacpan or  search on metacpan

lib/IO/Busy.pm  view on Meta::CPAN

    #"Okay, fine. Type whatever you like. Whatever makes you happy.\n",
    #"La la la la. I can't hear you.\n",
    "",
);

sub busy (&) :Export(:MANDATORY) {
    my ($block_ref) = @_;
    my $count = 0;

    my ($read, $write);
    pipe $read, $write;

lib/IO/Busy.pm  view on Meta::CPAN

=head1 SYNOPSIS

    use IO::Busy;

    my $fh = busy {
        non_interactive_stuff();
    };

  
=head1 DESCRIPTION

This module exports a single subroutine, named C<busy>. That subroutine takes
a single argument, which must be a block of code. C<busy> forks off a separate
process that intercepts and stores any input, then executes the block (in the
original process). 

If the user types anything during the execution of the block, that input
does not appear on the STDIN of the original process. Instead the busy
block informs the user that their input is not being received, and
stores the input in a separate filehandle. That filehandle is then
returned by the C<busy> call, at the end of the block's execution, at which
time STDIN is reconnected to the process.


=head1 INTERFACE 

=head2 $FH = busy {...}

The C<busy> subroutine expects a code block as its only argument. It executes
the block, intercepting any input during that execution. It returns a
filehandle opened for reading, from which the intercepted input can be re-read
if desired.

lib/IO/Busy.pm  view on Meta::CPAN

=over

=item That input was ignored. %s

You typed something whilst the C<busy> block was executing. The C<busy> did
its job and ignored the input, warning you of the fact.

=back

=head1 CONFIGURATION AND ENVIRONMENT

lib/IO/Busy.pm  view on Meta::CPAN

=head1 BUGS AND LIMITATIONS

No bugs have been reported.

Please report any bugs or feature requests to
C<bug-io-busy@rt.cpan.org>, or through the web interface at
L<http://rt.cpan.org>.


=head1 AUTHOR

 view release on metacpan or  search on metacpan

ChangeLog  view on Meta::CPAN

  * Remove ‘use File::Spec’ from IO::File (It is not using it any more.)
  * [RT #36079] Convert ` to '.
  * use :raw to avoid interference from PERL_UNICODE when creating test data
  * Make IO::Handle::getline(s) respect the open pragma (RT 66474)
  * Fix setting sockets nonblocking in Win32
  * Use the exception set in select (connect()) to early return when remote end is busy or in non existing port
  * Keep verbatim pod within 79 cols
  * Keep verbatim pod in IO.pm within 80 cols
  * [perl #88486] IO::File does not always export SEEK*
  * Explicitly force the load of IO::File in IO::Handle (see the discussion in [perl #87940]).
  * Remove various indirect method calls in IO's docs