view release on metacpan or  search on metacpan

lib/Astro/FITS/Header/AST.pm  view on Meta::CPAN

  my %args = @_;

  # initialise the inherited status to OK.
  my $status = 0;

  return $self->SUPER::configure(%args)
    if exists $args{Cards} or exists $args{Items};

  # read the args hash
  unless (exists $args{FrameSet}) {
     croak("Arguement hash does not contain FrameSet or Cards");

lib/Astro/FITS/Header/AST.pm  view on Meta::CPAN

       # Historical default
       $fchan->Set( Encoding => "FITS-WCS" );
     }
     $status = $fchan->Write( $wcsinfo );
  }
  return $self->SUPER::configure( Cards => \@cards );
}

# shouldn't need to do this, croak! croak!
sub writehdr {
  my $self = shift;

 view release on metacpan or  search on metacpan

lib/Astro/Montenbruck/Ephemeris/Planet/Jupiter.pm  view on Meta::CPAN

our $VERSION = 0.01;

sub new {
    my $class = shift;
    $class->SUPER::new( id => $JU);
}


sub heliocentric {
    my ($self, $t) = @_;

 view release on metacpan or  search on metacpan

inc/Module/Build/AstroNova.pm  view on Meta::CPAN

sub ACTION_code {
  my $self = shift;
  $self->depends_on("libnova");
  $self->depends_on("structs");
  return $self->SUPER::ACTION_code(@_);
}

sub ACTION_patchlibnova {
  my $self = shift;
  if ($^O =~ /bsd/i or $^O =~ /solaris/i) {

 view release on metacpan or  search on metacpan

Build.PL  view on Meta::CPAN

            erfasrc/src/erfaversion.c
            palsrc/palVers.c
            palsrc/palTest.c
        ];
        return () if exists $exclude{$_[0]};
        return $self->SUPER::compile_c(@_);
    }
EOF

my $build = $class->new
  (

 view release on metacpan or  search on metacpan

inc/My/Module/Build.pm  view on Meta::CPAN

    return;
}

sub harness_switches {
    my ( $self ) = @_;
    my @res = $self->SUPER::harness_switches();
    foreach ( @res ) {
	'-MDevel::Cover' eq $_
	    or next;
	$_ .= '=-db,cover_db,-ignore,inc/';
    }

 view release on metacpan or  search on metacpan

Table/Base.pm  view on Meta::CPAN

  sub new
  { 
    my $this = shift;
    my $class = ref($this) || $this;

    my $self = $class->SUPER::new();

    ...

    bless $self, $class;
  }

 view release on metacpan or  search on metacpan

inc/Astro/SpaceTrack/Dumper.pm  view on Meta::CPAN

sub new {
    my ( $class, %arg ) = @_;
    local $Mock::LWP::UserAgent::CANNED_RESPONSE_FILE = delete
    $arg{canned_response_file};
    my $self = $class->SUPER::new( %arg );
    $self->{ +__PACKAGE__ } = Mock::LWP::UserAgent::__load_data(
	optional	=> 1,
    );
    return $self;
}

 view release on metacpan or  search on metacpan

Build.PL  view on Meta::CPAN

    print $MPC_PM_FH $_;
  }
  close $MPC_DATA_FH || die "Error closing data input file: $!";
  close $MPC_PM_FH   || die "Error closing output module: $!";

  $self->SUPER::ACTION_build;
}

# Remove the file on clean
sub ACTION_clean {
  my $self = shift;
  # Ignore errors
  unlink File::Spec->catfile( "lib", "Astro", "Telescope", "MPC.pm" );
  $self->SUPER::ACTION_clean;
}

 view release on metacpan or  search on metacpan

inc/Astro/Coord/ECI/TLE/Period.pm  view on Meta::CPAN

my $pkg = __PACKAGE__;

sub new {
    my ( $class, %args ) = @_;
    my $self = $class->SUPER::new();
    $self->{$pkg}{period} = delete $args{period};
    $self->set( %args );
    return $self;
}

 view release on metacpan or  search on metacpan

t/lib/Test/AQWrapper.pm  view on Meta::CPAN

use Test::More;
use Test::Builder;

sub new {
    my ($class, @args) = @_;
    my $self = $class->SUPER::new(@args);
    $self->{__finish_num} = 0;
    $self->{__push_num} = 0;
    return $self;
}

sub push {
    my ($self, @args) = @_;
    $self->{__push_num}++;
    return $self->SUPER::push(@args);
}

sub finish {
    my ($self) = @_;
    $self->{__finish_num}++;

 view release on metacpan or  search on metacpan

lib/Async/Stream/FromArray.pm  view on Meta::CPAN

sub new {
	my $class = shift;
	my $items = \@_;

	return $class->SUPER::new(
		sub { 
			$_[0]->( @{$items} ? (shift @{$items}) : () );
			return;
		}
	);

 view release on metacpan or  search on metacpan

inc/MyModuleBuild.pm  view on Meta::CPAN

        my $orig = ExtUtils::CBuilder->can('compile');
        *ExtUtils::CBuilder::compile = sub {
            return __MyModuleBuild_CBuilder_patched_compile($orig, @_);
        };
    };
    my $cbuilder = shift->SUPER::cbuilder(@_);
    $cbuilder->have_cplusplus or die "C++ compiler required";
    return $cbuilder;
}

sub _construct {

inc/MyModuleBuild.pm  view on Meta::CPAN

                warn "env $var not set\n";
            }
        }
    }

    return $class->SUPER::_construct(@args);
}

sub __MyModuleBuild_CBuilder_patched_compile {
    my ($orig, $self, %args) = @_;
    my $source = $args{source};

inc/MyModuleBuild.pm  view on Meta::CPAN

    return $self->$orig(%args);
}

sub _infer_xs_spec {
    my ($self, $file) = @_;
    my $spec = $self->SUPER::_infer_xs_spec($file);

    # The spec always infers a ".c" file.
    # Fix it: .xs -> .c, .xs++ -> .cpp
    $spec->{c_file} =~ s/\.c$/.cpp/ if $file =~ /\.xs\+\+$/;

 view release on metacpan or  search on metacpan

Async.pm  view on Meta::CPAN

		alarm $timeout;
		my $s = eval { $task->() };
		return $msg if not defined $s and $@ eq "TIMEOUT\n";
		return $s;
	};
	$class->SUPER::new( $newtask );
}

package AsyncData;
our $VERSION = '0.14';

Async.pm  view on Meta::CPAN

	my ( $class, $task ) = ( shift, @_ );
	my $newtask = sub {
		my $v = $task->();
		return Storable::freeze( $v );
	};
	$class->SUPER::new( $newtask );
}

sub result {
	require Storable;
	my $self = shift;
	my $rc = $self->SUPER::result( @_ );
	return defined $rc ? Storable::thaw( $rc ) : $rc;
}

1;

 view release on metacpan or  search on metacpan

lib/Asynchat.pm  view on Meta::CPAN

    my($self, $sock, $map) = @_;

    $self->{_ac_in_buffer} = '';
    $self->{_incoming} = [];
    $self->{_producer_fifo} = []; # a list of data;
    $self->SUPER::init($sock, $map);
    
    return $self;
}

sub collect_incoming_data {

 view release on metacpan or  search on metacpan

script/TimeServer.pm  view on Meta::CPAN

use base qw( Asyncore::Dispatcher );

sub init {
    my($self, $port, $family, $type) = @_;

    $self->SUPER::init();

    if (not $port) {
        $port = 37;
    }

 view release on metacpan or  search on metacpan

t/lib/My/Server.pm  view on Meta::CPAN

use base qw( Atompub::Server );

sub init {
    my $server = shift;
    $server->realm('Atompub');
    $server->SUPER::init(@_);
}

sub handle_request {
    my $server = shift;
    $server->authenticate || return;

 view release on metacpan or  search on metacpan

lib/Attean/Expression.pm  view on Meta::CPAN

	has 'value' => (is => 'ro', isa => ConsumerOf['Attean::API::TermOrVariableOrTriplePattern']);

	sub arity { return 0 }
	sub BUILDARGS {
		my $class	= shift;
		return $class->SUPER::BUILDARGS(@_, operator => '_value');
	}
	
	sub tree_attributes { return qw(operator) }

	sub is_stable {

lib/Attean/Expression.pm  view on Meta::CPAN

	with 'Attean::API::UnaryExpression', 'Attean::API::Expression', 'Attean::API::UnaryQueryTree';

	has 'datatype'	=> (is => 'ro', isa => ConsumerOf['Attean::API::IRI']);
	sub BUILDARGS {
		my $class	= shift;
		return $class->SUPER::BUILDARGS(@_, operator => '_cast');
	}
	sub BUILD {
		my $self	= shift;
		state $type	= Enum[map { "http://www.w3.org/2001/XMLSchema#$_" } qw(integer decimal float double string boolean dateTime)];
		$type->assert_valid($self->datatype->value);

lib/Attean/Expression.pm  view on Meta::CPAN

	with 'Attean::API::Expression';

	sub arity { return 0 }
	sub BUILDARGS {
		my $class	= shift;
		return $class->SUPER::BUILDARGS(@_, operator => '_exists');
	}
	has 'pattern' => (is => 'ro', isa => ConsumerOf['Attean::API::Algebra']);
	sub as_string {
		my $self	= shift;
		my $sparql	= $self->pattern->as_sparql;

lib/Attean/Expression.pm  view on Meta::CPAN

	with 'Attean::API::Expression';
	sub arity { return 0 }
	sub BUILDARGS {
		my $class	= shift;
		return $class->SUPER::BUILDARGS(@_, operator => '_existsplan');
	}
	has 'plan' => (is => 'ro', isa => ConsumerOf['Attean::API::BindingSubstitutionPlan']);
	sub as_string {
		my $self	= shift;
		# TODO: implement as_string for EXISTS patterns

 view release on metacpan or  search on metacpan

lib/AtteanX/Endpoint.pm  view on Meta::CPAN

			$args{ model }	= shift @params;
			$args{ conf }	= shift @params;
			$args{ graph }	= Attean::IRI->new('http://example.org/graph');
		} elsif (any { blessed($_) && $_->does('Attean::API::Model') } @params) {
			# Assume the buildargs can be taken directly
			return $class->SUPER::BUILDARGS(@params);
		} else {
			# ->new( \%conf )
			my $conf		= shift @params;
			my $store_conf	= $conf->{store};
			my ($name, $file)	= split(';', $store_conf, 2);

lib/AtteanX/Endpoint.pm  view on Meta::CPAN

			$args{ model }	= $model;
			$args{ conf }	= $conf;
			$args{ graph }	= $graph;
		}
		
		return $class->SUPER::BUILDARGS(%args);
	}

=item C<< run ( $request ) >>

Run the SPARQL request contained in the given C<< $request >> object and return

 view release on metacpan or  search on metacpan

lib/Sub/Attempts.pm  view on Meta::CPAN

This has the same effect as writing:

    sub get_pie
    {
      my $self = shift;
      $self->SUPER::get_pie(@_);
    }

    attempts("get_pie", tries => 3);

If a method is defined by a subroutine in the current package then

lib/Sub/Attempts.pm  view on Meta::CPAN

      # typeglobs.
      eval qq{package $package;
              sub $subname
              {
                 my \$this = shift;
                 \$this->SUPER::$subname(\@_)
              }
      };
      $old_sub = *{ $glob }{CODE};
    }
    else

 view release on metacpan or  search on metacpan

inc/Spiffy.pm  view on Meta::CPAN

# This line is here to convince "autouse" into believing we are autousable.
sub can {
    ($_[1] eq 'import' and caller()->isa('autouse'))
        ? \&Exporter::import        # pacify autouse's equality test
        : $_[0]->SUPER::can($_[1])  # normal case
}

# TODO
#
# Exported functions like field and super should be hidden so as not to

 view release on metacpan or  search on metacpan

t/02_CallControl.t  view on Meta::CPAN

use base qw{ClassA};

sub new :Constructor{ 
	my $proto = shift; 
	my $class = ref($proto) || $proto; 
	my $self = $class->SUPER::new();
	bless($self, $class); 
}

sub methodA : Public {
	my $self = shift;
	return $self->SUPER::methodA;
}

sub methodB : Public {
	my $self = shift;
	return $self->SUPER::methodB;
}

sub methodC : Public {
	my $self = shift;
	return $self->SUPER::methodC;
}


1;

 view release on metacpan or  search on metacpan

lib/Tie/Array/Queue.pm  view on Meta::CPAN

	my $self = shift;
	
	# The first item on the stack can be peeked at.
	if ($_[0] == 0)
	{
		return $self->SUPER::FETCH(@_);
	}
	
	croak "FETCH operation not permitted on queue";
}

 view release on metacpan or  search on metacpan

lib/Attribute/Method.pm  view on Meta::CPAN

 Attribute::Method::_Deparse;

BEGIN { our @ISA = 'B::Deparse' }

sub maybe_qualify {
    my $ret = SUPER::maybe_qualify{@_};
    my ($pack,$name) = $ret =~ /(.*)::(.+)/;
    length $pack && $pack eq $dppack and return $name;
    $ret;
}

 view release on metacpan or  search on metacpan

DB/Adaptor/dbi/mysql.pm  view on Meta::CPAN

=cut

sub debug {
  my $self = shift;
  $self->dbh->debug(@_);
  $self->SUPER::debug(@_);
}

 view release on metacpan or  search on metacpan

MPG123/Client.pm  view on Meta::CPAN

@ISA = qw(Audio::Daemon::MPG123);
my $VERSION='0.9Beta';
 
sub new {
  my $class = shift;
  my $self = $class->SUPER::new(@_);
  bless $self, $class;
  return $self;
}

sub inline {

 view release on metacpan or  search on metacpan

Daemon/Client.pm  view on Meta::CPAN

@ISA = qw(Audio::Daemon);
my $VERSION='0.99Beta';
 
sub new {
  my $class = shift;
  my $self = $class->SUPER::new(@_);
  bless $self, $class;
  $self->warn("instantiated...");
  return $self;
}

 view release on metacpan or  search on metacpan

inc/Pod/Markdown.pm  view on Meta::CPAN

use parent qw(Pod::Parser);
use Pod::ParseLink (); # core

sub initialize {
    my $self = shift;
    $self->SUPER::initialize(@_);
    $self->_private;
    $self;
}

sub _private {

 view release on metacpan or  search on metacpan

lib/Audio/Nama/IO.pm  view on Meta::CPAN

our $VERSION = 1.0;
our @ISA = 'Audio::Nama::IO';
sub new {
	my $class = shift;
	my %vals = @_;
	$class->SUPER::new( %vals, device_id => "loop,$vals{endpoint}");
}
sub _format { 
	my $self = shift;
	return if $Audio::Nama::config->{opts}->{T}; # XX don't break tests
	Audio::Nama::signal_format($self->format_template, $config->{loop_chain_channel_width});

lib/Audio/Nama/IO.pm  view on Meta::CPAN

our @ISA = 'Audio::Nama::IO';
sub new {
	my $class = shift;
	my %vals = @_;
	print "from_bus: ", Audio::Nama::Dumper \%vals;
	#$class->SUPER::new( %vals, device_id => "loop,$vals{endpoint}");
}
}
{
package Audio::Nama::IO::any;
use v5.36;

 view release on metacpan or  search on metacpan

lib/Audio/NoiseGen.pm  view on Meta::CPAN

# sub import {
  # my $class = shift;
  # # if(grep { /^:init$/ } @_) {
    # # Audio::NoiseGen::init();
  # # }
  # $class->SUPER::import(@_);
# }

sub log10 {
  my $n = shift;
  return log($n)/log(10);

 view release on metacpan or  search on metacpan

Data/Filter.pm  view on Meta::CPAN

use base 'Audio::Filter::AllPole';

sub new
{
 my $class = shift;
 my $o = $class->SUPER::new(@_);
 $o->data(1.0,0.0,0.0,0.0,0.0);
 return $o;
}

sub setpole

Data/Filter.pm  view on Meta::CPAN

use base 'Audio::Filter::FIR';

sub new
{
 my $class = shift;
 my $o = $class->SUPER::new(@_);
 $o->data(1.0,0.0,0.0,0.0,0.0);
 return $o;
}

sub setzero