Class::MOP::Class->initialize(blessed($_[0]) || $_[0])
};
}
+ else {
+ my $pkg = caller();
+ no strict 'refs';
+ *{$pkg . '::' . $_[0]} = sub {
+ Class::MOP::Class->initialize(blessed($_[0]) || $_[0])
+ };
+ }
}
-## Bootstrapping
+## ----------------------------------------------------------------------------
+## Bootstrapping
+## ----------------------------------------------------------------------------
+## The code below here is to bootstrap our MOP with itself. This is also
+## sometimes called "tying the knot". By doing this, we make it much easier
+## to extend the MOP through subclassing and such since now you can use the
+## MOP itself to extend itself.
+##
+## Yes, I know, thats weird and insane, but it's a good thing, trust me :)
+## ----------------------------------------------------------------------------
# We need to add in the meta-attributes here so that
# any subclass of Class::MOP::* will be able to
bless $class->meta->construct_instance(name => $name, %options) => $class;
});
-# NOTE: (meta-circularity)
-# This is how we "tie the knot" for the class
-# meta-objects. This is used to construct the
-# Class::MOP::Class instances after all the
-# bootstrapping is complete.
-Class::MOP::Class->meta->add_method('construct_class_instance' => sub {
- my ($class, $package_name) = @_;
- (defined $package_name && $package_name)
- || confess "You must pass a package name";
- bless Class::MOP::Class->meta->construct_instance(':pkg' => $package_name) => blessed($class) || $class
-});
-
1;
__END__
=head1 SYNOPSIS
- use Class::MOP ':universal';
-
- package Foo;
-
- Foo->meta->add_method('foo' => sub { ... });
+ # ... This will come later, for now see
+ # the other SYNOPSIS for more information
=head1 DESCRIPTON
it's 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 does require you subclass it, or even that you
-C<use> it in within your module's package.
+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
-both optional features as well. The only reason for this is because
+both completely optional features. The only reason for this is because
Perl 5's object system does not actually have these features built
in. More information about this feature can be found below.
=head2 Books
+There are very few books out on Meta Object Protocols and Metaclasses
+because it is such an esoteric topic. The following books are really
+the only ones I have found. If you know of any more, B<I<please>>
+email me and let me know, I would love to hear about them.
+
=over 4
=item "The Art of the Meta Object Protocol"
=item "Advances in Object-Oriented Metalevel Architecture and Reflection"
+=item "Putting MetaClasses to Work"
+
+=item "Smalltalk: The Language"
+
=back
=head2 Prior Art
=over 4
-=item The Perl 6 MetaModel work
+=item The Perl 6 MetaModel work in the Pugs project
=over 4
=back
-=head1 AUTHOR
+=head1 SIMILAR MODULES
+
+As I have said above, this module is a class-builder-builder, so it is
+not the same thing as modules like L<Class::Accessor> and
+L<Class::MethodMaker>. That being said there are very few modules on CPAN
+with similar goals to this module. The one I have found which is most
+like this module is L<Class::Meta>, although it's philosophy is very
+different from this module.
+
+To start with, it provides wrappers around common Perl data types, and even
+extends those types with more specific subtypes. This module does not
+go into that area at all.
+
+L<Class::Meta> also seems to create it's own custom meta-object protocol,
+which is both more restrictive and more featureful than the vanilla
+Perl 5 one. This module attempts to model the existing Perl 5 MOP as it is.
+
+It's introspection capabilities also seem to be heavily rooted in this
+custom MOP, so that you can only introspect classes which are already
+created with L<Class::Meta>. This module does not make such restictions.
-Stevan Little E<gt>stevan@iinteractive.comE<lt>
+Now, all this said, L<Class::Meta> is much more featureful than B<Class::MOP>
+would ever try to be. But B<Class::MOP> has some features which L<Class::Meta>
+could not easily implement. It would be very possible to completely re-implement
+L<Class::Meta> using B<Class::MOP> and bring some of these features to
+L<Class::Meta> though.
+
+But in the end, this module's admitedly ambitious goals have no direct equal
+on CPAN since surely no one has been crazy enough to try something as silly
+as this ;) until now.
+
+=head1 BUGS
+
+All complex software has bugs lurking in it, and this module is no
+exception. If you find a bug please either email me, or add the bug
+to cpan-RT.
+
+=head1 ACKNOWLEDGEMENTS
+
+=over 4
+
+=item Rob Kinyon E<lt>rob@iinteractive.comE<gt>
+
+Thanks to Rob for actually getting the development of this module kick-started.
+
+=back
+
+=head1 AUTHOR
-Rob Kinyon E<gt>rob@iinteractive.comE<lt>
+Stevan Little E<lt>stevan@iinteractive.comE<gt>
=head1 COPYRIGHT AND LICENSE
projects / gitmo/Class-MOP.git / blobdiff