view release on metacpan or  search on metacpan

t/04-working_with_emacs.t  view on Meta::CPAN

  echo_home() if $DEBUG;

  my $er = Emacs::Run->new;
  my $emacs_version = $er->emacs_version;

  # Make every other word upper-case - return number of iterations
  my $elisp = q{
        (let ( (count 0) )
          (while (progn
                   (upcase-word 1) (forward-word 1)
                   (setq count (+ count 1))

 view release on metacpan or  search on metacpan

lib/Encode/Arabic.pm  view on Meta::CPAN

    # 'use Encode::Arabic ":modes"' would export the functions controlling the conversion modes

    Encode::Arabic::demode 'arabtex', 'default';
    Encode::Arabic::enmode 'buckwalter', 'full', 'xml', 'strip off kashida';

    # Arabic in lower ASCII transliterations <--> Arabic script in Perl's internal encoding

    $string = decode 'ArabTeX', $octets;
    $octets = encode 'Buckwalter', $string;

    $string = decode 'Buckwalter', $octets;
    $octets = encode 'ArabTeX', $string;

    # Arabic in lower ASCII transliterations <--> Latin phonetic transcription, Perl's utf8

    $string = decode 'Buckwalter', $octets;
    $octets = encode 'ArabTeX', $string;

    $string = decode 'ArabTeX-ZDMG', $octets;

 view release on metacpan or  search on metacpan

t/data/demos/12169614.utf8  view on Meta::CPAN

more than 2.5 standard deviations away from the mean was considered an
outlier. Outliers were then removed from the population, and the means
and standard deviations were recalculated. Once again, any spot more
than 2.5 standard deviations away from the mean was considered an
outlier. This process was repeated until few or no outliers were
detected. In these experiments generally three iterations were needed
to identify all outliers in the population.
Array data were also analyzed with the Rosetta Resolver application
Axon error model (Rosetta Biosoftware). The lists of outliers from the
two analysis methods were compared, and only those genes that were
considered significantly changed in both were considered further. The

 view release on metacpan or  search on metacpan

lib/Env/Export.pm  view on Meta::CPAN

    my $prefix   = q{};
    my $override = 0;
    my $split    = q{};

    # Establish the set of allowable %ENV keys that are eligible for export.
    # This will avoid repeated iterations over %ENV later, and will remove
    # any keys that could not be used to create valid sub names
    my @choices = grep { /^[A-Za-z_]\w*$/ } keys %ENV;
    # This list will accumulate the set of subs to be created, in the form of
    # metadata:
    my @subs = ();

 view release on metacpan or  search on metacpan

Eobj/PLerrsys.pm  view on Meta::CPAN

	# if the $error error string is newline terminated then it
	# is copied into $mess.  Otherwise, $mess gets set (at the end of
	# the 'else' section below) to one of two things.  The first time
	# through, it is set to the "$error at $file line $line" message.
	# $error is then set to 'called' which triggers subsequent loop
	# iterations to append $sub to $mess before appending the "$error
	# at $file line $line" which now actually reads "called at $file line
	# $line".  Thus, the stack trace message is constructed:
	#
	#        first time: $mess  = $error at $file line $line
	#  subsequent times: $mess .= $sub $error at $file line $line

 view release on metacpan or  search on metacpan

bench/try_tiny.pl  view on Meta::CPAN

}));


__END__

Benchmark: timing 500000 iterations of RETURN, manual...
    RETURN: 6.84833 wallclock secs ( 6.58 usr +  0.03 sys =  6.61 CPU) @ 75642.97/s (n=500000)
    manual: 6.35331 wallclock secs ( 6.31 usr +  0.01 sys =  6.32 CPU) @ 79113.92/s (n=500000)
          Rate RETURN manual
RETURN 75643/s     --    -4%
manual 79114/s     5%     --

Benchmark: timing 10000000 iterations of RETURN, manual...
    RETURN: 23.4454 wallclock secs (23.34 usr +  0.03 sys = 23.37 CPU) @ 427899.02/s (n=10000000)
    manual: 3.0584 wallclock secs ( 3.02 usr +  0.01 sys =  3.03 CPU) @ 3300330.03/s (n=10000000)
            Rate RETURN manual
RETURN  427899/s     --   -87%
manual 3300330/s   671%     --

 view release on metacpan or  search on metacpan

bench/bench.pl  view on Meta::CPAN

use warnings;
use Time::HiRes qw(gettimeofday tv_interval);
use Eshu;

# Benchmark Eshu indentation engines
# Usage: perl bench/bench.pl [iterations]

my $iterations = $ARGV[0] || 100;

# Generate a sizeable C source
my $c_src = generate_c(500);
# Generate a sizeable Perl source
my $pl_src = generate_pl(500);
# Generate a sizeable XS source
my $xs_src = generate_xs(100);

printf "Benchmark: %d iterations each\n", $iterations;
printf "C source:    %d lines (%d bytes)\n", scalar(() = $c_src =~ /\n/g), length($c_src);
printf "Perl source: %d lines (%d bytes)\n", scalar(() = $pl_src =~ /\n/g), length($pl_src);
printf "XS source:   %d lines (%d bytes)\n", scalar(() = $xs_src =~ /\n/g), length($xs_src);
print "-" x 50, "\n";

bench/bench.pl  view on Meta::CPAN

bench("indent_xs", sub { Eshu->indent_xs($xs_src) });

sub bench {
	my ($label, $code) = @_;
	my $t0 = [gettimeofday];
	for (1 .. $iterations) {
		$code->();
	}
	my $elapsed = tv_interval($t0);
	printf "%-12s %8.3f ms total  %8.3f ms/iter\n",
		$label, $elapsed * 1000, ($elapsed / $iterations) * 1000;
}

sub generate_c {
	my ($funcs) = @_;
	my $out = "#include <stdio.h>\n\n";

 view release on metacpan or  search on metacpan

t/Event-Lib-UDPPump.t  view on Meta::CPAN

  }
  my $leaked = Devel::Leak::NoteSV($handle) - $SVcount;
  
  # I'm comparing for < 5 because I've seen issues where this varies by
  # a few one way or another with different versions of perl.  However,
  # we ran 1000 iterations, it should be much more than 5 if there is a
  # real leak in the XS.
  ok($leaked < 5, "No leaks");
#  print "leaked: $leaked\n";
}

 view release on metacpan or  search on metacpan

lib/Excel/Template/Container/Conditional.pm  view on Meta::CPAN

  <if name="__ODD__" is="false">
    ... Children here
  </if>

In the above example, the children will be executed if the value of __ODD__ (which is set by the L<LOOP|Excel::Template::Container::Loop> node) is false. So, for all even iterations.

=head1 AUTHOR

Rob Kinyon (rob.kinyon@gmail.com)

 view release on metacpan or  search on metacpan

perltidyrc  view on Meta::CPAN

-npro
-nsfs
--blank-lines-before-packages=0
--opening-hash-brace-right
--no-outdent-long-comments
--iterations=2
-wbb="% + - * / x != == >= <= =~ !~ < > | & >= < = **= += *= &= <<= &&= -= /= |= >>= ||= .= %= ^= x="

 view release on metacpan or  search on metacpan

benchmark-all.pl  view on Meta::CPAN

}

for ([200,2,4,8], [200,5,4,20], [100,2,10,30], [100,5,10,30], [50,10,50,20], [10,50,50,200]) {
	my ($loop, $export_mods, $exports, $packages)= @$_;
	print "\nCreating $export_mods modules, each exporting $exports symbols, imported into each of $packages packages\n";
	print "$loop iterations (invocations of perl interpreter)\n";
	cmpthese($loop, {
		'Exporter'             => "run_exporter('Exporter',$export_mods,$exports,$packages)",
		'Exporter::Tiny'       => "run_exporter('Exporter::Tiny',$export_mods,$exports,$packages)",
		'Sub::Exporter'        => "run_exporter('Sub::Exporter',$export_mods,$exports,$packages)",
		'Exporter::Extensible' => "run_exporter('Exporter::Extensible',$export_mods,$exports,$packages)",

 view release on metacpan or  search on metacpan

bundled/CPAN-Meta/CPAN/Meta/History.pm  view on Meta::CPAN

version 2.143240

=head1 DESCRIPTION

The CPAN Meta Spec has gone through several iterations.  It was
originally written in HTML and later revised into POD (though published
in HTML generated from the POD).  Fields were added, removed or changed,
sometimes by design and sometimes to reflect real-world usage after the
fact.

 view release on metacpan or  search on metacpan

lib/ExtUtils/ParseXS/Node.pm  view on Meta::CPAN

              . "|VERSIONCHECK|INCLUDE|INCLUDE_COMMAND|SCOPE|TYPEMAP";

        # Die if the next line is indented: all file-scoped things (CPP,
        # keywords, XSUB starts) are supposed to start on column 1
        # (although see the comment below about multiple parse_keywords()
        # iterations sneaking in indented keywords).
        #

        if ($pxs->{line}[0] =~ /^\s/) {
            # Try to customise the error message based around why this
            # line is indented, to better hint to the user what the

 view release on metacpan or  search on metacpan

lib/FAST/Bio/Search/Result/CrossMatchResult.pm  view on Meta::CPAN

FAST::Bio::Search::Result::CrossMatchResult - CrossMatch-specific subclass of FAST::Bio::Search::Result::GenericResult

=head1 SYNOPSIS

    # Working with iterations (CrossMatch results)

    $result->next_iteration();
    $result->num_iterations();
    $result->iteration();
    $result->iterations();

# See FAST::Bio::Search::Result::GenericResult for information about working with Results.

# See L<FAST::Bio::Search::Iteration::IterationI|FAST::Bio::Search::Iteration::IterationI>
# for details about working with iterations.

# TODO:
#     * Show how to configure a SearchIO stream so that it generates
#       CrossMatchResult objects.

lib/FAST/Bio/Search/Result/CrossMatchResult.pm  view on Meta::CPAN

 Usage   : my $obj = FAST::Bio::Search::Result::CrossMatchResult->new();
 Function: Builds a new FAST::Bio::Search::Result::CrossMatchResult object
 Returns : FAST::Bio::Search::Result::CrossMatchResult
 Args    : See FAST::Bio::Search::Result::GenericResult();
           The following parameters are specific to CrossMatchResult:
             -iterations  => array ref of FAST::Bio::Search::Iteration::IterationI objects
             -inclusion_threshold => e-value threshold for inclusion in the
                                     CrossMatch score matrix model (blastpgp)

=cut

sub new {
  my($class,@args) = @_;

  my $self = $class->SUPER::new(@args);

  $self->{'_iterations'} = [];
  $self->{'_iteration_index'} = 0;
  $self->{'_iteration_count'} = 0;

  my( $iters, $ithresh ) = $self->_rearrange([qw(ITERATIONS
                                                 INCLUSION_THRESHOLD)],@args);

lib/FAST/Bio/Search/Result/CrossMatchResult.pm  view on Meta::CPAN

          $self->add_iteration($i);
      }
  } 
  else {
      # This shouldn't get called with the new SearchIO::blast.
      #print STDERR "CrossMatchResult::new(): Not adding iterations.\n";
      $self->{'_no_iterations'} = 1;
  }

  #$self->SUPER::algorithm('cross_match');
  return $self;
}


=head2 hits

This method overrides L<FAST::Bio::Search::Result::GenericResult::hits> to take 
into account the possibility of multiple iterations, as occurs in CrossMatch reports.

If there are multiple iterations, all 'new' hits for all iterations are returned.
These are the hits that did not occur in a previous iteration.

See Also: L<FAST::Bio::Search::Result::GenericResult::hits>

=cut

sub hits {
   my ($self) = shift;
   if ($self->{'_no_iterations'}) {
       return $self->SUPER::hits;
   }
   my @hits = ();
   foreach my $it ($self->iterations) {
       push @hits, $it->hits;
   }
   return @hits;
}

=head2 next_hit

This method overrides L<FAST::Bio::Search::Result::GenericResult::next_hit> to take 
into account the possibility of multiple iterations, as occurs in CrossMatch reports.

If there are multiple iterations, calling next_hit() traverses the
all of the hits, old and new, for each iteration, calling next_hit() on each iteration. 

See Also: L<FAST::Bio::Search::Iteration::GenericIteration::next_hit>

=cut

sub next_hit {
    my ($self,@args) = @_;
    if ($self->{'_no_iterations'}) {
        return $self->SUPER::next_hit(@args);
    }

    my $iter_index;
    if (not defined $self->{'_last_hit'}) {
        $iter_index = $self->{'_iter_index'} = $self->_next_iteration_index;
    } else {
        $iter_index = $self->{'_iter_index'};
    }

    return if $iter_index >= scalar @{$self->{'_iterations'}};

    my $it = $self->{'_iterations'}->[$iter_index];
    my $hit = $self->{'_last_hit'} = $it->next_hit;

    return defined($hit) ? $hit : $self->next_hit;
}


=head2 num_hits

This method overrides L<FAST::Bio::Search::Result::GenericResult::num_hits> to take 
into account the possibility of multiple iterations, as occurs in CrossMatch reports.

If there are multiple iterations, calling num_hits() returns the number of
'new' hits for each iteration. These are the hits that did not occur
in a previous iteration.

See Also: L<FAST::Bio::Search::Result::GenericResult::num_hits>

=cut

sub num_hits{
   my ($self) = shift;
   if ($self->{'_no_iterations'}) {
       return $self->SUPER::num_hits;
   }
   if (not defined $self->{'_iterations'}) {
       $self->throw("Can't get Hits: data not collected.");
    }
    return scalar( $self->hits );
}

=head2 add_iteration

 Title   : add_iteration
 Usage   : $report->add_iteration($iteration)
 Function: Adds a IterationI to the stored list of iterations
 Returns : Number of IterationI currently stored
 Args    : FAST::Bio::Search::Iteration::IterationI

=cut

sub add_iteration {
    my ($self,$i) = @_;
    if( $i->isa('FAST::Bio::Search::Iteration::IterationI') ) { 
        push @{$self->{'_iterations'}}, $i;
        $self->{'_iteration_count'}++;
    } else { 
        $self->throw("Passed in a " .ref($i). 
                     " as a Iteration which is not a FAST::Bio::Search::IterationI.");
    }
    return scalar @{$self->{'_iterations'}};
}


=head2 next_iteration

lib/FAST/Bio/Search/Result/CrossMatchResult.pm  view on Meta::CPAN

sub next_iteration {
    my ($self) = @_;

   unless($self->{'_iter_queue_started'}) {
       $self->{'_iter_queue'} = [$self->iterations()];
       $self->{'_iter_queue_started'} = 1;
   }
   return shift @{$self->{'_iter_queue'}};
}

lib/FAST/Bio/Search/Result/CrossMatchResult.pm  view on Meta::CPAN

 Usage     : $iteration = $blast->iteration( $number );
 Purpose   : Get an IterationI object for the specified iteration
             in the search result (CrossMatch).
 Returns   : FAST::Bio::Search::Iteration::IterationI object
 Throws    : FAST::Bio::Root::NoSuchThing exception if $number is not within 
             range of the number of iterations in this report.
 Argument  : integer (optional, if not specified get the last iteration)
             First iteration = 1

=cut

sub iteration {
    my ($self,$num) = @_;
    $num = scalar @{$self->{'_iterations'}} unless defined $num;
    unless ($num >= 1 and $num <= scalar $self->{'_iteration_count'}) {
        $self->throw(-class=>'FAST::Bio::Root::NoSuchThing',
                     -text=>"No such iteration number: $num. Valid range=1-$self->{'_iteration_count'}",
                     -value=>$num);
    }
    return $self->{'_iterations'}->[$num-1];
}

=head2 num_iterations

 Usage     : $num_iterations = $blast->num_iterations; 
 Purpose   : Get the number of iterations in the search result (CrossMatch).
 Returns   : Total number of iterations in the report
 Argument  : none (read-only)

=cut

sub num_iterations { shift->{'_iteration_count'} }

# Methods provided for consistency with BPpsilite.pm (now deprecated);
# these are now merely synonyms

=head2 number_of_iterations

Same as L<num_iterations>.

=cut

sub number_of_iterations { shift->num_iterations }

=head2 round

Same as L<iteration>.

=cut

sub round { shift->iteration(@_) }


=head2 iterations

 Title   : iterations
 Usage   : my @iterations = $result->iterations
 Function: Returns the IterationI objects contained within this Result
 Returns : Array of L<FAST::Bio::Search::Iteration::IterationI> objects
 Args    : none

=cut

sub iterations { 
    my $self = shift;
    my @its = ();
    if( ref($self->{'_iterations'}) =~ /ARRAY/i ) {
       @its = @{$self->{'_iterations'}};
    }
    return @its;
}

=head2 no_hits_found

lib/FAST/Bio/Search/Result/CrossMatchResult.pm  view on Meta::CPAN

             for hitless reports generated when filtering.

 Returns   : Boolean
 Argument  : (optional) integer indicating the iteration number (CrossMatch)
             If iteration number is not specified and this is a CrossMatch result,
             then this method will return true only if all iterations had
             no hits found.

=cut

sub no_hits_found {
    my ($self, $round) = @_;

    my $result = 0;   # final return value of this method.
    # Watch the double negative! 
    # result = 0 means "yes hits were found"
    # result = 1 means "no hits were found" (for the indicated iteration or all iterations)

    # If a iteration was not specified and there were multiple iterations,
    # this method should return true only if all iterations had no hits found.
    if( not defined $round ) {
        if( $self->{'_iterations'} > 1) {
            $result = 1;
            foreach my $i( 1..$self->{'_iterations'} ) {
                if( not defined $self->{"_iteration_$i"}->{'_no_hits_found'} ) {
                    $result = 0;
                    last;
                }
            }

lib/FAST/Bio/Search/Result/CrossMatchResult.pm  view on Meta::CPAN

sub rewind {
   my $self = shift;
   $self->SUPER::rewind(@_);
   $self->{'_iteration_index'} = 0;
   foreach ($self->iterations) {
       $_->rewind;
   }
}

 view release on metacpan or  search on metacpan

lib/FFI/Platypus/Declare.pm  view on Meta::CPAN

for the platform that you are using.  This includes strings, opaque and
pointers to other types.

This function is not very fast, so you might want to save this value as
a constant, particularly if you need the size in a loop with many
iterations.

=head2 lang

 lang $language;

 view release on metacpan or  search on metacpan

lib/FFI/Platypus.pm  view on Meta::CPAN

for the platform that you are using.  This includes strings, opaque and
pointers to other types.

This function is not very fast, so you might want to save this value as
a constant, particularly if you need the size in a loop with many
iterations.

=head2 alignof

[version 0.21]

 view release on metacpan or  search on metacpan

deps/libffi/ltmain.sh  view on Meta::CPAN

    *)
      # Relative path, prepend $cwd.
      func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath
    ;;
  esac
  # Cancel out all the simple stuff to save iterations.  We also want
  # the path to end with a slash for ease of parsing, so make sure
  # there is one (and only one) here.
  func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
        -e "$removedotparts" -e "$collapseslashes" -e "$finalslash"`
  while :; do

 view release on metacpan or  search on metacpan

t/base.t  view on Meta::CPAN

    1 => { rules => [ 0 => [ 1, sub { $_[0]->done($_[0]->machine->{count} == 3 ) } ] ] },
), "Construct with simple states to run";

is $fsa->run, $fsa, "... Run should return the FSA object";
is $fsa->{count}, 3,
  "... And it should have run through the proper number of iterations.";
# Reset and try again.
$fsa->{count} = 0;
is $fsa->done(0), $fsa, "... We should be able to reset done";
ok $state = $fsa->curr_state,  "... We should be left in state '0'";
isa_ok $state, 'FSA::State';

 view release on metacpan or  search on metacpan

perltidyrc  view on Meta::CPAN

-npro
-nsfs
--blank-lines-before-packages=0
--opening-hash-brace-right
--no-outdent-long-comments
--iterations=2
-wbb="% + - * / x != == >= <= =~ !~ < > | & >= < = **= += *= &= <<= &&= -= /= |= >>= ||= .= %= ^= x="

 view release on metacpan or  search on metacpan

perltidyrc  view on Meta::CPAN

-npro
-nsfs
--blank-lines-before-packages=0
--opening-hash-brace-right
--no-outdent-long-comments
--iterations=2
-wbb="% + - * / x != == >= <= =~ !~ < > | & >= < = **= += *= &= <<= &&= -= /= |= >>= ||= .= %= ^= x="

 view release on metacpan or  search on metacpan

perltidyrc  view on Meta::CPAN

-npro
-nsfs
--blank-lines-before-packages=0
--opening-hash-brace-right
--no-outdent-long-comments
--iterations=2
-wbb="% + - * / x != == >= <= =~ !~ < > | & >= < = **= += *= &= <<= &&= -= /= |= >>= ||= .= %= ^= x="

 view release on metacpan or  search on metacpan

benchmark/simple_digest.pl  view on Meta::CPAN

    [5, 1_000_000_000],
]);

foreach my $test (@$test_set) {
    my ($file, $iter, $size) = @$test;
    say "# $iter iterations on ${size}B file";
    cmpthese(
        $iter,
        {
            'md5'    => sub { $file->digest('MD5') },
            'sha1'   => sub { $file->digest('SHA-1') },

 view release on metacpan or  search on metacpan

eg/benchmark.pl  view on Meta::CPAN

use File::KDBX::XS;

use Benchmark qw(:all :hireswallclock);
use Test::More;

my $iterations  = shift // 50;

my $rounds      = 500_000;
my $key         = "\1" x 32;
my $seed        = "\1" x 16;
my $expected    = pack('H*', '3f7dfb512060cc8be094cd259c7ff03c');

eg/benchmark.pl  view on Meta::CPAN

is $r, cryptx(), 'XS transform agrees with CryptX';
is $r, crypt_rijndael(), 'XS transform agrees with Crypt::Rijndael';

done_testing;

my $timings = timethese($iterations, {
    crypt_rijndael  => \&crypt_rijndael,
    cryptx          => \&cryptx,
    xs              => \&xs,
});
cmpthese($timings);

 view release on metacpan or  search on metacpan

lib/File/KDBX.pm  view on Meta::CPAN

The transform seed I<should> be changed each time the database is saved to file.

=head2 transform_rounds

The number of rounds or iterations used in the key derivation function. Increasing this number makes loading
and saving the database slower in order to make dictionary and brute force attacks more costly.

=head2 encryption_iv

The initialization vector used by the cipher.

 view release on metacpan or  search on metacpan

lib/File/Locate/Iterator.pm  view on Meta::CPAN

Iterators from this module are stand-alone and don't need any of the Perl
iterator frameworks.  But see L<Iterator::Locate>,
L<Iterator::Simple::Locate> and L<MooseX::Iterator::Locate> to inter-operate
with those others.  Those frameworks include ways to grep, map and otherwise
manipulate iterations.

=head2 Forks and Threads

If an iterator using a file handle is cloned to a new thread or to a process
level C<fork()> then generally it can be used by the parent or the child but

 view release on metacpan or  search on metacpan

t/002-file-callbacks.t  view on Meta::CPAN

    my $empty = "$tmpdir/empty.txt";
    File::Raw::spew($empty, "");

    my $count = 0;
    File::Raw::each_line($empty, sub { $count++ });
    is($count, 0, 'no iterations for empty file');
};

subtest 'each_line nonexistent file' => sub {
    my @collected;
    File::Raw::each_line("$tmpdir/nonexistent.txt", sub {

 view release on metacpan or  search on metacpan

t/02-aurora.t  view on Meta::CPAN

Defaults to 0.2. Seconds to sleep between the cration of the initial
files.

=item B<--sleep2=f>

Defaults to 0.1. Seconds to sleep between the iterations of the second
phase.

=item B<--iterations=i>

Defaults to 30. Number of iterations in the second phase.

=back

=head1 DESCRIPTION

t/02-aurora.t  view on Meta::CPAN

          ) or pod2usage(1);

$Opt{cleanup}    = 1   unless defined $Opt{cleanup};
$Opt{sleep1}     = 0.2 unless defined $Opt{sleep1};
$Opt{sleep2}     = 0.1 unless defined $Opt{sleep2};
$Opt{iterations} = 30  unless defined $Opt{iterations};
$Opt{files}      = 15  unless defined $Opt{files};


use File::Basename qw(dirname);
use File::Find;

t/02-aurora.t  view on Meta::CPAN

    my $rfs = $rrr->recentfiles;
    for my $rf (@$rfs) {
        $rf->sleep_per_connection(0);
    }
    $rrr->_rmirror_sleep_per_connection(0.001);
    for (my $t=0; $t < $Opt{iterations}; $t++) {
        $rf0->aggregate;
        $rrr->rmirror;
        archive;
        sleep $Opt{sleep2};
    }

 view release on metacpan or  search on metacpan

lib/File/Sip.pm  view on Meta::CPAN

    is      => 'ro',
    default => sub {1},
);


# internal cursor for iterations
has _read_line_position => (
    is      => 'rw',
    default => sub {0},
);

 view release on metacpan or  search on metacpan

lib/File/Which/Cached.pm  view on Meta::CPAN

which twice for the same executable, it performs twice.

This module will save the result, so that if your code is called to lookup an 
executable a thousand times, it takes just as long as one time.

This is desirable in iterations of many calls, etc.
In 2 thousand calls, we save one second.

=head1 SUBS

Not exported by default.

 view release on metacpan or  search on metacpan

Makefile.PL  view on Meta::CPAN

decryption.  (This is known as "password-based encryption" (PBE).)  The special
value "rand" means that a 32-byte password will be randomly generated using the
random number generator specified by the B<--rng> option.

The key will be derived using the PBKDF2 algorithm defined in PKCS#5 v2.0 (which
is also available as RFC2898).  An 8-byte random salt and 2048 iterations are
used.  A random initialization vector (IV) is also generated if required.  When
encrypting, both the salt and IV are prepended to the ciphertext so that they
may be recovered for use when decrypting.

Alternatively, the key may be specified directly (or randomly generated) using