lib/Moose/Meta/Class.pm

   1
   2 package Moose::Meta::Class;
   3
   4 use strict;
   5 use warnings;
   6
   7 use Class::MOP;
   8
   9 use Carp qw( confess );
  10 use Data::OptList;
  11 use List::Util qw( first );
  12 use List::MoreUtils qw( any all uniq first_index );
  13 use Scalar::Util 'blessed';
  14
  15 use Moose::Meta::Method::Overridden;
  16 use Moose::Meta::Method::Augmented;
  17 use Moose::Error::Default;
  18 use Moose::Meta::Class::Immutable::Trait;
  19 use Moose::Meta::Method::Constructor;
  20 use Moose::Meta::Method::Destructor;
  21 use Moose::Meta::Method::Meta;
  22 use Moose::Util;
  23 use Class::MOP::MiniTrait;
  24
  25 use base 'Class::MOP::Class';
  26
  27 Class::MOP::MiniTrait::apply(__PACKAGE__, 'Moose::Meta::Object::Trait');
  28
  29 __PACKAGE__->meta->add_attribute('roles' => (
  30     reader  => 'roles',
  31     default => sub { [] }
  32 ));
  33
  34 __PACKAGE__->meta->add_attribute('role_applications' => (
  35     reader  => '_get_role_applications',
  36     default => sub { [] }
  37 ));
  38
  39 __PACKAGE__->meta->add_attribute(
  40     Class::MOP::Attribute->new('immutable_trait' => (
  41         accessor => "immutable_trait",
  42         default  => 'Moose::Meta::Class::Immutable::Trait',
  43     ))
  44 );
  45
  46 __PACKAGE__->meta->add_attribute('constructor_class' => (
  47     accessor => 'constructor_class',
  48     default  => 'Moose::Meta::Method::Constructor',
  49 ));
  50
  51 __PACKAGE__->meta->add_attribute('destructor_class' => (
  52     accessor => 'destructor_class',
  53     default  => 'Moose::Meta::Method::Destructor',
  54 ));
  55
  56 __PACKAGE__->meta->add_attribute('error_class' => (
  57     accessor => 'error_class',
  58     default  => 'Moose::Error::Default',
  59 ));
  60
  61 sub initialize {
  62     my $class = shift;
  63     my @args = @_;
  64     unshift @args, 'package' if @args % 2;
  65     my %opts = @args;
  66     my $package = delete $opts{package};
  67     return Class::MOP::get_metaclass_by_name($package)
  68         || $class->SUPER::initialize($package,
  69                 'attribute_metaclass' => 'Moose::Meta::Attribute',
  70                 'method_metaclass'    => 'Moose::Meta::Method',
  71                 'instance_metaclass'  => 'Moose::Meta::Instance',
  72                 %opts,
  73             );
  74 }
  75
  76 sub create {
  77     my $class = shift;
  78     my @args = @_;
  79
  80     unshift @args, 'package' if @args % 2 == 1;
  81     my %options = @args;
  82
  83     (ref $options{roles} eq 'ARRAY')
  84         || $class->throw_error("You must pass an ARRAY ref of roles", data => $options{roles})
  85             if exists $options{roles};
  86
  87     my $package = delete $options{package};
  88     my $roles   = delete $options{roles};
  89
  90     my $new_meta = $class->SUPER::create($package, %options);
  91
  92     if ($roles) {
  93         Moose::Util::apply_all_roles( $new_meta, @$roles );
  94     }
  95
  96     return $new_meta;
  97 }
  98
  99 sub _meta_method_class { 'Moose::Meta::Method::Meta' }
 100
 101 sub _anon_package_prefix { 'Moose::Meta::Class::__ANON__::SERIAL::' }
 102
 103 sub _anon_cache_key {
 104     my $class = shift;
 105     my %options = @_;
 106
 107     my $superclass_key = join('|',
 108         map { $_->[0] } @{ Data::OptList::mkopt($options{superclasses} || []) }
 109     );
 110
 111     my $roles = Data::OptList::mkopt(($options{roles} || []), {
 112         moniker  => 'role',
 113         val_test => sub { ref($_[0]) eq 'HASH' },
 114     });
 115
 116     my @role_keys;
 117     for my $role_spec (@$roles) {
 118         my ($role, $params) = @$role_spec;
 119         $params = { %$params } if $params;
 120
 121         my $key = blessed($role) ? $role->name : $role;
 122
 123         if ($params && %$params) {
 124             my $alias    = delete $params->{'-alias'}
 125                         || delete $params->{'alias'}
 126                         || {};
 127             my $excludes = delete $params->{'-excludes'}
 128                         || delete $params->{'excludes'}
 129                         || [];
 130             $excludes = [$excludes] unless ref($excludes) eq 'ARRAY';
 131
 132             if (%$params) {
 133                 warn "Roles with parameters cannot be cached. Consider "
 134                    . "applying the parameters before calling "
 135                    . "create_anon_class, or using 'weaken => 0' instead";
 136                 return;
 137             }
 138
 139             my $alias_key = join('%',
 140                 map { $_ => $alias->{$_} } sort keys %$alias
 141             );
 142             my $excludes_key = join('%',
 143                 sort @$excludes
 144             );
 145             $key .= '<' . join('+', 'a', $alias_key, 'e', $excludes_key) . '>';
 146         }
 147
 148         push @role_keys, $key;
 149     }
 150
 151     my $role_key = join('|', sort @role_keys);
 152
 153     # Makes something like Super::Class|Super::Class::2=Role|Role::1
 154     return join('=', $superclass_key, $role_key);
 155 }
 156
 157 sub reinitialize {
 158     my $self = shift;
 159     my $pkg  = shift;
 160
 161     my $meta = blessed $pkg ? $pkg : Class::MOP::class_of($pkg);
 162
 163     my %existing_classes;
 164     if ($meta) {
 165         %existing_classes = map { $_ => $meta->$_() } qw(
 166             attribute_metaclass
 167             method_metaclass
 168             wrapped_method_metaclass
 169             instance_metaclass
 170             constructor_class
 171             destructor_class
 172             error_class
 173         );
 174     }
 175
 176     return $self->SUPER::reinitialize(
 177         $pkg,
 178         %existing_classes,
 179         @_,
 180     );
 181 }
 182
 183 sub add_role {
 184     my ($self, $role) = @_;
 185     (blessed($role) && $role->isa('Moose::Meta::Role'))
 186         || $self->throw_error("Roles must be instances of Moose::Meta::Role", data => $role);
 187     push @{$self->roles} => $role;
 188 }
 189
 190 sub role_applications {
 191     my ($self) = @_;
 192
 193     return @{$self->_get_role_applications};
 194 }
 195
 196 sub add_role_application {
 197     my ($self, $application) = @_;
 198     (blessed($application) && $application->isa('Moose::Meta::Role::Application::ToClass'))
 199         || $self->throw_error("Role applications must be instances of Moose::Meta::Role::Application::ToClass", data => $application);
 200     push @{$self->_get_role_applications} => $application;
 201 }
 202
 203 sub calculate_all_roles {
 204     my $self = shift;
 205     my %seen;
 206     grep { !$seen{$_->name}++ } map { $_->calculate_all_roles } @{ $self->roles };
 207 }
 208
 209 sub calculate_all_roles_with_inheritance {
 210     my $self = shift;
 211     my %seen;
 212     grep { !$seen{$_->name}++ }
 213          map { Class::MOP::class_of($_)->can('calculate_all_roles')
 214                    ? Class::MOP::class_of($_)->calculate_all_roles
 215                    : () }
 216              $self->linearized_isa;
 217 }
 218
 219 sub does_role {
 220     my ($self, $role_name) = @_;
 221
 222     (defined $role_name)
 223         || $self->throw_error("You must supply a role name to look for");
 224
 225     foreach my $class ($self->class_precedence_list) {
 226         my $meta = Class::MOP::class_of($class);
 227         # when a Moose metaclass is itself extended with a role,
 228         # this check needs to be done since some items in the
 229         # class_precedence_list might in fact be Class::MOP
 230         # based still.
 231         next unless $meta && $meta->can('roles');
 232         foreach my $role (@{$meta->roles}) {
 233             return 1 if $role->does_role($role_name);
 234         }
 235     }
 236     return 0;
 237 }
 238
 239 sub excludes_role {
 240     my ($self, $role_name) = @_;
 241
 242     (defined $role_name)
 243         || $self->throw_error("You must supply a role name to look for");
 244
 245     foreach my $class ($self->class_precedence_list) {
 246         my $meta = Class::MOP::class_of($class);
 247         # when a Moose metaclass is itself extended with a role,
 248         # this check needs to be done since some items in the
 249         # class_precedence_list might in fact be Class::MOP
 250         # based still.
 251         next unless $meta && $meta->can('roles');
 252         foreach my $role (@{$meta->roles}) {
 253             return 1 if $role->excludes_role($role_name);
 254         }
 255     }
 256     return 0;
 257 }
 258
 259 sub new_object {
 260     my $self   = shift;
 261     my $params = @_ == 1 ? $_[0] : {@_};
 262     my $object = $self->SUPER::new_object($params);
 263
 264     foreach my $attr ( $self->get_all_attributes() ) {
 265
 266         next unless $attr->can('has_trigger') && $attr->has_trigger;
 267
 268         my $init_arg = $attr->init_arg;
 269
 270         next unless defined $init_arg;
 271
 272         next unless exists $params->{$init_arg};
 273
 274         $attr->trigger->(
 275             $object,
 276             (
 277                   $attr->should_coerce
 278                 ? $attr->get_read_method_ref->($object)
 279                 : $params->{$init_arg}
 280             ),
 281         );
 282     }
 283
 284     $object->BUILDALL($params) if $object->can('BUILDALL');
 285
 286     return $object;
 287 }
 288
 289 sub _generate_fallback_constructor {
 290     my $self = shift;
 291     my ($class) = @_;
 292     return $class . '->Moose::Object::new(@_)'
 293 }
 294
 295 sub _inline_params {
 296     my $self = shift;
 297     my ($params, $class) = @_;
 298     return (
 299         'my ' . $params . ' = ',
 300         $self->_inline_BUILDARGS($class, '@_'),
 301         ';',
 302     );
 303 }
 304
 305 sub _inline_BUILDARGS {
 306     my $self = shift;
 307     my ($class, $args) = @_;
 308
 309     my $buildargs = $self->find_method_by_name("BUILDARGS");
 310
 311     if ($args eq '@_'
 312      && (!$buildargs or $buildargs->body == \&Moose::Object::BUILDARGS)) {
 313         return (
 314             'do {',
 315                 'my $params;',
 316                 'if (scalar @_ == 1) {',
 317                     'if (!defined($_[0]) || ref($_[0]) ne \'HASH\') {',
 318                         $self->_inline_throw_error(
 319                             '"Single parameters to new() must be a HASH ref"',
 320                             'data => $_[0]',
 321                         ) . ';',
 322                     '}',
 323                     '$params = { %{ $_[0] } };',
 324                 '}',
 325                 'elsif (@_ % 2) {',
 326                     'Carp::carp(',
 327                         '"The new() method for ' . $class . ' expects a '
 328                       . 'hash reference or a key/value list. You passed an '
 329                       . 'odd number of arguments"',
 330                     ');',
 331                     '$params = {@_, undef};',
 332                 '}',
 333                 'else {',
 334                     '$params = {@_};',
 335                 '}',
 336                 '$params;',
 337             '}',
 338         );
 339     }
 340     else {
 341         return $class . '->BUILDARGS(' . $args . ')';
 342     }
 343 }
 344
 345 sub _inline_slot_initializer {
 346     my $self  = shift;
 347     my ($attr, $idx) = @_;
 348
 349     return (
 350         '## ' . $attr->name,
 351         $self->_inline_check_required_attr($attr),
 352         $self->SUPER::_inline_slot_initializer(@_),
 353     );
 354 }
 355
 356 sub _inline_check_required_attr {
 357     my $self = shift;
 358     my ($attr) = @_;
 359
 360     return unless defined $attr->init_arg;
 361     return unless $attr->can('is_required') && $attr->is_required;
 362     return if $attr->has_default || $attr->has_builder;
 363
 364     return (
 365         'if (!exists $params->{\'' . $attr->init_arg . '\'}) {',
 366             $self->_inline_throw_error(
 367                 '"Attribute (' . quotemeta($attr->name) . ') is required"'
 368             ) . ';',
 369         '}',
 370     );
 371 }
 372
 373 # XXX: these two are duplicated from cmop, because we have to pass the tc stuff
 374 # through to _inline_set_value - this should probably be fixed, but i'm not
 375 # quite sure how. -doy
 376 sub _inline_init_attr_from_constructor {
 377     my $self = shift;
 378     my ($attr, $idx) = @_;
 379
 380     my @initial_value = $attr->_inline_set_value(
 381         '$instance',
 382         '$params->{\'' . $attr->init_arg . '\'}',
 383         '$type_constraint_bodies[' . $idx . ']',
 384         '$type_constraints[' . $idx . ']',
 385         'for constructor',
 386     );
 387
 388     push @initial_value, (
 389         '$attrs->[' . $idx . ']->set_initial_value(',
 390             '$instance,',
 391             $attr->_inline_instance_get('$instance'),
 392         ');',
 393     ) if $attr->has_initializer;
 394
 395     return @initial_value;
 396 }
 397
 398 sub _inline_init_attr_from_default {
 399     my $self = shift;
 400     my ($attr, $idx) = @_;
 401
 402     return if $attr->can('is_lazy') && $attr->is_lazy;
 403     my $default = $self->_inline_default_value($attr, $idx);
 404     return unless $default;
 405
 406     my @initial_value = (
 407         'my $default = ' . $default . ';',
 408         $attr->_inline_set_value(
 409             '$instance',
 410             '$default',
 411             '$type_constraint_bodies[' . $idx . ']',
 412             '$type_constraints[' . $idx . ']',
 413             'for constructor',
 414         ),
 415     );
 416
 417     push @initial_value, (
 418         '$attrs->[' . $idx . ']->set_initial_value(',
 419             '$instance,',
 420             $attr->_inline_instance_get('$instance'),
 421         ');',
 422     ) if $attr->has_initializer;
 423
 424     return @initial_value;
 425 }
 426
 427 sub _inline_extra_init {
 428     my $self = shift;
 429     return (
 430         $self->_inline_triggers,
 431         $self->_inline_BUILDALL,
 432     );
 433 }
 434
 435 sub _inline_triggers {
 436     my $self = shift;
 437     my @trigger_calls;
 438
 439     my @attrs = sort { $a->name cmp $b->name } $self->get_all_attributes;
 440     for my $i (0 .. $#attrs) {
 441         my $attr = $attrs[$i];
 442
 443         next unless $attr->can('has_trigger') && $attr->has_trigger;
 444
 445         my $init_arg = $attr->init_arg;
 446         next unless defined $init_arg;
 447
 448         push @trigger_calls,
 449             'if (exists $params->{\'' . $init_arg . '\'}) {',
 450                 '$attrs->[' . $i . ']->trigger->(',
 451                     '$instance,',
 452                     $attr->_inline_instance_get('$instance') . ',',
 453                 ');',
 454             '}';
 455     }
 456
 457     return @trigger_calls;
 458 }
 459
 460 sub _inline_BUILDALL {
 461     my $self = shift;
 462
 463     my @methods = reverse $self->find_all_methods_by_name('BUILD');
 464     my @BUILD_calls;
 465
 466     foreach my $method (@methods) {
 467         push @BUILD_calls,
 468             '$instance->' . $method->{class} . '::BUILD($params);';
 469     }
 470
 471     return @BUILD_calls;
 472 }
 473
 474 sub superclasses {
 475     my $self = shift;
 476     my $supers = Data::OptList::mkopt(\@_);
 477     foreach my $super (@{ $supers }) {
 478         my ($name, $opts) = @{ $super };
 479         Class::MOP::load_class($name, $opts);
 480         my $meta = Class::MOP::class_of($name);
 481         $self->throw_error("You cannot inherit from a Moose Role ($name)")
 482             if $meta && $meta->isa('Moose::Meta::Role')
 483     }
 484     return $self->SUPER::superclasses(map { $_->[0] } @{ $supers });
 485 }
 486
 487 ### ---------------------------------------------
 488
 489 sub add_attribute {
 490     my $self = shift;
 491     my $attr =
 492         (blessed $_[0] && $_[0]->isa('Class::MOP::Attribute')
 493             ? $_[0]
 494             : $self->_process_attribute(@_));
 495     $self->SUPER::add_attribute($attr);
 496     # it may be a Class::MOP::Attribute, theoretically, which doesn't have
 497     # 'bare' and doesn't implement this method
 498     if ($attr->can('_check_associated_methods')) {
 499         $attr->_check_associated_methods;
 500     }
 501     return $attr;
 502 }
 503
 504 sub add_override_method_modifier {
 505     my ($self, $name, $method, $_super_package) = @_;
 506
 507     (!$self->has_method($name))
 508         || $self->throw_error("Cannot add an override method if a local method is already present");
 509
 510     $self->add_method($name => Moose::Meta::Method::Overridden->new(
 511         method  => $method,
 512         class   => $self,
 513         package => $_super_package, # need this for roles
 514         name    => $name,
 515     ));
 516 }
 517
 518 sub add_augment_method_modifier {
 519     my ($self, $name, $method) = @_;
 520     (!$self->has_method($name))
 521         || $self->throw_error("Cannot add an augment method if a local method is already present");
 522
 523     $self->add_method($name => Moose::Meta::Method::Augmented->new(
 524         method  => $method,
 525         class   => $self,
 526         name    => $name,
 527     ));
 528 }
 529
 530 ## Private Utility methods ...
 531
 532 sub _find_next_method_by_name_which_is_not_overridden {
 533     my ($self, $name) = @_;
 534     foreach my $method ($self->find_all_methods_by_name($name)) {
 535         return $method->{code}
 536             if blessed($method->{code}) && !$method->{code}->isa('Moose::Meta::Method::Overridden');
 537     }
 538     return undef;
 539 }
 540
 541 ## Metaclass compatibility
 542
 543 sub _base_metaclasses {
 544     my $self = shift;
 545     my %metaclasses = $self->SUPER::_base_metaclasses;
 546     for my $class (keys %metaclasses) {
 547         $metaclasses{$class} =~ s/^Class::MOP/Moose::Meta/;
 548     }
 549     return (
 550         %metaclasses,
 551         error_class => 'Moose::Error::Default',
 552     );
 553 }
 554
 555 sub _fix_class_metaclass_incompatibility {
 556     my $self = shift;
 557     my ($super_meta) = @_;
 558
 559     $self->SUPER::_fix_class_metaclass_incompatibility(@_);
 560
 561     if ($self->_class_metaclass_can_be_made_compatible($super_meta)) {
 562         ($self->is_pristine)
 563             || confess "Can't fix metaclass incompatibility for "
 564                      . $self->name
 565                      . " because it is not pristine.";
 566         my $super_meta_name = $super_meta->_real_ref_name;
 567         my $class_meta_subclass_meta_name = Moose::Util::_reconcile_roles_for_metaclass(blessed($self), $super_meta_name);
 568         my $new_self = $class_meta_subclass_meta_name->reinitialize(
 569             $self->name,
 570         );
 571
 572         $self->_replace_self( $new_self, $class_meta_subclass_meta_name );
 573     }
 574 }
 575
 576 sub _fix_single_metaclass_incompatibility {
 577     my $self = shift;
 578     my ($metaclass_type, $super_meta) = @_;
 579
 580     $self->SUPER::_fix_single_metaclass_incompatibility(@_);
 581
 582     if ($self->_single_metaclass_can_be_made_compatible($super_meta, $metaclass_type)) {
 583         ($self->is_pristine)
 584             || confess "Can't fix metaclass incompatibility for "
 585                      . $self->name
 586                      . " because it is not pristine.";
 587         my $super_meta_name = $super_meta->_real_ref_name;
 588         my $class_specific_meta_subclass_meta_name = Moose::Util::_reconcile_roles_for_metaclass($self->$metaclass_type, $super_meta->$metaclass_type);
 589         my $new_self = $super_meta->reinitialize(
 590             $self->name,
 591             $metaclass_type => $class_specific_meta_subclass_meta_name,
 592         );
 593
 594         $self->_replace_self( $new_self, $super_meta_name );
 595     }
 596 }
 597
 598 sub _replace_self {
 599     my $self      = shift;
 600     my ( $new_self, $new_class)   = @_;
 601
 602     %$self = %$new_self;
 603     bless $self, $new_class;
 604
 605     # We need to replace the cached metaclass instance or else when it goes
 606     # out of scope Class::MOP::Class destroy's the namespace for the
 607     # metaclass's class, causing much havoc.
 608     my $weaken = Class::MOP::metaclass_is_weak( $self->name );
 609     Class::MOP::store_metaclass_by_name( $self->name, $self );
 610     Class::MOP::weaken_metaclass( $self->name ) if $weaken;
 611 }
 612
 613 sub _process_attribute {
 614     my ( $self, $name, @args ) = @_;
 615
 616     @args = %{$args[0]} if scalar @args == 1 && ref($args[0]) eq 'HASH';
 617
 618     if (($name || '') =~ /^\+(.*)/) {
 619         return $self->_process_inherited_attribute($1, @args);
 620     }
 621     else {
 622         return $self->_process_new_attribute($name, @args);
 623     }
 624 }
 625
 626 sub _process_new_attribute {
 627     my ( $self, $name, @args ) = @_;
 628
 629     $self->attribute_metaclass->interpolate_class_and_new($name, @args);
 630 }
 631
 632 sub _process_inherited_attribute {
 633     my ($self, $attr_name, %options) = @_;
 634     my $inherited_attr = $self->find_attribute_by_name($attr_name);
 635     (defined $inherited_attr)
 636         || $self->throw_error("Could not find an attribute by the name of '$attr_name' to inherit from in ${\$self->name}", data => $attr_name);
 637     if ($inherited_attr->isa('Moose::Meta::Attribute')) {
 638         return $inherited_attr->clone_and_inherit_options(%options);
 639     }
 640     else {
 641         # NOTE:
 642         # kind of a kludge to handle Class::MOP::Attributes
 643         return $inherited_attr->Moose::Meta::Attribute::clone_and_inherit_options(%options);
 644     }
 645 }
 646
 647 # reinitialization support
 648
 649 sub _restore_metaobjects_from {
 650     my $self = shift;
 651     my ($old_meta) = @_;
 652
 653     $self->SUPER::_restore_metaobjects_from($old_meta);
 654
 655     for my $role ( @{ $old_meta->roles } ) {
 656         $self->add_role($role);
 657     }
 658
 659     for my $application ( @{ $old_meta->_get_role_applications } ) {
 660         $application->class($self);
 661         $self->add_role_application ($application);
 662     }
 663 }
 664
 665 ## Immutability
 666
 667 sub _immutable_options {
 668     my ( $self, @args ) = @_;
 669
 670     $self->SUPER::_immutable_options(
 671         inline_destructor => 1,
 672
 673         # Moose always does this when an attribute is created
 674         inline_accessors => 0,
 675
 676         @args,
 677     );
 678 }
 679
 680 ## -------------------------------------------------
 681
 682 our $error_level;
 683
 684 sub throw_error {
 685     my ( $self, @args ) = @_;
 686     local $error_level = ($error_level || 0) + 1;
 687     $self->raise_error($self->create_error(@args));
 688 }
 689
 690 sub _inline_throw_error {
 691     my ( $self, $msg, $args ) = @_;
 692     "\$meta->throw_error($msg" . ($args ? ", $args" : "") . ")"; # FIXME makes deparsing *REALLY* hard
 693 }
 694
 695 sub raise_error {
 696     my ( $self, @args ) = @_;
 697     die @args;
 698 }
 699
 700 sub create_error {
 701     my ( $self, @args ) = @_;
 702
 703     require Carp::Heavy;
 704
 705     local $error_level = ($error_level || 0 ) + 1;
 706
 707     if ( @args % 2 == 1 ) {
 708         unshift @args, "message";
 709     }
 710
 711     my %args = ( metaclass => $self, last_error => $@, @args );
 712
 713     $args{depth} += $error_level;
 714
 715     my $class = ref $self ? $self->error_class : "Moose::Error::Default";
 716
 717     Class::MOP::load_class($class);
 718
 719     $class->new(
 720         Carp::caller_info($args{depth}),
 721         %args
 722     );
 723 }
 724
 725 1;
 726
 727 # ABSTRACT: The Moose metaclass
 728
 729 __END__
 730
 731 =pod
 732
 733 =head1 DESCRIPTION
 734
 735 This class is a subclass of L<Class::MOP::Class> that provides
 736 additional Moose-specific functionality.
 737
 738 To really understand this class, you will need to start with the
 739 L<Class::MOP::Class> documentation. This class can be understood as a
 740 set of additional features on top of the basic feature provided by
 741 that parent class.
 742
 743 =head1 INHERITANCE
 744
 745 C<Moose::Meta::Class> is a subclass of L<Class::MOP::Class>.
 746
 747 =head1 METHODS
 748
 749 =over 4
 750
 751 =item B<< Moose::Meta::Class->initialize($package_name, %options) >>
 752
 753 This overrides the parent's method in order to provide its own
 754 defaults for the C<attribute_metaclass>, C<instance_metaclass>, and
 755 C<method_metaclass> options.
 756
 757 These all default to the appropriate Moose class.
 758
 759 =item B<< Moose::Meta::Class->create($package_name, %options) >>
 760
 761 This overrides the parent's method in order to accept a C<roles>
 762 option. This should be an array reference containing roles
 763 that the class does, each optionally followed by a hashref of options
 764 (C<-excludes> and C<-alias>).
 765
 766   my $metaclass = Moose::Meta::Class->create( 'New::Class', roles => [...] );
 767
 768 =item B<< Moose::Meta::Class->create_anon_class >>
 769
 770 This overrides the parent's method to accept a C<roles> option, just
 771 as C<create> does.
 772
 773 It also accepts a C<cache> option. If this is true, then the anonymous
 774 class will be cached based on its superclasses and roles. If an
 775 existing anonymous class in the cache has the same superclasses and
 776 roles, it will be reused.
 777
 778   my $metaclass = Moose::Meta::Class->create_anon_class(
 779       superclasses => ['Foo'],
 780       roles        => [qw/Some Roles Go Here/],
 781       cache        => 1,
 782   );
 783
 784 Each entry in both the C<superclasses> and the C<roles> option can be
 785 followed by a hash reference with arguments. The C<superclasses>
 786 option can be supplied with a L<-version|Class::MOP/Class Loading
 787 Options> option that ensures the loaded superclass satisfies the
 788 required version. The C<role> option also takes the C<-version> as an
 789 argument, but the option hash reference can also contain any other
 790 role relevant values like exclusions or parameterized role arguments.
 791
 792 =item B<< $metaclass->make_immutable(%options) >>
 793
 794 This overrides the parent's method to add a few options. Specifically,
 795 it uses the Moose-specific constructor and destructor classes, and
 796 enables inlining the destructor.
 797
 798 Since Moose always inlines attributes, it sets the C<inline_accessors> option
 799 to false.
 800
 801 =item B<< $metaclass->new_object(%params) >>
 802
 803 This overrides the parent's method in order to add support for
 804 attribute triggers.
 805
 806 =item B<< $metaclass->superclasses(@superclasses) >>
 807
 808 This is the accessor allowing you to read or change the parents of
 809 the class.
 810
 811 Each superclass can be followed by a hash reference containing a
 812 L<-version|Class::MOP/Class Loading Options> value. If the version
 813 requirement is not satisfied an error will be thrown.
 814
 815 =item B<< $metaclass->add_override_method_modifier($name, $sub) >>
 816
 817 This adds an C<override> method modifier to the package.
 818
 819 =item B<< $metaclass->add_augment_method_modifier($name, $sub) >>
 820
 821 This adds an C<augment> method modifier to the package.
 822
 823 =item B<< $metaclass->calculate_all_roles >>
 824
 825 This will return a unique array of C<Moose::Meta::Role> instances
 826 which are attached to this class.
 827
 828 =item B<< $metaclass->calculate_all_roles_with_inheritance >>
 829
 830 This will return a unique array of C<Moose::Meta::Role> instances
 831 which are attached to this class, and each of this class's ancestors.
 832
 833 =item B<< $metaclass->add_role($role) >>
 834
 835 This takes a L<Moose::Meta::Role> object, and adds it to the class's
 836 list of roles. This I<does not> actually apply the role to the class.
 837
 838 =item B<< $metaclass->role_applications >>
 839
 840 Returns a list of L<Moose::Meta::Role::Application::ToClass>
 841 objects, which contain the arguments to role application.
 842
 843 =item B<< $metaclass->add_role_application($application) >>
 844
 845 This takes a L<Moose::Meta::Role::Application::ToClass> object, and
 846 adds it to the class's list of role applications. This I<does not>
 847 actually apply any role to the class; it is only for tracking role
 848 applications.
 849
 850 =item B<< $metaclass->does_role($role) >>
 851
 852 This returns a boolean indicating whether or not the class does the specified
 853 role. The role provided can be either a role name or a L<Moose::Meta::Role>
 854 object. This tests both the class and its parents.
 855
 856 =item B<< $metaclass->excludes_role($role_name) >>
 857
 858 A class excludes a role if it has already composed a role which
 859 excludes the named role. This tests both the class and its parents.
 860
 861 =item B<< $metaclass->add_attribute($attr_name, %params|$params) >>
 862
 863 This overrides the parent's method in order to allow the parameters to
 864 be provided as a hash reference.
 865
 866 =item B<< $metaclass->constructor_class($class_name) >>
 867
 868 =item B<< $metaclass->destructor_class($class_name) >>
 869
 870 These are the names of classes used when making a class immutable. These
 871 default to L<Moose::Meta::Method::Constructor> and
 872 L<Moose::Meta::Method::Destructor> respectively. These accessors are
 873 read-write, so you can use them to change the class name.
 874
 875 =item B<< $metaclass->error_class($class_name) >>
 876
 877 The name of the class used to throw errors. This defaults to
 878 L<Moose::Error::Default>, which generates an error with a stacktrace
 879 just like C<Carp::confess>.
 880
 881 =item B<< $metaclass->throw_error($message, %extra) >>
 882
 883 Throws the error created by C<create_error> using C<raise_error>
 884
 885 =back
 886
 887 =head1 BUGS
 888
 889 See L<Moose/BUGS> for details on reporting bugs.
 890
 891 =cut
 892