view release on metacpan or  search on metacpan

lib/Mac/OSVersion/Lite.pm  view on Meta::CPAN

sub major { shift->{major} }
sub minor { shift->{minor} }

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

    $self->_init_by_current_version     if @_ == 0;
    $self->_init_by_version_string(@_)  if @_ == 1;
    $self->_init_by_version_numbers(@_) if @_ >= 2;

 view release on metacpan or  search on metacpan

lib/Mac/PropertyList/SAX.pm  view on Meta::CPAN

use overload '""' => sub { shift->value };
sub new {
    my $class = shift;
    my ($type) = $class =~ /::([^:]+)$/;
    my $b = lc $type eq "true";
    bless Object::MultiType->new(scalar => $type, bool => $b) => $class
}
sub value { ${${$_[0]}->scalar} }
package Mac::PropertyList::SAX::true;
use base qw(Mac::PropertyList::SAX::Boolean Mac::PropertyList::true);
package Mac::PropertyList::SAX::false;

 view release on metacpan or  search on metacpan

Catalog/Catalog.pm  view on Meta::CPAN

sub get{
    my ($class, $path) = @_;
    my $self = xs_getcatalog($path) or return;
    @$self or return;
    bless $self => $class;
}

=item $catalog->set([$path]);

=item setcatalog($catalog, [$path]);

 view release on metacpan or  search on metacpan

lib/Macro/Micro.pm  view on Meta::CPAN

my $DEFAULT_MACRO_FORMAT = qr/(?<!\\)([\[<] (\w+) [>\]])/x;

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

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

  $arg{macro_format} = $DEFAULT_MACRO_FORMAT unless $arg{macro_format};

  $self->macro_format($arg{macro_format});

 view release on metacpan or  search on metacpan

ExpandAliases.pm  view on Meta::CPAN

    }
}

sub new {
    my ($class, $file) = @_;
    my $self = bless [ { }, { }, "" ] => $class;

    $self->[ FILE ] = (grep { -e $_ && -r _ }
                       ($file, @POSSIBLE_ALIAS_FILES))[0];
    $self->debug("Using alias file " . $self->[ FILE ]);
    $self->init();

 view release on metacpan or  search on metacpan

lib/Mail/SpamAssassin/SimpleClient.pm  view on Meta::CPAN

  $arg->{host} = 'localhost' unless defined $arg->{host};
  $arg->{port} = 783 unless defined $arg->{port};
  $arg->{timeout} = 120 unless defined $arg->{timeout};

  bless $arg => $class;
}


sub check {
  my ($self, $message) = @_;

 view release on metacpan or  search on metacpan

lib/Markup/Perl.pm  view on Meta::CPAN

my $print_end   = "\nmupl_EOS\n";
my $in_file = $0;

BEGIN { # catch prints into a variable, and dump at the end
	{	package Buffer;
		sub TIEHANDLE { my ($class, $b) = @_; bless $b => $class;              }
		sub PRINT	  { my $b = shift; $$b .= join '', @_;                     }
		sub PRINTF	  { my $b = shift; my $fm = shift; $$b .= sprintf($fm, @_);}
	} tie *STDOUT=>"Buffer", \$output;
	
	set_message(sub{ # for pretty CGI::Carp output

 view release on metacpan or  search on metacpan

lib/MarpaX/Languages/ECMAScript/AST/Grammar/Base.pm  view on Meta::CPAN

}


sub make_grammar_option {
    my ($class, $spec) = @_;
    return {bless_package => $class->make_bless_package,
	    source        => \$class->make_content($spec, $class->make_grammar_content)};
}


sub make_grammar_content {

 view release on metacpan or  search on metacpan

Expression.pm  view on Meta::CPAN

		EnablePrintf	=>	0,			# Enable printf function
		Functions	=>	{%InFuns},		# Known functions, initialise to builtins

	);

	my $self = bless \%ExprVars => $class;
	$self->SetOpt(@_);	# Process new options

	return $self;
}

 view release on metacpan or  search on metacpan

lib/Math/Fractal/Curve.pm  view on Meta::CPAN

	for (my $i = 0; $i < @_; $i+=2) {
		$self->{$_[$i]} = $_[$i+1];
	}

	delete $self->{_edges};
	bless $self => $class;

	if (not exists $self->{generator}) {
		croak "You need to supply a generator subroutine.";
	}
	

 view release on metacpan or  search on metacpan

lib/Math/Project3D/Plot.pm  view on Meta::CPAN

   # put them into our object.
   foreach my $arg (@valid_args) {
      $self->{$arg} = $args{$arg} if exists $args{$arg};
   }

   bless $self => $class;

   # get min/max logical x/y coordinates
   ( $self->{min_x}, $self->{min_y} ) = $self->_g_l(0, 0);
   ( $self->{max_x}, $self->{max_y} ) = $self->_g_l(
                                          $self->{image}->getwidth(),

 view release on metacpan or  search on metacpan

lib/Math/Project3D.pm  view on Meta::CPAN

   my $self  = {
     function => undef,
     @_
   };

   bless $self => $class;

   # Some attributes are required.
   my $missing_attribute = $self->_require_attributes(qw(
                                   plane_basis_vector
                                   plane_direction1

 view release on metacpan or  search on metacpan

lib/Math/Random/AcceptReject.pm  view on Meta::CPAN

        croak("'xmin' must be smaller than 'xmax'");
    }

    $self->{xdiff} = $self->{xmax} - $self->{xmin};

    bless $self => $class;

    return $self;
}

=head2 rand

 view release on metacpan or  search on metacpan

lib/Math/Random/Cauchy.pm  view on Meta::CPAN

        middle => $args{middle},
        random => $args{random},
        cache => [],
    };

    bless $self => $class;

    return $self;
}

=head2 rand

 view release on metacpan or  search on metacpan

lib/Math/Sequence.pm  view on Meta::CPAN

        formula       => $parsed,
        current       => 0,
        current_value => $start,
        cache         => [$start],
    };
    return bless $self => $class;
}

=item next()

The next() method returns the next element of the sequence and advances the

 view release on metacpan or  search on metacpan

lib/Math/Series.pm  view on Meta::CPAN

        current_value => $start,
        cache         => [$start],
        iter_var      => $iter_var,
        start_index   => $start_index,
    };
    return bless $self => $class;
}

=item next()

The next() method returns the next element of the series and advances the

 view release on metacpan or  search on metacpan

lib/Math/SimpleHisto/XS/Named.pm  view on Meta::CPAN

  my $struct = $Math::SimpleHisto::XS::JSON->decode($data);
  $class = delete $struct->{class};
  my $hclass = delete $struct->{histclass};
  $struct->{hist} = $hclass->new_from_dump($type, delete $struct->{hist});
  return bless($struct => $class);
}

# Can't simply be delegated, eventhough the implementation is the same :(
sub STORABLE_freeze {
  my $self = shift;

 view release on metacpan or  search on metacpan

lib/Math/Symbolic/Custom/Pattern.pm  view on Meta::CPAN

    pattern => $pattern,
    info    => $info,
    string  => $proto->to_string(),
  };

  return bless $self => $class;
}


sub _descend_build {
  my ($proto, $info) = @_;

 view release on metacpan or  search on metacpan

lib/Math/Symbolic/Custom/Transformation.pm  view on Meta::CPAN

    my $self = {
        pattern => $pattern,
        replacement => $replacement,
    };

    bless $self => $class;

    return $self;
}

 view release on metacpan or  search on metacpan

lib/Math/Symbolic/Constant.pm  view on Meta::CPAN

        ( ref($proto) ? %$proto : () ),
        value => $value,
        %args,
    };

    bless $self => $class;
}

=head2 Constructor zero

Arguments are treated as key-value pairs of object attributes.

 view release on metacpan or  search on metacpan

lib/Math/SymbolicX/Calculator/Interface/Shell.pm  view on Meta::CPAN

        input_handle     => $args{input_handle} || \*STDIN,
        prompt           => _dor($args{prompt}, '~> '),
        continued_prompt => _dor($args{continued_prompt}, '>> '),
        app_name         => _dor($args{app_name}, 'Symbolic Calculator Shell'),
    };
    bless $self => $class;

    $self->_setup_readline();

    return $self;
}

 view release on metacpan or  search on metacpan

lib/Math/SymbolicX/Calculator/Interface/Web.pm  view on Meta::CPAN

    my $self = {
        calc             => $args{calculator}
                            || Math::SymbolicX::Calculator->new(),
    };
    bless $self => $class;

    return $self;
}

=head2 execute_expression

 view release on metacpan or  search on metacpan

lib/Math/SymbolicX/Calculator.pm  view on Meta::CPAN

    my $self = {
        stash => {},
        history => [],
    };
    bless $self => $class;

    return $self;
}

 view release on metacpan or  search on metacpan

lib/Math/Taylor.pm  view on Meta::CPAN

        $self->{point} = $proto->{point} if defined $proto->{point};
        $self->{remainder_type} = $proto->{remainder_type}
          if defined $proto->{remainder_type};
    }

    bless $self => $class;

    $self->function( $args{function} ) if exists $args{function};
    $self->variable( $args{variable} ) if exists $args{variable};
    $self->point( $args{point} )       if exists $args{point};

 view release on metacpan or  search on metacpan

lib/Metabase/Client/Simple.pm  view on Meta::CPAN

    my $args = $class->__validate_args( \@args, { map { $_ => 1 } @valid_args } );

    # uri must have a trailing slash
    $args->{uri} .= "/" unless substr( $args->{uri}, -1 ) eq '/';

    my $self = bless $args => $class;

    unless ( $self->profile->isa('Metabase::User::Profile') ) {
        Carp::confess("'profile' argument for $class must be a Metabase::User::Profile");
    }
    unless ( $self->secret->isa('Metabase::User::Secret') ) {

 view release on metacpan or  search on metacpan

lib/Metabase/Web/Model/Metabase.pm  view on Meta::CPAN

sub COMPONENT {
  my ($class, $c, $user_config) = @_;

  my $config = Catalyst::Utils::merge_hashes($default_config, $user_config);

  my $self = bless {} => $class;
  
  my $fact_classes = $config->{fact_classes};
  Carp::croak "no fact_classes supplied to $class configuration"
    unless $fact_classes and @$fact_classes;

 view release on metacpan or  search on metacpan

t/delegate.t  view on Meta::CPAN

    package Second;

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

    sub name { return __PACKAGE__ }
}

 view release on metacpan or  search on metacpan

lib/Mixin/ExtraFields/Driver/DBIC.pm  view on Meta::CPAN

    id_column    => $arg->{id_column}    || 'object_id',
    name_column  => $arg->{name_column}  || 'extra_name',
    value_column => $arg->{value_column} || 'extra_value',
  };

  bless $self => $class;
}

sub id_column       { $_[0]->{id_column}    }
sub name_column     { $_[0]->{name_column}  }
sub value_column    { $_[0]->{value_column} }

 view release on metacpan or  search on metacpan

lib/Mixin/ExtraFields/Driver/HashGuts.pm  view on Meta::CPAN

}

sub from_args {
  my ($class, $arg) = @_;

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

  $self->{hash_key} = $arg->{hash_key} || $self->default_hash_key;

  return $self;
}