← Index
NYTProf Performance Profile   « block view • line view • sub view »
For 01.HTTP.t
  Run on Tue May 4 15:25:55 2010
Reported on Tue May 4 15:26:21 2010

File /usr/local/lib/perl5/site_perl/5.10.1/Data/OptList.pm
Statements Executed 1164
Statement Execution Time 18.6ms
Subroutines — ordered by exclusive time
Calls P F Exclusive
Time
Inclusive
Time
Subroutine
11117.9ms18.7msData::OptList::::BEGIN@7Data::OptList::BEGIN@7
1112.44ms2.88msData::OptList::::BEGIN@8Data::OptList::BEGIN@8
2932723µs1.22msData::OptList::::mkoptData::OptList::mkopt
7721332µs496µsData::OptList::::__is_aData::OptList::__is_a
1521140µs1.10msData::OptList::::mkopt_hashData::OptList::mkopt_hash
11129µs35µsData::OptList::::BEGIN@3Data::OptList::BEGIN@3
11117µs29µsData::OptList::::BEGIN@214Data::OptList::BEGIN@214
11111µs11µsData::OptList::::BEGIN@131Data::OptList::BEGIN@131
1119µs23µsData::OptList::::BEGIN@4Data::OptList::BEGIN@4
1114µs4µsData::OptList::::BEGIN@6Data::OptList::BEGIN@6
0000s0sData::OptList::::__ANON__[:143]Data::OptList::__ANON__[:143]
Call graph for these subroutines as a Graphviz dot language file.
Line State
ments
Time
on line
Calls Time
in subs
Code
1
2package Data::OptList;
3335µs242µs
# spent 35µs (29+7) within Data::OptList::BEGIN@3 which was called # once (29µs+7µs) by Sub::Exporter::BEGIN@7 at line 3
use strict;
# spent 35µs making 1 call to Data::OptList::BEGIN@3 # spent 6µs making 1 call to strict::import
4324µs237µs
# spent 23µs (9+14) within Data::OptList::BEGIN@4 which was called # once (9µs+14µs) by Sub::Exporter::BEGIN@7 at line 4
use warnings;
# spent 23µs making 1 call to Data::OptList::BEGIN@4 # spent 14µs making 1 call to warnings::import
5
6330µs14µs
# spent 4µs within Data::OptList::BEGIN@6 which was called # once (4µs+0s) by Sub::Exporter::BEGIN@7 at line 6
use List::Util ();
# spent 4µs making 1 call to Data::OptList::BEGIN@6
7315.8ms118.7ms
# spent 18.7ms (17.9+741µs) within Data::OptList::BEGIN@7 which was called # once (17.9ms+741µs) by Sub::Exporter::BEGIN@7 at line 7
use Params::Util ();
# spent 18.7ms making 1 call to Data::OptList::BEGIN@7
83304µs22.92ms
# spent 2.88ms (2.44+441µs) within Data::OptList::BEGIN@8 which was called # once (2.44ms+441µs) by Sub::Exporter::BEGIN@7 at line 8
use Sub::Install 0.92 ();
# spent 2.88ms making 1 call to Data::OptList::BEGIN@8 # spent 32µs making 1 call to UNIVERSAL::VERSION
9
10=head1 NAME
11
12Data::OptList - parse and validate simple name/value option pairs
13
14=head1 VERSION
15
16version 0.104
17
18=cut
19
2011µsour $VERSION = '0.104';
21
22=head1 SYNOPSIS
23
24 use Data::OptList;
25
26 my $options = Data::Optlist::mkopt([
27 qw(key1 key2 key3 key4),
28 key5 => { ... },
29 key6 => [ ... ],
30 key7 => sub { ... },
31 key8 => { ... },
32 key8 => [ ... ],
33 ]);
34
35...is the same thing, more or less, as:
36
37 my $options = [
38 [ key1 => undef, ],
39 [ key2 => undef, ],
40 [ key3 => undef, ],
41 [ key4 => undef, ],
42 [ key5 => { ... }, ],
43 [ key6 => [ ... ], ],
44 [ key7 => sub { ... }, ],
45 [ key8 => { ... }, ],
46 [ key8 => [ ... ], ],
47 ]);
48
49=head1 DESCRIPTION
50
51Hashes are great for storing named data, but if you want more than one entry
52for a name, you have to use a list of pairs. Even then, this is really boring
53to write:
54
55 $values = [
56 foo => undef,
57 bar => undef,
58 baz => undef,
59 xyz => { ... },
60 ];
61
62Just look at all those undefs! Don't worry, we can get rid of those:
63
64 $values = [
65 map { $_ => undef } qw(foo bar baz),
66 xyz => { ... },
67 ];
68
69Aaaauuugh! We've saved a little typing, but now it requires thought to read,
70and thinking is even worse than typing... and it's got a bug! It looked right,
71didn't it? Well, the C<< xyz => { ... } >> gets consumed by the map, and we
72don't get the data we wanted.
73
74With Data::OptList, you can do this instead:
75
76 $values = Data::OptList::mkopt([
77 qw(foo bar baz),
78 xyz => { ... },
79 ]);
80
81This works by assuming that any defined scalar is a name and any reference
82following a name is its value.
83
84=head1 FUNCTIONS
85
86=head2 mkopt
87
88 my $opt_list = Data::OptList::mkopt(
89 $input,
90 $moniker,
91 $require_unique,
92 $must_be,
93 );
94
95This produces an array of arrays; the inner arrays are name/value pairs.
96Values will be either "undef" or a reference.
97
98Valid values for C<$input>:
99
100 undef -> []
101 hashref -> [ [ key1 => value1 ] ... ] # non-ref values become undef
102 arrayref -> every value followed by a ref becomes a pair: [ value => ref ]
103 every value followed by undef becomes a pair: [ value => undef ]
104 otherwise, it becomes [ value => undef ] like so:
105 [ "a", "b", [ 1, 2 ] ] -> [ [ a => undef ], [ b => [ 1, 2 ] ] ]
106
107C<$moniker> is a name describing the data, which will be used in error
108messages.
109
110If C<$require_unique> is true, an error will be thrown if any name is given
111more than once.
112
113C<$must_be> is either a scalar or array of scalars; it defines what kind(s) of
114refs may be values. If an invalid value is found, an exception is thrown. If
115no value is passed for this argument, any reference is valid. If C<$must_be>
116specifies that values must be CODE, HASH, ARRAY, or SCALAR, then Params::Util
117is used to check whether the given value can provide that interface.
118Otherwise, it checks that the given value is an object of the kind.
119
120In other words:
121
122 [ qw(SCALAR HASH Object::Known) ]
123
124Means:
125
126 _SCALAR0($value) or _HASH($value) or _INSTANCE($value, 'Object::Known')
127
128=cut
129
1301200nsmy %test_for;
131
# spent 11µs within Data::OptList::BEGIN@131 which was called # once (11µs+0s) by Sub::Exporter::BEGIN@7 at line 138
BEGIN {
132112µs %test_for = (
133 CODE => \&Params::Util::_CODELIKE, ## no critic
134 HASH => \&Params::Util::_HASHLIKE, ## no critic
135 ARRAY => \&Params::Util::_ARRAYLIKE, ## no critic
136 SCALAR => \&Params::Util::_SCALAR0, ## no critic
137 );
13811.05ms111µs}
# spent 11µs making 1 call to Data::OptList::BEGIN@131
139
140
# spent 496µs (332+164) within Data::OptList::__is_a which was called 77 times, avg 6µs/call: # 41 times (169µs+-169µs) by List::Util::first at line 143, avg 0s/call # 36 times (163µs+333µs) by Data::OptList::mkopt at line 178, avg 14µs/call
sub __is_a {
1417727µs my ($got, $expected) = @_;
142
143118252µs77333µs return List::Util::first { __is_a($got, $_) } @$expected if ref $expected;
# spent 333µs making 36 calls to List::Util::first, avg 9µs/call # spent 198µs making 41 calls to Data::OptList::__is_a, avg 5µs/call, recursion: max depth 1, time 198µs
144
145 return defined (
14641205µs4129µs exists($test_for{$expected})
# spent 15µs making 31 calls to Params::Util::_CODELIKE, avg 497ns/call # spent 8µs making 5 calls to Params::Util::_HASHLIKE, avg 2µs/call # spent 6µs making 5 calls to Params::Util::_ARRAYLIKE, avg 1µs/call
147 ? $test_for{$expected}->($got)
148 : Params::Util::_INSTANCE($got, $expected) ## no critic
149 );
150}
151
152
# spent 1.22ms (723µs+496µs) within Data::OptList::mkopt which was called 29 times, avg 42µs/call: # 11 times (465µs+496µs) by Data::OptList::mkopt_hash at line 203, avg 87µs/call # 11 times (126µs+0s) by Sub::Exporter::__ANON__[/usr/local/lib/perl5/site_perl/5.10.1/Sub/Exporter.pm:756] at line 735 of Sub/Exporter.pm, avg 11µs/call # 7 times (131µs+0s) by Sub::Exporter::_expand_group at line 505 of Sub/Exporter.pm, avg 19µs/call
sub mkopt {
1532919µs my ($opt_list, $moniker, $require_unique, $must_be) = @_;
154
155294µs return [] unless $opt_list;
156
157 $opt_list = [
1582959µs map { $_ => (ref $opt_list->{$_} ? $opt_list->{$_} : ()) } keys %$opt_list
159 ] if ref $opt_list eq 'HASH';
160
161294µs my @return;
162294µs my %seen;
163
1642960µs for (my $i = 0; $i < @$opt_list; $i++) { ## no critic
1658937µs my $name = $opt_list->[$i];
166893µs my $value;
167
1688930µs if ($require_unique) {
169 Carp::croak "multiple definitions provided for $name" if $seen{$name}++;
170 }
171
17289107µs if ($i == $#$opt_list) { $value = undef; }
173 elsif (not defined $opt_list->[$i+1]) { $value = undef; $i++ }
174 elsif (ref $opt_list->[$i+1]) { $value = $opt_list->[++$i] }
175415µs else { $value = undef; }
176
1778961µs if ($must_be and defined $value) {
1783637µs36496µs unless (__is_a($value, $must_be)) {
# spent 496µs making 36 calls to Data::OptList::__is_a, avg 14µs/call
179 my $ref = ref $value;
180 Carp::croak "$ref-ref values are not valid in $moniker opt list";
181 }
182 }
183
1848983µs push @return, [ $name => $value ];
185297µs }
186
18729125µs return \@return;
188}
189
190=head2 mkopt_hash
191
192 my $opt_hash = Data::OptList::mkopt_hash($input, $moniker, $must_be);
193
194Given valid C<L</mkopt>> input, this routine returns a reference to a hash. It
195will throw an exception if any name has more than one value.
196
197=cut
198
199
# spent 1.10ms (140µs+961µs) within Data::OptList::mkopt_hash which was called 15 times, avg 73µs/call: # 10 times (107µs+753µs) by Sub::Exporter::_rewrite_build_config at line 672 of Sub/Exporter.pm, avg 86µs/call # 5 times (33µs+209µs) by Sub::Exporter::_rewrite_build_config at line 685 of Sub/Exporter.pm, avg 48µs/call
sub mkopt_hash {
2001513µs my ($opt_list, $moniker, $must_be) = @_;
2011511µs return {} unless $opt_list;
202
2031114µs11961µs $opt_list = mkopt($opt_list, $moniker, 1, $must_be);
# spent 961µs making 11 calls to Data::OptList::mkopt, avg 87µs/call
2041150µs my %hash = map { $_->[0] => $_->[1] } @$opt_list;
2051145µs return \%hash;
206}
207
208=head1 EXPORTS
209
210Both C<mkopt> and C<mkopt_hash> may be exported on request.
211
212=cut
213
214
# spent 29µs (17+12) within Data::OptList::BEGIN@214 which was called # once (17µs+12µs) by Sub::Exporter::BEGIN@7 at line 218
BEGIN {
215110µs112µs *import = Sub::Install::exporter {
# spent 12µs making 1 call to Sub::Install::exporter
216 exports => [qw(mkopt mkopt_hash)],
217 };
218149µs129µs}
# spent 29µs making 1 call to Data::OptList::BEGIN@214
219
220=head1 AUTHOR
221
222Ricardo SIGNES, C<< <rjbs@cpan.org> >>
223
224=head1 BUGS
225
226Please report any bugs or feature requests at L<http://rt.cpan.org>. I will be
227notified, and then you'll automatically be notified of progress on your bug as
228I make changes.
229
230=head1 COPYRIGHT
231
232Copyright 2006-2007, Ricardo SIGNES. This program is free software; you can
233redistribute it and/or modify it under the same terms as Perl itself.
234
235=cut
236
23716µs1;