view release on metacpan or  search on metacpan

lib/HTTP/UserAgentString/Parser.pm  view on Meta::CPAN

		Carp::carp("Can't get .ini from $INI_URL: " . $res_ini->status_line . "\n");
		return 0;
	}
}

sub updateDB($;$) {
	my ($self, $force) = @_;

	# Check if cache file needs to be updated according to max_age

	my $cache_file = $self->cache_file;

 view release on metacpan or  search on metacpan

lib/HTTPD/UserAdmin.pm  view on Meta::CPAN

	delete $attr{$_}; #just incase, everything else should be OK
    }
    return new HTTPD::GroupAdmin (%attr, @_);
}

sub update {
    my($self, $username, $passwd, @fields) = @_;
    return (0, "User '$username' does not exist") unless $self->exists($username);
    my ($old_encr, $bool);
    if (!defined $passwd) {
	$bool = 1;

 view release on metacpan or  search on metacpan

lib/Handel/Storage/RDBO/Result.pm  view on Meta::CPAN

sub discard_changes {
    return shift->storage_result->load(@_);
};

sub update {
    my ($self, $data) = @_;
    my $storage_result = $self->storage_result;
    my $coldata = Rose::DB::Object::Helpers::column_value_pairs($storage_result);

    if ($data) {

 view release on metacpan or  search on metacpan

lib/Catalyst/Helper/Controller/Handel/Cart.pm  view on Meta::CPAN

    [% uri %]/update/

=cut

sub update : Local {
    my ($self, $c) = @_;

    if ($c->req->method eq 'POST') {
        if ($c->forward('validate')) {
            if (my $cart = $c->forward('load')) {

 view release on metacpan or  search on metacpan

lib/Hardware/Vhdl/Automake/PreProcessor/Cish.pm  view on Meta::CPAN

    my @args = split(',', $args);
    delete $self->[0]{macros}{$macname.'('.scalar(@args)};
    $self->update_macro_re;
}

sub update_macro_re {
    my $perm  = shift->[0];
    my @macnames;
    my %macfuncnames;
    for my $search (map { $perm->{macros}{$_}{search} } keys %{$perm->{macros}}) {
        if (substr($search, -1) eq '(') {

 view release on metacpan or  search on metacpan

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

	}
	delete($self->{prios}->{$elem});
	return $elem;
}

sub update {
	my ($self, $payload, $priority) = @_;
	my $op = $self->{prios}->{$payload};
	if (defined($op)) {
		$self->{queue}->{$op} = [ grep { $_ ne $payload } @{$self->{queue}->{$op}} ];
		if (!@{$self->{queue}->{$op}}) {

 view release on metacpan or  search on metacpan

lib/Healthchecks.pm  view on Meta::CPAN

=cut

#################### subroutine header end ####################

sub update_check($c, $uuid, $data){
    return $c->_execute({
        api    => 'v1/checks/'.$uuid,
        method => 'post',
        data   => $data
    });

 view release on metacpan or  search on metacpan

eg/Helios-App-MP3IndexerService/lib/Helios/App/MP3IndexerService.pm  view on Meta::CPAN

method, and it has a hash with all of the configuration parameters for the 
current application running on the current host.

=cut 

sub updateDb 
{
	my $self = shift;
	my $filename = shift;
	my $mp3i = shift;
	my $config = $self->getConfig();

 view release on metacpan or  search on metacpan

t/10_hg_repository.t  view on Meta::CPAN

    my $command_result;
    $command_result = `$edit_file_command`;
}

sub update_repo {
    my $revision = shift || 0;

    my $update_command = "$hg -R $test_repo update -r $revision";

    my $command_result;

 view release on metacpan or  search on metacpan

lib/HiPi/Interface/Common/HD44780.pm  view on Meta::CPAN

sub send_text { croak('send_text must be overriden in derived class'); }

sub send_command { croak('send_command must be overriden in derived class'); }

sub update_baudrate { croak('update_baudrate must be overriden in derived class'); }

sub update_geometry { croak('update_geometry must be overriden in derived class'); }

1;

__END__

 view release on metacpan or  search on metacpan

lib/HoneyClient/Agent.pm  view on Meta::CPAN

#
# Check to make sure this issue is not critical.
#
# We must base64 encode the data, since SOAP doesn't like URLs
# that contain amperstands.
sub updateState {

    # Extract arguments.
    my ($class, $arg) = @_;
    my %args = ();

 view release on metacpan or  search on metacpan

lib/Hoobot/Page.pm  view on Meta::CPAN

  return $self;
}

# method (do the actual downloading thing)
sub update {
  my $self = shift;
  $self = $self->new unless ref $self; # does this make sense?!

  $self->prepare_update; # setup anything necessary before updating

 view release on metacpan or  search on metacpan

lib/Hypothesis/API.pm  view on Meta::CPAN

Returns a boolean value indicating whether or not the annotation for
that id has been successfully updated (1 = yes, 0 = no).

=cut

sub update_id {
    my ($self, $id, $payload) = @_;
    if (not defined $id) {
        die "Can only call update if given an id.";
    }
    my $data = $json->encode($payload);

 view release on metacpan or  search on metacpan

lib/IMDB/Local/DB/BaseObject.pm  view on Meta::CPAN

	$self->$key($value);
    }
    return(1);
}

sub update($@)
{
    my $self=shift;
    my $args={@_};
    my %updates;
    

 view release on metacpan or  search on metacpan

lib/IO/EPP/Base.pm  view on Meta::CPAN

Part of update_* functions

=cut

sub update_statuses_add {
    my ( undef, $type, $statuses ) = @_;

    my $add = '';
    my %sts;

lib/IO/EPP/Base.pm  view on Meta::CPAN

Part of update_* functions

=cut

sub update_statuses_rem {
    my ( undef, $type, $statuses ) = @_;

    my $rem = '';
    my @sts;

lib/IO/EPP/Base.pm  view on Meta::CPAN

        },
    );

=cut

sub update_contact {
    my ( $self, $params ) = @_;

    return ( 0, 0, 'no params' ) unless ref $params;

    return ( 0, 0, 'no cont_id' ) unless $params->{cont_id};

lib/IO/EPP/Base.pm  view on Meta::CPAN

        conn => $conn,
    } );

=cut

sub update_ns {
    my ( $self, $params ) = @_;

    return ( 0, 0, 'no ns' ) unless $$params{ns};

    my $add = '';

lib/IO/EPP/Base.pm  view on Meta::CPAN

Can be overwritten in a child module, example, in L<IO::EPP::DrsUa>

=cut

sub update_domain_add_nss {
    my ( undef, $params ) = @_;

    my $add = "     <domain:ns>\n";

    foreach my $ns ( @{$$params{add}{nss}} ) {

lib/IO/EPP/Base.pm  view on Meta::CPAN

Can be overwritten in a child module.

=cut

sub update_domain_rem_nss {
    my ( undef, $params ) = @_;

    my $rem = "     <domain:ns>\n";

    foreach my $ns ( @{$$params{rem}{nss}} ) {

lib/IO/EPP/Base.pm  view on Meta::CPAN

In this function this module contains the DNSSEC extension

=cut

sub update_domain_ext {
    my ( undef, $params ) = @_;

    my $ext = '';

    my $rem_ds = '';

lib/IO/EPP/Base.pm  view on Meta::CPAN

        conn => $c,
    } );

=cut

sub update_domain {
    my ( $self, $params ) = @_;

    return ( 0, 0, 'no params' ) unless ref $params;

    return ( 0, 0, 'no dname' ) unless $params->{dname};

 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;

Album.pm  view on Meta::CPAN

# Update an images preview file

sub update_preview {
  my $self    = shift;
  my $imageno = shift;
  my %opts    = %{$self->{'preview_opts'}};

  my $image   = $self->{'images'}->{$imageno};

 view release on metacpan or  search on metacpan

lib/Imgur/API/Endpoint/Account.pm  view on Meta::CPAN

		'get',
		\%p
	);
}

sub updateSettings {
	my ($this,%p) = @_;

	return $this->dispatcher->request(
		$this->path("",[],[],\%p),
		'put | post',

 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}) {