view release on metacpan or search on metacpan
lib/Acme/URM.pm view on Meta::CPAN
}
sub new {
my $class = shift;
my $self = {@_};
$self = bless $self, $class;
$self->_init();
$self
}
sub _init {
view release on metacpan or search on metacpan
lib/Acme/Umlautify.pm view on Meta::CPAN
our %map = ( A => 196, E => 203, I => 207, O => 214, U => 220, a => 228,
e => 235, i => 239, o => 246, u => 252, y => 255 );
sub new {
bless({},$_[0]);
}
sub do {
my $self = shift @_;
return $self->umlautify(@_);
view release on metacpan or search on metacpan
lib/Acme/Undead.pm view on Meta::CPAN
die() #died;
=head1 DESCRIPTION
Acme::Undead is export routines, die(), bless() and sleep().
Use Acme::Undead when dont die at die(), die at bless() and not sleep at sleep().
=head1 OVERRIDE METHODS
=head2 die
lib/Acme/Undead.pm view on Meta::CPAN
=head2 sleep
undead is not sleeping
=head2 bless
the god bless clean undead auras.
=cut
our @EXPORT = qw/die sleep bless/;
our $IS_UNDEAD = 0;
sub import {
my $class = shift;
my $caller = shift;
lib/Acme/Undead.pm view on Meta::CPAN
sub _sleep {
my $hinthash = (caller(0))[10];
return $hinthash->{acme_undead} ? undef : sleep(shift);
}
sub _bless {
my $hinthash = (caller(0))[10];
return $hinthash->{acme_undead} ? die('blessed') : do {
my $arg = shift;
my $pkg = shift || (caller(0))[0];
bless($arg, $pkg);
}
}
sub END {
return unless $IS_UNDEAD;
view release on metacpan or search on metacpan
lib/Acme/Unicodify.pm view on Meta::CPAN
sub new {
my $class = shift;
my $self = {};
bless $self, $class;
$self->_define_cache();
return $self;
}
view release on metacpan or search on metacpan
lib/Acme/Urinal.pm view on Meta::CPAN
sub new {
my ($class, $resources) = @_;
if (ref $resources) {
return bless [ map { [ 0, $_ ] } @$resources ], $class;
}
elsif ($resources > 0) {
return bless [ map { [ 0, $_ ] } 0 .. ($resources - 1) ], $class;
}
else {
croak "incorrect argument";
}
}
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
$args{path} = $args{name};
$args{path} =~ s!::!/!g;
}
$args{file} ||= "$args{prefix}/$args{path}.pm";
bless(\%args, $class);
}
#line 212
sub call {
view release on metacpan or search on metacpan
lib/Acme/VerySign.pm view on Meta::CPAN
####################################################################
# unique that array
my %orig = map { $_ => 1 } @orig;
my $this = bless [keys %orig], $class;
return $this;
}
sub as_string { "64.94.110.11" }
view release on metacpan or search on metacpan
no strict 'refs';
for(@void){
*{$pkg . "::$_"} = sub :lvalue {
lnoreturn
if want qw(LVALUE ASSIGN);
return my $self = bless sub {}, $class
if want qw(OBJECT LVALUE);
return;
};
}
}
view release on metacpan or search on metacpan
lib/Acme/Voodoo.pm view on Meta::CPAN
if ( $instance =~ /HASH/ ) { $ref = {}; }
elsif ( $instance =~ /ARRAY/ ) { $ref = []; }
elsif ( $instance =~ /GLOB/ ) {
croak "glob objects are currently resistant to our voodoo spells!";
}
$doll = bless $ref, $dollClass;
## make our voodoo doll namespace inherit the AUTLOADER
## from the Acme::Voodoo namespace so we can trap method calls
push( @{ "${dollClass}::ISA" }, 'Acme::Voodoo' );
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
$args{path} =~ s!::!/!g;
}
$args{file} ||= "$args{base}/$args{prefix}/$args{path}.pm";
$args{wrote} = 0;
bless( \%args, $class );
}
sub call {
my ($self, $method) = @_;
my $obj = $self->load($method) or return;
view release on metacpan or search on metacpan
}
if ($conf{'list_file'} eq $conf{'hash_file'}) {
die "list_file and hash_file cannot point to the same file";
}
# Return our blessed object
return bless({ conf=>\%conf, data=>\%data}, __PACKAGE__);
}
# A destructor for the object, so that we get a chance to autosave the state
# if the caller so desired.
# Arguments: None.
view release on metacpan or search on metacpan
lib/Acme/WalkMethods.pm view on Meta::CPAN
sub new {
my ($proto,$conf) = @_;
my $class = ref($proto) || $proto;
my $self = {};
bless($self, $class);
return $self;
}
sub AUTOLOAD {
my $name = $AUTOLOAD;
view release on metacpan or search on metacpan
lib/Acme/Want5000trillion.pm view on Meta::CPAN
sub new {
my ($class,%parameters) = @_;
my $self = bless ({},ref($class) || $class);
return $self;
}
view release on metacpan or search on metacpan
lib/Acme/Web20/Validator.pm view on Meta::CPAN
__PACKAGE__->mk_accessors(qw(ua is_validated ok_count));
sub new {
my $class = shift;
my $self = bless {}, $class;
$self->_init(@_);
$self;
}
sub _init {
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
$args{path} =~ s!::!/!g;
}
$args{file} ||= "$args{base}/$args{prefix}/$args{path}.pm";
$args{wrote} = 0;
bless( \%args, $class );
}
sub call {
my ($self, $method) = @_;
my $obj = $self->load($method) or return;
view release on metacpan or search on metacpan
lib/Acme/YAPC/Okinawa/ppport.h view on Meta::CPAN
sv_2uv_flags||5.009001|
sv_2uv|5.004000||p
sv_add_arena|||
sv_add_backref|||
sv_backoff|||n
sv_bless|||
sv_buf_to_ro|||
sv_buf_to_rw|||
sv_cat_decode||5.008001|
sv_catpv_flags||5.013006|
sv_catpv_mg|5.004050||p
view release on metacpan or search on metacpan
lib/Acme/Yoda.pm view on Meta::CPAN
sub new {
my $class = shift;
my %args = @_;
$args{_link_parser} = $_link;
my $self = bless \%args, ref($class) || $class ;
return $self;
}
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
$args{path} = $args{name};
$args{path} =~ s!::!/!g;
}
$args{file} ||= "$args{base}/$args{prefix}/$args{path}.pm";
bless( \%args, $class );
}
sub call {
my ($self, $method) = @_;
my $obj = $self->load($method) or return;
view release on metacpan or search on metacpan
landmine.pm view on Meta::CPAN
eval <<EOF;
sub $AUTOLOAD {
my \$flavor = shift;
my \$sin = shift;
bless \\\$sin, \$flavor;
}
EOF
}else{
eval <<EOF;
sub $AUTOLOAD {
landmine.pm view on Meta::CPAN
we've got two functions, DESTROY, which is just there so
AUTOLOAD isn't called at DESTROY time, and AUTOLOAD, which
behaves differently if you are calling TIE-something or if
you are using your tied variable. at C<tie> time, the AUTOLOAD
function blesses the tie argument, if any, as a scalar reference,
so the argument is saved as the "sin" to "confess" (that is,
die with a stack-trace) when the
exploding variable is used any other way.
If you look at the source code of this module, which is very short,
view release on metacpan or search on metacpan
sub TIESCALAR{
shift; #Package
my %P = (please => $PLEASE, pctg => $PCTG, @_);
bless \%P;
};
sub FETCH{
rand(100) > $_[0]->{pctg} and return '';
$_[0]->{please}
view release on metacpan or search on metacpan
lib/Acme/rafl/Everywhere.pm view on Meta::CPAN
q{rafl is so everywhere, the Da Vinci code is actually a Base64 Rot13 representation of rafl},
);
sub new {
my $class = shift;
my $self = bless {@_}, $class;
exists $self->{'facts'}
or $self->{'facts'} = \@default_facts;
return $self;
view release on metacpan or search on metacpan
package GagMe;
use strict;
sub TIEHANDLE {
my $class = shift;
bless(\( my $ref = ''), $class);
}
sub PRINT {
my $self = shift;
$$self .= join('', @_);
view release on metacpan or search on metacpan
sub new{
my($class) = shift;
my($self) = {};
bless($self,$class);
$rfield = Acpi::Field->new;
return $self;
}
view release on metacpan or search on metacpan
lib/Acrux/DBI.pm view on Meta::CPAN
# Default attributes
my %_opts = (%{(DEFAULT_DBI_OPTS)}, %$opts);
my $autoclean = delete $_opts{autoclean};
my $self = bless {
url => $url,
uri => $uri,
dsn => '',
cachekey=> '',
driver => '',
view release on metacpan or search on metacpan
lib/Acme/Crux.pm view on Meta::CPAN
# Current dir
my $pwd = getcwd();
# Create
my $self = bless {
# Common
error => "",
script => $Script,
invocant => scalar(caller(0)),
project => $project,
view release on metacpan or search on metacpan
lib/Action/CircuitBreaker.pm view on Meta::CPAN
package Action::CircuitBreaker;
$Action::CircuitBreaker::VERSION = '0.1';
# ABSTRACT: Module to try to perform an action, with an option to suspend execution after a number of failures.
use Scalar::Util qw(blessed);
use Time::HiRes qw(gettimeofday);
use Carp;
use base 'Exporter';
our @EXPORT = ((caller())[1] eq '-e' ? @EXPORT_OK : ());
view release on metacpan or search on metacpan
lib/Action/Retry.pm view on Meta::CPAN
}
# ABSTRACT: Module to try to perform an action, with various ways of retrying and sleeping between retries.
use Module::Runtime qw(use_module);
use Scalar::Util qw(blessed);
use Time::HiRes qw(usleep gettimeofday);
use Carp;
use base 'Exporter';
our @EXPORT_OK = qw(retry);
lib/Action/Retry.pm view on Meta::CPAN
has strategy => (
is => 'ro',
default => sub { 'Constant' },
coerce => sub {
my $attr = $_[0];
blessed($attr)
and return $attr;
my $class_name = $attr;
my $constructor_params = {};
if (ref $attr eq 'HASH') {
$class_name = (keys %$attr)[0];
view release on metacpan or search on metacpan
lib/Activator/Config.pm view on Meta::CPAN
=cut
sub new {
my ( $pkg ) = @_;
my $self = bless( {
REGISTRY => Activator::Registry->new(),
ARGV_EXTRA => {},
ARGV => undef,
BAREWORDS => undef,
}, $pkg);
view release on metacpan or search on metacpan
lib/ActiveRecord/Simple.pm view on Meta::CPAN
our $VERSION = '1.11';
use utf8;
use Carp;
use Scalar::Util qw/blessed/;
use ActiveRecord::Simple::QueryManager;
use ActiveRecord::Simple::Utils qw/all_blessed class_to_table_name load_module/;
use ActiveRecord::Simple::Connect;
our $connector;
my $qm = ActiveRecord::Simple::QueryManager->new();
lib/ActiveRecord/Simple.pm view on Meta::CPAN
my $params = (scalar @_ > 1) ? {@_} : $_[0];
# relations
$class->_init_relations if $class->can('_get_relations');
return bless $params || {}, $class;
}
sub auto_load {
my ($class) = @_;
lib/ActiveRecord/Simple.pm view on Meta::CPAN
### Private
sub _get_primary_key_value {
my ($self) = @_;
croak "Sory, you can call method '_get_primary_key_value' on unblessed scalar."
unless blessed $self;
my $pk = $self->_get_primary_key;
return $self->$pk;
}
lib/ActiveRecord/Simple.pm view on Meta::CPAN
if (grep { $full_relation_type eq $_ } qw/one_to_many one_to_one one_to_only/) {
*{$pkg_method_name} = sub {
my ($self, @args) = @_;
if (@args) {
my $object = shift @args;
croak "Using unblessed scalar as an object reference"
unless blessed $object;
$object->save() if ! exists $object->{isin_database} && !$object->{isin_database} == 1;
#$self->$fk($object->$pk);
$self->{$fk} = $object->{$pk};
lib/ActiveRecord/Simple.pm view on Meta::CPAN
elsif ($full_relation_type eq 'many_to_one') {
*{$pkg_method_name} = sub {
my ($self, @args) = @_;
if (@args) {
unless (all_blessed(\@args)) {
return $related_class->find(@args)->left_join($self->_get_table_name);
}
OBJECT:
for my $object (@args) {
next OBJECT if !blessed $object;
my $pk = $self->_get_primary_key;
#$object->$fk($self->$pk)->save;
$object->{$fk} = $self->{$pk};
$object->save();
lib/ActiveRecord/Simple.pm view on Meta::CPAN
if (@args) {
my $related_subclass = _get_related_subclass($relation);
unless (all_blessed(\@args)) {
return $related_class->_find_many_to_many({
root_class => $class,
via_table => $relation->{via_table},
m_class => $related_subclass,
self => $self,
lib/ActiveRecord/Simple.pm view on Meta::CPAN
defined $pk1 or croak 'You are trying to create relations between unsaved objects. Save your ' . $class . ' object first';
OBJECT:
for my $object (@args) {
next OBJECT if !blessed $object;
my $pk2_name = $object->_get_primary_key;
my $pk2 = $object->{$pk2_name};
$related_subclass->new($fk1 => $pk1, $fk2 => $pk2)->save;
lib/ActiveRecord/Simple.pm view on Meta::CPAN
my $via_table = $relation->{via_table};
OBJECT:
for my $object (@args) {
next OBJECT if !blessed $object;
my $pk2_name = $object->_get_primary_key;
my $pk2 = $object->{$pk2_name};
my $sql = qq/INSERT INTO "$via_table" ("$fk1", "$fk2") VALUES (?, ?)/;
lib/ActiveRecord/Simple.pm view on Meta::CPAN
$user->update({ last_login => \'NOW()' });
=head2 to_hash
Unbless object, get naked hash
=head2 increment
Increment fields
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
$args{path} =~ s!::!/!g;
}
$args{file} ||= "$args{base}/$args{prefix}/$args{path}.pm";
$args{wrote} = 0;
bless( \%args, $class );
}
sub call {
my ($self, $method) = @_;
my $obj = $self->load($method) or return;