7 use Devel::GlobalDestruction qw(in_global_destruction);
12 use if ( not our $__mx_is_compiled ), 'Moose::Meta::Class';
13 use if ( not our $__mx_is_compiled ), metaclass => 'Moose::Meta::Class';
15 our $VERSION = '0.89_02';
16 $VERSION = eval $VERSION;
17 our $AUTHORITY = 'cpan:STEVAN';
22 Carp::cluck 'Calling new() on an instance is deprecated,'
23 . ' please use (blessed $obj)->new' if blessed $class;
25 my $params = $class->BUILDARGS(@_);
27 my $real_class = Scalar::Util::blessed($class) || $class;
28 my $self = Class::MOP::Class->initialize($real_class)->new_object($params);
30 $self->BUILDALL($params);
37 if ( scalar @_ == 1 ) {
38 unless ( defined $_[0] && ref $_[0] eq 'HASH' ) {
39 Class::MOP::class_of($class)->throw_error(
40 "Single parameters to new() must be a HASH ref",
43 return { %{ $_[0] } };
51 # NOTE: we ask Perl if we even
52 # need to do this first, to avoid
53 # extra meta level calls
54 return unless $_[0]->can('BUILD');
55 my ($self, $params) = @_;
56 foreach my $method (reverse Class::MOP::class_of($self)->find_all_methods_by_name('BUILD')) {
57 $method->{code}->execute($self, $params);
63 my ($in_global_destruction) = @_;
65 # NOTE: we ask Perl if we even
66 # need to do this first, to avoid
67 # extra meta level calls
68 return unless $self->can('DEMOLISH');
71 if ( my $meta = Class::MOP::class_of($self ) ) {
72 @isa = $meta->linearized_isa;
74 # We cannot count on being able to retrieve a previously made
75 # metaclass, _or_ being able to make a new one during global
76 # destruction. However, we should still be able to use mro at
77 # that time (at least tests suggest so ;)
78 my $class_name = ref $self;
79 @isa = @{ mro::get_linear_isa($class_name) }
82 foreach my $class (@isa) {
84 my $demolish = *{"${class}::DEMOLISH"}{CODE};
85 $self->$demolish($in_global_destruction)
96 $self->DEMOLISHALL(in_global_destruction);
99 # Without this, Perl will warn "\t(in cleanup)$@" because of some
100 # bizarre fucked-up logic deep in the internals.
108 # support for UNIVERSAL::DOES ...
110 my $does = UNIVERSAL->can("DOES") ? "SUPER::DOES" : "isa";
112 my ( $self, $class_or_role_name ) = @_;
113 return $self->'.$does.'($class_or_role_name)
114 || $self->does($class_or_role_name);
118 # new does() methods will be created
119 # as appropiate see Moose::Meta::Role
121 my ($self, $role_name) = @_;
122 my $meta = Class::MOP::class_of($self);
124 || $meta->throw_error("You much supply a role name to does()");
125 foreach my $class ($meta->class_precedence_list) {
126 my $m = $meta->initialize($class);
128 if $m->can('does_role') && $m->does_role($role_name);
135 require Data::Dumper;
136 local $Data::Dumper::Maxdepth = shift if @_;
137 Data::Dumper::Dumper $self;
148 Moose::Object - The base object for Moose
152 This class is the default base class for all Moose-using classes. When
153 you C<use Moose> in this class, your class will inherit from this
156 It provides a default constructor and destructor, which run the
157 C<BUILDALL> and C<DEMOLISHALL> methods respectively.
159 You don't actually I<need> to inherit from this in order to use Moose,
160 but it makes it easier to take advantage of all of Moose's features.
166 =item B<< Moose::Object->new(%params) >>
168 This method calls C<< $class->BUILDARGS(@_) >>, and then creates a new
169 instance of the appropriate class. Once the instance is created, it
170 calls C<< $instance->BUILDALL($params) >>.
172 =item B<< Moose::Object->BUILDARGS(%params) >>
174 The default implementation of this method accepts a hash or hash
175 reference of named parameters. If it receives a single argument that
176 I<isn't> a hash reference it throws an error.
178 You can override this method in your class to handle other types of
179 options passed to the constructor.
181 This method should always return a hash reference of named options.
183 =item B<< $object->BUILDALL($params) >>
185 This method will call every C<BUILD> method in the inheritance
186 hierarchy, starting with the most distant parent class and ending with
189 The C<BUILD> method will be passed the hash reference returned by
192 =item B<< $object->DEMOLISHALL >>
194 This will call every C<DEMOLISH> method in the inheritance hierarchy,
195 starting with the object's class and ending with the most distant
196 parent. C<DEMOLISHALL> and C<DEMOLISH> will receive a boolean
197 indicating whether or not we are currently in global destruction.
199 =item B<< $object->does($role_name) >>
201 This returns true if the object does the given role.
203 =item B<DOES ($class_or_role_name)>
205 This is a a Moose role-aware implementation of L<UNIVERSAL/DOES>.
207 This is effectively the same as writing:
209 $object->does($name) || $object->isa($name)
211 This method will work with Perl 5.8, which did not implement
214 =item B<< $object->dump($maxdepth) >>
216 This is a handy utility for C<Data::Dumper>ing an object. By default,
217 the maximum depth is 1, to avoid making a mess.
223 All complex software has bugs lurking in it, and this module is no
224 exception. If you find a bug please either email me, or add the bug
229 Stevan Little E<lt>stevan@iinteractive.comE<gt>
231 =head1 COPYRIGHT AND LICENSE
233 Copyright 2006-2009 by Infinity Interactive, Inc.
235 L<http://www.iinteractive.com>
237 This library is free software; you can redistribute it and/or modify
238 it under the same terms as Perl itself.