7 use Devel::GlobalDestruction qw(in_global_destruction);
11 use if ( not our $__mx_is_compiled ), 'Moose::Meta::Class';
12 use if ( not our $__mx_is_compiled ), metaclass => 'Moose::Meta::Class';
14 our $VERSION = '0.85';
15 $VERSION = eval $VERSION;
16 our $AUTHORITY = 'cpan:STEVAN';
21 my $params = $class->BUILDARGS(@_);
23 # We want to support passing $self->new, but initialize
24 # takes only an unblessed class name
25 my $real_class = Scalar::Util::blessed($class) || $class;
26 my $self = Class::MOP::Class->initialize($real_class)->new_object($params);
28 $self->BUILDALL($params);
35 if ( scalar @_ == 1 ) {
36 unless ( defined $_[0] && ref $_[0] eq 'HASH' ) {
37 Class::MOP::class_of($class)->throw_error(
38 "Single parameters to new() must be a HASH ref",
41 return { %{ $_[0] } };
49 # NOTE: we ask Perl if we even
50 # need to do this first, to avoid
51 # extra meta level calls
52 return unless $_[0]->can('BUILD');
53 my ($self, $params) = @_;
54 foreach my $method (reverse Class::MOP::class_of($self)->find_all_methods_by_name('BUILD')) {
55 $method->{code}->execute($self, $params);
61 my ($in_global_destruction) = @_;
63 # NOTE: we ask Perl if we even
64 # need to do this first, to avoid
65 # extra meta level calls
66 return unless $self->can('DEMOLISH');
69 if ( my $meta = Class::MOP::class_of($self ) ) {
70 @isa = $meta->linearized_isa;
72 # We cannot count on being able to retrieve a previously made
73 # metaclass, _or_ being able to make a new one during global
74 # destruction. However, we should still be able to use mro at
75 # that time (at least tests suggest so ;)
76 my $class_name = ref $self;
77 @isa = @{ mro::get_linear_isa($class_name) }
80 foreach my $class (@isa) {
82 my $demolish = *{"${class}::DEMOLISH"}{CODE};
83 $self->$demolish($in_global_destruction)
89 # if we have an exception here ...
93 # run DEMOLISHALL ourselves, ...
94 $_[0]->DEMOLISHALL(in_global_destruction);
98 # otherwise it is normal destruction
99 $_[0]->DEMOLISHALL(in_global_destruction);
102 # support for UNIVERSAL::DOES ...
104 my $does = UNIVERSAL->can("DOES") ? "SUPER::DOES" : "isa";
106 my ( $self, $class_or_role_name ) = @_;
107 return $self->'.$does.'($class_or_role_name)
108 || $self->does($class_or_role_name);
112 # new does() methods will be created
113 # as appropiate see Moose::Meta::Role
115 my ($self, $role_name) = @_;
116 my $meta = Class::MOP::class_of($self);
118 || $meta->throw_error("You much supply a role name to does()");
119 foreach my $class ($meta->class_precedence_list) {
120 my $m = $meta->initialize($class);
122 if $m->can('does_role') && $m->does_role($role_name);
129 require Data::Dumper;
130 local $Data::Dumper::Maxdepth = shift if @_;
131 Data::Dumper::Dumper $self;
142 Moose::Object - The base object for Moose
146 This class is the default base class for all Moose-using classes. When
147 you C<use Moose> in this class, your class will inherit from this
150 It provides a default constructor and destructor, which run the
151 C<BUILDALL> and C<DEMOLISHALL> methods respectively.
153 You don't actually I<need> to inherit from this in order to use Moose,
154 but it makes it easier to take advantage of all of Moose's features.
160 =item B<< Moose::Object->new(%params) >>
162 This method calls C<< $class->BUILDARGS(@_) >>, and then creates a new
163 instance of the appropriate class. Once the instance is created, it
164 calls C<< $instance->BUILDALL($params) >>.
166 =item B<< Moose::Object->BUILDARGS(%params) >>
168 The default implementation of this method accepts a hash or hash
169 reference of named parameters. If it receives a single argument that
170 I<isn't> a hash reference it throws an error.
172 You can override this method in your class to handle other types of
173 options passed to the constructor.
175 This method should always return a hash reference of named options.
177 =item B<< $object->BUILDALL($params) >>
179 This method will call every C<BUILD> method in the inheritance
180 hierarchy, starting with the most distant parent class and ending with
183 The C<BUILD> method will be passed the hash reference returned by
186 =item B<< $object->DEMOLISHALL >>
188 This will call every C<DEMOLISH> method in the inheritance hierarchy,
189 starting with the object's class and ending with the most distant
190 parent. C<DEMOLISHALL> and C<DEMOLISH> will receive a boolean
191 indicating whether or not we are currently in global destruction.
193 =item B<< $object->does($role_name) >>
195 This returns true if the object does the given role.
197 =item B<DOES ($class_or_role_name)>
199 This is a a Moose role-aware implementation of L<UNIVERSAL/DOES>.
201 This is effectively the same as writing:
203 $object->does($name) || $object->isa($name)
205 This method will work with Perl 5.8, which did not implement
208 =item B<< $object->dump($maxdepth) >>
210 This is a handy utility for C<Data::Dumper>ing an object. By default,
211 the maximum depth is 1, to avoid making a mess.
217 All complex software has bugs lurking in it, and this module is no
218 exception. If you find a bug please either email me, or add the bug
223 Stevan Little E<lt>stevan@iinteractive.comE<gt>
225 =head1 COPYRIGHT AND LICENSE
227 Copyright 2006-2009 by Infinity Interactive, Inc.
229 L<http://www.iinteractive.com>
231 This library is free software; you can redistribute it and/or modify
232 it under the same terms as Perl itself.