use MRO::Compat;
use Carp 'confess';
-use Scalar::Util 'weaken';
-
-use Sub::Identify 'get_code_info';
-
-BEGIN {
- local $@;
- eval {
- require Sub::Name;
- Sub::Name->import(qw(subname));
- 1
- } or eval 'sub subname { $_[1] }';
-
- # this is either part of core or set up appropriately by MRO::Compat
- *check_package_cache_flag = \&mro::get_pkg_gen;
-
- eval {
- require Devel::GlobalDestruction;
- Devel::GlobalDestruction->import("in_global_destruction");
- 1;
- } or *in_global_destruction = sub () { !1 };
-}
-
+use Devel::GlobalDestruction qw( in_global_destruction );
+use Scalar::Util 'weaken', 'reftype', 'blessed';
+use Sub::Name qw( subname );
use Class::MOP::Class;
use Class::MOP::Attribute;
use Class::MOP::Immutable;
BEGIN {
- *IS_RUNNING_ON_5_10 = ($] < 5.009_005)
+ *IS_RUNNING_ON_5_10 = ($] < 5.009_005)
? sub () { 0 }
- : sub () { 1 };
-
- *HAVE_ISAREV = defined(&mro::get_isarev)
- ? sub () { 1 }
: sub () { 1 };
+
+ sub HAVE_ISAREV () {
+ Carp::cluck("Class::MOP::HAVE_ISAREV is deprecated and will be removed in a future release. It has always returned 1 anyway.");
+ return 1;
+ }
+
+ # this is either part of core or set up appropriately by MRO::Compat
+ *check_package_cache_flag = \&mro::get_pkg_gen;
}
-our $VERSION = '0.64_02';
+our $VERSION = '0.80_01';
+our $XS_VERSION = $VERSION;
$VERSION = eval $VERSION;
-our $AUTHORITY = 'cpan:STEVAN';
-
-# after that everything is loaded, if we're allowed try to load faster XS
-# versions of various things
-unless ($ENV{CLASS_MOP_NO_XS}) {
- my $e = do {
- local $@;
- eval {
- require XSLoader;
- __PACKAGE__->XSLoader::load($VERSION);
- };
- $@;
- };
+our $AUTHORITY = 'cpan:STEVAN';
+
+require XSLoader;
+XSLoader::load( __PACKAGE__, $XS_VERSION );
- die $e if $e && $e !~ /object version|loadable object/;
-}
{
# Metaclasses are singletons, so we cache them here.
sub does_metaclass_exist { exists $METAS{$_[0]} && defined $METAS{$_[0]} }
sub remove_metaclass_by_name { $METAS{$_[0]} = undef }
+ # This handles instances as well as class names
+ sub class_of {
+ return unless defined $_[0];
+ my $class = blessed($_[0]) || $_[0];
+ return $METAS{$class};
+ }
+
# NOTE:
# We only cache metaclasses, meaning instances of
# Class::MOP::Class. We do not cache instance of
# because I don't yet see a good reason to do so.
}
-sub load_class {
+sub _class_to_pmfile {
my $class = shift;
- if (ref($class) || !defined($class) || !length($class)) {
- my $display = defined($class) ? $class : 'undef';
- confess "Invalid class name ($display)";
- }
+ my $file = $class . '.pm';
+ $file =~ s{::}{/}g;
+
+ return $file;
+}
- # if the class is not already loaded in the symbol table..
- unless (is_class_loaded($class)) {
- # require it
- my $file = $class . '.pm';
- $file =~ s{::}{/}g;
- my $e = do { local $@; eval { require($file) }; $@ };
- confess "Could not load class ($class) because : $e" if $e;
+sub load_first_existing_class {
+ my @classes = @_
+ or return;
+
+ foreach my $class (@classes) {
+ unless ( _is_valid_class_name($class) ) {
+ my $display = defined($class) ? $class : 'undef';
+ confess "Invalid class name ($display)";
+ }
}
- # initialize a metaclass if necessary
- unless (does_metaclass_exist($class)) {
- my $e = do { local $@; eval { Class::MOP::Class->initialize($class) }; $@ };
- confess "Could not initialize class ($class) because : $e" if $e;
+ my $found;
+ my %exceptions;
+ for my $class (@classes) {
+ my $pmfile = _class_to_pmfile($class);
+ my $e = _try_load_one_class($class);
+
+ if ($e) {
+ $exceptions{$class} = $e;
+ last if $e !~ /^Can't locate \Q$pmfile\E in \@INC/;
+ }
+ else {
+ $found = $class;
+ last;
+ }
}
- return get_metaclass_by_name($class) if defined wantarray;
+ return $found if $found;
+
+ confess join(
+ "\n",
+ map {
+ sprintf(
+ "Could not load class (%s) because : %s", $_,
+ $exceptions{$_}
+ )
+ }
+ grep {
+ exists $exceptions{$_}
+ } @classes
+ );
}
-sub is_class_loaded {
+sub _try_load_one_class {
my $class = shift;
- return 0 if ref($class) || !defined($class) || !length($class);
+ return if is_class_loaded($class);
- # walk the symbol table tree to avoid autovififying
- # \*{${main::}{"Foo::"}} == \*main::Foo::
+ my $file = _class_to_pmfile($class);
- my $pack = \*::;
- foreach my $part (split('::', $class)) {
- return 0 unless exists ${$$pack}{"${part}::"};
- $pack = \*{${$$pack}{"${part}::"}};
- }
-
- # check for $VERSION or @ISA
- return 1 if exists ${$$pack}{VERSION}
- && defined *{${$$pack}{VERSION}}{SCALAR};
- return 1 if exists ${$$pack}{ISA}
- && defined *{${$$pack}{ISA}}{ARRAY};
+ return do {
+ local $@;
+ eval { require($file) };
+ $@;
+ };
+}
- # check for any method
- foreach ( keys %{$$pack} ) {
- next if substr($_, -2, 2) eq '::';
+sub load_class {
+ my $class = load_first_existing_class($_[0]);
+ return get_metaclass_by_name($class) || $class;
+}
- my $glob = ${$$pack}{$_} || next;
+sub _is_valid_class_name {
+ my $class = shift;
- # constant subs
- if ( IS_RUNNING_ON_5_10 ) {
- return 1 if ref $glob eq 'SCALAR';
- }
+ return 0 if ref($class);
+ return 0 unless defined($class);
+ return 0 unless length($class);
- return 1 if defined *{$glob}{CODE};
- }
+ return 1 if $class =~ /^\w+(?:::\w+)*$/;
- # fail
return 0;
}
-
## ----------------------------------------------------------------------------
## Setting up our environment ...
## ----------------------------------------------------------------------------
# We need to add in the meta-attributes here so that
# any subclass of Class::MOP::* will be able to
-# inherit them using &construct_instance
+# inherit them using _construct_instance
## --------------------------------------------------------
## Class::MOP::Package
);
Class::MOP::Class->meta->add_attribute(
+ Class::MOP::Attribute->new('wrapped_method_metaclass' => (
+ reader => {
+ # NOTE:
+ # we just alias the original method
+ # rather than re-produce it here
+ 'wrapped_method_metaclass' => \&Class::MOP::Class::wrapped_method_metaclass
+ },
+ default => 'Class::MOP::Method::Wrapped',
+ ))
+);
+
+Class::MOP::Class->meta->add_attribute(
Class::MOP::Attribute->new('instance_metaclass' => (
reader => {
# NOTE: we need to do this in order
))
);
+Class::MOP::Class->meta->add_attribute(
+ Class::MOP::Attribute->new('immutable_transformer' => (
+ reader => {
+ 'immutable_transformer' => \&Class::MOP::Class::immutable_transformer
+ },
+ writer => {
+ '_set_immutable_transformer' => \&Class::MOP::Class::_set_immutable_transformer
+ },
+ ))
+);
+
# NOTE:
# we don't actually need to tie the knot with
# Class::MOP::Class here, it is actually handled
# within Class::MOP::Class itself in the
-# construct_class_instance method.
+# _construct_class_instance method.
## --------------------------------------------------------
## Class::MOP::Attribute
);
Class::MOP::Attribute->meta->add_attribute(
+ Class::MOP::Attribute->new('definition_context' => (
+ reader => { 'definition_context' => \&Class::MOP::Attribute::definition_context },
+ ))
+);
+
+Class::MOP::Attribute->meta->add_attribute(
Class::MOP::Attribute->new('writer' => (
reader => { 'writer' => \&Class::MOP::Attribute::writer },
predicate => { 'has_writer' => \&Class::MOP::Attribute::has_writer },
))
);
+Class::MOP::Method->meta->add_attribute(
+ Class::MOP::Attribute->new('original_method' => (
+ reader => { 'original_method' => \&Class::MOP::Method::original_method },
+ writer => { '_set_original_method' => \&Class::MOP::Method::_set_original_method },
+ ))
+);
+
Class::MOP::Method->meta->add_method('clone' => sub {
my $self = shift;
- $self->meta->clone_object($self, @_);
+ my $clone = $self->meta->clone_object($self, @_);
+ $clone->_set_original_method($self);
+ return $clone;
});
## --------------------------------------------------------
))
);
+Class::MOP::Method::Generated->meta->add_attribute(
+ Class::MOP::Attribute->new('definition_context' => (
+ reader => { 'definition_context' => \&Class::MOP::Method::Generated::definition_context },
+ ))
+);
+
## --------------------------------------------------------
## Class::MOP::Method::Accessor
## --------------------------------------------------------
## Now close all the Class::MOP::* classes
-# NOTE:
-# we don't need to inline the
-# constructors or the accessors
-# this only lengthens the compile
-# time of the MOP, and gives us
-# no actual benefits.
+# NOTE: we don't need to inline the the accessors this only lengthens
+# the compile time of the MOP, and gives us no actual benefits.
$_->meta->make_immutable(
inline_constructor => 1,
Class::MOP - A Meta Object Protocol for Perl 5
-=head1 DESCRIPTON
+=head1 DESCRIPTION
This module is a fully functioning meta object protocol for the
Perl 5 object system. It makes no attempt to change the behavior or
characteristics of the Perl 5 object system, only to create a
protocol for its manipulation and introspection.
-That said, it does attempt to create the tools for building a rich
-set of extensions to the Perl 5 object system. Every attempt has been
-made for these tools to keep to the spirit of the Perl 5 object
-system that we all know and love.
+That said, it does attempt to create the tools for building a rich set
+of extensions to the Perl 5 object system. Every attempt has been made
+to abide by the spirit of the Perl 5 object system that we all know
+and love.
-This documentation is admittedly sparse on details, as time permits
-I will try to improve them. For now, I suggest looking at the items
-listed in the L<SEE ALSO> section for more information. In particular
-the book "The Art of the Meta Object Protocol" was very influential
-in the development of this system.
+This documentation is sparse on conceptual details. We suggest looking
+at the items listed in the L<SEE ALSO> section for more
+information. In particular the book "The Art of the Meta Object
+Protocol" was very influential in the development of this system.
=head2 What is a Meta Object Protocol?
A meta object protocol is an API to an object system.
-To be more specific, it is a set of abstractions of the components of
-an object system (typically things like; classes, object, methods,
-object attributes, etc.). These abstractions can then be used to both
-inspect and manipulate the object system which they describe.
+To be more specific, it abstracts the components of an object system
+(classes, object, methods, object attributes, etc.). These
+abstractions can then be used to inspect and manipulate the object
+system which they describe.
It can be said that there are two MOPs for any object system; the
-implicit MOP, and the explicit MOP. The implicit MOP handles things
+implicit MOP and the explicit MOP. The implicit MOP handles things
like method dispatch or inheritance, which happen automatically as
part of how the object system works. The explicit MOP typically
handles the introspection/reflection features of the object system.
-All object systems have implicit MOPs, without one, they would not
-work. Explict MOPs however as less common, and depending on the
-language can vary from restrictive (Reflection in Java or C#) to
-wide open (CLOS is a perfect example).
-=head2 Yet Another Class Builder!! Why?
+All object systems have implicit MOPs. Without one, they would not
+work. Explicit MOPs are much less common, and depending on the
+language can vary from restrictive (Reflection in Java or C#) to wide
+open (CLOS is a perfect example).
+
+=head2 Yet Another Class Builder! Why?
-This is B<not> a class builder so much as it is a I<class builder
-B<builder>>. My intent is that an end user does not use this module
-directly, but instead this module is used by module authors to
-build extensions and features onto the Perl 5 object system.
+This is B<not> a class builder so much as a I<class builder
+B<builder>>. The intent is that an end user will not use this module
+directly, but instead this module is used by module authors to build
+extensions and features onto the Perl 5 object system.
+
+This system is used by L<Moose>, which supplies a powerful class
+builder system built entirely on top of C<Class::MOP>.
=head2 Who is this module for?
-This module is specifically for anyone who has ever created or
-wanted to create a module for the Class:: namespace. The tools which
-this module will provide will hopefully make it easier to do more
-complex things with Perl 5 classes by removing such barriers as
-the need to hack the symbol tables, or understand the fine details
-of method dispatch.
+This module is for anyone who has ever created or wanted to create a
+module for the Class:: namespace. The tools which this module provides
+make doing complex Perl 5 wizardry simpler, by removing such barriers
+as the need to hack symbol tables, or understand the fine details of
+method dispatch.
=head2 What changes do I have to make to use this module?
-This module was designed to be as unintrusive as possible. Many of
-its features are accessible without B<any> change to your existsing
-code at all. It is meant to be a compliment to your existing code and
-not an intrusion on your code base. Unlike many other B<Class::>
-modules, this module B<does not> require you subclass it, or even that
-you C<use> it in within your module's package.
+This module was designed to be as unintrusive as possible. Many of its
+features are accessible without B<any> change to your existing
+code. It is meant to be a compliment to your existing code and not an
+intrusion on your code base. Unlike many other B<Class::> modules,
+this module B<does not> require you subclass it, or even that you
+C<use> it in within your module's package.
The only features which requires additions to your code are the
attribute handling and instance construction features, and these are
Perl 5's object system does not actually have these features built
in. More information about this feature can be found below.
-=head2 A Note about Performance?
+=head2 About Performance
+
+It is a common misconception that explicit MOPs are a performance hit.
+This is not a universal truth, it is a side-effect of some specific
+implementations. For instance, using Java reflection is slow because
+the JVM cannot take advantage of any compiler optimizations, and the
+JVM has to deal with much more runtime type information as well.
-It is a common misconception that explict MOPs are performance drains.
-But this is not a universal truth at all, it is an side-effect of
-specific implementations. For instance, using Java reflection is much
-slower because the JVM cannot take advantage of any compiler
-optimizations, and the JVM has to deal with much more runtime type
-information as well. Reflection in C# is marginally better as it was
-designed into the language and runtime (the CLR). In contrast, CLOS
-(the Common Lisp Object System) was built to support an explicit MOP,
-and so performance is tuned for it.
+Reflection in C# is marginally better as it was designed into the
+language and runtime (the CLR). In contrast, CLOS (the Common Lisp
+Object System) was built to support an explicit MOP, and so
+performance is tuned for it.
-This library in particular does it's absolute best to avoid putting
+This library in particular does its absolute best to avoid putting
B<any> drain at all upon your code's performance. In fact, by itself
-it does nothing to affect your existing code. So you only pay for
-what you actually use.
+it does nothing to affect your existing code. So you only pay for what
+you actually use.
=head2 About Metaclass compatibility
class's ancestors.
Downward metaclass compatibility means that the metaclasses of a
-given class's anscestors are all either the same as (or a subclass
+given class's ancestors are all either the same as (or a subclass
of) that metaclass.
Here is a diagram showing a set of two classes (C<A> and C<B>) and
+---------+ +---------+
As I said this is a highly esoteric topic and one you will only run
-into if you do a lot of subclassing of B<Class::MOP::Class>. If you
-are interested in why this is an issue see the paper
-I<Uniform and safe metaclass composition> linked to in the
-L<SEE ALSO> section of this document.
+into if you do a lot of subclassing of L<Class::MOP::Class>. If you
+are interested in why this is an issue see the paper I<Uniform and
+safe metaclass composition> linked to in the L<SEE ALSO> section of
+this document.
=head2 Using custom metaclasses
-Always use the metaclass pragma when using a custom metaclass, this
-will ensure the proper initialization order and not accidentely
+Always use the L<metaclass> pragma when using a custom metaclass, this
+will ensure the proper initialization order and not accidentally
create an incorrect type of metaclass for you. This is a very rare
problem, and one which can only occur if you are doing deep metaclass
programming. So in other words, don't worry about it.
-=head1 PROTOCOLS
+Note that if you're using L<Moose> we encourage you to I<not> use
+L<metaclass> pragma, and instead use L<Moose::Util::MetaRole> to apply
+roles to a class's metaclasses. This topic is covered at length in
+various L<Moose::Cookbook> recipes.
-The protocol is divided into 4 main sub-protocols:
+=head1 PROTOCOLS
-=over 4
+The meta-object protocol is divided into 4 main sub-protocols:
-=item The Class protocol
+=head2 The Class protocol
This provides a means of manipulating and introspecting a Perl 5
-class. It handles all of symbol table hacking for you, and provides
-a rich set of methods that go beyond simple package introspection.
+class. It handles symbol table hacking for you, and provides a rich
+set of methods that go beyond simple package introspection.
See L<Class::MOP::Class> for more details.
-=item The Attribute protocol
+=head2 The Attribute protocol
-This provides a consistent represenation for an attribute of a
-Perl 5 class. Since there are so many ways to create and handle
-attributes in Perl 5 OO, this attempts to provide as much of a
-unified approach as possible, while giving the freedom and
-flexibility to subclass for specialization.
+This provides a consistent representation for an attribute of a Perl 5
+class. Since there are so many ways to create and handle attributes in
+Perl 5 OO, the Attribute protocol provide as much of a unified
+approach as possible. Of course, you are always free to extend this
+protocol by subclassing the appropriate classes.
See L<Class::MOP::Attribute> for more details.
-=item The Method protocol
+=head2 The Method protocol
-This provides a means of manipulating and introspecting methods in
-the Perl 5 object system. As with attributes, there are many ways to
+This provides a means of manipulating and introspecting methods in the
+Perl 5 object system. As with attributes, there are many ways to
approach this topic, so we try to keep it pretty basic, while still
making it possible to extend the system in many ways.
See L<Class::MOP::Method> for more details.
-=item The Instance protocol
+=head2 The Instance protocol
-This provides a layer of abstraction for creating object instances.
-Since the other layers use this protocol, it is relatively easy to
-change the type of your instances from the default HASH ref to other
-types of references. Several examples are provided in the F<examples/>
-directory included in this distribution.
+This provides a layer of abstraction for creating object instances.
+Since the other layers use this protocol, it is relatively easy to
+change the type of your instances from the default hash reference to
+some other type of reference. Several examples are provided in the
+F<examples/> directory included in this distribution.
See L<Class::MOP::Instance> for more details.
-=back
-
=head1 FUNCTIONS
+Note that this module does not export any constants or functions.
+
=head2 Constants
=over 4
-=item I<IS_RUNNING_ON_5_10>
+=item I<Class::MOP::IS_RUNNING_ON_5_10>
-We set this constant depending on what version perl we are on, this
-allows us to take advantage of new 5.10 features and stay backwards
-compat.
-
-=item I<HAVE_ISAREV>
-
-Whether or not C<mro> provides C<get_isarev>, a much faster way to get all the
-subclasses of a certain class.
+We set this constant depending on what version perl we are on, this
+allows us to take advantage of new 5.10 features and stay backwards
+compatible.
=back
=head2 Utility functions
-=over 4
+Note that these are all called as B<functions, not methods>.
-=item B<load_class ($class_name)>
+=over 4
-This will load a given C<$class_name> and if it does not have an
-already initialized metaclass, then it will intialize one for it.
-This function can be used in place of tricks like
-C<eval "use $module"> or using C<require>.
+=item B<Class::MOP::load_class($class_name)>
-=item B<is_class_loaded ($class_name)>
+This will load the specified C<$class_name>. This function can be used
+in place of tricks like C<eval "use $module"> or using C<require>
+unconditionally. This will return the metaclass of C<$class_name>.
-This will return a boolean depending on if the C<$class_name> has
-been loaded.
+=item B<Class::MOP::is_class_loaded($class_name)>
-NOTE: This does a basic check of the symbol table to try and
-determine as best it can if the C<$class_name> is loaded, it
-is probably correct about 99% of the time.
+Returns a boolean indicating whether or not C<$class_name> has been
+loaded.
-=item B<check_package_cache_flag ($pkg)>
+This does a basic check of the symbol table to try and determine as
+best it can if the C<$class_name> is loaded, it is probably correct
+about 99% of the time, but it can be fooled into reporting false
+positives.
-This will return an integer that is managed by C<Class::MOP::Class>
-to determine if a module's symbol table has been altered.
+=item B<Class::MOP::get_code_info($code)>
-In Perl 5.10 or greater, this flag is package specific. However in
-versions prior to 5.10, this will use the C<PL_sub_generation> variable
-which is not package specific.
+This function returns two values, the name of the package the C<$code>
+is from and the name of the C<$code> itself. This is used by several
+elements of the MOP to determine where a given C<$code> reference is
+from.
-=item B<get_code_info ($code)>
+=item B<Class::MOP::class_of($instance_or_class_name)>
-This function returns two values, the name of the package the C<$code>
-is from and the name of the C<$code> itself. This is used by several
-elements of the MOP to detemine where a given C<$code> reference is from.
+This will return the metaclass of the given instance or class name.
+Even if the class lacks a metaclass, no metaclass will be initialized
+and C<undef> will be returned.
-=item B<subname ($name, $code)>
+=item B<Class::MOP::check_package_cache_flag($pkg)>
B<NOTE: DO NOT USE THIS FUNCTION, IT IS FOR INTERNAL USE ONLY!>
-If possible, we will load the L<Sub::Name> module and this will function
-as C<Sub::Name::subname> does, otherwise it will just return the C<$code>
-argument.
+This will return an integer that is managed by L<Class::MOP::Class> to
+determine if a module's symbol table has been altered.
+
+In Perl 5.10 or greater, this flag is package specific. However in
+versions prior to 5.10, this will use the C<PL_sub_generation>
+variable which is not package specific.
-=item B<in_global_destruction>
+=item B<Class::MOP::load_first_existing_class(@class_names)>
-If L<Devel::GlobalDestruction> is available, this returns true under global
-destruction.
+B<NOTE: DO NOT USE THIS FUNCTION, IT IS FOR INTERNAL USE ONLY!>
-Otherwise it's a constant returning false.
+Given a list of class names, this function will attempt to load each
+one in turn.
+
+If it finds a class it can load, it will return that class' name. If
+none of the classes can be loaded, it will throw an exception.
=back
=head2 Metaclass cache functions
-Class::MOP holds a cache of metaclasses, the following are functions
+Class::MOP holds a cache of metaclasses. The following are functions
(B<not methods>) which can be used to access that cache. It is not
-recommended that you mess with this, bad things could happen. But if
-you are brave and willing to risk it, go for it.
+recommended that you mess with these. Bad things could happen, but if
+you are brave and willing to risk it: go for it!
=over 4
-=item B<get_all_metaclasses>
+=item B<Class::MOP::get_all_metaclasses>
-This will return an hash of all the metaclass instances that have
-been cached by B<Class::MOP::Class> keyed by the package name.
+This will return a hash of all the metaclass instances that have
+been cached by L<Class::MOP::Class>, keyed by the package name.
-=item B<get_all_metaclass_instances>
+=item B<Class::MOP::get_all_metaclass_instances>
-This will return an array of all the metaclass instances that have
-been cached by B<Class::MOP::Class>.
+This will return a list of all the metaclass instances that have
+been cached by L<Class::MOP::Class>.
-=item B<get_all_metaclass_names>
+=item B<Class::MOP::get_all_metaclass_names>
-This will return an array of all the metaclass names that have
-been cached by B<Class::MOP::Class>.
+This will return a list of all the metaclass names that have
+been cached by L<Class::MOP::Class>.
-=item B<get_metaclass_by_name ($name)>
+=item B<Class::MOP::get_metaclass_by_name($name)>
-This will return a cached B<Class::MOP::Class> instance of nothing
-if no metaclass exist by that C<$name>.
+This will return a cached L<Class::MOP::Class> instance, or nothing
+if no metaclass exists with that C<$name>.
-=item B<store_metaclass_by_name ($name, $meta)>
+=item B<Class::MOP::store_metaclass_by_name($name, $meta)>
This will store a metaclass in the cache at the supplied C<$key>.
-=item B<weaken_metaclass ($name)>
+=item B<Class::MOP::weaken_metaclass($name)>
-In rare cases it is desireable to store a weakened reference in
-the metaclass cache. This function will weaken the reference to
-the metaclass stored in C<$name>.
+In rare cases (e.g. anonymous metaclasses) it is desirable to
+store a weakened reference in the metaclass cache. This
+function will weaken the reference to the metaclass stored
+in C<$name>.
-=item B<does_metaclass_exist ($name)>
+=item B<Class::MOP::does_metaclass_exist($name)>
-This will return true of there exists a metaclass stored in the
-C<$name> key and return false otherwise.
+This will return true of there exists a metaclass stored in the
+C<$name> key, and return false otherwise.
-=item B<remove_metaclass_by_name ($name)>
+=item B<Class::MOP::remove_metaclass_by_name($name)>
-This will remove a the metaclass stored in the C<$name> key.
+This will remove the metaclass stored in the C<$name> key.
=back
=over 4
-=item "The Art of the Meta Object Protocol"
+=item I<The Art of the Meta Object Protocol>
-=item "Advances in Object-Oriented Metalevel Architecture and Reflection"
+=item I<Advances in Object-Oriented Metalevel Architecture and Reflection>
-=item "Putting MetaClasses to Work"
+=item I<Putting MetaClasses to Work>
-=item "Smalltalk: The Language"
+=item I<Smalltalk: The Language>
=back
=over 4
-=item Uniform and safe metaclass composition
+=item "Uniform and safe metaclass composition"
An excellent paper by the people who brought us the original Traits paper.
This paper is on how Traits can be used to do safe metaclass composition,
L<http://www.iam.unibe.ch/~scg/Archive/Papers/Duca05ySafeMetaclassTrait.pdf>
-=item Safe Metaclass Programming
+=item "Safe Metaclass Programming"
This paper seems to precede the above paper, and propose a mix-in based
approach as opposed to the Traits based approach. Both papers have similar
Brandon (blblack) Black
+Florian (rafl) Ragwitz
+
Guillermo (groditi) Roditi
Matt (mst) Trout
=head1 COPYRIGHT AND LICENSE
-Copyright 2006-2008 by Infinity Interactive, Inc.
+Copyright 2006-2009 by Infinity Interactive, Inc.
L<http://www.iinteractive.com>
projects / gitmo/Class-MOP.git / blobdiff