view release on metacpan or search on metacpan
lib/AnyMongo/BSON/OID.pm view on Meta::CPAN
builder => 'build_value',
);
sub BUILDARGS {
my $class = shift;
return $class->SUPER::BUILDARGS(flibble => @_) if @_ % 2;
return $class->SUPER::BUILDARGS(@_);
}
sub build_value {
my ($self, $str) = @_;
$str = '' unless defined $str;
view release on metacpan or search on metacpan
inc/Pod/Markdown.pm view on Meta::CPAN
# ABSTRACT: Convert POD to Markdown
use parent qw(Pod::Parser);
sub initialize {
my $self = shift;
$self->SUPER::initialize(@_);
$self->_private;
$self;
}
sub _private {
view release on metacpan or search on metacpan
lib/Apache/ASP/Application.pm view on Meta::CPAN
}
bless \%self;
}
sub Lock { shift->SUPER::LOCK };
sub UnLock { shift->SUPER::UNLOCK };
sub SessionCount {
my $asp = tied(%{$_[0]})->{asp};
if($asp->{session_count}) {
$asp->{Internal}{SessionCount};
view release on metacpan or search on metacpan
examples/auth/AuthTest.pm view on Meta::CPAN
sub Configure {
my $self = shift;
# Pull defaults from AuthBase and save.
$self->SUPER::Configure();
my $conft = $self->{conf};
# Initial configuration. Put defaults here before the @_ args are
# pulled in.
$self->{conf} = { %{$conft},
view release on metacpan or search on metacpan
lib/Apache/Auth/UserDB/File.pm view on Meta::CPAN
# Implementation:
##############################################################################
sub new {
my ($class, %options) = @_;
my $self = $class->SUPER::new(%options);
$self->{file_write_mode} ||= $self->file_write_mode_write_rename;
return $self;
}
sub open {
view release on metacpan or search on metacpan
lib/Apache/AuthCookie/Params.pm view on Meta::CPAN
return Apache::Request->new($r);
}
else {
$r->server->log_error("params: using CGI") if $debug >= 3;
return $class->SUPER::_new_instance($r);
}
return;
}
view release on metacpan or search on metacpan
Session/Session.pm view on Meta::CPAN
unless ($nonce) {
$log->info('Apache::AuthDigest::API::Session - no session found for ',
"session key $key, using default request time instead");
return $r->SUPER::note_digest_auth_failure;
}
$log->info("Apache::AuthDigest::API::Session - using notes() key $key ",
"with session $nonce");
Session/Session.pm view on Meta::CPAN
sub compare_digest_response {
my $r = shift;
my $rc = $r->SUPER::compare_digest_response(@_);
return unless $rc;
my ($key, $session) = $r->get_session;
view release on metacpan or search on metacpan
lib/Apache/AuthTicket/Base.pm view on Meta::CPAN
##################### END STATIC METHODS ###########################3
sub new {
my ($class, $r) = @_;
return $class->SUPER::new({request => $r});
}
sub dbh {
my $self = shift;
view release on metacpan or search on metacpan
lib/Apache/AxKit/Provider/File/Formatter.pm view on Meta::CPAN
my $r = $self->apache_request();
# Let the superclass A:A:P:File handle the request if
# this is a directory. Nacho++
if ($self->_is_dir()) {
return $self->SUPER::get_strref();
}
# From SUPER:
my $fh = $self->SUPER::get_fh();
local $/;
my $contents = <$fh>;
my $whichformatter = $r->dir_config('FormatterModule');
AxKit::Debug(5, "Formatter Provider configured to use " . $whichformatter);
view release on metacpan or search on metacpan
return \$$self{xml} if ($self->{xml});
# Let the superclass A:A:P:File handle the request if
# this is a directory
if ($self->_is_dir()) {
return $self->SUPER::get_strref();
}
# Process the file with Text::VimColor
my $filetype = '';
$filetype = $self->_resolve_type unless $noMimeInfo;
view release on metacpan or search on metacpan
Makefile.PL view on Meta::CPAN
eval { require Test::More } or return <<EOF;
test::
\t\@echo sorry, cannot run tests without Test::More
EOF
return $self->SUPER::test();
}
sub MY::postamble {
my $self = shift;
view release on metacpan or search on metacpan
CVS/Directory.pm view on Meta::CPAN
=cut
sub new {
my $proto = shift;
my $class = ref($proto) || $proto;
my $self = $class->SUPER::new(shift);
$self->{plain_files} = [];
$self->{files} = [];
$self->{directories} = [];
$self->{loaded} = 0;
view release on metacpan or search on metacpan
lib/Apache/Cache.pm view on Meta::CPAN
{
croak("$pkg object creation missing $name parameter.")
unless(defined($options->{$name}) && $options->{$name} ne '');
}
my $self = $class->SUPER::new(@_, namespace=>$options->{namespace});
return(undef()) unless(defined($self));
$self->{cache_options} = $options;
unless($self->SUPER::exists($options->{cachename}, $self->_lock_timeout))
{
return(undef()) if($self->SUPER::status eq FAILURE);
$self->_init_cache || return undef;
}
bless($self, $class);
return($self);
lib/Apache/Cache.pm view on Meta::CPAN
push(@{$data->{'_cache_metadata'}->{'queue'}}, $key);
$self->_check_keys($data);
$self->_check_size($data);
$self->SUPER::set($self->{cache_options}->{cachename}=>$data, NOWAIT);
my $rv = $self->status; # saving returned status
$self->unlock; # don't wait for Apache::SharedMem to auto unlock on destroy
return(undef()) if($rv eq FAILURE);
return($value);
lib/Apache/Cache.pm view on Meta::CPAN
if(exists $data->{$key})
{
$rv = delete($data->{$key});
delete($data->{_cache_metadata}->{timestamps}->{$key});
$data->{_cache_metadata}->{queue} = \@{grep($_ ne $key, @{$data->{_cache_metadata}->{queue}})};
$self->SUPER::set($self->{cache_options}->{cachename}=>$data);
return(undef()) if($self->status & FAILURE);
}
$self->unlock;
}
return($rv);
lib/Apache/Cache.pm view on Meta::CPAN
{
timestamps => {},
queue => [],
}
};
$self->SUPER::set($self->{cache_options}->{cachename}=>$cache_registry, $self->_lock_timeout);
return($self->SUPER::status eq FAILURE ? undef : 1);
}
sub _lock_timeout
{
my $self = shift;
lib/Apache/Cache.pm view on Meta::CPAN
sub _get_datas
{
my $self = shift;
my $data = $self->SUPER::get($self->{cache_options}->{cachename}, $self->_lock_timeout);
if($self->status eq FAILURE)
{
$self->_set_error("can't get the cacheroot: ", $self->error);
return(undef());
}
view release on metacpan or search on metacpan
eg/CacheWeather.pm view on Meta::CPAN
my $uri = $r->uri;
return(60) if ($uri=~ /hourly\.html$/);
return(60 * 24) if ($uri=~ /daily\.html$/);
return $self->SUPER::ttl($r);
}
sub handler ($$) {
my ($self,$r) = @_;
view release on metacpan or search on metacpan
lib/Apache/Clickable.pm view on Meta::CPAN
use URI::Find;
sub new {
my($class, %args) = @_;
my $self = $class->SUPER::new;
$self->{apr} = $args{apr};
$self->{currently_in_a} = 0;
return $self;
}
view release on metacpan or search on metacpan
my $conf_file = File::Spec->catfile($self->cwd, 't', 'httpd.conf');
$self->do_system(File::Spec->catfile('t', 'httpd'), '-f', $conf_file)
or die "Couldn't start httpd\n";
local $ENV{PORT} = $self->notes('apache_params')->{port};
$self->SUPER::ACTION_test;
my $pidfile = File::Spec->catfile('t', 'httpd.pid');
my $pid = do {open my($fh), $pidfile; local $/; <$fh>};
warn "Stopping httpd, process ID = $pid\n";
kill "TERM", $pid;
view release on metacpan or search on metacpan
lib/Apache/Config/Preproc.pm view on Meta::CPAN
}
}
if (@_) {
croak "Too many import parameters";
}
$class->SUPER::import();
}
sub new {
my $class = shift;
my $file = shift;
my $explist = Apache::Admin::Config::Tree::_get_arg(\@_, '-expand')
|| [ qw(include) ];
my $self = $class->SUPER::new($file, @_) or return;
bless $self, $class;
$self->{_filename} = $file;
$self->{_options} = \@_;
eval {
view release on metacpan or search on metacpan
lib/Apache/ConfigParser/Directive.pm view on Meta::CPAN
# initialized. This is done here. Tree::DAG_Node->new calls
# Apache::ConfigParser::Directive->_init, which will call
# Tree::DAG_Node->_init.
sub _init {
my $self = shift;
$self->SUPER::_init;
$self->{name} = '';
$self->{value} = '';
$self->{value_array} = [];
$self->{orig_value} = '';
$self->{orig_value_array} = [];
view release on metacpan or search on metacpan
ContentHandler.pm view on Meta::CPAN
return $result;
}
sub _init {
my $self = shift || die 'need $self';
$self->SUPER::_init(@_);
# overrides
$self->{title} = 'Project Algometer';
$self->{subtitle} = "Version $VERSION";
$self->{default_action} = 'hello';
view release on metacpan or search on metacpan
lib/Apache/DBI/Cache.pm view on Meta::CPAN
if( $GLOBAL_DESTROY ) {
if( $GLOBAL_DESTROY>1 ) {
$LOG->(2, "GLOBAL DESTROY $dbh->{$PRIVATE}->{idx}");
}
$dbh->SUPER::disconnect;
$dbh->SUPER::DESTROY;
} else {
$LOG->(2, "DESTROY $dbh->{$PRIVATE}->{idx}");
$dbh->disconnect;
}
1;
view release on metacpan or search on metacpan
Makefile.PL view on Meta::CPAN
use ExtUtils::MakeMaker;
sub MY::dist {
package MY; # so that "SUPER" works right
my $inherited = shift->SUPER::dist(@_);
$inherited .= "\nSCP = scp\n";
$inherited;
}
sub MY::dist_core {
package MY;
my $inherited = shift->SUPER::dist_core(@_);
$inherited .= <<'EOT';
mydist : tardist copydist
copydist :
view release on metacpan or search on metacpan
t/TestHttpd.pm view on Meta::CPAN
print $fh "export $k\n";
}
close $fh;
$_{environ} = $name;
}
$class->SUPER::new(server => "$^X ".$INC{'MockHttpd.pm'}, %_);
}
1;
view release on metacpan or search on metacpan
Makefile.PL view on Meta::CPAN
'clean' => { FILES => "*~ tmp*"}
);
sub MY::top_targets {
package MY;
my $inherited = shift->SUPER::top_targets(@_);
$inherited =~ s/(pure_all\s+::.+)/$1 README/;
$inherited;
}
sub MY::post_constants {
view release on metacpan or search on metacpan
t/lib/RPC/ExtDirect/Test/Qux.pm view on Meta::CPAN
use base 'RPC::ExtDirect::Test::Bar';
use RPC::ExtDirect Action => 'Qux';
# Redefine subs into Qux package without actually changing them
sub foo_foo : ExtDirect( 1 ) { shift; __PACKAGE__->SUPER::foo_foo(@_); }
sub foo_bar : ExtDirect( 2 ) { shift; __PACKAGE__->SUPER::foo_bar(@_); }
sub foo_baz : ExtDirect( params => [ qw( foo bar baz ) ] )
{ shift; __PACKAGE__->SUPER::foo_baz(@_); }
sub bar_foo : ExtDirect( 4 ) { shift; __PACKAGE__->SUPER::bar_foo(@_); }
sub bar_bar : ExtDirect( 5 ) { shift; __PACKAGE__->SUPER::bar_bar(@_); }
sub bar_baz : ExtDirect( formHandler ) {
shift;
__PACKAGE__->SUPER::bar_baz(@_);
}
1;
view release on metacpan or search on metacpan
lib/Apache/Filter.pm view on Meta::CPAN
# Prevent early filters from messing up the content-length of late filters
$self->header_out('Content-Length'=> undef);
return;
}
return $self->SUPER::send_http_header(@_);
}
sub send_fd {
my $self = shift;
if ($self->is_last_filter and eval{fileno $_[0]}) {
# Can send native filehandle directly to client
$self->SUPER::send_fd(@_);
} else {
my $fd = shift;
print while <$fd>;
}
}
view release on metacpan or search on metacpan
Client/lib/HTTunnel/Client.pm view on Meta::CPAN
sub new {
my $class = shift ;
my $url = shift ;
my %lwp_agent_args = @_ ;
my $this = $class->SUPER::new(
agent => 'HTTunnel::Client/$HTTunnel::Client::VERSION',
keep_alive => 1,
%lwp_agent_args
) ;
view release on metacpan or search on metacpan
lib/Apache/Hadoop/WebHDFS.pm view on Meta::CPAN
if ($_[0]->{'namenodeport'}) { $namenodeport = $_[0]->{'namenodeport'}; }
if ($_[0]->{'authmethod'}) { $authmethod = $_[0]->{'authmethod'}; }
if ($_[0]->{'user'}) { $user = $_[0]->{'user'}; }
# stack_depth set to 0 so we don't blow-up ram by saving content with each request.
my $self = $class-> SUPER::new( agent=>"Apache_Hadoop_WebHDFS",
stack_depth=>"0",
);
$self->{'namenode'} = $namenode;
$self->{'namenodeport'} = $namenodeport;
view release on metacpan or search on metacpan
examples/site/modules/Apache/JAF/MyJAF.pm view on Meta::CPAN
sub site_handler {
my ($self) = @_;
# common stuff before handler is called
# $self->{m} = JAF::MyJAF->new(); # create modeller -- if needed
$self->SUPER::site_handler();
# common stuff after handler is called
return $self->{status}
}
1;
view release on metacpan or search on metacpan
use vars qw(@ISA);
@ISA = qw(DBI::db);
sub prepare {
my ($dbh, @args) = @_;
my $sth = $dbh->SUPER::prepare(@args)
or return;
$sth->{private_mysubdbi_info} = { foo => 'bar' };
return $sth;
}
use vars qw(@ISA);
@ISA = qw(DBI::st);
sub fetch {
my ($sth, @args) = @_;
my $row = $sth->SUPER::fetch(@args)
or return;
do_something_magical_with_row_data($row)
or return $sth->set_err(1234, "The magic failed", undef, "fetch");
return $row;
}
When calling a SUPER::method that returns a handle, be careful to
check the return value before trying to do other things with it in
your overridden method. This is especially important if you want
to set a hash attribute on the handle, as Perl's autovivification
will bite you by (in)conveniently creating an unblessed hashref,
which your method will then return with usually baffling results
view release on metacpan or search on metacpan
MP3/L10N/ar.pm view on Meta::CPAN
package Apache::MP3::L10N::ar; # Arabic
use strict;
use Apache::MP3::L10N::RightToLeft;
use vars qw($VERSION @ISA %Lexicon);
@ISA = qw(Apache::MP3::L10N::RightToLeft);
sub language_tag {__PACKAGE__->SUPER::language_tag}
# Translators for this module, in no particular order:
# Isam Bayazidi <bayazidi|@arabeyes.org>
sub encoding { "utf-8" }