view release on metacpan or  search on metacpan

lib/CatalystX/Crudite/Util/Random.pm  view on Meta::CPAN

busted
buster
bustle
bustling
busts
busy
but
butane
butcher
butchered
butchers

 view release on metacpan or  search on metacpan

root/static/js/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/CfgTie/TieGeneric.pm  view on Meta::CPAN

This is an associative array that automatially ties other configuration hashes

=head1 DESCRIPTION

This is a tie to bring other ties together automatically so you, the busy
programmer and/or system administrator, don't have to.  The related Perl
module is not loaded unless it is needed at runtime.

        my %gen;
        tie %gen, 'CfgTie::TieGeneric';

 view release on metacpan or  search on metacpan

t/001_parse/ecs_taskdefinition.res  view on Meta::CPAN

      ],
      "Memory":"500",
      "Essential": "true"
    },
    {
      "Name": "busybox",
      "Image": "busybox",
      "Cpu": "10",
      "EntryPoint": [
        "sh",
        "-c"
      ],

 view release on metacpan or  search on metacpan

lib/Chat/iFly.pm  view on Meta::CPAN

        image_path      => $self->static_asset_base_uri.'/themes/'.$self->theme.'/images',
        isLog           => JSON::true,
        whichTheme      => 'blue',
        enableStatus    => JSON::true,
        role            => $user->{is_admin} ? 'admin' : ((exists $user->{custom_roles}) ? $user->{custom_roles} : 'normal'),
        validState      => ['available','offline','busy','idle'],
        up              => (exists $user->{avatar_uri}) ? $user->{avatar_uri} : $self->static_asset_base_uri.'/themes/'.$self->theme.'/images/default_avatar.png',
        upl             => (exists $user->{profile_uri}) ? $user->{profile_uri} : '#',
        rel             => (exists $user->{relationships_set}) ? 1 : undef,
        valid_uids      => $user->{relationships_set},
    }));

 view release on metacpan or  search on metacpan

lib/Cisco/IronPort.pm  view on Meta::CPAN

	sending.domainN.com => {
	  ...
	}

Where each domain having sent email in the current hour period is used as the value of a hash key in the returned hash having
the subkeys listed above.  For a busy device this hash may contain hundreds or thousands of domains so caution should be 
excercised in storing and parsing this structure.

=head3 incoming_mail_details_current_day

This method returns a nested hash as described in the B<incoming_mail_details_current_hour> method above but for a period

 view release on metacpan or  search on metacpan

lib/Class/CompoundMethods.pm  view on Meta::CPAN

    # Return the method as a convenience (for who knows what, I don't know)
    return \&{$method_name};
}

"Fine!  Since you're too busy playing with people's minds, I'll just go off to the other room to play with myself!";

 view release on metacpan or  search on metacpan

lib/Class/DBI/SAK.pm  view on Meta::CPAN

This module encapsulates the pain and suffering that is importing
Class::DBI and all it's little helper friends.

=head1 DESCRIPTION

By taking the busy work out of using Class::DBI as you see fit,
your code becomes more useful by size.  Most of us end up using at
least a couple Class::DBI extensions in our programs, and it's just
a pain.  Enter the Swiss Army Knife.

This module is intelligent.  It knows how each module is supposed

 view release on metacpan or  search on metacpan

lib/Class/Implements.pm  view on Meta::CPAN

   unless $object->isa( "The::Class:I'm::Willing::To::Deal::With" );

So that other module authors can provide an isa method if they decide
to.

Of course, while they're busy contemplating what they've done wrong
their existing code isn't going to be changed, so you'll have to use
this module.  It brings some relief by supplying a fake UNIVERSAL::isa
which understands how to stretch the truth a little.

=head1 AUTHOR

 view release on metacpan or  search on metacpan

t/Telephone.pm  view on Meta::CPAN

}

sub switch_off {
    my $self = shift;
    TRACE('Switching off: ' . $self->{number});
    $self->hangup if $self->busy;
    $self->online(0);
    $self->notify_subscribers('disconnect');
}

sub busy {
    my $self = shift;
    return defined $_[0] ? $self->{busy} = shift : $self->{busy}
}

sub online {
    my $self = shift;
    return defined $_[0] ? $self->{online} = shift : $self->{online}

t/Telephone.pm  view on Meta::CPAN

sub call {
    my $self = shift;
    my $number = shift;
    return unless $self->online();
    if ($self->busy()) {
        TRACE('Cannot make a call. Call already in progress');
    }

    $self->busy(1);
    delete $self->{hangup};
    $self->{calls_made}++;
    TRACE($self->{number} . "calling $number");
    $self->notify_subscribers('call', number => $number);
    return 1;

t/Telephone.pm  view on Meta::CPAN

    $self->{other_party} = $other_phone;

    # Ordinarily the exchange would route communications
    $other_phone->add_subscriber('communicate', $self);

    $self->busy(1);
}

sub hangup {
    my $self = shift;
    my ($reason) = @_;

t/Telephone.pm  view on Meta::CPAN

    if ($self->{other_party}) {
        $self->delete_subscriber('communicate', $self->{other_party});
        $self->notify_subscribers('end_call');
        delete $self->{other_party};
    }
    $self->busy(0);
    $self->{listened_to} = undef;
    $self->{hangup} = $reason;
}

sub speak {

t/Telephone.pm  view on Meta::CPAN

    my $self = shift;
    my ($caller, $action, %params) = @_;

    my $recipient = $self->{$params{number}};
    if ($recipient) {
        if ($recipient->busy()) {
            $caller->hangup('BUSY');
        } else {
            $caller->connect($recipient);
            $recipient->connect($caller);
        }

 view release on metacpan or  search on metacpan

lib/Class/Std/Slots.pm  view on Meta::CPAN

use Scalar::Util qw(blessed refaddr weaken);

our $VERSION = '0.31';

my %signal_map  = ();   # maps id -> signame -> array of connected slots
my %signal_busy = ();   # maps id -> signame -> busy flag
my %patched     = ();   # classes whose DESTROY we've patched

# Subs we export to caller's namespace
my @exported_subs = qw(
 connect

lib/Class/Std/Slots.pm  view on Meta::CPAN

  unless ( blessed( $self ) ) {
    croak "Signal '$sig_name' must be invoked as a method\n";
  }

  if ( exists( $signal_busy{$src_id}->{$sig_name} ) ) {
    croak "Attempt to re-enter signal '$sig_name'";
  }

  # Flag this signal as busy
  $signal_busy{$src_id}->{$sig_name}++;

  # We still want to remove the busy lock on the signal
  # even if one of the slots dies - so wrap the whole
  # thing in an eval.
  eval {

    # Get the slots registered with this signal

lib/Class/Std/Slots.pm  view on Meta::CPAN

        }
      }
    }
  };

  # Remove busy flag
  delete $signal_busy{$src_id}->{$sig_name};

  # Rethrow any error
  die if $@;
}

sub _destroy {
  my $src_id = shift;
  delete $signal_map{$src_id};
  delete $signal_busy{$src_id};
}

sub has_slots {
  my $src_obj   = shift;
  my $sig_names = _massage_signal_names( shift );

 view release on metacpan or  search on metacpan

Cmenu.pm  view on Meta::CPAN

# ----------------------------------------------------------------------------------
# &menu_initialise      : sets up all menu variables and constructs
# &menu_button_set      : swicthes menu buttons on and off
# &menu_item            : create a menu item
# &menu_display         : display a menu and get a response from it
# &menu_popup           : flash a busy window
# &menu_show            : gives a full screen text display
# &menu_terminate       : close the menu environment down
# ----------------------------------------------------------------------------------
# All Curses functions can of course be used in user programs but be aware that
# management of all windows then becomes the users responsibility and behaviour

 view release on metacpan or  search on metacpan

share/js/cog.js  view on Meta::CPAN

// $Cog is the Cog prototype object. You can use it anywhere to extend Cog.

$Cog = (Cog = function() {this.init()}).prototype = {
    url_map: {},
    setup_functions: [],
    busy: false
};

$Cog.init = function() {
    var funcs = this.setup_functions;
    for (var i = 0, l = funcs.length; i < l; i++) {

 view release on metacpan or  search on metacpan

LeadingBlankSpaces.pm  view on Meta::CPAN

Basically, the outgoing web content (HTML, JavaScript, etc.) contains a lot of leading blank spaces,
because of being structured on development stage.
Usually, the browser ignores all leading blank spaces.
Indeed, the amount of those blank spaces is significant
and could be estimated as 10 to 20 percent of the length of regular web page.
We can reduce this part of the web traffic on busy servers
with no visible impact on transferred web content. This could be helpful
especially for old browsers incapable to understand modern content compression.

The main functionality of this class is concentrated within the C<squeeze_string> member function
that is supposed to be used inside the data transfer loop on server side.

 view release on metacpan or  search on metacpan

ext/zstd/CHANGELOG  view on Meta::CPAN

api: Support for Block-Level Sequence Producer (#3333, @embg)
api: Support for in-place decompression (#3432, @terrelln)
api: New  `ZSTD_CCtx_setCParams()`  function, set all parameters defined in a  `ZSTD_compressionParameters`  structure (#3403, @Cyan4973)
api: Streaming decompression detects incorrect header ID sooner (#3175, @Cyan4973)
api: Window size resizing optimization for edge case (#3345, @daniellerozenblit)
api: More accurate error codes for busy-loop scenarios (#3413, #3455, @Cyan4973)
api: Fix limit overflow in `compressBound` and `decompressBound` (#3362, #3373, Cyan4973) reported by @nigeltao
api: Deprecate several advanced experimental functions: streaming (#3408, @embg), copy (#3196, @mileshu)
bug: Fix corruption that rarely occurs in 32-bit mode with wlog=25 (#3361, @terrelln)
bug: Fix for block-splitter (#3033, @Cyan4973)
bug: Fixes for Sequence Compression API (#3023, #3040, @Cyan4973)

 view release on metacpan or  search on metacpan

t/07largeconf.t  view on Meta::CPAN

        ca.beadwork.about.com ca.beauty.about.com ca.beginnersinvest.about.com ca.bicycling.about.com 
        ca.biology.about.com ca.biotech.about.com ca.bipolar.about.com ca.birding.about.com 
        ca.blues.about.com ca.boardgames.about.com ca.bodybuilding.about.com ca.boston.about.com 
        ca.boxing.about.com ca.breastcancer.about.com ca.brooklyn.about.com ca.buddhism.about.com 
        ca.budgettravel.about.com ca.businessmajors.about.com ca.businesssoft.about.com ca.businesstravel.about.com 
        ca.busycooks.about.com ca.motorcycles.about.com preview.motortrend.com preview.trucktrend.com 
        preview.surfermag.com preview.anaheim.com preview.importtuner.com postad.sailmag.about.com 
        ca.sailmag.com ca.exercise.about.com ca.weightloss.about.com ca.austin.about.com 
        ca.vintagecars.about.com ca.ecommerce.about.com ca.email.about.com preview.sportrider.com 
        postad.primediaautomotive.about.com ca.primediaautomotive.com );

 view release on metacpan or  search on metacpan

lib/Config/Model/models/Systemd/Common/Exec.pl  view on Meta::CPAN

If not set \x{2013} but file system namespaces are enabled through another file system namespace unit setting \x{2013}
C<shared> mount propagation is used, but \x{2014} as mentioned \x{2014} as C<slave> is applied
first, propagation from the unit's processes to the host is still turned off.

It is not recommended to use C<private> mount propagation for units, as this means
temporary mounts (such as removable media) of the host will stay mounted and thus indefinitely busy in forked
off processes, as unmount propagation events won't be received by the file system namespace of the unit.

Usually, it is best to leave this setting unmodified, and use higher level file system namespacing
options instead, in particular C<PrivateMounts>, see above.",
        'type' => 'leaf',

 view release on metacpan or  search on metacpan

examples/ldap  view on Meta::CPAN

                             aliasDereferencingProblem    (36),
                                        -- 37-47 unused --
                             inappropriateAuthentication  (48),
                             invalidCredentials           (49),
                             insufficientAccessRights     (50),
                             busy                         (51),
                             unavailable                  (52),
                             unwillingToPerform           (53),
                             loopDetect                   (54),
                                        -- 55-63 unused --
                             namingViolation              (64),

examples/ldap  view on Meta::CPAN

               virtualListViewResult ENUMERATED {
                       success (0),
                       operatonsError (1),
                       unwillingToPerform (53),
                       insufficientAccessRights (50),
                       busy (51),
                       timeLimitExceeded (3),
                       adminLimitExceeded (11),
                       sortControlMissing (60),
                       indexRangeError (61),
                       other (80) }  }

 view release on metacpan or  search on metacpan

tests/include/pdclib/auxiliary/errno/errno_readout.c  view on Meta::CPAN

    { "_PDCLIB_EAFNOSUPPORT", EAFNOSUPPORT, "Address family not supported" },
    { "_PDCLIB_EAGAIN", EAGAIN, "Resource unavailable, try again" },
    { "_PDCLIB_EALREADY", EALREADY, "Connection already in progress" },
    { "_PDCLIB_EBADF", EBADF, "Bad file descriptor" },
    { "_PDCLIB_EBADMSG", EBADMSG, "Bad message" },
    { "_PDCLIB_EBUSY", EBUSY, "Device or resource busy" },
    { "_PDCLIB_ECANCELED", ECANCELED, "Operation canceled" },
    { "_PDCLIB_ECHILD", ECHILD, "No child processes" },
    { "_PDCLIB_ECONNABORTED", ECONNABORTED, "Connection aborted" },
    { "_PDCLIB_ECONNREFUSED", ECONNREFUSED, "Connection refused" },
    { "_PDCLIB_ECONNRESET", ECONNRESET, "Connection reset" },

tests/include/pdclib/auxiliary/errno/errno_readout.c  view on Meta::CPAN

    { "_PDCLIB_EROFS", EROFS, "Read-only file system" },
    { "_PDCLIB_ESPIPE", ESPIPE, "Invalid seek" },
    { "_PDCLIB_ESRCH", ESRCH, "No such process" },
    { "_PDCLIB_ETIME", ETIME, "Stream ioctl() timeout" },
    { "_PDCLIB_ETIMEDOUT", ETIMEDOUT, "Connection timed out" },
    { "_PDCLIB_ETXTBSY", ETXTBSY, "Text file busy" },
    { "_PDCLIB_EWOULDBLOCK", EWOULDBLOCK, "Operation would block" },
    { "_PDCLIB_EXDEV", EXDEV, "Cross-device link" },

};

 view release on metacpan or  search on metacpan

UUlib.pm  view on Meta::CPAN

      $path=~s/^.*[\/\\]//;

      $path
   }

   sub busycb {
      my ($action, $curfile, $partno, $numparts, $percent, $fsize) = @_;
      $_[0]=straction($action);
      print "busy_callback(", (join ",",@_), ")\n";
      0
   }

   SetOption OPT_RBUF, 128*1024;
   SetOption OPT_WBUF, 1024*1024;

UUlib.pm  view on Meta::CPAN

   # show the three ways you can set callback functions. I normally
   # prefer the one with the sub inplace.
   SetFNameFilter \&namefilter;

   SetBusyCallback "busycb", 333;

   SetMsgCallback sub {
      my ($msg, $level) = @_;
      print uc strmsglevel $_[1], ": $msg\n";
   };

 view release on metacpan or  search on metacpan

lib/Coro/DataPipe.pm  view on Meta::CPAN

    return unless $result;
    return wantarray?@$result:$result;
}

sub run_pipes {
    my ($prev_busy,$me,@next) = @_;
    while (1) {
        my $data_loaded = $me->load_data;        
        my $me_busy = $data_loaded || $me->busy_processors;
        # get processed data 
        schedule if $me_busy;
        # push it to next pipe
        $me_busy = $data_loaded || $me->busy_processors;
        my $next_busy = @next && run_pipes($prev_busy || $me_busy, @next);
        # I am busy either when I am already busy or my child are busy
        $me_busy ||= $next_busy;
        # pipeline is free if every pipe is free and no more data to process
        return 0 unless $me_busy || $data_loaded;
        # get data from pipe if we have free_processors
        return $me_busy if $prev_busy && $me->free_processors;
    }
    return 0;
}

sub set_input_iterator {

lib/Coro/DataPipe.pm  view on Meta::CPAN

    my $process_data_callback = extract_param($param,qw(process));
    my $main =  $Coro::current;
    $self->{process_iterator} = sub {
        my $data = shift;
        my $item_number = $self->{item_number}++;
        $self->{busy}++;
        my $coro = async {
            local $_ = $data;
            $_ = $process_data_callback->($data);
            $self->{output_iterator}->($_,$item_number);
            $self->{busy}--;
            $main->ready;
        };
    };
}

lib/Coro/DataPipe.pm  view on Meta::CPAN

sub extract_param {
    my ($param, @alias) = @_;
    return first {defined($_)} map delete($param->{$_}), @alias;
}

sub busy_processors {
    my $self = shift;
    return $self->{busy};
}

sub free_processors {
    my $self = shift;
    return $self->{busy} < $self->{number_of_data_processors};    
}

sub new {
    my ($class, $param) = @_;	
	my $self = {};

lib/Coro/DataPipe.pm  view on Meta::CPAN

    unless ($number_of_data_processors) {
        $number_of_data_processors = 2;
        warn "number_of_data_processors set to $number_of_data_processors";
    }
    $self->{number_of_data_processors} = $number_of_data_processors;
    # item_number & busy
    $self->{$_} = 0 for qw(item_number busy);
    $self->set_input_iterator($param);
    $self->set_output_iterator($param);
    $self->set_process_iterator($param);
    my $not_supported = join ", ", keys %$param;
    die "Parameters are redundant or not supported:". $not_supported if $not_supported;	

lib/Coro/DataPipe.pm  view on Meta::CPAN

See description of alorithm and subroutines there.

This module uses cooperative threads, so all threads share the same memory and no forks are used.
Good use case is when you make some long lasting queries to database/www and then process data
and want to do it asynchronosuly.
In that case even if you have one processor you will win because processor will be always busy thanks to Coro.

=head1 SEE ALSO

L<Coro>

 view release on metacpan or  search on metacpan

Multicore.pm  view on Meta::CPAN

Then code that runs in an event loop callback and executes
Digest::MD5::md5 would work fine without C<Coro::Multicore> - it would
simply calculate the MD5 digest and block execution of anything else. But
with C<Coro::Multicore> enabled, the same operation would try to run other
threads. And when those wait for events, there is no event loop anymore,
as the event loop thread is busy doing the MD5 calculation, leading to a
deadlock.

=head2 USE IT IN THE MAIN PROGRAM

One way to avoid this is to not run perlmulticore enabled functions

 view release on metacpan or  search on metacpan

Coro/AnyEvent.pm  view on Meta::CPAN

 # or load it manually for its utility functions:
 use Coro::AnyEvent;

 Coro::AnyEvent::sleep 5;     # block current thread for 5s
 Coro::AnyEvent::poll;        # poll for new events once
 Coro::AnyEvent::idle;        # block until process no longer busy
 Coro::AnyEvent::idle_upto 5; # same, but only up to 5 seconds

 Coro::AnyEvent::readable $fh, 60
    or die "fh didn't become readable within 60 seconds\n";

Coro/AnyEvent.pm  view on Meta::CPAN

=item Coro::AnyEvent::idle_upto $seconds

Like C<idle>, but with a maximum waiting time.

If your process is busy handling events, calling C<idle> can mean that
your thread will never be resumed. To avoid this, you can use C<idle_upto>
and specify a timeout, after which your thread will be resumed even if the
process is completely busy.

=item Coro::AnyEvent::readable $fh_or_fileno[, $timeout]

=item Coro::AnyEvent::writable $fh_or_fileno[, $timeout]

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

  [ENHANCEMENTS]

  * Implemented Crixa::Queue->consume(), a blocking API for waiting until
    messages are received. Unlike the wait_for_message() method, this method
    does not use a busy loop. Internally, it uses the poll() system call, so
    it should be much kinder on your CPU.

  * Added a Crixa::Message->consumer_tag() attribute. This will be set for
    messages received via the new Crixa::Queue->consume() API.

 view release on metacpan or  search on metacpan

lib/Crypt/Diceware/Wordlist/Beale.pm  view on Meta::CPAN

  brutal brute bryan bs bt btu bu bub buck bucks bud buddha buddy budge buds
  buff bug buggy bugle bugs buick build built bulb bulbs bulge bulk bulky
  bull bulls bully bum bump bumps bumpy bums bun bunch bunco bundy bunk bunny
  buns bunt bunts buoy bureau burg burger buried burke burly burma burn burns
  burnt burp burps burro burst burt burton bury bus bush bushel bushy buss
  bust busy but butane butch butt butte buxom buy buyer buys buzz bv bvm bw
  bwana bx by bye bylaw byline byob bypass byrd byron byte bytes byway bz c
  c&w c's c/o ca cab cabal cabana cabin cable cabot cache cackle cacti
  caddy cadet caesar cafe cage caged cages cagey cain cairn cairo cajun cake
  cakes calf calico call calls callus calm calms calvin cam came camel cameo
  camera camp camps camry can can't canal canary cancer candle candy cane

 view release on metacpan or  search on metacpan

lib/Crypt/HSXKPasswd/Dictionary/EN.pm  view on Meta::CPAN

    'building',
    'built',
    'burn',
    'burning',
    'business',
    'busy',
    'butter',
    'cake',
    'call',
    'came',
    'cannot',

 view release on metacpan or  search on metacpan

lib/Crypt/OpenSSL/CA.pm  view on Meta::CPAN

=back

=head1 ACKNOWLEDGEMENTS

IDEALX (L<http://www.idealx.com/>) is the company that put food on my
family's table for 5 years while I was busy coding IDX-PKI.  I owe
them pretty much everything I know about PKIX, and a great deal of my
todays' Perl-fu.  However, the implementation of this module is
original and does not re-use any code in IDX-PKI.

=head1 COPYRIGHT & LICENSE

 view release on metacpan or  search on metacpan

src/build-aux/install-sh  view on Meta::CPAN

      # to itself, or perhaps because mv is so ancient that it does not
      # support -f.
      {
	# Now remove or move aside any old file at destination location.
	# We try this two ways since rm can't unlink itself on some
	# systems and the destination file might be busy for other
	# reasons.  In this case, the final cleanup might fail but the new
	# file should still install successfully.
	{
	  test ! -f "$dst" ||
	  $doit $rmcmd -f "$dst" 2>/dev/null ||

 view release on metacpan or  search on metacpan

lib/Crypt/XKCDCommon1949.pm  view on Meta::CPAN

"both","bottle","bottom","bound","bow","bowl","box","boy",
"brain","branch","brass","brave","bread","break","breakfast","breath",
"breathe","breathing","breeze","brick","bridge","brief","bright","bring",
"broad","broke","broken","brother","brought","brown","brush","buffalo",
"build","building","built","buried","burn","burst","bus","bush",
"business","busy","but","butter","buy","by","cabin","cage",
"cake","call","calm","came","camera","camp","can","canal",
"cannot","cap","capital","captain","captured","car","carbon","card",
"care","careful","carefully","carried","carry","case","cast","castle",
"cat","catch","cattle","caught","cause","cave","cell","cent",
"center","central","century","certain","certainly","chain","chair","chamber",

 view release on metacpan or  search on metacpan

lib/Crypt/XkcdPassword/Words/EN.pm  view on Meta::CPAN

rather
julian
involved
swear
piece
busy
law
decided
black
joey
happening