use Sub::Name 'subname';
use B 'svref_2object';
-our $VERSION = '0.12';
+our $VERSION = '0.14';
+
+use Class::MOP::Instance;
# Self-introspection
# Creation
-{
+#{
# Metaclasses are singletons, so we cache them here.
# there is no need to worry about destruction though
# because they should die only when the program dies.
my $package_name = $options{':package'};
(defined $package_name && $package_name)
|| confess "You must pass a package name";
- # NOTE:
- # return the metaclass if we have it cached,
- # and it is still defined (it has not been
- # reaped by DESTROY yet, which can happen
- # annoyingly enough during global destruction)
+ # NOTE:
+ # return the metaclass if we have it cached,
+ # and it is still defined (it has not been
+ # reaped by DESTROY yet, which can happen
+ # annoyingly enough during global destruction)
return $METAS{$package_name}
- if exists $METAS{$package_name} && defined $METAS{$package_name};
+ if exists $METAS{$package_name} && defined $METAS{$package_name};
$class = blessed($class) || $class;
# now create the metaclass
my $meta;
'$:package' => $package_name,
'%:attributes' => {},
'$:attribute_metaclass' => $options{':attribute_metaclass'} || 'Class::MOP::Attribute',
- '$:method_metaclass' => $options{':method_metaclass'} || 'Class::MOP::Method',
+ '$:method_metaclass' => $options{':method_metaclass'} || 'Class::MOP::Method',
+ '$:instance_metaclass' => $options{':instance_metaclass'} || 'Class::MOP::Instance',
} => $class;
}
else {
$class_name . "->meta => (" . (blessed($meta)) . ")";
}
}
-}
+#}
sub create {
my ($class, $package_name, $package_version, %options) = @_;
sub get_attribute_map { $_[0]->{'%:attributes'} }
sub attribute_metaclass { $_[0]->{'$:attribute_metaclass'} }
sub method_metaclass { $_[0]->{'$:method_metaclass'} }
+sub instance_metaclass { $_[0]->{'$:instance_metaclass'} }
# Instance Construction & Cloning
# which will deal with the singletons
return $class->construct_class_instance(@_)
if $class->name->isa('Class::MOP::Class');
- bless $class->construct_instance(@_) => $class->name;
+ return $class->construct_instance(@_);
}
sub construct_instance {
my ($class, %params) = @_;
- my $instance = {};
+ my $instance = $class->get_meta_instance->create_instance();
foreach my $attr ($class->compute_all_applicable_attributes()) {
- $attr->initialize_instance_slot($class, $instance, \%params);
+ $attr->initialize_instance_slot($instance, \%params);
}
return $instance;
}
+sub get_meta_instance {
+ my $class = shift;
+ $class->{':instance_meta_object_cache'} ||= $class->instance_metaclass->new($class);
+}
+
sub clone_object {
my $class = shift;
my $instance = shift;
# This will do nothing if all is well, and blow
# up otherwise. Yes, it's an ugly hack, better
# suggestions are welcome.
- { $self->name->isa('This is a test for circular inheritance') }
+ { ($self->name || return)->isa('This is a test for circular inheritance') }
# ... and now back to our regularly scheduled program
(
$self->name,
map {
- $self->initialize($_)->class_precedence_list()
+ # OPTIMIZATION NOTE:
+ # we grab the metaclass from the %METAS
+ # hash here to save the initialize() call
+ # if we can, but it is not always possible
+ ($METAS{$_} || $self->initialize($_))->class_precedence_list()
} $self->superclasses()
);
}
|| confess "Your code block must be a CODE reference";
my $full_method_name = ($self->name . '::' . $method_name);
- $method = $self->method_metaclass->wrap($method) unless blessed($method);
-
+ $method = $self->method_metaclass->wrap($method) unless blessed($method);
+
no strict 'refs';
no warnings 'redefine';
*{$full_method_name} = subname $full_method_name => $method;
}
{
- my $fetch_and_prepare_method = sub {
- my ($self, $method_name) = @_;
- # fetch it locally
- my $method = $self->get_method($method_name);
- # if we dont have local ...
- unless ($method) {
- # make sure this method even exists ...
- ($self->find_next_method_by_name($method_name))
- || confess "The method '$method_name' is not found in the inherience hierarchy for this class";
- # if so, then create a local which just
- # calls the next applicable method ...
- $self->add_method($method_name => sub {
- $self->find_next_method_by_name($method_name)->(@_);
- });
- $method = $self->get_method($method_name);
- }
-
- # now make sure we wrap it properly
- # (if it isnt already)
- unless ($method->isa('Class::MOP::Method::Wrapped')) {
- $method = Class::MOP::Method::Wrapped->wrap($method);
- $self->add_method($method_name => $method);
- }
- return $method;
- };
-
- sub add_before_method_modifier {
- my ($self, $method_name, $method_modifier) = @_;
- (defined $method_name && $method_name)
- || confess "You must pass in a method name";
- my $method = $fetch_and_prepare_method->($self, $method_name);
- $method->add_before_modifier(subname ':before' => $method_modifier);
- }
-
- sub add_after_method_modifier {
- my ($self, $method_name, $method_modifier) = @_;
- (defined $method_name && $method_name)
- || confess "You must pass in a method name";
- my $method = $fetch_and_prepare_method->($self, $method_name);
- $method->add_after_modifier(subname ':after' => $method_modifier);
- }
-
- sub add_around_method_modifier {
- my ($self, $method_name, $method_modifier) = @_;
- (defined $method_name && $method_name)
- || confess "You must pass in a method name";
- my $method = $fetch_and_prepare_method->($self, $method_name);
- $method->add_around_modifier(subname ':around' => $method_modifier);
- }
+ my $fetch_and_prepare_method = sub {
+ my ($self, $method_name) = @_;
+ # fetch it locally
+ my $method = $self->get_method($method_name);
+ # if we dont have local ...
+ unless ($method) {
+ # make sure this method even exists ...
+ ($self->find_next_method_by_name($method_name))
+ || confess "The method '$method_name' is not found in the inherience hierarchy for this class";
+ # if so, then create a local which just
+ # calls the next applicable method ...
+ $self->add_method($method_name => sub {
+ $self->find_next_method_by_name($method_name)->(@_);
+ });
+ $method = $self->get_method($method_name);
+ }
+
+ # now make sure we wrap it properly
+ # (if it isnt already)
+ unless ($method->isa('Class::MOP::Method::Wrapped')) {
+ $method = Class::MOP::Method::Wrapped->wrap($method);
+ $self->add_method($method_name => $method);
+ }
+ return $method;
+ };
+
+ sub add_before_method_modifier {
+ my ($self, $method_name, $method_modifier) = @_;
+ (defined $method_name && $method_name)
+ || confess "You must pass in a method name";
+ my $method = $fetch_and_prepare_method->($self, $method_name);
+ $method->add_before_modifier(subname ':before' => $method_modifier);
+ }
+
+ sub add_after_method_modifier {
+ my ($self, $method_name, $method_modifier) = @_;
+ (defined $method_name && $method_name)
+ || confess "You must pass in a method name";
+ my $method = $fetch_and_prepare_method->($self, $method_name);
+ $method->add_after_modifier(subname ':after' => $method_modifier);
+ }
+
+ sub add_around_method_modifier {
+ my ($self, $method_name, $method_modifier) = @_;
+ (defined $method_name && $method_name)
+ || confess "You must pass in a method name";
+ my $method = $fetch_and_prepare_method->($self, $method_name);
+ $method->add_around_modifier(subname ':around' => $method_modifier);
+ }
# NOTE:
# the methods above used to be named like this:
|| confess "Your code block must be a CODE reference";
my $full_method_name = ($self->name . '::' . $method_name);
- $method = $self->method_metaclass->wrap($method) unless blessed($method);
+ $method = $self->method_metaclass->wrap($method) unless blessed($method);
no strict 'refs';
no warnings 'redefine';
no strict 'refs';
return 0 if !defined(&{$sub_name});
- my $method = \&{$sub_name};
+ my $method = \&{$sub_name};
return 0 if (svref_2object($method)->GV->STASH->NAME || '') ne $self->name &&
- (svref_2object($method)->GV->NAME || '') ne '__ANON__';
-
- # at this point we are relatively sure
- # it is our method, so we bless/wrap it
- $self->method_metaclass->wrap($method) unless blessed($method);
+ (svref_2object($method)->GV->NAME || '') ne '__ANON__';
+
+ # at this point we are relatively sure
+ # it is our method, so we bless/wrap it
+ $self->method_metaclass->wrap($method) unless blessed($method);
return 1;
}
(defined $method_name && $method_name)
|| confess "You must define a method name";
- return unless $self->has_method($method_name);
+ return unless $self->has_method($method_name);
no strict 'refs';
return \&{$self->name . '::' . $method_name};
sub find_next_method_by_name {
my ($self, $method_name) = @_;
(defined $method_name && $method_name)
- || confess "You must define a method name to find";
+ || confess "You must define a method name to find";
# keep a record of what we have seen
# here, this will handle all the
# inheritence issues because we are
# using the &class_precedence_list
my %seen_class;
- my @cpl = $self->class_precedence_list();
- shift @cpl; # discard ourselves
+ my @cpl = $self->class_precedence_list();
+ shift @cpl; # discard ourselves
foreach my $class (@cpl) {
next if $seen_class{$class};
$seen_class{$class}++;
# fetch the meta-class ...
my $meta = $self->initialize($class);
- return $meta->get_method($method_name)
- if $meta->has_method($method_name);
+ return $meta->get_method($method_name)
+ if $meta->has_method($method_name);
}
- return;
+ return;
}
## Attributes
($attribute->isa('Class::MOP::Attribute'))
|| confess "Your attribute must be an instance of Class::MOP::Attribute (or a subclass)";
$attribute->attach_to_class($self);
- $attribute->install_accessors();
+ $attribute->install_accessors();
$self->get_attribute_map->{$attribute->name} = $attribute;
}
my ($self, $attribute_name) = @_;
(defined $attribute_name && $attribute_name)
|| confess "You must define an attribute name";
- return $self->get_attribute_map->{$attribute_name}
- if $self->has_attribute($attribute_name);
+ # OPTIMIZATION NOTE:
+ # we used to say `if $self->has_attribute($attribute_name)`
+ # here, but since get_attribute is called so often, we
+ # eliminate the function call here
+ return $self->{'%:attributes'}->{$attribute_name}
+ if exists $self->{'%:attributes'}->{$attribute_name};
return;
}
my $removed_attribute = $self->get_attribute_map->{$attribute_name};
return unless defined $removed_attribute;
delete $self->get_attribute_map->{$attribute_name};
- $removed_attribute->remove_accessors();
- $removed_attribute->detach_from_class();
+ $removed_attribute->remove_accessors();
+ $removed_attribute->detach_from_class();
return $removed_attribute;
}
sub get_attribute_list {
my $self = shift;
- keys %{$self->get_attribute_map};
+ # OPTIMIZATION NOTE:
+ # We don't use get_attribute_map here because
+ # we ask for the attribute list quite often
+ # in compute_all_applicable_attributes, so
+ # eliminating the function call helps
+ keys %{$self->{'%:attributes'}};
}
sub compute_all_applicable_attributes {
next if $seen_class{$class};
$seen_class{$class}++;
# fetch the meta-class ...
- my $meta = $self->initialize($class);
+ # OPTIMIZATION NOTE:
+ # we grab the metaclass from the %METAS
+ # hash here to save the initialize() call
+ my $meta = $METAS{$class};
foreach my $attr_name ($meta->get_attribute_list()) {
next if exists $seen_attr{$attr_name};
$seen_attr{$attr_name}++;
}
confess "Could not get the package variable ($variable) because : $e" if $e;
# if we didn't die, then we can return it
- return $ref;
+ return $ref;
}
sub remove_package_variable {
=over 4
+=item B<instance_metaclass>
+
+=item B<get_meta_instance>
+
=item B<new_object (%params)>
This is a convience method for creating a new object of the class, and
This library is free software; you can redistribute it and/or modify
it under the same terms as Perl itself.
-=cut
\ No newline at end of file
+=cutchistian
\ No newline at end of file