view release on metacpan or  search on metacpan

DB/Pg.pm  view on Meta::CPAN

    my $self = {
        dbh        => $dbh,
        distro     => undef,    # hashref w/ info on current working distro
        path_cache => { },      # $path_cache->{node_id} eq $path
    };
    bless($self => $class);

    #self->workOnDistro(name => $opt{name}, board => $opt{board});
    return $self;
}

 view release on metacpan or  search on metacpan

ECD.pm  view on Meta::CPAN

            'if'                => undef,
        },
    };
    delete($opt{name});
    @{$self->{attribute}}{keys %opt} = values %opt;
    return bless($self => $class);
}

# constructor, object
#_______________________________________
sub newFromCons {

 view release on metacpan or  search on metacpan

lib/Encode/Encoder.pm  view on Meta::CPAN

    }
    my $self = {
        data     => $data,
        encoding => $encname,
    };
    bless $self => $class;
}

sub encoder { __PACKAGE__->new(@_) }

sub data {

 view release on metacpan or  search on metacpan

lib/Enumeration.pm  view on Meta::CPAN

    my %instance_value;

    sub new
    {
        my $class = shift;
        my $self = bless \do { my $dummy } => $class;

        # Caller is creating an on-the-fly enumeration
        if ($class eq 'Enumeration')
        {
            my %values = map {$_ => 1} @_;

 view release on metacpan or  search on metacpan

lib/Error/Base.pm  view on Meta::CPAN

# 
sub new {
    my $class   = shift;
    my $self    = {};           # always hashref
    
    bless ($self => $class);
    $self->init(@_);            # init remaining args
    
    return $self;
}; ## new

 view release on metacpan or  search on metacpan

t/50_cleanup.t  view on Meta::CPAN

my $_DESTROY = "not called";

sub new {
    my $class = shift;
    bless Event::Lib::timer_new(shift) => $class;
}

sub DESTROY {
    $_DESTROY = "called";
    shift->SUPER::DESTROY;

 view release on metacpan or  search on metacpan

lib/Exception/Backtrace/Wrapper.pm  view on Meta::CPAN

    fallback => 1;

sub new {
    my ($class, $value) = @_;
    my $obj = { _value => $value };
    return bless $obj => $class;
}

sub set_message {
    my ($self, $value) = @_;
    $self->{_value} = $value;

 view release on metacpan or  search on metacpan

lib/Exception/Base.pm  view on Meta::CPAN

    };

    # Defaults for this object
    $e->{defaults} = { %$defaults };

    bless $e => $class;

    # Collect system data and eval error
    $e->_collect_system_data;

    return $e;

 view release on metacpan or  search on metacpan

lib/Exception/Died.pm  view on Meta::CPAN

    # Rebless if called as Exception::DiedDerivedClass->catch()
    if (do { local $@; local $SIG{__DIE__}; eval { $e->isa(__PACKAGE__) } }
        and ref $e ne $class and $e->{catch_can_rebless})
    {
        bless $e => $class;
    };

    return $e;
};

 view release on metacpan or  search on metacpan

lib/Exception/Reporter/Summarizer/Catalyst.pm  view on Meta::CPAN

sub new {
  my ($class, $arg) = @_;
  $arg ||= {};

  return bless { resolve_hostname => !! $arg->{resolve_hostname} } => $class;
}

sub resolve_hostname { $_[0]->{resolve_hostname} }

sub can_summarize {

 view release on metacpan or  search on metacpan

lib/Exception/Reporter/Summarizer/PlackRequest.pm  view on Meta::CPAN

sub new {
  my ($class, $arg) = @_;
  $arg ||= {};

  return bless { } => $class;
}

sub can_summarize {
  my ($self, $entry) = @_;
  return try { $entry->[1]->isa('Plack::Request') };

 view release on metacpan or  search on metacpan

lib/Exception/Reporter.pm  view on Meta::CPAN

    Carp::confess("no $key given") unless $arg->{$key} and @{ $arg->{$key} };
    Carp::confess("entry in $key is not an $class")
      if grep { ! $_->isa($class) } @{ $arg->{$key} };
  }

  bless $self => $class;

  $_->register_reporter($self) for $self->_summarizers;

  return $self;
}

 view release on metacpan or  search on metacpan

lib/Expect.pm  view on Meta::CPAN

	$class = ref($class) if ref($class); # so we can be called as $exp->new()

	# Create the pty which we will use to pass process info.
	my ($self) = IO::Pty->new;
	die "$class: Could not assign a pty" unless $self;
	bless $self => $class;
	$self->autoflush(1);

	# This is defined here since the default is different for
	# initialized handles as opposed to spawned processes.
	${*$self}{exp_Log_Stdout} = 1;

 view release on metacpan or  search on metacpan

lib/ExtUtils/InferConfig.pm  view on Meta::CPAN

        perl => undef,
        config => undef,
        inc => undef,
        ($args{debug} ? (debug => 1) : ()),
    };
    bless $self => $class;

    # get interpreter, check that we have access
    my $perl = $args{perl} || $^X;
    $perl = $self->_perl_to_file($perl);

 view release on metacpan or  search on metacpan

lib/ExtUtils/LibBuilder.pm  view on Meta::CPAN

sub new {
    my $class = shift;
    my %options = @_;

    my $self = bless ExtUtils::CBuilder->new(%options) => $class;
    # $self->{quiet} = 1;

    $self->{libext} = $^O eq "darwin" ? ".dylib" : ( $^O =~ /win/i ? ".dll" : ".so");
    $self->{exeext} = $^O =~ /win32/i ? ".exe" : "";

 view release on metacpan or  search on metacpan

bundled/CPAN-Meta-Requirements/CPAN/Meta/Requirements.pm  view on Meta::CPAN

  $options ||= {};
  Carp::croak "Argument to $class\->new() must be a hash reference"
    unless ref $options eq 'HASH';
  my %self = map {; $_ => $options->{$_}} @valid_options;

  return bless \%self => $class;
}

# from version::vpp
sub _find_magic_vstring {
  my $value = shift;

 view release on metacpan or  search on metacpan

lib/ExtUtils/XSpp/Plugin/Cloning.pm  view on Meta::CPAN

=cut

sub new {
  my $class = shift;
  my $self = {@_};
  bless $self => $class;
  return $self;
}

sub register_plugin {
  my ($class, $parser) = @_;

 view release on metacpan or  search on metacpan

lib/FAST/List/Gen.pm  view on Meta::CPAN

        FAST::List::Gen::DwimCode;
        my %save;
        sub new {
            my ($class, $gen) = @_;
            my $code = \&$gen;
            bless $code => $class;
            $save{$code} = $gen;
            $code
        }
        sub DESTROY {
            delete $save{$_[0]}

 view release on metacpan or  search on metacpan

lib/FASTX/Reader.pm  view on Meta::CPAN

sub new {
    # Instantiate object
    my $class = shift @_;
    my $self = bless {} => $class;
    my $args = {};
    
    # Named parameters: undefined $_[0] will read STDIN!
    if (defined $_[0] and substr($_[0], 0, 1) eq '-') {
      my %data = @_;

 view release on metacpan or  search on metacpan

lib/FSA/Rules.pm  view on Meta::CPAN

=cut

sub new {
    my $class = shift;
    return bless {@_} => $class;
}

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

=head2 Instance Methods

 view release on metacpan or  search on metacpan

FakeHash.pm  view on Meta::CPAN

package FakeHash::Node;

sub new {
  my ($class, @data) = @_;
  bless \@data => $class;
}

sub _access {
  my $self = shift;
  my $index = shift;

 view release on metacpan or  search on metacpan

script/rsybak  view on Meta::CPAN

#  croak "Cannot open a pty" if not defined $ptyfd;
#
#  my $pty = $class->SUPER::new_from_fd($ptyfd, "r+");
#  croak "Cannot create a new $class from fd $ptyfd: $!" if not $pty;
#  $pty->autoflush(1);
#  bless $pty => $class;
#
#  my $slave = IO::Tty->new_from_fd($ttyfd, "r+");
#  croak "Cannot create a new IO::Tty from fd $ttyfd: $!" if not $slave;
#  $slave->autoflush(1);
#

 view release on metacpan or  search on metacpan

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

        separator   => undef,
        buffer      => '',
        die_on_anchors => 1,
        @_
    };
    bless $self => $class;
}

sub READLINE { goto &readline; }

sub PRINT {

 view release on metacpan or  search on metacpan

lib/Filesys/Notify/KQueue.pm  view on Meta::CPAN

sub default_timeout { 1000 }

sub new {
    my $class = shift;
    my $args  = (@_ == 1) ? $_[0] : +{ @_ };
    my $self  = bless(+{} => $class);

    $self->timeout(exists $args->{timeout} ? $args->{timeout} : $class->default_timeout);
    $self->{_kqueue} = $args->{kqueue} if exists($args->{kqueue});
    $self->add(@{$args->{path}})       if exists($args->{path});

 view release on metacpan or  search on metacpan

lib/HAL/Resource.pm  view on Meta::CPAN

    my $class = $options{ class } || ref $self;
    my $ua = $self->ua;
    my $url = $self->resource_url( $name )
        or croak "Couldn't find resource '$name' in " . join ",", sort keys %{$self->_links};
    Future->done( $ua->get( $url ))->then( sub( $res ) {
        Future->done( bless { ua => $ua, %{ decode_json( $res->content )} } => $class );
    });
}

sub fetch_resource( $self, $name, %options ) {
    $self->fetch_resource_future( $name, %options )->get

 view release on metacpan or  search on metacpan

inc/Class/MOP/Instance.pm  view on Meta::CPAN

    $self->inline_set_slot_value($instance, $slot_name, $self->inline_slot_access($instance, $slot_name));
}

sub inline_rebless_instance_structure {
    my ($self, $instance, $class_variable) = @_;
    "bless $instance => $class_variable";
}

sub _inline_get_mop_slot {
    my ($self, $instance) = @_;
    $self->inline_get_slot_value($instance, $RESERVED_MOP_SLOT);

 view release on metacpan or  search on metacpan

FlatFile.pm  view on Meta::CPAN

my $classid = "A";
sub new {
  my ($class, %opts) = @_;
  my $self = {recno => 0};

  bless $self => $class;

  # acquire object properties from argument list (%opts)
  # or from class defaults or default defaults, as appropriate.
  # _default will detect missing required values
  # and unknown key names

 view release on metacpan or  search on metacpan

lib/Foorum/Scraper/MailMan.pm  view on Meta::CPAN

sub new {
    my $class = shift;
    my $self  = {};

    return bless $self => $class;
}

sub scraper {
    my ( $self, $url ) = @_;

 view release on metacpan or  search on metacpan

lib/Function/Interface/Info/Function.pm  view on Meta::CPAN

our $VERSION = "0.06";

sub new {
    my ($class, %args) = @_;
    bless \%args => $class;
}

sub subname() { $_[0]->{subname} }
sub keyword() { $_[0]->{keyword} }
sub params() { $_[0]->{params} }