bump version and update changes

[gitmo/Class-MOP.git] / lib / Class / MOP / Class.pm

diff --git a/lib/Class/MOP/Class.pm b/lib/Class/MOP/Class.pm
index d3cf084..b197e5e 100644 (file)
--- a/lib/Class/MOP/Class.pm
+++ b/lib/Class/MOP/Class.pm
@@ -11,7 +11,7 @@ use Class::MOP::Method::Wrapped;
 use Carp         'confess';
 use Scalar::Util 'blessed', 'weaken';
 
-our $VERSION   = '0.70_01';
+our $VERSION   = '0.74';
 $VERSION = eval $VERSION;
 our $AUTHORITY = 'cpan:STEVAN';
 
@@ -311,12 +311,12 @@ sub attribute_metaclass { $_[0]->{'attribute_metaclass'} }
 sub method_metaclass    { $_[0]->{'method_metaclass'}    }
 sub instance_metaclass  { $_[0]->{'instance_metaclass'}  }
 
-# FIXME:
-# this is a prime canidate for conversion to XS
 sub get_method_map {
     my $self = shift;
-    
-    my $current = Class::MOP::check_package_cache_flag($self->name);
+
+    my $class_name = $self->name;
+
+    my $current = Class::MOP::check_package_cache_flag($class_name);
 
     if (defined $self->{'_package_cache_flag'} && $self->{'_package_cache_flag'} == $current) {
         return $self->{'methods'} ||= {};
@@ -324,15 +324,14 @@ sub get_method_map {
 
     $self->{_package_cache_flag} = $current;
 
-    my $map  = $self->{'methods'} ||= {};
+    my $map = $self->{'methods'} ||= {};
 
-    my $class_name       = $self->name;
     my $method_metaclass = $self->method_metaclass;
 
-    my %all_code = $self->get_all_package_symbols('CODE');
+    my $all_code = $self->get_all_package_symbols('CODE');
 
-    foreach my $symbol (keys %all_code) {
-        my $code = $all_code{$symbol};
+    foreach my $symbol (keys %{ $all_code }) {
+        my $code = $all_code->{$symbol};
 
         next if exists  $map->{$symbol} &&
                 defined $map->{$symbol} &&
@@ -644,15 +643,16 @@ sub add_method {
 
     $method->attach_to_class($self);
 
-    $self->get_method_map->{$method_name} = $method;
+    # This used to call get_method_map, which meant we would build all
+    # the method objects for the class just because we added one
+    # method. This is hackier, but quicker too.
+    $self->{methods}{$method_name} = $method;
     
     my $full_method_name = ($self->name . '::' . $method_name);    
     $self->add_package_symbol(
         { sigil => '&', type => 'CODE', name => $method_name }, 
         Class::MOP::subname($full_method_name => $body)
     );
-
-    $self->update_package_cache_flag; # still valid, since we just added the method to the map, and if it was invalid before that then get_method_map updated it
 }
 
 {
@@ -736,7 +736,7 @@ sub has_method {
     (defined $method_name && $method_name)
         || confess "You must define a method name";
 
-    exists $self->get_method_map->{$method_name};
+    exists $self->{methods}{$method_name} || exists $self->get_method_map->{$method_name};
 }
 
 sub get_method {
@@ -750,7 +750,7 @@ sub get_method {
     # will just return undef for me now
     # return unless $self->has_method($method_name);
 
-    return $self->get_method_map->{$method_name};
+    return $self->{methods}{$method_name} || $self->get_method_map->{$method_name};
 }
 
 sub remove_method {
@@ -1183,6 +1183,10 @@ manipulation of Perl 5 classes (and it can create them too). The
 best way to understand what this module can do, is to read the
 documentation for each of it's methods.
 
+=head1 INHERITANCE
+
+B<Class::MOP::Class> is a subclass of L<Class::MOP::Module>
+
 =head1 METHODS
 
 =head2 Self Introspection
@@ -1351,7 +1355,7 @@ This method is used to construct an instance structure suitable for
 C<bless>-ing into your package of choice. It works in conjunction
 with the Attribute protocol to collect all applicable attributes.
 
-This will construct and instance using a HASH ref as storage
+This will construct an instance using a HASH ref as storage
 (currently only HASH references are supported). This will collect all
 the applicable attributes and layout out the fields in the HASH ref,
 it will then initialize them using either use the corresponding key
@@ -1616,8 +1620,10 @@ the call tree might looks something like this:
     around 2
      around 1
       primary
-     after 1
-    after 2
+     around 1
+    around 2
+   after 1
+  after 2
 
 To see examples of using method modifiers, see the following examples
 included in the distribution; F<InstanceCountingClass>, F<Perl6Attribute>,