use warnings;
use Carp 'confess';
-use Scalar::Util 'blessed', 'reftype';
+use Scalar::Util 'blessed', 'reftype', 'weaken';
use Sub::Name 'subname';
use B 'svref_2object';
# 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.
$class->construct_class_instance(':package' => $package_name, @_);
}
+ sub reinitialize {
+ my $class = shift;
+ my $package_name = shift;
+ (defined $package_name && $package_name && !blessed($package_name))
+ || confess "You must pass a package name and it cannot be blessed";
+ $METAS{$package_name} = undef;
+ $class->construct_class_instance(':package' => $package_name, @_);
+ }
+
+ # NOTE:
+ # we need a sufficiently annoying prefix
+ # this should suffice for now
+ my $ANON_CLASS_PREFIX = 'Class::MOP::Class::__ANON__::SERIAL::';
+
+ {
+ # NOTE:
+ # this should be sufficient, if you have a
+ # use case where it is not, write a test and
+ # I will change it.
+ my $ANON_CLASS_SERIAL = 0;
+
+ sub create_anon_class {
+ my ($class, %options) = @_;
+ my $package_name = $ANON_CLASS_PREFIX . ++$ANON_CLASS_SERIAL;
+ return $class->create($package_name, '0.00', %options);
+ }
+ }
+
# NOTE: (meta-circularity)
# this is a special form of &construct_instance
# (see below), which is used to construct class
# it is safe to use meta here because
# class will always be a subclass of
# Class::MOP::Class, which defines meta
- $meta = bless $class->meta->construct_instance(%options) => $class
+ $meta = $class->meta->construct_instance(%options)
}
# and check the metaclass compatibility
$meta->check_metaclass_compatability();
$METAS{$package_name} = $meta;
+ # NOTE:
+ # we need to weaken any anon classes
+ # so that they can call DESTROY properly
+ weaken($METAS{$package_name})
+ if $package_name =~ /^$ANON_CLASS_PREFIX/;
+ $meta;
+ }
+
+ # NOTE:
+ # this will only get called for
+ # anon-classes, all other calls
+ # are assumed to occur during
+ # global destruction and so don't
+ # really need to be handled explicitly
+ sub DESTROY {
+ my $self = shift;
+ return unless $self->name =~ /^$ANON_CLASS_PREFIX/;
+ my ($serial_id) = ($self->name =~ /^$ANON_CLASS_PREFIX(\d+)/);
+ no strict 'refs';
+ foreach my $key (keys %{$ANON_CLASS_PREFIX . $serial_id}) {
+ delete ${$ANON_CLASS_PREFIX . $serial_id}{$key};
+ }
+ delete ${'main::' . $ANON_CLASS_PREFIX}{$serial_id . '::'};
}
sub check_metaclass_compatability {
my $self = shift;
# this is always okay ...
- return if blessed($self) eq 'Class::MOP::Class';
+ return if blessed($self) eq 'Class::MOP::Class' &&
+ $self->instance_metaclass eq 'Class::MOP::Instance';
my @class_list = $self->class_precedence_list;
shift @class_list; # shift off $self->name
|| confess $self->name . "->meta => (" . (blessed($self)) . ")" .
" is not compatible with the " .
$class_name . "->meta => (" . (blessed($meta)) . ")";
+ # NOTE:
+ # we also need to check that instance metaclasses
+ # are compatabile in the same the class.
+ ($self->instance_metaclass->isa($meta->instance_metaclass))
+ || confess $self->name . "->meta => (" . ($self->instance_metaclass) . ")" .
+ " is not compatible with the " .
+ $class_name . "->meta => (" . ($meta->instance_metaclass) . ")";
}
- }
-#}
+ }
+}
sub create {
my ($class, $package_name, $package_version, %options) = @_;
return $meta;
}
-{
- # NOTE:
- # this should be sufficient, if you have a
- # use case where it is not, write a test and
- # I will change it.
- my $ANON_CLASS_SERIAL = 0;
-
- sub create_anon_class {
- my ($class, %options) = @_;
- my $package_name = 'Class::MOP::Class::__ANON__::SERIAL::' . ++$ANON_CLASS_SERIAL;
- return $class->create($package_name, '0.00', %options);
- }
-}
-
## Attribute readers
# NOTE:
sub construct_instance {
my ($class, %params) = @_;
- my $instance = $class->get_meta_instance->create_instance();
+ my $meta_instance = $class->get_meta_instance();
+ my $instance = $meta_instance->create_instance();
foreach my $attr ($class->compute_all_applicable_attributes()) {
- $attr->initialize_instance_slot($instance, \%params);
+ $attr->initialize_instance_slot($meta_instance, $instance, \%params);
}
return $instance;
}
sub get_meta_instance {
my $class = shift;
- $class->{':instance_meta_object_cache'} ||= $class->instance_metaclass->new($class);
+ return $class->instance_metaclass->new(
+ $class,
+ $class->compute_all_applicable_attributes()
+ );
}
sub clone_object {
# Class::MOP::Class singletons here, they
# should not be cloned.
return $instance if $instance->isa('Class::MOP::Class');
- bless $class->clone_instance($instance, @_) => blessed($instance);
+ $class->clone_instance($instance, @_);
}
sub clone_instance {
my ($class, $instance, %params) = @_;
(blessed($instance))
|| confess "You can only clone instances, \$self is not a blessed instance";
- my $clone = { %$instance, %params };
+ my $meta_instance = $class->get_meta_instance();
+ my $clone = $meta_instance->clone_instance($instance);
+ foreach my $key (%params) {
+ next unless $meta_instance->is_valid_slot($key);
+ $meta_instance->set_slot_value($clone, $key, $params{$key});
+ }
return $clone;
}
if (@_) {
my @supers = @_;
@{$self->name . '::ISA'} = @supers;
+ # NOTE:
+ # we need to check the metaclass
+ # compatability here so that we can
+ # be sure that the superclass is
+ # not potentially creating an issues
+ # we don't know about
+ $self->check_metaclass_compatability();
}
@{$self->name . '::ISA'};
}
(
$self->name,
map {
- # 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->initialize($_)->class_precedence_list()
} $self->superclasses()
);
}
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))
+ # try to find the next method
+ $method = $self->find_next_method_by_name($method_name);
+ # die if it does not exist
+ (defined $method)
|| 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')) {
+ # and now make sure to wrap it
+ # even if it is already wrapped
+ # because we need a new sub ref
$method = Class::MOP::Method::Wrapped->wrap($method);
- $self->add_method($method_name => $method);
- }
+ }
+ else {
+ # now make sure we wrap it properly
+ $method = Class::MOP::Method::Wrapped->wrap($method)
+ unless $method->isa('Class::MOP::Method::Wrapped');
+ }
+ $self->add_method($method_name => $method);
return $method;
};
sub get_method_list {
my $self = shift;
no strict 'refs';
- grep { $self->has_method($_) } %{$self->name . '::'};
+ grep { $self->has_method($_) } keys %{$self->name . '::'};
}
sub compute_all_applicable_methods {
$attribute->attach_to_class($self);
$attribute->install_accessors();
$self->get_attribute_map->{$attribute->name} = $attribute;
+
+ # FIXME
+ # in theory we have to tell everyone the slot structure may have changed
}
sub has_attribute {
my ($self, $attribute_name) = @_;
(defined $attribute_name && $attribute_name)
|| confess "You must define an 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 $self->get_attribute_map->{$attribute_name}
+ if $self->has_attribute($attribute_name);
return;
}
sub get_attribute_list {
my $self = shift;
- # 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'}};
+ keys %{$self->get_attribute_map};
}
sub compute_all_applicable_attributes {
next if $seen_class{$class};
$seen_class{$class}++;
# fetch the meta-class ...
- # OPTIMIZATION NOTE:
- # we grab the metaclass from the %METAS
- # hash here to save the initialize() call
- my $meta = $METAS{$class};
+ my $meta = $self->initialize($class);
foreach my $attr_name ($meta->get_attribute_list()) {
next if exists $seen_attr{$attr_name};
$seen_attr{$attr_name}++;
it does not need a C<$package_name>. Instead it will create a suitably
unique package name for you to stash things into.
-=item B<initialize ($package_name)>
+=item B<initialize ($package_name, %options)>
This initializes and returns returns a B<Class::MOP::Class> object
for a given a C<$package_name>.
+=item B<reinitialize ($package_name, %options)>
+
+This removes the old metaclass, and creates a new one in it's place.
+Do B<not> use this unless you really know what you are doing, it could
+very easily make a very large mess of your program.
+
=item B<construct_class_instance (%options)>
This will construct an instance of B<Class::MOP::Class>, it is
This library is free software; you can redistribute it and/or modify
it under the same terms as Perl itself.
-=cutchistian
\ No newline at end of file
+=cut
projects / gitmo/Class-MOP.git / blobdiff