view release on metacpan or  search on metacpan

inc/Email/Address.pm  view on Meta::CPAN

sub new {
  my ($class, $phrase, $email, $comment, $orig) = @_;
  $phrase =~ s/\A"(.+)"\z/$1/ if $phrase;

  bless [ $phrase, $email, $comment, $orig ] => $class;
}

#line 274

sub purge_cache {

 view release on metacpan or  search on metacpan

inc/Email/Address.pm  view on Meta::CPAN

sub new {
  my ($class, $phrase, $email, $comment, $orig) = @_;
  $phrase =~ s/\A"(.+)"\z/$1/ if $phrase;

  bless [ $phrase, $email, $comment, $orig ] => $class;
}

#line 274

sub purge_cache {

 view release on metacpan or  search on metacpan

lib/Email/MessageID.pm  view on Meta::CPAN

    $args{user} ||= $class->create_user;
    $args{host} ||= $class->create_host;

    my $str = "$args{user}\@$args{host}";

    bless \$str => $class;
}

#pod =method create_host
#pod
#pod   my $domain_part = Email::MessageID->create_host;

 view release on metacpan or  search on metacpan

lib/Email/Send.pm  view on Meta::CPAN

    my %plugins = map {
        my ($short_name) = /^Email::Send::(.+)/;
        ($short_name, $_);
    } $class->plugins;
    $args->{_plugin_list} = \%plugins;
    return bless $args => $class;
}

BEGIN {
  for my $field (qw(mailer mailer_args message_modifier _plugin_list)) {
    my $code = sub {

 view release on metacpan or  search on metacpan

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

  Carp::carp 'Message with wide characters' if ${$text_ref} =~ /[^\x00-\xFF]/;

  my ($pos, $mycrlf) = $class->_split_head_from_body($text_ref);

  my $self = bless { mycrlf => $mycrlf } => $class;

  my $head;
  if (defined $pos) {
    $head = substr $$text_ref, 0, $pos, '';
    substr($head, -(length $mycrlf)) = '';

 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});