8 use Devel::GlobalDestruction ();
13 use if ( not our $__mx_is_compiled ), 'Moose::Meta::Class';
14 use if ( not our $__mx_is_compiled ), metaclass => 'Moose::Meta::Class';
18 my $real_class = Scalar::Util::blessed($class) || $class;
20 my $params = $real_class->BUILDARGS(@_);
22 return Class::MOP::Class->initialize($real_class)->new_object($params);
27 if ( scalar @_ == 1 ) {
28 unless ( defined $_[0] && ref $_[0] eq 'HASH' ) {
29 Class::MOP::class_of($class)->throw_error(
30 "Single parameters to new() must be a HASH ref",
33 return { %{ $_[0] } };
37 "The new() method for $class expects a hash reference or a key/value list."
38 . " You passed an odd number of arguments" );
47 # NOTE: we ask Perl if we even
48 # need to do this first, to avoid
49 # extra meta level calls
50 return unless $_[0]->can('BUILD');
51 my ($self, $params) = @_;
52 foreach my $method (reverse Class::MOP::class_of($self)->find_all_methods_by_name('BUILD')) {
53 $method->{code}->execute($self, $params);
59 my ($in_global_destruction) = @_;
61 # NOTE: we ask Perl if we even
62 # need to do this first, to avoid
63 # extra meta level calls
64 return unless $self->can('DEMOLISH');
67 if ( my $meta = Class::MOP::class_of($self ) ) {
68 @isa = $meta->linearized_isa;
70 # We cannot count on being able to retrieve a previously made
71 # metaclass, _or_ being able to make a new one during global
72 # destruction. However, we should still be able to use mro at
73 # that time (at least tests suggest so ;)
74 my $class_name = ref $self;
75 @isa = @{ mro::get_linear_isa($class_name) }
78 foreach my $class (@isa) {
80 my $demolish = *{"${class}::DEMOLISH"}{CODE};
81 $self->$demolish($in_global_destruction)
92 $self->DEMOLISHALL(Devel::GlobalDestruction::in_global_destruction);
101 # support for UNIVERSAL::DOES ...
103 my $does = UNIVERSAL->can("DOES") ? "SUPER::DOES" : "isa";
105 my ( $self, $class_or_role_name ) = @_;
106 return $self->'.$does.'($class_or_role_name)
107 || $self->does($class_or_role_name);
111 # new does() methods will be created
112 # as appropiate see Moose::Meta::Role
114 my ($self, $role_name) = @_;
115 my $meta = Class::MOP::class_of($self);
117 || $meta->throw_error("You must supply a role name to does()");
118 return 1 if $meta->can('does_role') && $meta->does_role($role_name);
124 require Data::Dumper;
125 local $Data::Dumper::Maxdepth = shift if @_;
126 Data::Dumper::Dumper $self;
131 # ABSTRACT: The base object for Moose
139 This class is the default base class for all Moose-using classes. When
140 you C<use Moose> in this class, your class will inherit from this
143 It provides a default constructor and destructor, which run all of the
144 C<BUILD> and C<DEMOLISH> methods in the inheritance hierarchy,
147 You don't actually I<need> to inherit from this in order to use Moose,
148 but it makes it easier to take advantage of all of Moose's features.
154 =item B<< Moose::Object->new(%params|$params) >>
156 This method calls C<< $class->BUILDARGS(@_) >>, and then creates a new
157 instance of the appropriate class. Once the instance is created, it
158 calls C<< $instance->BUILD($params) >> for each C<BUILD> method in the
159 inheritance hierarchy.
161 =item B<< Moose::Object->BUILDARGS(%params|$params) >>
163 The default implementation of this method accepts a hash or hash
164 reference of named parameters. If it receives a single argument that
165 I<isn't> a hash reference it throws an error.
167 You can override this method in your class to handle other types of
168 options passed to the constructor.
170 This method should always return a hash reference of named options.
172 =item B<< $object->does($role_name) >>
174 This returns true if the object does the given role.
176 =item B<< $object->DOES($class_or_role_name) >>
178 This is a a Moose role-aware implementation of L<UNIVERSAL/DOES>.
180 This is effectively the same as writing:
182 $object->does($name) || $object->isa($name)
184 This method will work with Perl 5.8, which did not implement
187 =item B<< $object->dump($maxdepth) >>
189 This is a handy utility for C<Data::Dumper>ing an object. By default,
190 the maximum depth is 1, to avoid making a mess.
192 =item B<< $object->DESTROY >>
194 A default destructor is provided, which calls
195 C<< $instance->DEMOLISH($in_global_destruction) >> for each C<DEMOLISH>
196 method in the inheritance hierarchy.
202 See L<Moose/BUGS> for details on reporting bugs.