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
if (param('Add to Playlist')) {
my $dir = dirname($r->uri);
my @new = param('file') or return HTTP_NO_CONTENT;
my %seen;
# The line below is the only line that's different than SUPER::process_playlist
@playlist = grep !$seen{$_}++,(@playlist,map {(m/^\//) ? "$_" : "$dir/$_" } @new);
$changed++;
}
if (param('Play Selected') and param('playlist')) {
my $uri = dirname($r->uri);
$self->send_playlist([map { (m/^\//) ? "$_" : "$uri/$_" } @files]);
return OK;
}
return $self->SUPER::run();
}
$page =~ s!(</BODY[^>]*>)!</FORM>$1!oi;
print $page;
} else {
return $self->SUPER::list_directory($dir);
}
return OK;
}
=over 4
=item list_directory()
Checks to see if this is a skin file, if not hands off to SUPER::list_directory().
If there is a skin files, gets it, processes it, adds in the <SCRIPT> and <FORM>
tags and the prints it.
=item run()
Looks for the "Shuffle Selected" parameter and handles the request if there is one.
Otherwise, sends to SUPER::run().
=item process_playlist()
Same as SUPER::process_playlist with only one line changed. If there is an 'Add to
Playlist' param. file param values that begin with '/' are not prepended with the
current uri and are treated as document root relative.
=back
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" }
view release on metacpan or search on metacpan
PAR/PerlRun.pm view on Meta::CPAN
}
sub can_compile {
my $pr = shift;
my $status = $pr->SUPER::can_compile();
return $status unless $status eq OK();
return $pr->_can_compile();
}
sub namespace_from {
PAR/PerlRun.pm view on Meta::CPAN
}
sub compile {
my ($pr, $eval) = @_;
$pr->_set_path_info();
return $pr->SUPER::compile($eval);
}
1;
__END__