← Index
NYTProf Performance Profile   « line view »
For svc/members/upsert
  Run on Tue Jan 13 11:50:22 2015
Reported on Tue Jan 13 12:09:49 2015

Filename/usr/share/perl5/Library/CallNumber/LC.pm
StatementsExecuted 1281 statements in 2.57ms
Subroutines
Calls P F Exclusive
Time		 Inclusive
Time		 Subroutine
11113.0ms24.5msLibrary::CallNumber::LC::::BEGIN@5Library::CallNumber::LC::BEGIN@5
11153µs65µsLibrary::CallNumber::LC::::_normalizeLibrary::CallNumber::LC::_normalize
11113µs17µsLibrary::CallNumber::LC::::BEGIN@3Library::CallNumber::LC::BEGIN@3
11113µs21µsLibrary::CallNumber::LC::::BEGIN@247Library::CallNumber::LC::BEGIN@247
11110µs23µsLibrary::CallNumber::LC::::BEGIN@277Library::CallNumber::LC::BEGIN@277
11110µs28µsLibrary::CallNumber::LC::::BEGIN@241Library::CallNumber::LC::BEGIN@241
7218µs8µsLibrary::CallNumber::LC::::CORE:matchLibrary::CallNumber::LC::CORE:match (opcode)
1118µs17µsLibrary::CallNumber::LC::::BEGIN@4Library::CallNumber::LC::BEGIN@4
1116µs72µsLibrary::CallNumber::LC::::normalizeLibrary::CallNumber::LC::normalize
1115µs5µsLibrary::CallNumber::LC::::newLibrary::CallNumber::LC::new
2213µs3µsLibrary::CallNumber::LC::::CORE:qrLibrary::CallNumber::LC::CORE:qr (opcode)
1112µs2µsLibrary::CallNumber::LC::::topperLibrary::CallNumber::LC::topper
1112µs2µsLibrary::CallNumber::LC::::CORE:regcompLibrary::CallNumber::LC::CORE:regcomp (opcode)
551900ns900nsLibrary::CallNumber::LC::::CORE:substLibrary::CallNumber::LC::CORE:subst (opcode)
0000s0sLibrary::CallNumber::LC::::bottomerLibrary::CallNumber::LC::bottomer
0000s0sLibrary::CallNumber::LC::::call_numberLibrary::CallNumber::LC::call_number
0000s0sLibrary::CallNumber::LC::::componentsLibrary::CallNumber::LC::components
0000s0sLibrary::CallNumber::LC::::end_of_rangeLibrary::CallNumber::LC::end_of_range
0000s0sLibrary::CallNumber::LC::::start_of_rangeLibrary::CallNumber::LC::start_of_range
0000s0sLibrary::CallNumber::LC::::toLongIntLibrary::CallNumber::LC::toLongInt
Call graph for these subroutines as a Graphviz dot language file.
Line State
ments		 Time
on line		 Calls Time
in subs		 Code
1package Library::CallNumber::LC;
2
3223µs222µs
# spent 17µs (13+5) within Library::CallNumber::LC::BEGIN@3 which was called: # once (13µs+5µs) by C4::ClassSortRoutine::LCC::BEGIN@23 at line 3
use warnings;
# spent 17µs making 1 call to Library::CallNumber::LC::BEGIN@3 # spent 5µs making 1 call to warnings::import
4219µs227µs
# spent 17µs (8+10) within Library::CallNumber::LC::BEGIN@4 which was called: # once (8µs+10µs) by C4::ClassSortRoutine::LCC::BEGIN@23 at line 4
use strict;
# spent 17µs making 1 call to Library::CallNumber::LC::BEGIN@4 # spent 10µs making 1 call to strict::import
521.17ms235.3ms
# spent 24.5ms (13.0+11.5) within Library::CallNumber::LC::BEGIN@5 which was called: # once (13.0ms+11.5ms) by C4::ClassSortRoutine::LCC::BEGIN@23 at line 5
use Math::BigInt;
# spent 24.5ms making 1 call to Library::CallNumber::LC::BEGIN@5 # spent 10.8ms making 1 call to Math::BigInt::import
6
7=head1 NAME
8
9Library::CallNumber::LC - Deal with Library-of-Congress call numbers
10
11=head1 VERSION
12
13Version 0.22;
14
15=cut
16
171400nsour $VERSION = '0.22';
18
19
20=head1 SYNOPSIS
21
22Utility functions to deal with Library of Congress Call Numbers
23
24 use Library::CallNumber::LC;
25 my $a = Library::CallNumber::LC->new('A 123.4 .c11');
26 print $a->normalize; # normalizes for string comparisons.
27 # gives 'A01234 C11'
28 print $a->start_of_range; # same as "normalize"
29 my $b = Library::CallNumber::LC->new('B11 .c13 .d11');
30 print $b->normalize;
31 # gives 'B0011 C13 D11'
32 my @range = ($a->start_of_range, $b->end_of_range);
33 # end of range is 'B0011 C13 D11~'
34
35 # Get components suitable for printing (e.g., number and decimal joined, leading dot on first cutter)
36 @comps = Library::CallNumber::LC->new('A 123.4 .c11')->components()
37
38 # Same thing, but return empty strings for missing components (e.g., the cutters)
39 @comps = Library::CallNumber::LC->new('A 123.4 .c11')->components('true');
40
41=head1 ABSTRACT
42
43Library::CallNumber::LC is mostly designed to do call number normalization, with the following goals:
44
45=over 4
46
47=item * The normalized call numbers are comparable with each other, for proper sorting
48
49=item * The normalized call number is a short as possible, so left-anchored wildcard searches are possible (e.g., searching on "A11*" should give you all the A11 call numbers)
50
51=item * A range defined by start_of_range and end_of_range should be correct, assuming that the string given for the end of the range is, in fact, a left prefix.
52
53=back
54
55That last point needs some explanation. The idea is that if someone gives a range of, say, A-AZ, what they really mean is A - AZ9999.99. The end_of_range method generates a key which lies immediately beyond the last possible key for a given starting point. There is no attempt to make end_of_range normalization correspond to anything in real life.
56
57=cut
58
59# Set up the prefix mapping for longints
601200nsmy %intmap;
611300nsmy $i = 0;
6218µsforeach my $prefix (qw(a aa ab abc ac ae ag ah ai al am an anl ao ap aq arx as at aug aw awo ay az b bc bd bf bg bh bj bl bm bn bp bq br bs bt bu bv bx c cb cc cd ce cg cis cj cmh cmm cn cr cs ct cz d da daa daw db dc dd de df dff dg dh dj djk dk dkj dl doc dp dq dr ds dt dth du dx e ea eb ec ed ee ek ep epa ex f fb fc fem fg fj fnd fp fsd ft ful g ga gb gc gda ge gf gh gn gr gs gt gv h ha hb hc hcg hd he hf hfs hg hh hhg hj hjc hm hmk hn hq hs ht hv hx i ia ib iid ill ilm in ioe ip j ja jan jb jc jf jg jh jhe jj jk jkc jl jln jn jq js jv jx jz k kb kbm kbp kbq kbr kbu kc kd kdc kde kdg kdk kds kdz ke kea keb kem ken keo keq kes kf kfa kfc kfd kff kfg kfh kfi kfk kfl kfm kfn kfo kfp kfr kfs kft kfu kfv kfw kfx kfz kg kga kgb kgc kgd kge kgf kgg kgh kgj kgk kgl kgn kgq kgs kgt kgv kgx kh kha khc khd khf khh khk khp khq khu khw kit kj kja kjc kje kjg kjj kjk kjm kjn kjp kjq kjr kjs kjt kjv kjw kk kka kkb kkc kke kkf kkg kkh kki kkj kkm kkn kkp kkq kkr kks kkt kkv kkw kkx kky kkz kl kla klb kld kle klf klg klh klm kln klp klr kls klt klv klw km kmc kme kmf kmh kmj kmk kml kmm kmn kmo kmp kmq kmt kmu kmv kmx kn knc knd kne knf kng knh knk knl knm knn knp knq knr kns knt knu knw knx kny kp kpa kpc kpe kpf kpg kph kpj kpk kpl kpm kpp kps kpt kpv kpw kq kqc kqe kqg kqj kqk kqp kqw krb krc krg krm krn krp krr krs kru krv krx ks ksa ksc ksh ksj ksk ksl ksp kss kst ksv ksw ksx ksy kta ktd ktg ktj ktk ktl ktq ktr ktt ktu ktv ktw ktx kty ktz ku kuc kuq kvc kvf kvm kvn kvp kvq kvr kvs kvw kwc kwg kwh kwl kwp kwr kww kwx kz kza kzd l la law lb lc ld le lf lg lh lj ll ln lrm lt lv m may mb mc me mf mh mkl ml mpc mr ms mt my n na nat nax nb nc nd nda nds ne ner new ng nh nk nl nmb nn no nt nv nx ok onc p pa pb pc pcr pd pe pf pg ph phd pj pjc pk pl pm pn pnb pp pq pr ps pt pz q qa qb qc qd qe qh qk ql qm qp qr qry qu qv r ra rb rbw rc rcc rd re ref res rf rg rh rj rk rl rm rn rp rs rt rv rx rz s sb sd see sf sfk sgv sh sk sn sql sw t ta tc td tdd te tf tg tgg th tj tk tl tn tnj to tp tr ts tt tx tz u ua ub uc ud ue uf ug uh un use v va vb vc vd ve vf vg vk vla vm w wq x xp xx y yh yl yy z za zhn zz zzz)) {
63608264µs $intmap{$prefix} = $i;
6460877µs $i++;
65}
66
67# Regexp constants to deal with matching LC and variants
68
6918µs13µsmy $lcregex = qr/^
# spent 3µs making 1 call to Library::CallNumber::LC::CORE:qr
70 \s*
71 (?:VIDEO-D)? # for video stuff
72 (?:DVD-ROM)? # DVDs, obviously
73 (?:CD-ROM)? # CDs
74 (?:TAPE-C)? # Tapes
75 \s*
76 ([A-Z]{1,3}) # alpha
77 \s*
78 (?: # optional numbers with optional decimal point
79 (\d+)
80 (?:\s*?\.\s*?(\d+))?
81 )?
82 \s*
83 (\d+[stndrh]*)? # optional extra numbering including suffixes (1st, 2nd, etc.)
84 \s*
85 (?: # optional cutter
86 \.? \s*
87 ([A-Z]) # cutter letter
88 \s*
89 (\d+ | \Z)? # cutter numbers
90 )?
91 \s*
92 (?: # optional cutter
93 \.? \s*
94 ([A-Z]) # cutter letter
95 \s*
96 (\d+ | \Z)? # cutter numbers
97 )?
98 \s*
99 (?: # optional cutter
100 \.? \s*
101 ([A-Z]) # cutter letter
102 \s*
103 (\d+ | \Z)? # cutter numbers
104 )?
105 (\s+.+?)? # everthing else
106 \s*$
107 /x;
108
- -
11112µs1600nsmy $weird = qr/
# spent 600ns making 1 call to Library::CallNumber::LC::CORE:qr
112 ^
113 \s*[A-Z]+\s*\d+\.\d+\.\d+
114/x;
115
116# Class variables for top/bottom sort chars
1171200nsmy $Topper = ' '; # must sort before 'A'
1181100nsmy $Bottomer = '~'; # must sort after 'Z' and '9'
119
120
121=head1 CONSTRUCTORS
122
123=head2 new([call_number_text, [topper_character, [bottomer_character]]]) -- create a new object, optionally passing in the initial string, a "topper", and a "bottomer" (explained below)
124
125=cut
126
127
# spent 5µs within Library::CallNumber::LC::new which was called: # once (5µs+0s) by C4::ClassSortRoutine::LCC::get_class_sort_key at line 55 of C4/ClassSortRoutine/LCC.pm
sub new {
1281300ns my $proto = shift;
1291200ns my $class = ref($proto) || $proto;
1301200ns my $lc = shift || '';
1311100ns my $topper = shift;
1321200ns $topper = $Topper if !defined($topper); # ZERO is false but might be a reasonable value, so we need this more specific check
1331200ns my $bottomer = shift || $Bottomer;
13412µs my $self = {
135 callno => uc($lc),
136 topper => $topper,
137 bottomer => $bottomer
138 };
1391900ns bless $self, $class;
14015µs return $self;
141}
142
143
144=head1 BASIC ACCESSORS
145
146=head2 call_number([call_number_text])
147
148The text of the call number we are dealing with.
149
150=cut
151
152sub call_number {
153 my $self = shift;
154 if (@_) { $self->{callno} = uc(shift) }
155 return $self->{callno};
156}
157
158=head2 topper([character])
159
160Specify which character occupies the 'always-sort-to-the-top' slots in the sort keys. Defaults to the SPACE character, but can reasonably be anything with an ASCII value lower than 48 (i.e. the 'zero' character, '0'). This can function as either a class or instance method depending on need.
161
162=cut
163
164
# spent 2µs within Library::CallNumber::LC::topper which was called: # once (2µs+0s) by Library::CallNumber::LC::_normalize at line 270
sub topper {
1651200ns my $self = shift;
16610s my $topper = shift;
1671400ns if (ref $self) {
1681100ns $self->{topper} = $topper if $topper; # just myself
169117µs return $self->{topper};
170 } else {
171 $Topper = $topper if $topper; # whole class
172 return $Topper;
173 }
174}
175
176=head2 bottomer([character])
177
178Specify which character occupies the 'always-sort-to-the-bottom' slots in the sort keys. Defaults to the TILDE character, but can reasonably be anything with an ASCII value higher than 90 (i.e. 'Z'). This can function as either a class or instance method depending on need.
179
180=cut
181
182sub bottomer {
183 my $self = shift;
184 my $bottomer = shift;
185 if (ref $self) {
186 $self->{bottomer} = $bottomer if $bottomer; # just myself
187 return $self->{bottomer};
188 } else {
189 $Bottomer = $bottomer if $bottomer; # whole class
190 return $Bottomer;
191 }
192}
193
194=head1 OTHER METHODS
195
196=head2 components(boolean returnAll = false)
197
198 @comps = Library::CallNumber::LC->new('A 123.4 .c11')->components($returnAll)
199
200Returns an array of the individual components of the call number (or undef if it doesn't look like a call number).
201Components are:
202
203=over 4
204
205=item * alpha
206
207=item * number (numeric.decimal)
208
209=item * cutter1
210
211=item * cutter2
212
213=item * cutter3
214
215=item * "extra" (anything after the cutters)
216
217=back
218
219The optional argument <I returnAll> (false by default) determines whether or not empty components (e.g.,
220extra cutters) get a slot in the returned list.
221
222=cut
223
224sub components {
225 my $self = shift;
226 my $returnAll = shift;
227 my $lc = $self->{callno};
228
229 return undef if ($lc =~ $weird);
230 return undef unless ($lc =~ $lcregex);
231
232
233 my ($alpha, $num, $dec, $othernum, $c1alpha, $c1num, $c2alpha, $c2num, $c3alpha, $c3num, $extra) = ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11);
234
235 #combine stuff if need be
236
237 if ($dec) {
238 $num .= '.' . $dec;
239 }
240
241265µs245µs
# spent 28µs (10+17) within Library::CallNumber::LC::BEGIN@241 which was called: # once (10µs+17µs) by C4::ClassSortRoutine::LCC::BEGIN@23 at line 241
no warnings;
# spent 28µs making 1 call to Library::CallNumber::LC::BEGIN@241 # spent 17µs making 1 call to warnings::unimport
242 my $c1 = join('', $c1alpha, $c1num);
243 my $c2 = join('', $c2alpha, $c2num);
244 my $c3 = join('', $c3alpha, $c3num);
245
246 $c1 = '.' . $c1 if ($c1 =~ /\S/);
2472228µs229µs
# spent 21µs (13+8) within Library::CallNumber::LC::BEGIN@247 which was called: # once (13µs+8µs) by C4::ClassSortRoutine::LCC::BEGIN@23 at line 247
use warnings;
# spent 21µs making 1 call to Library::CallNumber::LC::BEGIN@247 # spent 8µs making 1 call to warnings::import
248
249 my @return;
250 foreach my $comp ($alpha, $num, $othernum, $c1, $c2, $c3, $extra) {
251 $comp = '' unless (defined $comp);
252 next unless ($comp =~ /\S/ or $returnAll);
253 $comp =~ m/^\s*(.*?)\s*$/;
254 $comp = $1;
255 push @return, $comp;
256 }
257 return @return;
258}
259
260=head2 _normalize(call_number_text)
261
262Base function to perform normalization.
263
264=cut
265
266
# spent 65µs (53+12) within Library::CallNumber::LC::_normalize which was called: # once (53µs+12µs) by Library::CallNumber::LC::normalize at line 310
sub _normalize {
2671100ns my $self = shift;
2681400ns my $lc = uc(shift);
269
2701900ns12µs my $topper = $self->topper;
# spent 2µs making 1 call to Library::CallNumber::LC::topper
271
272# return undef if ($lc =~ $weird);
273115µs28µs return undef unless ($lc =~ $lcregex);
# spent 6µs making 1 call to Library::CallNumber::LC::CORE:match # spent 2µs making 1 call to Library::CallNumber::LC::CORE:regcomp
274
27515µs my ($alpha, $num, $dec, $othernum, $c1alpha, $c1num, $c2alpha, $c2num, $c3alpha, $c3num, $extra) = ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11);
276
2772578µs236µs
# spent 23µs (10+13) within Library::CallNumber::LC::BEGIN@277 which was called: # once (10µs+13µs) by C4::ClassSortRoutine::LCC::BEGIN@23 at line 277
no warnings;
# spent 23µs making 1 call to Library::CallNumber::LC::BEGIN@277 # spent 13µs making 1 call to warnings::unimport
2781300ns my $class = $alpha;
2791100ns $class .= sprintf('%04s', $num) if $num;
2801100ns $class .= $dec if $dec;
2811500ns my $c1 = $c1alpha.$c1num;
2821500ns my $c2 = $c2alpha.$c2num;
2831300ns my $c3 = $c3alpha.$c3num;
284
285 # normalize extra (most commonly years/numbering, benefits from padding)
286 # this could be reduced to a four digit pad, as very, very few numbers
287 # reach 10000, but we'll be conservative here (for now)
28813µs1400ns $extra =~ s/^\s+//g;
# spent 400ns making 1 call to Library::CallNumber::LC::CORE:subst
28912µs1100ns $extra =~ s/\.\s+/./g;
# spent 100ns making 1 call to Library::CallNumber::LC::CORE:subst
29012µs1200ns $extra =~ s/(\d)\s*-\s*(\d)/$1-$2/g;
# spent 200ns making 1 call to Library::CallNumber::LC::CORE:subst
29112µs1100ns $extra =~ s/(\d+)/sprintf("%05s", $1)/ge;
# spent 100ns making 1 call to Library::CallNumber::LC::CORE:subst
2921300ns $extra = $topper . $extra if ($extra ne ''); # give the extra less 'weight' for falling down the list
293
294 # pad out othernum (again, conservatively)
29512µs1100ns $othernum =~ s/(\d+)/sprintf("%05s", $1)/ge;
# spent 100ns making 1 call to Library::CallNumber::LC::CORE:subst
296
297716µs62µs return join($topper, grep {/\S/} ($class, $othernum, $c1, $c2, $c3, $extra));
# spent 2µs making 6 calls to Library::CallNumber::LC::CORE:match, avg 333ns/call
298}
299
300=head2 normalize([call_number_text])
301
302Normalize the stored or passed call number as a sortable string
303
304=cut
305
306
# spent 72µs (6+65) within Library::CallNumber::LC::normalize which was called: # once (6µs+65µs) by C4::ClassSortRoutine::LCC::get_class_sort_key at line 57 of C4/ClassSortRoutine/LCC.pm
sub normalize {
3071200ns my $self = shift;
3081100ns my $lc = shift;
30912µs $lc = $lc? uc($lc) : $self->{callno};
31013µs165µs return $self->_normalize($lc)
# spent 65µs making 1 call to Library::CallNumber::LC::_normalize
311}
312
313=head2 start_of_range([call_number_text])
314
315Alias for normalize
316
317=cut
318
319sub start_of_range {
320 my $self = shift;
321 return $self->normalize(@_);
322}
323
324=head2 end_of_range([call_number_text])
325
326Downshift an lc number so it represents the end of a range
327
328=cut
329
330sub end_of_range {
331 my $self = shift;
332 my $lc = shift;
333 $lc = $lc? uc($lc) : $self->{callno};
334 my $bottomer = $self->bottomer;
335 return $self->_normalize($lc) . $bottomer;
336}
337
338=head2 toLongInt(call_number_text, num_digits)
339
340Attempt to turn a call number into an integer value. Possibly useful for fast range checks, although obviously not perfectly accurate. Optional argument I<$num_digits> can be used to control the number of digits used, and therefore the precision of the results.
341
342=cut
343
34413µs1118µsmy $minval = new Math::BigInt('0'); # set to zero until this code matures
# spent 118µs making 1 call to Math::BigInt::new
34512µs116µsmy $minvalstring = $minval->bstr;
# spent 16µs making 1 call to Math::BigInt::bstr
346
347# this is a work in progress, with room for improvement in both exception
348# logic and overall economy of bits
349sub toLongInt {
350 my $self = shift;
351 my $lc = shift;
352 my $num_digits = shift || 19; # 19 is a max-fit for 64-bits within our scope
353
354 my $topper = $self->topper;
355 my $bottomer = $self->bottomer;
356
357 #print "$lc\n";
358 my $topper_ord = ord($topper);
359 my $long = $self->normalize($lc);
360
361 return $minvalstring unless ($long);
362
363 my ($alpha, $num, $rest);
364 if ($long =~ /^([A-Z]+)(\d{4})(.*)$/) { # we have a 'full' call number
365 ($alpha, $num, $rest) = (lc($1), $2, $3);
366 } elsif ($long =~ /^([A-Z]+)(.*)$/) { # numberless class; generally invalid, but let it slide for now
367 ($alpha, $rest) = (lc($1), $2);
368 if ($rest =~ /^$bottomer/) { # bottomed-out class
369 $num = '9999';
370 } else {
371 $num = '0000';
372 }
373 }
374 my $class_int_string = '';
375 if (defined($intmap{$alpha})) {
376 $class_int_string .= $intmap{$alpha} . $num;
377 } else {
378 warn "Unknown prefix '$alpha'\n";
379 return $minvalstring;
380 }
381 my $rest_int_string = '';
382 my $bottomout;
383 foreach my $char (split('', $rest)) {
384 if ($char eq $bottomer) {
385 $bottomout = 1;
386 last;
387 }
388 $rest_int_string .= sprintf('%02d', ord($char) - $topper_ord);
389 }
390
391 $rest_int_string = substr($rest_int_string, 0, $num_digits - 7); # Reserve first seven digits for $alpha and $num
392 if ($bottomout) {
393 $rest_int_string .= '9' x (($num_digits - 7) - length($rest_int_string)); # pad it if need be
394 } else {
395 $rest_int_string .= '0' x (($num_digits - 7) - length($rest_int_string)); # pad it if need be
396 }
397
398# print " $long => ", join('', @rv), "\n";
399 my $longint = Math::BigInt->new($class_int_string . $rest_int_string);
400 $longint->badd($minval);
401# warn "\n\n".$self->_normalize($lc)." = ".$longint->bstr." ( $class_int_string + $rest_int_string) \n\n";
402 return $longint->bstr;
403
404}
405
- -
408=head1 AUTHOR
409
410Current Maintainer: Dan Wells, C<< <dbw2 at calvin.edu> >>
411Original Author: Bill Dueber, C<< <dueberb at umich.edu> >>
412
413=head1 BUGS
414
415Please report any bugs or feature requests through the web interface at
416L<http://code.google.com/p/library-callnumber-lc/issues/list>. I will be
417notified, and then you'll automatically be notified of progress on your bug as
418I make changes.
419
420
421=head1 SUPPORT
422
423You can find documentation for this module with the perldoc command.
424
425 perldoc Library::CallNumber::LC
426
427
428You can also look for information at the Google Code page:
429
430 http://code.google.com/p/library-callnumber-lc/
431
432
433=head1 COPYRIGHT & LICENSE
434
435Copyright 2009 Bill Dueber, all rights reserved.
436Copyright 2011 Dan Wells, all rights reserved.
437
438This program is free software; you can redistribute it and/or modify it
439under the same terms as Perl itself and also under the new BSD license
440as described at http://www.opensource.org/licenses/bsd-license.php
441
442
443=cut
444
445139µs1; # End of Library::CallNumber::LC
 
# spent 8µs within Library::CallNumber::LC::CORE:match which was called 7 times, avg 1µs/call: # 6 times (2µs+0s) by Library::CallNumber::LC::_normalize at line 297, avg 333ns/call # once (6µs+0s) by Library::CallNumber::LC::_normalize at line 273
sub Library::CallNumber::LC::CORE:match; # opcode
# spent 3µs within Library::CallNumber::LC::CORE:qr which was called 2 times, avg 2µs/call: # once (3µs+0s) by C4::ClassSortRoutine::LCC::BEGIN@23 at line 69 # once (600ns+0s) by C4::ClassSortRoutine::LCC::BEGIN@23 at line 111
sub Library::CallNumber::LC::CORE:qr; # opcode
# spent 2µs within Library::CallNumber::LC::CORE:regcomp which was called: # once (2µs+0s) by Library::CallNumber::LC::_normalize at line 273
sub Library::CallNumber::LC::CORE:regcomp; # opcode
# spent 900ns within Library::CallNumber::LC::CORE:subst which was called 5 times, avg 180ns/call: # once (400ns+0s) by Library::CallNumber::LC::_normalize at line 288 # once (200ns+0s) by Library::CallNumber::LC::_normalize at line 290 # once (100ns+0s) by Library::CallNumber::LC::_normalize at line 291 # once (100ns+0s) by Library::CallNumber::LC::_normalize at line 289 # once (100ns+0s) by Library::CallNumber::LC::_normalize at line 295
sub Library::CallNumber::LC::CORE:subst; # opcode
Report produced by the NYTProf 5.06 Perl profiler, developed by Tim Bunce and Adam Kaplan.