← Index
NYTProf Performance Profile   « block view • line view • sub view »
For bin/pan_genome_post_analysis
  Run on Fri Mar 27 11:43:32 2015
Reported on Fri Mar 27 11:45:24 2015

Filename/Users/ap13/perl5/lib/perl5/Class/Load.pm
StatementsExecuted 25 statements in 2.26ms
Subroutines
Calls P F Exclusive
Time
Inclusive
Time
Subroutine
1111.38ms28.2msClass::Load::::BEGIN@9Class::Load::BEGIN@9
1111.10ms14.6msClass::Load::::BEGIN@8Class::Load::BEGIN@8
1111.09ms2.58msClass::Load::::BEGIN@7Class::Load::BEGIN@7
11128µs57µsClass::Load::::BEGIN@5Class::Load::BEGIN@5
11122µs87µsClass::Load::::BEGIN@10Class::Load::BEGIN@10
11114µs25µsClass::Load::::BEGIN@6Class::Load::BEGIN@6
11114µs60µsClass::Load::::BEGIN@16Class::Load::BEGIN@16
0000s0sClass::Load::::__ANON__[:152]Class::Load::__ANON__[:152]
0000s0sClass::Load::::__ANON__[:155]Class::Load::__ANON__[:155]
0000s0sClass::Load::::__ANON__[:180]Class::Load::__ANON__[:180]
0000s0sClass::Load::::__ANON__[:183]Class::Load::__ANON__[:183]
0000s0sClass::Load::::_croakClass::Load::_croak
0000s0sClass::Load::::_errorClass::Load::_error
0000s0sClass::Load::::_nonexistent_fail_reClass::Load::_nonexistent_fail_re
0000s0sClass::Load::::_or_listClass::Load::_or_list
0000s0sClass::Load::::_version_fail_reClass::Load::_version_fail_re
0000s0sClass::Load::::load_classClass::Load::load_class
0000s0sClass::Load::::load_first_existing_classClass::Load::load_first_existing_class
0000s0sClass::Load::::load_optional_classClass::Load::load_optional_class
0000s0sClass::Load::::try_load_classClass::Load::try_load_class
Call graph for these subroutines as a Graphviz dot language file.
Line State
ments
Time
on line
Calls Time
in subs
Code
1package Class::Load;
2{
322µs $Class::Load::VERSION = '0.20';
4}
5243µs286µs
# spent 57µs (28+29) within Class::Load::BEGIN@5 which was called: # once (28µs+29µs) by Moose::BEGIN@12 at line 5
use strict;
# spent 57µs making 1 call to Class::Load::BEGIN@5 # spent 29µs making 1 call to strict::import
6244µs236µs
# spent 25µs (14+11) within Class::Load::BEGIN@6 which was called: # once (14µs+11µs) by Moose::BEGIN@12 at line 6
use warnings;
# spent 25µs making 1 call to Class::Load::BEGIN@6 # spent 11µs making 1 call to warnings::import
72214µs22.67ms
# spent 2.58ms (1.09+1.49) within Class::Load::BEGIN@7 which was called: # once (1.09ms+1.49ms) by Moose::BEGIN@12 at line 7
use base 'Exporter';
# spent 2.58ms making 1 call to Class::Load::BEGIN@7 # spent 92µs making 1 call to base::import
82151µs214.8ms
# spent 14.6ms (1.10+13.5) within Class::Load::BEGIN@8 which was called: # once (1.10ms+13.5ms) by Moose::BEGIN@12 at line 8
use Data::OptList 'mkopt';
# spent 14.6ms making 1 call to Class::Load::BEGIN@8 # spent 153µs making 1 call to Sub::Install::__ANON__[Sub/Install.pm:284]
93276µs228.2ms
# spent 28.2ms (1.38+26.8) within Class::Load::BEGIN@9 which was called: # once (1.38ms+26.8ms) by Moose::BEGIN@12 at line 9
use Module::Implementation 0.04;
# spent 28.2ms making 1 call to Class::Load::BEGIN@9 # spent 21µs making 1 call to UNIVERSAL::VERSION
10334µs
# spent 87µs (22+65) within Class::Load::BEGIN@10 which was called: # once (22µs+65µs) by Moose::BEGIN@12 at line 15
use Module::Runtime 0.012 qw(
11 check_module_name
12 module_notional_filename
13 require_module
14 use_module
15132µs3153µs);
# spent 87µs making 1 call to Class::Load::BEGIN@10 # spent 51µs making 1 call to Module::Runtime::import # spent 14µs making 1 call to UNIVERSAL::VERSION
1621.42ms2107µs
# spent 60µs (14+47) within Class::Load::BEGIN@16 which was called: # once (14µs+47µs) by Moose::BEGIN@12 at line 16
use Try::Tiny;
# spent 60µs making 1 call to Class::Load::BEGIN@16 # spent 47µs making 1 call to Exporter::import
17
18{
1927µs144µs my $loader = Module::Implementation::build_loader_sub(
# spent 44µs making 1 call to Module::Implementation::build_loader_sub
20 implementations => [ 'XS', 'PP' ],
21 symbols => ['is_class_loaded'],
22 );
23
2417µs11.11ms $loader->();
25}
26
2712µsour @EXPORT_OK = qw/load_class load_optional_class try_load_class is_class_loaded load_first_existing_class/;
2812µsour %EXPORT_TAGS = (
29 all => \@EXPORT_OK,
30);
31
321100nsour $ERROR;
33
34sub load_class {
35 my $class = shift;
36 my $options = shift;
37
38 my ($res, $e) = try_load_class($class, $options);
39 return $class if $res;
40
41 _croak($e);
42}
43
44sub load_first_existing_class {
45 my $classes = Data::OptList::mkopt(\@_)
46 or return;
47
48 foreach my $class (@{$classes}) {
49 check_module_name($class->[0]);
50 }
51
52 for my $class (@{$classes}) {
53 my ($name, $options) = @{$class};
54
55 # We need to be careful not to pass an undef $options to this sub,
56 # since the XS version will blow up if that happens.
57 return $name if is_class_loaded($name, ($options ? $options : ()));
58
59 my ($res, $e) = try_load_class($name, $options);
60
61 return $name if $res;
62
63 my $file = module_notional_filename($name);
64
65 next if $e =~ /^Can't locate \Q$file\E in \@INC/;
66 next
67 if $options
68 && defined $options->{-version}
69 && $e =~ _version_fail_re($name, $options->{-version});
70
71 _croak("Couldn't load class ($name) because: $e");
72 }
73
74 my @list = map {
75 $_->[0]
76 . ( $_->[1] && defined $_->[1]{-version}
77 ? " (version >= $_->[1]{-version})"
78 : q{} )
79 } @{$classes};
80
81 my $err
82 .= q{Can't locate }
83 . _or_list(@list)
84 . " in \@INC (\@INC contains: @INC).";
85 _croak($err);
86}
87
88sub _version_fail_re {
89 my $name = shift;
90 my $vers = shift;
91
92 return qr/\Q$name\E version \Q$vers\E required--this is only version/;
93}
94
95sub _nonexistent_fail_re {
96 my $name = shift;
97
98 my $file = module_notional_filename($name);
99 return qr/Can't locate \Q$file\E in \@INC/;
100}
101
102sub _or_list {
103 return $_[0] if @_ == 1;
104
105 return join ' or ', @_ if @_ ==2;
106
107 my $last = pop;
108
109 my $list = join ', ', @_;
110 $list .= ', or ' . $last;
111
112 return $list;
113}
114
115sub load_optional_class {
116 my $class = shift;
117 my $options = shift;
118
119 check_module_name($class);
120
121 my ($res, $e) = try_load_class($class, $options);
122 return 1 if $res;
123
124 return 0
125 if $options
126 && defined $options->{-version}
127 && $e =~ _version_fail_re($class, $options->{-version});
128
129 return 0
130 if $e =~ _nonexistent_fail_re($class);
131
132 _croak($e);
133}
134
135sub try_load_class {
136 my $class = shift;
137 my $options = shift;
138
139 check_module_name($class);
140
141 local $@;
142 undef $ERROR;
143
144 if (is_class_loaded($class)) {
145 # We need to check this here rather than in is_class_loaded() because
146 # we want to return the error message for a failed version check, but
147 # is_class_loaded just returns true/false.
148 return 1 unless $options && defined $options->{-version};
149 return try {
150 $class->VERSION($options->{-version});
151 1;
152 }
153 catch {
154 _error($_);
155 };
156 }
157
158 my $file = module_notional_filename($class);
159 # This says "our diagnostics of the package
160 # say perl's INC status about the file being loaded are
161 # wrong", so we delete it from %INC, so when we call require(),
162 # perl will *actually* try reloading the file.
163 #
164 # If the file is already in %INC, it won't retry,
165 # And on 5.8, it won't fail either!
166 #
167 # The extra benefit of this trick, is it helps even on
168 # 5.10, as instead of dying with "Compilation failed",
169 # it will die with the actual error, and thats a win-win.
170 delete $INC{$file};
171 return try {
172 local $SIG{__DIE__} = 'DEFAULT';
173 if ($options && defined $options->{-version}) {
174 use_module($class, $options->{-version});
175 }
176 else {
177 require_module($class);
178 }
179 1;
180 }
181 catch {
182 _error($_);
183 };
184}
185
186sub _error {
187 my $e = shift;
188
189 $e =~ s/ at .+?Runtime\.pm line [0-9]+\.$//;
190 chomp $e;
191
192 $ERROR = $e;
193 return 0 unless wantarray;
194 return 0, $ERROR;
195}
196
197sub _croak {
198 require Carp;
199 local $Carp::CarpLevel = $Carp::CarpLevel + 2;
200 Carp::croak(shift);
201}
202
203118µs1;
204
205# ABSTRACT: a working (require "Class::Name") and more
206
- -
209=pod
210
211=head1 NAME
212
213Class::Load - a working (require "Class::Name") and more
214
215=head1 VERSION
216
217version 0.20
218
219=head1 SYNOPSIS
220
221 use Class::Load ':all';
222
223 try_load_class('Class::Name')
224 or plan skip_all => "Class::Name required to run these tests";
225
226 load_class('Class::Name');
227
228 is_class_loaded('Class::Name');
229
230 my $baseclass = load_optional_class('Class::Name::MightExist')
231 ? 'Class::Name::MightExist'
232 : 'Class::Name::Default';
233
234=head1 DESCRIPTION
235
236C<require EXPR> only accepts C<Class/Name.pm> style module names, not
237C<Class::Name>. How frustrating! For that, we provide
238C<load_class 'Class::Name'>.
239
240It's often useful to test whether a module can be loaded, instead of throwing
241an error when it's not available. For that, we provide
242C<try_load_class 'Class::Name'>.
243
244Finally, sometimes we need to know whether a particular class has been loaded.
245Asking C<%INC> is an option, but that will miss inner packages and any class
246for which the filename does not correspond to the package name. For that, we
247provide C<is_class_loaded 'Class::Name'>.
248
249=head1 FUNCTIONS
250
251=head2 load_class Class::Name, \%options
252
253C<load_class> will load C<Class::Name> or throw an error, much like C<require>.
254
255If C<Class::Name> is already loaded (checked with C<is_class_loaded>) then it
256will not try to load the class. This is useful when you have inner packages
257which C<require> does not check.
258
259The C<%options> hash currently accepts one key, C<-version>. If you specify a
260version, then this subroutine will call C<< Class::Name->VERSION(
261$options{-version} ) >> internally, which will throw an error if the class's
262version is not equal to or greater than the version you requested.
263
264This method will return the name of the class on success.
265
266=head2 try_load_class Class::Name, \%options -> (0|1, error message)
267
268Returns 1 if the class was loaded, 0 if it was not. If the class was not
269loaded, the error will be returned as a second return value in list context.
270
271Again, if C<Class::Name> is already loaded (checked with C<is_class_loaded>)
272then it will not try to load the class. This is useful when you have inner
273packages which C<require> does not check.
274
275Like C<load_class>, you can pass a C<-version> in C<%options>. If the version
276is not sufficient, then this subroutine will return false.
277
278=head2 is_class_loaded Class::Name, \%options -> 0|1
279
280This uses a number of heuristics to determine if the class C<Class::Name> is
281loaded. There heuristics were taken from L<Class::MOP>'s old pure-perl
282implementation.
283
284Like C<load_class>, you can pass a C<-version> in C<%options>. If the version
285is not sufficient, then this subroutine will return false.
286
287=head2 load_first_existing_class Class::Name, \%options, ...
288
289This attempts to load the first loadable class in the list of classes
290given. Each class name can be followed by an options hash reference.
291
292If any one of the classes loads and passes the optional version check, that
293class name will be returned. If I<none> of the classes can be loaded (or none
294pass their version check), then an error will be thrown.
295
296If, when attempting to load a class, it fails to load because of a syntax
297error, then an error will be thrown immediately.
298
299=head2 load_optional_class Class::Name, \%options -> 0|1
300
301C<load_optional_class> is a lot like C<try_load_class>, but also a lot like
302C<load_class>.
303
304If the class exists, and it works, then it will return 1. If you specify a
305version in C<%options>, then the version check must succeed or it will return
3060.
307
308If the class doesn't exist, and it appears to not exist on disk either, it
309will return 0.
310
311If the class exists on disk, but loading from disk results in an error
312( i.e.: a syntax error ), then it will C<croak> with that error.
313
314This is useful for using if you want a fallback module system, i.e.:
315
316 my $class = load_optional_class($foo) ? $foo : $default;
317
318That way, if $foo does exist, but can't be loaded due to error, you won't
319get the behaviour of it simply not existing.
320
321=head1 SEE ALSO
322
323=over 4
324
325=item L<http://blog.fox.geek.nz/2010/11/searching-design-spec-for-ultimate.html>
326
327This blog post is a good overview of the current state of the existing modules
328for loading other modules in various ways.
329
330=item L<http://blog.fox.geek.nz/2010/11/handling-optional-requirements-with.html>
331
332This blog post describes how to handle optional modules with L<Class::Load>.
333
334=item L<http://d.hatena.ne.jp/tokuhirom/20110202/1296598578>
335
336This Japanese blog post describes why L<DBIx::Skinny> now uses L<Class::Load>
337over its competitors.
338
339=item L<Moose>, L<Jifty>, L<Prophet>, etc
340
341This module was designed to be used anywhere you have
342C<if (eval "require $module"; 1)>, which occurs in many large projects.
343
344=back
345
346=head1 AUTHOR
347
348Shawn M Moore <sartak at bestpractical.com>
349
350=head1 COPYRIGHT AND LICENSE
351
352This software is copyright (c) 2012 by Shawn M Moore.
353
354This is free software; you can redistribute it and/or modify it under
355the same terms as the Perl 5 programming language system itself.
356
357=cut
358
359
360__END__