view release on metacpan or  search on metacpan

lib/Crypt/Keyczar/Key.pm  view on Meta::CPAN

use warnings;

sub new { return bless {}, $_[0]; }
sub digest_size { return 0 }
sub init { return '' }
sub update {}
sub sign { return '' }
sub verify { return 1 }

 view release on metacpan or  search on metacpan

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

Returns: OK | INVALID_DATA | ERROR.

=cut

sub update_contacts {
    my ($self, $contacts) = @_;
    return $self->_status(INVALID_DATA, "Invalid call parameters.") unless ($contacts and (ref $contacts eq 'ARRAY'));
    my @set = map { /^\w+:/ ? $_ : "mailto:$_" } @{$contacts};
    my ($status, $content) = $self->_request($self->{directory}->{'reg'}, { resource => 'reg', contact => \@set });
    return ($status == $self->_compat_response(ACCEPTED)) ? $self->_status(OK, "Email has been updated.") : $self->_status(ERROR, $content);

 view release on metacpan or  search on metacpan

Rhash.pm  view on Meta::CPAN

	# the 'if' added as workaround for perl 'global destruction' bug
	# ($self->{context} can disappear on global destruction)
	rhash_free($self->{context}) if $self->{context};
}

sub update($$)
{
	my $self = shift;
	my $message = shift;
	rhash_update($self->{context}, $message);
	return $self;
}

sub update_fd($$;$$)
{
	my ($self, $fd, $start, $size) = @_;
	my $res = 0;
	my $num = 0;

Rhash.pm  view on Meta::CPAN

	}

	return (defined($res) ? $num : undef); # return undef on read error
}

sub update_file($$;$$)
{
	my ($self, $file, $start, $size) = @_;
	open(my $fd, "<", $file) or return undef;
	my $res = $self->update_fd($fd, $start, $size);
	close($fd);

 view release on metacpan or  search on metacpan

Rhash.pm  view on Meta::CPAN

	# the 'if' added as workaround for perl 'global destruction' bug
	# ($self->{context} can disappear on global destruction)
	rhash_free($self->{context}) if $self->{context};
}

sub update($$)
{
	my $self = shift;
	my $message = shift;
	rhash_update($self->{context}, $message);
	return $self;
}

sub update_fd($$;$$)
{
	my ($self, $fd, $start, $size) = @_;
	my $res = 0;
	my $num = 0;

Rhash.pm  view on Meta::CPAN

	}

	return (defined($res) ? $num : undef); # return undef on read error
}

sub update_file($$;$$)
{
	my ($self, $file, $start, $size) = @_;
	open(my $fd, "<", $file) or return undef;
	my $res = $self->update_fd($fd, $start, $size);
	close($fd);

 view release on metacpan or  search on metacpan

sample/demhist.pl  view on Meta::CPAN

&update_brightcont;
Cv->WaitKey;

# brightness/contrast callback function
sub update_brightcont {
	my $brightness = $brightness - 100;
	my $contrast = $contrast - 100;

	# The algorithm is by Werner D. Streidt
	# (http://visca.com/ffactory/archives/5-99/msg00021.html)

 view release on metacpan or  search on metacpan

lib/Cvs/Simple.pm  view on Meta::CPAN

sub upd {
    goto &update;
}

sub update {
# update() -> update workspace (cvs -q update -d).
# update(file) -> update file  (cvs -q update file [file ... ]).
# Doesn't permit -r.
    my($self) = shift;
    my(@args) = @_;

 view release on metacpan or  search on metacpan

lib/DB/CouchDB.pm  view on Meta::CPAN

    my $result = $db->update_doc($docname, $doc) #returns a DB::CouchDB::Result object

=cut

sub update_doc {
    my $self = shift;
    my $name = shift;
    my $doc  = shift;
    my $jdoc = $self->json()->encode($doc);
    return DB::CouchDB::Result->new($self->_call(PUT => $self->_uri_db_doc($name), $jdoc));

 view release on metacpan or  search on metacpan

lib/DB/Handy.pm  view on Meta::CPAN

        $set{$1} = $2 if $part =~ /^(\w+)\s*=\s*(.+)$/;
    }
    return %set;
}

sub update {
    my($self, $table, $set_exprs, $ws) = @_;
    return $self->_err("No database selected") unless $self->{db_name};
    my $sch = $self->_load_schema($table) or return undef;
    my $dat = $self->_file($table, 'dat');
    my $rs  = $sch->{recsize};

 view release on metacpan or  search on metacpan

lib/DB/Object/Cache/Tables.pm  view on Meta::CPAN

    return( $self );
}

sub timeout { return( shift->_set_get_number( 'timeout', @_ ) ); }

sub updated { return( shift->_set_get_number( 'updated', @_ ) ); }

sub write
{
    my $self = shift( @_ );
    my $hash = shift( @_ ) || return( $self->error( "No table cache data was provided to write to cache file \"", $self->cache_file, "\"." ) );

 view release on metacpan or  search on metacpan

lib/DBD/AnyData2.pm  view on Meta::CPAN

    my ( $self, $data, $aryref ) = @_;
    my $meta = $self->{meta};
    $meta->{ad2h}->delete_one_row($aryref);
}

sub update_one_row ($$$)
{
    my ( $self, $data, $aryref ) = @_;
    my $meta = $self->{meta};
    # we don't know the key item
    $meta->{ad2h}->update_one_row($aryref);
}

sub update_specific_row ($$$$)
{
    my ( $self, $data, $aryref, $origary ) = @_;
    my $meta   = $self->{meta};
    return unless ( defined $origary->[0] );
    $origary->[0] eq $aryref->[0] or croak "Updating a row with new transaction ID is not supported. DELETE and INSERT instead.";

 view release on metacpan or  search on metacpan

Chart/Plot.pm  view on Meta::CPAN

	my ($angle) = @_;
	
	return (cos($angle)/sin($angle));
}

sub updateImagemap {
	my ($obj, $shape, $alt, $plotNum, $x, $y, $z, @pts) = @_;
	$y = '' unless defined($y);
	$z = '' unless defined($z);
#
#	do different for Perl map

Chart/Plot.pm  view on Meta::CPAN

	$imgmap .= " SHAPE=$shape COORDS=\"" . join(',', @pts) . '">';
	$obj->{imgMap} = $imgmap;
	return 1;
}

sub updatePerlImagemap {
	my ($obj, $plotNum, $x, $y, $z, $shape, @pts) = @_;
#
#	render image map element:
#	hotspot is an 8 pixel diameter circle centered on datapoint for
#	lines, points, areas, and candlesticks.

 view release on metacpan or  search on metacpan

testme.tmp.pl  view on Meta::CPAN

#memory_leak_test_bug_65734();

#memory_leak_arrays();


sub update_rule_return {

my @statements = (
    q[DROP TABLE IF EXISTS test CASCADE],
    q[CREATE TABLE test(id int primary key, animal text, sound text)],
    q[CREATE VIEW test_view AS SELECT * FROM test],

 view release on metacpan or  search on metacpan

lib/JLdap.pm  view on Meta::CPAN

	$self->{dirty} = 0  if ($status > 0);
	return $status;
}

sub update
{
	my ($self, $csr, $query) = @_;
	my ($i, $path, $regex, $table, $extra, @attblist, $filter, $all_columns);
	my $status = 0;
	my ($psuedocols) = "CURVAL|NEXTVAL|ROWNUM";

 view release on metacpan or  search on metacpan

t/ExecuteArray.pm  view on Meta::CPAN

    check_data($dbh, \@p1, \@p2);
}

# test updates
# updates are special as you can update more rows than there are parameter rows
sub update
{
    my ($self, $dbh, $ref) = @_;

    note("update test");

 view release on metacpan or  search on metacpan

examples/ora_explain.pl  view on Meta::CPAN

return($dialog);
}

################################################################################

sub update_title()
{
$PlanMain->configure(-title =>
   $User
      ? $User eq $Schema
         ? "$ProgName - connected to $DbName as $User"

 view release on metacpan or  search on metacpan

t/03_DBD-PO/15_header_msgstr_hash.t  view on Meta::CPAN

        WHERE  msgid=''
EOT
    isa_ok($sth_update, 'DBI::st', 'prepare select');
}

sub update_header {
    my $name = shift;

    my ($test_keys, $test_values) = @{ $test_data{$name} };

    my %params;

 view release on metacpan or  search on metacpan

testme.tmp.pl  view on Meta::CPAN

#memory_leak_test_bug_65734();

#memory_leak_arrays();


sub update_rule_return {

my @statements = (
    q[DROP TABLE IF EXISTS test CASCADE],
    q[CREATE TABLE test(id int primary key, animal text, sound text)],
    q[CREATE VIEW test_view AS SELECT * FROM test],

 view release on metacpan or  search on metacpan

testme.tmp.pl  view on Meta::CPAN

#memory_leak_test_bug_65734();

#memory_leak_arrays();


sub update_rule_return {

my @statements = (
    q[DROP TABLE IF EXISTS test CASCADE],
    q[CREATE TABLE test(id int primary key, animal text, sound text)],
    q[CREATE VIEW test_view AS SELECT * FROM test],

 view release on metacpan or  search on metacpan

t/36_hooks.t  view on Meta::CPAN

# hooks : just count the commits / rollbacks / updates
my ($n_commits, $n_rollbacks, $n_updates, @update_args);
sub commit_hook   {  $n_commits   += 1; return 0; }
sub rollback_hook {  $n_rollbacks += 1; return 0; }
sub update_hook   {  $n_updates   += 1; 
                     @update_args  = @_;          }

my $sql_count_rows = "SELECT COUNT(foo) FROM hook_test";

foreach my $call_func (@CALL_FUNCS) {

 view release on metacpan or  search on metacpan

t/36_hooks.t  view on Meta::CPAN

# hooks : just count the commits / rollbacks / updates
my ($n_commits, $n_rollbacks, $n_updates, @update_args);
sub commit_hook   {  $n_commits   += 1; return 0; }
sub rollback_hook {  $n_rollbacks += 1; return 0; }
sub update_hook   {  $n_updates   += 1;
                     @update_args  = @_;          }

my $sql_count_rows = "SELECT COUNT(foo) FROM hook_test";

foreach my $call_func (@CALL_FUNCS) {

 view release on metacpan or  search on metacpan

t/36_hooks.t  view on Meta::CPAN

# hooks : just count the commits / rollbacks / updates
my ($n_commits, $n_rollbacks, $n_updates, @update_args);
sub commit_hook   {  $n_commits   += 1; return 0; }
sub rollback_hook {  $n_rollbacks += 1; return 0; }
sub update_hook   {  $n_updates   += 1; 
                     @update_args  = @_;          }

my $sql_count_rows = "SELECT COUNT(foo) FROM hook_test";

foreach my $call_func (@CALL_FUNCS) {

 view release on metacpan or  search on metacpan

lib/JSprite.pm  view on Meta::CPAN

		$errdetails = $query;
		return (-503);
    }
}

sub update
{
    my ($self, $query) = @_;
    my ($i, $path, $regex, $table, $extra, $condition, $all_columns, 
	$columns, $status);
	my ($psuedocols) = "CURRVAL|NEXTVAL";

 view release on metacpan or  search on metacpan

Makefile.PL  view on Meta::CPAN

        $examples =~ s/\r\n/\n/g;
        update_file( 'lib/WWW/Mechanize/Chrome/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/XBase.pm  view on Meta::CPAN

	$self->set_record($num, map { $data{$_} } $self->field_names );
}

# Write record, fields specified as hash, unspecified will be
# unchanged
sub update_record_hash {
	my ($self, $num) = ( shift, shift );
	$self->NullError();

	my %olddata = $self->get_record_hash($num);
	return unless %olddata;

lib/XBase.pm  view on Meta::CPAN

	$self->NullError();
	$self->write_record($num, " ");
}

# Update the last change date
sub update_last_change {
	my $self = shift;
	return 1 if defined $self->{'updated_today'};
	my ($y, $m, $d) = (localtime)[5, 4, 3]; $m++; $y -= 100 if $y >= 100;
	$self->write_to(1, pack "C3", ($y, $m, $d)) or return;
	$self->{'updated_today'} = 1;
}
# Update the number of records
sub update_last_record {
	my ($self, $last) = @_;
	$last++;
	$self->write_to(4, pack "V", $last);
	$self->{'num_rec'} = $last;
}

 view release on metacpan or  search on metacpan

lib/DBI/Easy/Record.pm  view on Meta::CPAN

sub fetched {
	return 1 if defined shift->{field_values};
}

# update by pk
sub update_by_pk {
	my $self   = shift;
	my %params = @_;
	
	# there we make decision:
	# a) programmmer can provide update values

 view release on metacpan or  search on metacpan

lib/DBD/DBM.pm  view on Meta::CPAN

    my ( $self, $data, $aryref ) = @_;
    my $meta = $self->{meta};
    delete $meta->{hash}->{ $aryref->[0] };
}

sub update_one_row ($$$)
{
    my ( $self, $data, $aryref ) = @_;
    my $meta = $self->{meta};
    my $key  = shift @$aryref;
    defined $key or return;
    my $row = ( ref($aryref) eq 'ARRAY' ) ? $aryref : [$aryref];
    $meta->{hash}->{$key} = $meta->{dbm_mldbm} ? $row : $row->[0];
}

sub update_specific_row ($$$$)
{
    my ( $self, $data, $aryref, $origary ) = @_;
    my $meta   = $self->{meta};
    my $key    = shift @$origary;
    my $newkey = shift @$aryref;

 view release on metacpan or  search on metacpan

lib/DBICx/Hooks.pm  view on Meta::CPAN

  $ret;
}


sub update {
  my $self = shift;
  my $ret  = $self->next::method(@_);

  $_->($self) for dbic_hooks_for($self, 'update');

 view release on metacpan or  search on metacpan

lib/DBICx/MaterializedPath.pm  view on Meta::CPAN

    $self->next::method(@_);
    $self->set_materialized_path;
    $self->update;
}

sub update :method {
    my $self = shift;
    my %to_update = $self->get_dirty_columns;
    my $parent_column = $self->parent_column;
    $self->next::method(@_);
    return $self unless $to_update{$parent_column};

 view release on metacpan or  search on metacpan

lib/DBICx/Modeler/Model/Source.pm  view on Meta::CPAN

    my $storage = $rs->create( $given );
    $storage->discard_changes if $self->create_refresh && $storage->can( 'discard_changes' );
    return $self->inflate( _model__storage => $storage, @_ );
}

sub update_or_create {
    my $self = shift;
    my $given = shift;

    my $rs = $self->schema->resultset( $self->moniker );
    my $storage = $rs->update_or_create( $given );

 view release on metacpan or  search on metacpan

lib/DBIx/Abstract.pm  view on Meta::CPAN

    $self->__logwrite_sql( 1, $sql, @bind_params );
    $self->__mod_query( $sql, @bind_params );
    return $self;
}

sub update {
    my $self = shift;
    my ($table, $fields, $where ) = @_;

    # $table   == Name of table to update
    # $fields  == A reference to a hash of field/value pairs containing the