8 use Devel::GlobalDestruction qw(in_global_destruction);
10 use if ( not our $__mx_is_compiled ), 'Moose::Meta::Class';
11 use if ( not our $__mx_is_compiled ), metaclass => 'Moose::Meta::Class';
13 our $VERSION = '0.77';
14 $VERSION = eval $VERSION;
15 our $AUTHORITY = 'cpan:STEVAN';
20 my $params = $class->BUILDARGS(@_);
22 # We want to support passing $self->new, but initialize
23 # takes only an unblessed class name
24 my $real_class = Scalar::Util::blessed($class) || $class;
25 my $self = Class::MOP::Class->initialize($real_class)->new_object($params);
27 $self->BUILDALL($params);
34 if ( scalar @_ == 1 ) {
35 unless ( defined $_[0] && ref $_[0] eq 'HASH' ) {
36 Class::MOP::class_of($class)->throw_error(
37 "Single parameters to new() must be a HASH ref",
40 return { %{ $_[0] } };
48 # NOTE: we ask Perl if we even
49 # need to do this first, to avoid
50 # extra meta level calls
51 return unless $_[0]->can('BUILD');
52 my ($self, $params) = @_;
53 foreach my $method (reverse Class::MOP::class_of($self)->find_all_methods_by_name('BUILD')) {
54 $method->{code}->execute($self, $params);
60 my ($in_global_destruction) = @_;
62 # NOTE: we ask Perl if we even
63 # need to do this first, to avoid
64 # extra meta level calls
65 return unless $self->can('DEMOLISH');
67 # This is a hack, because Moose::Meta::Class may not be the right
68 # metaclass, but class_of may return undef during global
69 # destruction, if the metaclass object has already been cleaned
71 my $meta = Class::MOP::class_of($self)
72 || Moose::Meta::Class->initialize( ref $self );
74 # can't just use find_all_methods_by_name here because during global
75 # destruction, the method meta-object may have already been
77 foreach my $class ( $meta->linearized_isa ) {
79 my $demolish = *{"${class}::DEMOLISH"}{CODE};
80 $self->$demolish($in_global_destruction)
86 # if we have an exception here ...
90 # run DEMOLISHALL ourselves, ...
91 $_[0]->DEMOLISHALL(in_global_destruction);
95 # otherwise it is normal destruction
96 $_[0]->DEMOLISHALL(in_global_destruction);
99 # support for UNIVERSAL::DOES ...
101 my $does = UNIVERSAL->can("DOES") ? "SUPER::DOES" : "isa";
103 my ( $self, $class_or_role_name ) = @_;
104 return $self->'.$does.'($class_or_role_name)
105 || $self->does($class_or_role_name);
109 # new does() methods will be created
110 # as appropiate see Moose::Meta::Role
112 my ($self, $role_name) = @_;
113 my $meta = Class::MOP::class_of($self);
115 || $meta->throw_error("You much supply a role name to does()");
116 foreach my $class ($meta->class_precedence_list) {
117 my $m = $meta->initialize($class);
119 if $m->can('does_role') && $m->does_role($role_name);
126 require Data::Dumper;
127 local $Data::Dumper::Maxdepth = shift if @_;
128 Data::Dumper::Dumper $self;
139 Moose::Object - The base object for Moose
143 This class is the default base class for all Moose-using classes. When
144 you C<use Moose> in this class, your class will inherit from this
147 It provides a default constructor and destructor, which run the
148 C<BUILDALL> and C<DEMOLISHALL> methods respectively.
150 You don't actually I<need> to inherit from this in order to use Moose,
151 but it makes it easier to take advantage of all of Moose's features.
157 =item B<< Moose::Object->new(%params) >>
159 This method calls C<< $class->BUILDARGS(@_) >>, and then creates a new
160 instance of the appropriate class. Once the instance is created, it
161 calls C<< $instance->BUILDALL($params) >>.
163 =item B<< Moose::Object->BUILDARGS(%params) >>
165 The default implementation of this method accepts a hash or hash
166 reference of named parameters. If it receives a single argument that
167 I<isn't> a hash reference it throws an error.
169 You can override this method in your class to handle other types of
170 options passed to the constructor.
172 This method should always return a hash reference of named options.
174 =item B<< $object->BUILDALL($params) >>
176 This method will call every C<BUILD> method in the inheritance
177 hierarchy, starting with the most distant parent class and ending with
180 The C<BUILD> method will be passed the hash reference returned by
183 =item B<< $object->DEMOLISHALL >>
185 This will call every C<DEMOLISH> method in the inheritance hierarchy,
186 starting with the object's class and ending with the most distant
187 parent. C<DEMOLISHALL> and C<DEMOLISH> will receive a boolean
188 indicating whether or not we are currently in global destruction.
190 =item B<< $object->does($role_name) >>
192 This returns true if the object does the given role.
194 =item B<DOES ($class_or_role_name)>
196 This is a a Moose role-aware implementation of L<UNIVERSAL/DOES>.
198 This is effectively the same as writing:
200 $object->does($name) || $object->isa($name)
202 This method will work with Perl 5.8, which did not implement
205 =item B<< $object->dump($maxdepth) >>
207 This is a handy utility for C<Data::Dumper>ing an object. By default,
208 the maximum depth is 1, to avoid making a mess.
214 All complex software has bugs lurking in it, and this module is no
215 exception. If you find a bug please either email me, or add the bug
220 Stevan Little E<lt>stevan@iinteractive.comE<gt>
222 =head1 COPYRIGHT AND LICENSE
224 Copyright 2006-2009 by Infinity Interactive, Inc.
226 L<http://www.iinteractive.com>
228 This library is free software; you can redistribute it and/or modify
229 it under the same terms as Perl itself.