view release on metacpan or  search on metacpan

lib/IO/Iron/IronMQ/Client.pm  view on Meta::CPAN

    $log->debugf( 'Returned info about queue %s.', $params{'name'} );
    $log->tracef( 'Exiting get_queue_info: %s', $info );
    return $info;
}

sub update_queue {
    my $self   = shift;
    my %params = validate(
        @_,
        {
            'name' => {

 view release on metacpan or  search on metacpan

lib/IO/Socket/SSL/PublicSuffix.pm  view on Meta::CPAN

	}
	return $data;
    }
}

sub update_self_from_url {
    my $url = shift || URL();
    my $dst = __FILE__;
    -w $dst or die "cannot write $dst";
    open( my $fh,'<',$dst ) or die "open $dst: $!";
    my $code = '';

 view release on metacpan or  search on metacpan

lib/IPC/LeaderBoard.pm  view on Meta::CPAN

    my @private_values = @all_values[$shared_size .. $shared_size + $self->slot_private_size - 1];

    return \@shared_values, \@private_values;
}

sub update {
    my ($self, $idx, @rest) = @_;
    my $values           = (@rest && ref($rest[0]) eq 'ARRAY') ? shift(@rest) : undef;
    my %private_values   = @rest;
    my $operation_result = 0;
    die("wrong index") if ($idx >= $self->n_slots) || $idx < 0;

 view release on metacpan or  search on metacpan

lib/IPC/Lock/WithTTL.pm  view on Meta::CPAN

    undef $self->{_fh};

    return 1;
}

sub update_heartbeat {
    args(my $self,
         my $pid => { isa => 'Int', default => $$ },
       );

    my $fh = $self->_fh;

 view release on metacpan or  search on metacpan

benchmarks/shared.pl  view on Meta::CPAN

        $event->interval
    );
}


sub update {
    # Because each event runs in its own process, $$ will be set to the
    # process ID of the calling event, even though they both call this
    # same function

    $shared_data{called_count}->{$$}++;

 view release on metacpan or  search on metacpan

lib/IPDR/Collection/Client.pm  view on Meta::CPAN

	}
return 1;
}

sub update_session_parameters
{
my ( $self ) = shift;
my ( $session_extract ) =  $self->{_GLOBAL}{'sessioninfo'};
my ( $debug ) = $self->{_GLOBAL}{'DEBUG'};
my ( @sessions ) = keys %{$session_extract};

 view release on metacpan or  search on metacpan

Makefile.PL  view on Meta::CPAN

        $examples =~ s/\r\n/\n/g;
        update_file( 'lib/Image/CCV/Examples.pm', $examples );
    };
};

sub update_file {
    my( $filename, $new_content ) = @_;
    my $content;
    if( -f $filename ) {
        open my $fh, '<', $filename
            or die "Couldn't read '$filename': $!";

 view release on metacpan or  search on metacpan

lib/Image/ColorCollection.pm  view on Meta::CPAN

}
sub addColor {
	my ($class, $c) = @_;
	push @{$class->{colors}}, $c;
}
sub updateCentroid {
		my ($class, $c) = @_;
		my $shift = 0;
		my @colors = @{$class->{colors}};
		if(scalar(@colors) == 0)
		{

 view release on metacpan or  search on metacpan

lib/Image/Fixup.pm  view on Meta::CPAN

		height => int($image->Get('height') / 2)
	);
	$self->updateInfo;
}

sub updateInfo {
	my $self  = shift;
	my $image = $self->getImage;
	$self->{height} = $image->Get('height');
	$self->{width} = $image->Get('width');
	$self->{filesize} = $image->Get('filesize');

 view release on metacpan or  search on metacpan

lib/Image/MetaData/JPEG/Segment.pm  view on Meta::CPAN

# to handle this case? It is however better to have a     #
# corrupt object in memory, than a corrupt object written #
# over the original. Currently, this is restricted to the #
# possibility that an updated segment becomes too large.  #
###########################################################
sub update {
    my ($this) = @_;
    # get the name of the segment
    my $name = $this->{name};
    # return immediately if this is an entropy-coded segment or 
    # past-the-end garbage. There is no need to "update" them

 view release on metacpan or  search on metacpan

examples/scanadf-perl  view on Meta::CPAN

}

# Keep track of top-left corner options (if they exist at
# all) and replace the bottom-right corner options by a
# width/height option (if they exist at all).
sub update_geometry {
    my ( $opt, $i ) = @_;
    if (    ( $opt->{type} == SANE_TYPE_FIXED || $opt->{type} == SANE_TYPE_INT )
        and ( $opt->{unit} == SANE_UNIT_MM || $opt->{unit} == SANE_UNIT_PIXEL )
      )
    {

 view release on metacpan or  search on metacpan

Album.pm  view on Meta::CPAN

# Find which images need to have previews
# updated and call update_preview on those.

sub update_previews {
  my $self    = shift;
  my %images  = %{$self->{'images'}};
  my @process = grep { !$images{$_}->{valid} } keys %images;
  my $imageno;
  my $c = 1;

 view release on metacpan or  search on metacpan

lib/InSilicoSpectro/Databanks/DBEntryUniprot.pm  view on Meta::CPAN

    if ($pos>0) {
      $self->seqSubstr(from=>1, to =>$pos);
    }
  }

  sub updateAnnotPos{
    my ($self, $pos, $len)=@_;
    #shift or remove all annotated PTM
    my @amr=$self->annotatedModRes;
    if (@amr) {
      $self->clear_annotatedModRes;

 view release on metacpan or  search on metacpan

lib/Inferno/RegMgr/Service.pm  view on Meta::CPAN

    }
    $self->{t} = undef;
    return;
}

sub update {
    my ($self, $attrs) = @_;
    while (my ($attr, $val) = each %{ $attrs }) {
        $self->{attr}{ $attr } = $val;
    }
    if (defined $self->{io}) {

 view release on metacpan or  search on metacpan

lib/InfluxDB.pm  view on Meta::CPAN

    $self->status($res);

    return $res->is_success ? 1 : ();
}

sub update_database_user {
    state $rule = Data::Validator->new(
        name     => { isa => 'Str' },
        password => { isa => 'Str', optional => 1 },
        admin    => { isa => 'JSONBool', optional => 1 },
    )->with('Method');

 view release on metacpan or  search on metacpan

lib/Installer/Target.pm  view on Meta::CPAN

  $export_sh .= ("#" x 60)."\n";
  io($export_filename)->print($export_sh);
  chmod(0755,$export_filename);
}

sub update_env {
  my ( $self ) = @_;
  my %seen = defined $self->meta->{seen_dirs}
    ? %{$self->meta->{seen_dirs}}
    : ();
  if (!$seen{'bin'} and -e $self->target_path('bin')) {

 view release on metacpan or  search on metacpan

lib/Interchange/Search/Solr/UpdateIndex.pm  view on Meta::CPAN

Requires C<$mode> parameter which is either I<full>
or I<delta>.

=cut

sub update {
    my ($self, $mode) = @_;
    my ($update_url, $command, $request, $response);

    # reset status line
    $self->_set_status_line('');

 view release on metacpan or  search on metacpan

lib/Interchange6/Schema/Base/Attribute.pm  view on Meta::CPAN

    $base->update_attribute('hair_color', 'brown');

=cut

sub update_attribute_value {
    my ($self, $attr, $attr_value) = @_;
    my $base = $self->result_source->source_name;

    my ($attribute, $attribute_value) = $self->find_or_create_attribute($attr, $attr_value);

 view release on metacpan or  search on metacpan

lib/Interchange6/Cart.pm  view on Meta::CPAN

L<Interchange6::Cart::Product/id> or C<index> where C<index> is
the zero-based index of the product within L</products>.

=cut

sub update {
    my ( $self, @args ) = @_;
    my @products;

  ARGS: while ( @args > 0 ) {

 view release on metacpan or  search on metacpan

lib/JBD/Core/Db.pm  view on Meta::CPAN

#/ @param JBD::Core::Db $this
#/ @param scalar $table    A database table
#/ @param arrayref $columns    Column names to update
#/ @param arrayref $clauses    Where clauses
#/ @param arrayref $values    Column values
sub update {
    die 'Missing required args' if @_ < 5;
    my ($this, $table, $columns, $clauses, $values) = @_;
    $this->execute(update_query($table, $columns, $clauses), $values);
}

 view release on metacpan or  search on metacpan

lib/JIRA/Client.pm  view on Meta::CPAN

	}
    }
}


sub update_issue
{
    my ($self, $issue, $params) = @_;
    my $key;
    if (is_instance($issue => 'RemoteIssue')) {
	$key = $issue->{key};

 view release on metacpan or  search on metacpan

lib/JIRA/REST/Class/Issue.pm  view on Meta::CPAN

#pod
#pod Puts an update to JIRA.  Accepts a hash of fields => values to be put.
#pod
#pod =cut

sub update {
    my $self = shift;
    my $hash = {};
    while ( @_ ) {
        my $field = shift;
        my $value = shift;

 view release on metacpan or  search on metacpan

lib/JMAP/Tester.pm  view on Meta::CPAN

#pod JMAP::Tester object, and in futures mode will return a future that will resolve
#pod to the Result.
#pod
#pod =cut

sub update_client_session {
  my ($self, $auth_uri) = @_;
  $auth_uri //= $self->authentication_uri;

  my $auth_req = HTTP::Request->new(
    GET => $auth_uri,

 view release on metacpan or  search on metacpan

lib/JSAN/Mini.pm  view on Meta::CPAN

The C<update_mirror> static method creates and executes a new L<JSAN::Mini>
object using the default params, normally pretty much Doing What You Mean.

=cut

sub update_mirror {
	my $class = shift;
	my $self  = $class->new(@_);
	$self->run;
}

 view release on metacpan or  search on metacpan

lib/JaM/GUI.pm  view on Meta::CPAN

	);
	
	1;
}

sub update_folder_limit {
	my $self = shift; $self->trace_in;
	my %par = @_;
	my ($folder_object) = @par{'folder_object'};
	
	if ( not $folder_object ) {

 view release on metacpan or  search on metacpan

Build/Tasks.pm  view on Meta::CPAN

=back

=cut

sub update_prop_file {
    my %args             = @_;
    my $name             = delete $args{NAME}
        or _my_croak "You didn't supply a NAME to update_prop_file";
    my $new_props        = delete $args{NEW_PROPS}
        or _my_croak "You didn't supply a NEW_PROPS to update_prop_file";

 view release on metacpan or  search on metacpan

lib/Java/JCR/Node.pm  view on Meta::CPAN

    if ($@) { my $e = Java::JCR::Exception->new($@); croak $e }

    return $result;
}

sub update {
    my $self = shift;
    my @args = Java::JCR::Base::_process_args(@_);

    my $result = eval { $self->{obj}->update(@args) };
    if ($@) { my $e = Java::JCR::Exception->new($@); croak $e }