view release on metacpan or  search on metacpan

script/cpan2aur  view on Meta::CPAN

END_ERROR

    return %info;
}

sub update_if_old
{
    my ($thing) = @_;

    status "Checking if $thing is up to date...";

 view release on metacpan or  search on metacpan

lib/CPANPLUS/Dist/Gentoo.pm  view on Meta::CPAN

Updates the F<Manifest> file for the ebuild associated to the current dist object.

=cut

sub update_manifest {
 my $self = shift;
 my $stat = $self->status;

 my $file = $stat->ebuild_file;
 unless (defined $file and -e $file) {

 view release on metacpan or  search on metacpan

lib/CPANPLUS/Backend.pm  view on Meta::CPAN

author with C<CPANID> C<LOCAL>. You can use this id to search for all
added packages.

=cut

sub update_custom_source {
    my $self = shift;

    ### if it mentions /remote/, the request is to update a single uri,
    ### not all the ones we have, so dispatch appropriately
    my $rv = grep( /remote/i, @_)

 view release on metacpan or  search on metacpan

lib/CSS/Watcher.pm  view on Meta::CPAN

        parser_css => CSS::Watcher::Parser->new(),
        parser_less => CSS::Watcher::ParserLess->new(),
    }, $class);
}

sub update {
    my $self = shift;
    my $obj = shift;

    # check what is the monobj. file? dir?
    if (-f $obj || -d $obj) {

 view release on metacpan or  search on metacpan

examples/Tkwic.perl  view on Meta::CPAN

        print STDERR "$p:$filename: Cannot open file\n";
    }
    return \@macros;
}

sub update_history_menu {
    my ($self) = @_;
    my ($menu, $history, $label);

    $menu = $self->{history_menu};
    $history = $self->{query_history};

examples/Tkwic.perl  view on Meta::CPAN

    }
    $self->{field2_menu}->configure(-state => $state);
    $self->{attr2_menu}->configure(-state => $state);
}

sub update_freq_dialog {
    my ($self) = @_;
    my ($freq_dialog, $attributes, $default_attribute, $attribute);

    $attributes = $self->{positional_attributes};
    $default_attribute = $attributes->[0];

examples/Tkwic.perl  view on Meta::CPAN

    $self->set_frequency_type(0);

    return $dialog;
}

sub update_tag_dialog {
    my ($self) = @_;
    my ($tag_dialog, $corpus, $hlist, $n, @tags, $id, $freq);

    $corpus = $self->{corpus};

 view release on metacpan or  search on metacpan

lib/Cache/CacheSizer.pm  view on Meta::CPAN

  $self->set_max_size( $p_max_size );
  return $self;
}


sub update_access_time
{
  my ( $self, $p_key ) = @_;

  Assert_Defined( $p_key );

 view release on metacpan or  search on metacpan

lib/Cache/Elasticache/Memcache.pm  view on Meta::CPAN

This method will update the server list regardles of how much time has passed since the server list was last checked.

=cut

sub updateServers {
    my $self = shift;

    my $servers = $self->getServersFromEndpoint($self->{'config_endpoint'});

    ## Cache::Memcached::Fast does not support updating the server list after creation

 view release on metacpan or  search on metacpan

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

    $useheap->add($time, $key);

    $self->set_index_entries($key, { age => $time, lastuse => $time });
}

sub update_last_use {
    my Cache::File $self = shift;
    my ($key, $time) = @_;

    my $index_entries = $self->get_index_entries($key)
        or warnings::warnif('Cache', "missing index entry for $key");

 view release on metacpan or  search on metacpan

lib/CallBackery/Database.pm  view on Meta::CPAN

Insert the given data into the table. If a match map is given, try an update first
with the given match only insert when update has 0 hits.

=cut

sub updateOrInsertData {
    my $self = shift;
    my $table = shift;
    my $data = shift;
    my $match = shift;
    my $db = $self->mojoSqlDb;

 view release on metacpan or  search on metacpan

lib/Carmel/App.pm  view on Meta::CPAN

    print "---> Checking updates...\n";

    $self->update_or_install($snapshot, @args);
}

sub update_or_install {
    my($self, $snapshot, @args) = @_;

    my $builder = $self->builder;
    my $requirements = $self->requirements;

lib/Carmel/App.pm  view on Meta::CPAN

        print "---> Installing modules...\n";
        $self->update_or_install($snapshot);
    }
}

sub update_dependencies {
    my($self, $root_reqs, $snapshot) = @_;

    my @artifacts = $self->install($root_reqs, $snapshot);
    $self->dump_bootstrap(\@artifacts);
    $self->save_snapshot(\@artifacts);

 view release on metacpan or  search on metacpan

lib/Carrot/Continuity/Coordination/Episode/Paragraph/TCP_Socket_IO/Buffer/Output.pm  view on Meta::CPAN

	$this->[ATR_SIZE] += $l;

	return($this->update);
}

sub update
# /type method
# /effect ""
# //parameters
# //returns
#	Mica::Projection::Flow_Control

 view release on metacpan or  search on metacpan

lib/Carton/Builder.pm  view on Meta::CPAN

    }

    return @options;
}

sub update {
    my($self, $path, @modules) = @_;

    $self->run_install(
        "-L", $path,
        (map { ("--mirror", $_->url) } $self->effective_mirrors),

 view release on metacpan or  search on metacpan

lib/Catalog/db.pm  view on Meta::CPAN

sub connect { shift->instance()->connect(@_); }
sub logoff { shift->instance()->logoff(@_); }
sub insert { shift->instance()->insert(@_); }
sub dict_update { shift->instance()->dict_update(@_); }
sub mdelete { shift->instance()->mdelete(@_); }
sub update { shift->instance()->update(@_); }
sub tables { shift->instance()->tables(@_); }
sub table_exists { shift->instance()->table_exists(@_); }
sub databases { shift->instance()->databases(@_); }
sub exec_info { shift->instance()->exec_info(@_); }
sub exec { shift->instance()->exec(@_); }

 view release on metacpan or  search on metacpan

lib/Catalyst/ActionRole/MatchRequestMethod.pm  view on Meta::CPAN

    __PACKAGE__->config(
        action_roles => ['MatchRequestMethod'],
    );

    sub get_foo    : Path Method('GET')                { ... }
    sub update_foo : Path Method('POST')               { ... }
    sub create_foo : Path Method('PUT')                { ... }
    sub delete_foo : Path Method('DELETE')             { ... }
    sub foo        : Path Method('GET') Method('POST') { ... }

=head1 DESCRIPTION

 view release on metacpan or  search on metacpan

lib/Catalyst/ActionRole/Tabs.pm  view on Meta::CPAN

    $form->action($c->uri_for('update'));
    ...
  }

  # update action uses same tab as edit action
  sub update : Local Does(Tabs) TabAlias(edit) {
    ...
    if ($form->result->has_errors) {
      $stash->{template} = 'edit.tt2';
    }
    else {

lib/Catalyst/ActionRole/Tabs.pm  view on Meta::CPAN

  # action 'edit' has a Tab with label "Edit"
  sub edit : Local Does(Tabs) Tab { ... }

  # action 'update' has a Tab with label "Edit" too
  sub update : Local Does(Tabs) TabAlias(edit) { ... }

=head1 METHODS

Normaly you never have to touch the following two methods.
They are documented here to reveal their purpose.

 view release on metacpan or  search on metacpan

lib/Catalyst/Controller/Atompub/Collection.pm  view on Meta::CPAN

        1;
    }

    # Update the requested Entry in the method with "Atompub(update)"
    # attribute
    sub update_entry :Atompub(update) {
        my($self, $c) = @_;

        my $uri = $c->entry_resource->uri;

        # app:edited element, which was assigned by C::C::Atompub,

 view release on metacpan or  search on metacpan

lib/Catalyst/Controller/DBIC/API.pm  view on Meta::CPAN

            $self->each_object_inflate( $c, $c->req->get_object(0)->[0] );
    }
}


sub update_or_create {
    my ( $self, $c ) = @_;

    if ( $c->req->has_objects ) {
        $self->validate_objects($c);
        $self->transact_objects( $c, sub { $self->save_objects( $c, @_ ) } );

lib/Catalyst/Controller/DBIC/API.pm  view on Meta::CPAN

    }

}


sub update_object_from_params {
    my ( $self, $c, $object, $params ) = @_;

    $params = {%$params, %{$object->ident_condition}};

    my $updated_object =

 view release on metacpan or  search on metacpan

lib/Catalyst/ControllerRole/At.pm  view on Meta::CPAN

    sub find   :At($controller/{id:Int}) { ... }  # http://localhost/user/$integer

    # Define an action with an HTTP Method match at the same time

    sub update :Get($controller/{id:Int}) { ... } # GET http://localhost/user/$integer

    __PACKAGE__->meta->make_immutable;

=head1 DESCRIPTION

lib/Catalyst/ControllerRole/At.pm  view on Meta::CPAN

    sub init :Via($parent) At({id:Int}/...) {
      my ($self, $c) = @_;
    }

      sub show    :Via(init) At($name) { ... }
      sub update  :Via(init) At($name) { ... }
      sub delete  :Via(init) At($name) { ... }

    __PACKAGE__->meta->make_immutable;

This creates four (4) URL templates:

 view release on metacpan or  search on metacpan

lib/Catalyst/Helper/AuthDBIC.pm  view on Meta::CPAN

    $helper->mk_file("root/auth/login.tt", $login);
    $helper->mk_file("root/auth/logout.tt", $logout);
    $helper->mk_file("root/auth/unauth.tt", $unauth);
}

=head2 sub update_makefile()

Adds the auth and session dependencies to Makefile.PL

=cut

sub update_makefile {
    my $deps = Catalyst::Helper->get_file(__PACKAGE__, 'requires');
    my $doc = PPI::Document->new('Makefile.PL');
    my $find = PPI::Find->new( \&_find_install_script );
    my ($found) = $find->in($doc);
    croak "There's something wrong with your Makefile.PL so we can't continue (can't find  the install_script directive\n" if ! $found;

 view release on metacpan or  search on metacpan

lib/Catalyst/Manual/Intro.pod  view on Meta::CPAN

    package MyApp::Controller::Cart;

    use base qw/Catalyst::Controller/;

    sub add : Local { }
    sub update : Local { }
    sub order : Local { }

Note that you can also supply attributes via the Controller's config so
long as you have at least one attribute on a subref to be exported
(:Action is commonly used for this) - for example the following is

 view release on metacpan or  search on metacpan

lib/Catalyst/Model/LDAP/Entry.pm  view on Meta::CPAN

    return $self;
}


sub update {
    my $self = shift;
    my $client = shift || $self->_ldap_client;
    croak 'No LDAP client provided to update' unless $client;

    return $self->next::method( $client, @_ );

 view release on metacpan or  search on metacpan

lib/Catalyst/Model/Riak.pm  view on Meta::CPAN

sub read {
	my($self, $data) = @_;
	return $self->get($data);
}

sub update {
	my($self, $data) = @_;
	
	if ( defined($data->{key}) ) {
		my $object = $self->get({ key => $data->{key} });

 view release on metacpan or  search on metacpan

lib/Catalyst/Model/Search.pm  view on Meta::CPAN

    Catalyst::Exception->throw(
        message => ( ref $self || $self ) . ' does not implement add()'
    );
}

sub update {
    my $self = shift;
    
    Catalyst::Exception->throw(
        message => ( ref $self || $self ) . ' does not implement update()'
    );

 view release on metacpan or  search on metacpan

lib/Catalyst/Model/XML/Feed/Item.pm  view on Meta::CPAN

sub uri {
    my $self = shift;
    return $self->{_uri};
}

sub updated {
    my $self = shift;
    return $self->{_updated};
}

1;

 view release on metacpan or  search on metacpan

lib/Catalyst/Plugin/AtomPP.pm  view on Meta::CPAN

      my ($self, $c) = @_;

      ...
  }

  sub update_entry : Remote {
      ...
  }

  sub delete_entry : Remote {
      ...

 view release on metacpan or  search on metacpan

lib/Catalyst/Plugin/Authentication.pm  view on Meta::CPAN

}


## this was a short lived method to update user information -
## you should use persist_user instead.
sub update_user_in_session {
    my $c = shift;

    return $c->persist_user;
}

 view release on metacpan or  search on metacpan

lib/Catalyst/Plugin/AutoCRUD/Controller/AJAX.pm  view on Meta::CPAN

sub list : Chained('base') Args(0) {
    my ($self, $c) = @_;
    $c->forward($c->stash->{cpac}->{g}->{backend}, 'list');
}

sub update : Chained('base') Args(0) {
    my ($self, $c) = @_;
    $c->forward($c->stash->{cpac}->{g}->{backend}, 'update');
}

sub delete : Chained('base') Args(0) {

 view release on metacpan or  search on metacpan

lib/Catalyst/Controller/CRUD.pm  view on Meta::CPAN

 $self->call_trigger( 'update_check', $c, $hash );
 $self->call_trigger( 'update_after', $c, $model );

=cut

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

    # update already record
    if ( $c->req->param('btn_update') ) {
        my $model = $this->get_model( $c, $self, $c->req->param( $self->setting($c)->{primary} ) );

 view release on metacpan or  search on metacpan

lib/Catalyst/Plugin/Data/Pensieve.pm  view on Meta::CPAN

                foo => [ qw/ foo_id name bar baz / ],
            },
        },
    );
    
    sub update_data :Local :Args(3) {
        my ($self, $c, $pk, $key, $value) = @_;
        
        $c->pensieve->store_revisions(
            some_kinda_data => $pk, {
                $key => $value

 view release on metacpan or  search on metacpan

lib/Catalyst/Plugin/Form/Processor.pm  view on Meta::CPAN

}




sub update_from_form {
    my ( $c, @rest ) = @_;

    my $form = $c->form( @rest ) || return;

    return