← Index
Performance Profile   « block view • line view • sub view »
For /wise/base/deliv/dev/bin/getfix
  Run on Thu May 20 15:30:03 2010
Reported on Thu May 20 16:25:29 2010

File/opt/wise/lib/perl5/5.10.0/x86_64-linux-thread-multi/IO/Compress/Base.pm
Statements Executed60
Total Time0.004679 seconds

Subroutines — ordered by exclusive time
Calls P F Exclusive
Time		 Inclusive
Time		 Subroutine
6616.0e-56.0e-5IO::Compress::Base::_notAvailable
00000IO::Compress::Base::BEGIN
00000IO::Compress::Base::DESTROY
00000IO::Compress::Base::TIEHANDLE
00000IO::Compress::Base::UNTIE
00000IO::Compress::Base::__ANON__[:912]
00000IO::Compress::Base::_create
00000IO::Compress::Base::_def
00000IO::Compress::Base::_singleTarget
00000IO::Compress::Base::_wr2
00000IO::Compress::Base::_writeFinalTrailer
00000IO::Compress::Base::_writeTrailer
00000IO::Compress::Base::addInterStream
00000IO::Compress::Base::autoflush
00000IO::Compress::Base::binmode
00000IO::Compress::Base::checkParams
00000IO::Compress::Base::ckOutputParam
00000IO::Compress::Base::close
00000IO::Compress::Base::closeError
00000IO::Compress::Base::croakError
00000IO::Compress::Base::eof
00000IO::Compress::Base::error
00000IO::Compress::Base::errorNo
00000IO::Compress::Base::fileno
00000IO::Compress::Base::filterUncompressed
00000IO::Compress::Base::flush
00000IO::Compress::Base::getFileInfo
00000IO::Compress::Base::getOneShotParams
00000IO::Compress::Base::input_line_number
00000IO::Compress::Base::newStream
00000IO::Compress::Base::opened
00000IO::Compress::Base::output
00000IO::Compress::Base::print
00000IO::Compress::Base::printf
00000IO::Compress::Base::reset
00000IO::Compress::Base::saveErrorString
00000IO::Compress::Base::saveStatus
00000IO::Compress::Base::seek
00000IO::Compress::Base::syswrite
00000IO::Compress::Base::tell
00000IO::Compress::Base::writeAt

LineStmts.Exclusive
Time		Avg.Code
1
2package IO::Compress::Base ;
3
412.0e-52.0e-5require 5.004 ;
5
632.7e-59.0e-6use strict ;
# spent 9µs making 1 call to strict::import
732.9e-59.7e-6use warnings;
# spent 40µs making 1 call to warnings::import
8
935.9e-52.0e-5use IO::Compress::Base::Common 2.008 ;
# spent 181µs making 1 call to Exporter::import # spent 29µs making 1 call to UNIVERSAL::VERSION
10
1130.000227.5e-5use IO::File ;
# spent 166µs making 1 call to Exporter::import
1232.9e-59.7e-6use Scalar::Util qw(blessed readonly);
# spent 43µs making 1 call to Exporter::import
13
14#use File::Glob;
15#require Exporter ;
1632.7e-59.0e-6use Carp ;
# spent 46µs making 1 call to Exporter::import
1732.6e-58.7e-6use Symbol;
# spent 45µs making 1 call to Exporter::import
1830.003630.00121use bytes;
# spent 8µs making 1 call to bytes::import
19
2011.0e-61.0e-6our (@ISA, $VERSION);
2112.0e-52.0e-5@ISA = qw(Exporter IO::File);
22
2311.0e-61.0e-6$VERSION = '2.008';
24
25#Can't locate object method "SWASHNEW" via package "utf8" (perhaps you forgot to load "utf8"?) at .../ext/Compress-Zlib/Gzip/blib/lib/Compress/Zlib/Common.pm line 16.
26
27sub saveStatus
28{
29 my $self = shift ;
30 ${ *$self->{ErrorNo} } = shift() + 0 ;
31 ${ *$self->{Error} } = '' ;
32
33 return ${ *$self->{ErrorNo} } ;
34}
35
36
37sub saveErrorString
38{
39 my $self = shift ;
40 my $retval = shift ;
41 ${ *$self->{Error} } = shift ;
42 ${ *$self->{ErrorNo} } = shift() + 0 if @_ ;
43
44 return $retval;
45}
46
47sub croakError
48{
49 my $self = shift ;
50 $self->saveErrorString(0, $_[0]);
51 croak $_[0];
52}
53
54sub closeError
55{
56 my $self = shift ;
57 my $retval = shift ;
58
59 my $errno = *$self->{ErrorNo};
60 my $error = ${ *$self->{Error} };
61
62 $self->close();
63
64 *$self->{ErrorNo} = $errno ;
65 ${ *$self->{Error} } = $error ;
66
67 return $retval;
68}
69
70
71
72sub error
73{
74 my $self = shift ;
75 return ${ *$self->{Error} } ;
76}
77
78sub errorNo
79{
80 my $self = shift ;
81 return ${ *$self->{ErrorNo} } ;
82}
83
84
85sub writeAt
86{
87 my $self = shift ;
88 my $offset = shift;
89 my $data = shift;
90
91 if (defined *$self->{FH}) {
92 my $here = tell(*$self->{FH});
93 return $self->saveErrorString(undef, "Cannot seek to end of output filehandle: $!", $!)
94 if $here < 0 ;
95 seek(*$self->{FH}, $offset, SEEK_SET)
96 or return $self->saveErrorString(undef, "Cannot seek to end of output filehandle: $!", $!) ;
97 defined *$self->{FH}->write($data, length $data)
98 or return $self->saveErrorString(undef, $!, $!) ;
99 seek(*$self->{FH}, $here, SEEK_SET)
100 or return $self->saveErrorString(undef, "Cannot seek to end of output filehandle: $!", $!) ;
101 }
102 else {
103 substr(${ *$self->{Buffer} }, $offset, length($data)) = $data ;
104 }
105
106 return 1;
107}
108
109sub output
110{
111 my $self = shift ;
112 my $data = shift ;
113 my $last = shift ;
114
115 return 1
116 if length $data == 0 && ! $last ;
117
118 if ( *$self->{FilterEnvelope} ) {
119 *_ = \$data;
120 &{ *$self->{FilterEnvelope} }();
121 }
122
123 if ( defined *$self->{FH} ) {
124 defined *$self->{FH}->write( $data, length $data )
125 or return $self->saveErrorString(0, $!, $!);
126 }
127 else {
128 ${ *$self->{Buffer} } .= $data ;
129 }
130
131 return 1;
132}
133
134sub getOneShotParams
135{
136 return ( 'MultiStream' => [1, 1, Parse_boolean, 1],
137 );
138}
139
140sub checkParams
141{
142 my $self = shift ;
143 my $class = shift ;
144
145 my $got = shift || IO::Compress::Base::Parameters::new();
146
147 $got->parse(
148 {
149 # Generic Parameters
150 'AutoClose' => [1, 1, Parse_boolean, 0],
151 #'Encode' => [1, 1, Parse_any, undef],
152 'Strict' => [0, 1, Parse_boolean, 1],
153 'Append' => [1, 1, Parse_boolean, 0],
154 'BinModeIn' => [1, 1, Parse_boolean, 0],
155
156 'FilterEnvelope' => [1, 1, Parse_any, undef],
157
158 $self->getExtraParams(),
159 *$self->{OneShot} ? $self->getOneShotParams()
160 : (),
161 },
162 @_) or $self->croakError("${class}: $got->{Error}") ;
163
164 return $got ;
165}
166
167sub _create
168{
169 my $obj = shift;
170 my $got = shift;
171
172 *$obj->{Closed} = 1 ;
173
174 my $class = ref $obj;
175 $obj->croakError("$class: Missing Output parameter")
176 if ! @_ && ! $got ;
177
178 my $outValue = shift ;
179 my $oneShot = 1 ;
180
181 if (! $got)
182 {
183 $oneShot = 0 ;
184 $got = $obj->checkParams($class, undef, @_)
185 or return undef ;
186 }
187
188 my $lax = ! $got->value('Strict') ;
189
190 my $outType = whatIsOutput($outValue);
191
192 $obj->ckOutputParam($class, $outValue)
193 or return undef ;
194
195 if ($outType eq 'buffer') {
196 *$obj->{Buffer} = $outValue;
197 }
198 else {
199 my $buff = "" ;
200 *$obj->{Buffer} = \$buff ;
201 }
202
203 # Merge implies Append
204 my $merge = $got->value('Merge') ;
205 my $appendOutput = $got->value('Append') || $merge ;
206 *$obj->{Append} = $appendOutput;
207 *$obj->{FilterEnvelope} = $got->value('FilterEnvelope') ;
208
209 if ($merge)
210 {
211 # Switch off Merge mode if output file/buffer is empty/doesn't exist
212 if (($outType eq 'buffer' && length $$outValue == 0 ) ||
213 ($outType ne 'buffer' && (! -e $outValue || (-w _ && -z _))) )
214 { $merge = 0 }
215 }
216
217 # If output is a file, check that it is writable
218 if ($outType eq 'filename' && -e $outValue && ! -w _)
219 { return $obj->saveErrorString(undef, "Output file '$outValue' is not writable" ) }
220
221
222
223 if ($got->parsed('Encode')) {
224 my $want_encoding = $got->value('Encode');
225 *$obj->{Encoding} = getEncoding($obj, $class, $want_encoding);
226 }
227
228 $obj->ckParams($got)
229 or $obj->croakError("${class}: " . $obj->error());
230
231
232 $obj->saveStatus(STATUS_OK) ;
233
234 my $status ;
235 if (! $merge)
236 {
237 *$obj->{Compress} = $obj->mkComp($class, $got)
238 or return undef;
239
240 *$obj->{UnCompSize} = new U64 ;
241 *$obj->{CompSize} = new U64 ;
242
243 if ( $outType eq 'buffer') {
244 ${ *$obj->{Buffer} } = ''
245 unless $appendOutput ;
246 }
247 else {
248 if ($outType eq 'handle') {
249 *$obj->{FH} = $outValue ;
250 setBinModeOutput(*$obj->{FH}) ;
251 $outValue->flush() ;
252 *$obj->{Handle} = 1 ;
253 if ($appendOutput)
254 {
255 seek(*$obj->{FH}, 0, SEEK_END)
256 or return $obj->saveErrorString(undef, "Cannot seek to end of output filehandle: $!", $!) ;
257
258 }
259 }
260 elsif ($outType eq 'filename') {
261 my $mode = '>' ;
262 $mode = '>>'
263 if $appendOutput;
264 *$obj->{FH} = new IO::File "$mode $outValue"
265 or return $obj->saveErrorString(undef, "cannot open file '$outValue': $!", $!) ;
266 *$obj->{StdIO} = ($outValue eq '-');
267 setBinModeOutput(*$obj->{FH}) ;
268 }
269 }
270
271 *$obj->{Header} = $obj->mkHeader($got) ;
272 $obj->output( *$obj->{Header} )
273 or return undef;
274 }
275 else
276 {
277 *$obj->{Compress} = $obj->createMerge($outValue, $outType)
278 or return undef;
279 }
280
281 *$obj->{Closed} = 0 ;
282 *$obj->{AutoClose} = $got->value('AutoClose') ;
283 *$obj->{Output} = $outValue;
284 *$obj->{ClassName} = $class;
285 *$obj->{Got} = $got;
286 *$obj->{OneShot} = 0 ;
287
288 return $obj ;
289}
290
291sub ckOutputParam
292{
293 my $self = shift ;
294 my $from = shift ;
295 my $outType = whatIsOutput($_[0]);
296
297 $self->croakError("$from: output parameter not a filename, filehandle or scalar ref")
298 if ! $outType ;
299
300 $self->croakError("$from: output filename is undef or null string")
301 if $outType eq 'filename' && (! defined $_[0] || $_[0] eq '') ;
302
303 $self->croakError("$from: output buffer is read-only")
304 if $outType eq 'buffer' && readonly(${ $_[0] });
305
306 return 1;
307}
308
309
310sub _def
311{
312 my $obj = shift ;
313
314 my $class= (caller)[0] ;
315 my $name = (caller(1))[3] ;
316
317 $obj->croakError("$name: expected at least 1 parameters\n")
318 unless @_ >= 1 ;
319
320 my $input = shift ;
321 my $haveOut = @_ ;
322 my $output = shift ;
323
324 my $x = new Validator($class, *$obj->{Error}, $name, $input, $output)
325 or return undef ;
326
327 push @_, $output if $haveOut && $x->{Hash};
328
329 *$obj->{OneShot} = 1 ;
330
331 my $got = $obj->checkParams($name, undef, @_)
332 or return undef ;
333
334 $x->{Got} = $got ;
335
336# if ($x->{Hash})
337# {
338# while (my($k, $v) = each %$input)
339# {
340# $v = \$input->{$k}
341# unless defined $v ;
342#
343# $obj->_singleTarget($x, 1, $k, $v, @_)
344# or return undef ;
345# }
346#
347# return keys %$input ;
348# }
349
350 if ($x->{GlobMap})
351 {
352 $x->{oneInput} = 1 ;
353 foreach my $pair (@{ $x->{Pairs} })
354 {
355 my ($from, $to) = @$pair ;
356 $obj->_singleTarget($x, 1, $from, $to, @_)
357 or return undef ;
358 }
359
360 return scalar @{ $x->{Pairs} } ;
361 }
362
363 if (! $x->{oneOutput} )
364 {
365 my $inFile = ($x->{inType} eq 'filenames'
366 || $x->{inType} eq 'filename');
367
368 $x->{inType} = $inFile ? 'filename' : 'buffer';
369
370 foreach my $in ($x->{oneInput} ? $input : @$input)
371 {
372 my $out ;
373 $x->{oneInput} = 1 ;
374
375 $obj->_singleTarget($x, $inFile, $in, \$out, @_)
376 or return undef ;
377
378 push @$output, \$out ;
379 #if ($x->{outType} eq 'array')
380 # { push @$output, \$out }
381 #else
382 # { $output->{$in} = \$out }
383 }
384
385 return 1 ;
386 }
387
388 # finally the 1 to 1 and n to 1
389 return $obj->_singleTarget($x, 1, $input, $output, @_);
390
391 croak "should not be here" ;
392}
393
394sub _singleTarget
395{
396 my $obj = shift ;
397 my $x = shift ;
398 my $inputIsFilename = shift;
399 my $input = shift;
400
401 if ($x->{oneInput})
402 {
403 $obj->getFileInfo($x->{Got}, $input)
404 if isaFilename($input) and $inputIsFilename ;
405
406 my $z = $obj->_create($x->{Got}, @_)
407 or return undef ;
408
409
410 defined $z->_wr2($input, $inputIsFilename)
411 or return $z->closeError(undef) ;
412
413 return $z->close() ;
414 }
415 else
416 {
417 my $afterFirst = 0 ;
418 my $inputIsFilename = ($x->{inType} ne 'array');
419 my $keep = $x->{Got}->clone();
420
421 #for my $element ( ($x->{inType} eq 'hash') ? keys %$input : @$input)
422 for my $element ( @$input)
423 {
424 my $isFilename = isaFilename($element);
425
426 if ( $afterFirst ++ )
427 {
428 defined addInterStream($obj, $element, $isFilename)
429 or return $obj->closeError(undef) ;
430 }
431 else
432 {
433 $obj->getFileInfo($x->{Got}, $element)
434 if $isFilename;
435
436 $obj->_create($x->{Got}, @_)
437 or return undef ;
438 }
439
440 defined $obj->_wr2($element, $isFilename)
441 or return $obj->closeError(undef) ;
442
443 *$obj->{Got} = $keep->clone();
444 }
445 return $obj->close() ;
446 }
447
448}
449
450sub _wr2
451{
452 my $self = shift ;
453
454 my $source = shift ;
455 my $inputIsFilename = shift;
456
457 my $input = $source ;
458 if (! $inputIsFilename)
459 {
460 $input = \$source
461 if ! ref $source;
462 }
463
464 if ( ref $input && ref $input eq 'SCALAR' )
465 {
466 return $self->syswrite($input, @_) ;
467 }
468
469 if ( ! ref $input || isaFilehandle($input))
470 {
471 my $isFilehandle = isaFilehandle($input) ;
472
473 my $fh = $input ;
474
475 if ( ! $isFilehandle )
476 {
477 $fh = new IO::File "<$input"
478 or return $self->saveErrorString(undef, "cannot open file '$input': $!", $!) ;
479 }
480 binmode $fh if *$self->{Got}->valueOrDefault('BinModeIn') ;
481
482 my $status ;
483 my $buff ;
484 my $count = 0 ;
485 while (($status = read($fh, $buff, 16 * 1024)) > 0) {
486 $count += length $buff;
487 defined $self->syswrite($buff, @_)
488 or return undef ;
489 }
490
491 return $self->saveErrorString(undef, $!, $!)
492 if $status < 0 ;
493
494 if ( (!$isFilehandle || *$self->{AutoClose}) && $input ne '-')
495 {
496 $fh->close()
497 or return undef ;
498 }
499
500 return $count ;
501 }
502
503 croak "Should not be here";
504 return undef;
505}
506
507sub addInterStream
508{
509 my $self = shift ;
510 my $input = shift ;
511 my $inputIsFilename = shift ;
512
513 if (*$self->{Got}->value('MultiStream'))
514 {
515 $self->getFileInfo(*$self->{Got}, $input)
516 #if isaFilename($input) and $inputIsFilename ;
517 if isaFilename($input) ;
518
519 # TODO -- newStream needs to allow gzip/zip header to be modified
520 return $self->newStream();
521 }
522 elsif (*$self->{Got}->value('AutoFlush'))
523 {
524 #return $self->flush(Z_FULL_FLUSH);
525 }
526
527 return 1 ;
528}
529
530sub getFileInfo
531{
532}
533
534sub TIEHANDLE
535{
536 return $_[0] if ref($_[0]);
537 die "OOPS\n" ;
538}
539
540sub UNTIE
541{
542 my $self = shift ;
543}
544
545sub DESTROY
546{
547 my $self = shift ;
548 $self->close() ;
549
550 # TODO - memory leak with 5.8.0 - this isn't called until
551 # global destruction
552 #
553 %{ *$self } = () ;
554 undef $self ;
555}
556
557
558
559sub filterUncompressed
560{
561}
562
563sub syswrite
564{
565 my $self = shift ;
566
567 my $buffer ;
568 if (ref $_[0] ) {
569 $self->croakError( *$self->{ClassName} . "::write: not a scalar reference" )
570 unless ref $_[0] eq 'SCALAR' ;
571 $buffer = $_[0] ;
572 }
573 else {
574 $buffer = \$_[0] ;
575 }
576
577 $] >= 5.008 and ( utf8::downgrade($$buffer, 1)
578 or croak "Wide character in " . *$self->{ClassName} . "::write:");
579
580
581 if (@_ > 1) {
582 my $slen = defined $$buffer ? length($$buffer) : 0;
583 my $len = $slen;
584 my $offset = 0;
585 $len = $_[1] if $_[1] < $len;
586
587 if (@_ > 2) {
588 $offset = $_[2] || 0;
589 $self->croakError(*$self->{ClassName} . "::write: offset outside string")
590 if $offset > $slen;
591 if ($offset < 0) {
592 $offset += $slen;
593 $self->croakError( *$self->{ClassName} . "::write: offset outside string") if $offset < 0;
594 }
595 my $rem = $slen - $offset;
596 $len = $rem if $rem < $len;
597 }
598
599 $buffer = \substr($$buffer, $offset, $len) ;
600 }
601
602 return 0 if ! defined $$buffer || length $$buffer == 0 ;
603
604 if (*$self->{Encoding}) {
605 $$buffer = *$self->{Encoding}->encode($$buffer);
606 }
607
608 $self->filterUncompressed($buffer);
609
610 my $buffer_length = defined $$buffer ? length($$buffer) : 0 ;
611 *$self->{UnCompSize}->add($buffer_length) ;
612
613 my $outBuffer='';
614 my $status = *$self->{Compress}->compr($buffer, $outBuffer) ;
615
616 return $self->saveErrorString(undef, *$self->{Compress}{Error},
617 *$self->{Compress}{ErrorNo})
618 if $status == STATUS_ERROR;
619
620 *$self->{CompSize}->add(length $outBuffer) ;
621
622 $self->output($outBuffer)
623 or return undef;
624
625 return $buffer_length;
626}
627
628sub print
629{
630 my $self = shift;
631
632 #if (ref $self) {
633 # $self = *$self{GLOB} ;
634 #}
635
636 if (defined $\) {
637 if (defined $,) {
638 defined $self->syswrite(join($,, @_) . $\);
639 } else {
640 defined $self->syswrite(join("", @_) . $\);
641 }
642 } else {
643 if (defined $,) {
644 defined $self->syswrite(join($,, @_));
645 } else {
646 defined $self->syswrite(join("", @_));
647 }
648 }
649}
650
651sub printf
652{
653 my $self = shift;
654 my $fmt = shift;
655 defined $self->syswrite(sprintf($fmt, @_));
656}
657
658
659
660sub flush
661{
662 my $self = shift ;
663
664 my $outBuffer='';
665 my $status = *$self->{Compress}->flush($outBuffer, @_) ;
666 return $self->saveErrorString(0, *$self->{Compress}{Error},
667 *$self->{Compress}{ErrorNo})
668 if $status == STATUS_ERROR;
669
670 if ( defined *$self->{FH} ) {
671 *$self->{FH}->clearerr();
672 }
673
674 *$self->{CompSize}->add(length $outBuffer) ;
675
676 $self->output($outBuffer)
677 or return 0;
678
679 if ( defined *$self->{FH} ) {
680 defined *$self->{FH}->flush()
681 or return $self->saveErrorString(0, $!, $!);
682 }
683
684 return 1;
685}
686
687sub newStream
688{
689 my $self = shift ;
690
691 $self->_writeTrailer()
692 or return 0 ;
693
694 my $got = $self->checkParams('newStream', *$self->{Got}, @_)
695 or return 0 ;
696
697 $self->ckParams($got)
698 or $self->croakError("newStream: $self->{Error}");
699
700 *$self->{Header} = $self->mkHeader($got) ;
701 $self->output(*$self->{Header} )
702 or return 0;
703
704 my $status = $self->reset() ;
705 return $self->saveErrorString(0, *$self->{Compress}{Error},
706 *$self->{Compress}{ErrorNo})
707 if $status == STATUS_ERROR;
708
709 *$self->{UnCompSize}->reset();
710 *$self->{CompSize}->reset();
711
712 return 1 ;
713}
714
715sub reset
716{
717 my $self = shift ;
718 return *$self->{Compress}->reset() ;
719}
720
721sub _writeTrailer
722{
723 my $self = shift ;
724
725 my $trailer = '';
726
727 my $status = *$self->{Compress}->close($trailer) ;
728 return $self->saveErrorString(0, *$self->{Compress}{Error}, *$self->{Compress}{ErrorNo})
729 if $status == STATUS_ERROR;
730
731 *$self->{CompSize}->add(length $trailer) ;
732
733 $trailer .= $self->mkTrailer();
734 defined $trailer
735 or return 0;
736
737 return $self->output($trailer);
738}
739
740sub _writeFinalTrailer
741{
742 my $self = shift ;
743
744 return $self->output($self->mkFinalTrailer());
745}
746
747sub close
748{
749 my $self = shift ;
750
751 return 1 if *$self->{Closed} || ! *$self->{Compress} ;
752 *$self->{Closed} = 1 ;
753
754 untie *$self
755 if $] >= 5.008 ;
756
757 $self->_writeTrailer()
758 or return 0 ;
759
760 $self->_writeFinalTrailer()
761 or return 0 ;
762
763 $self->output( "", 1 )
764 or return 0;
765
766 if (defined *$self->{FH}) {
767
768 #if (! *$self->{Handle} || *$self->{AutoClose}) {
769 if ((! *$self->{Handle} || *$self->{AutoClose}) && ! *$self->{StdIO}) {
770 $! = 0 ;
771 *$self->{FH}->close()
772 or return $self->saveErrorString(0, $!, $!);
773 }
774 delete *$self->{FH} ;
775 # This delete can set $! in older Perls, so reset the errno
776 $! = 0 ;
777 }
778
779 return 1;
780}
781
782
783#sub total_in
784#sub total_out
785#sub msg
786#
787#sub crc
788#{
789# my $self = shift ;
790# return *$self->{Compress}->crc32() ;
791#}
792#
793#sub msg
794#{
795# my $self = shift ;
796# return *$self->{Compress}->msg() ;
797#}
798#
799#sub dict_adler
800#{
801# my $self = shift ;
802# return *$self->{Compress}->dict_adler() ;
803#}
804#
805#sub get_Level
806#{
807# my $self = shift ;
808# return *$self->{Compress}->get_Level() ;
809#}
810#
811#sub get_Strategy
812#{
813# my $self = shift ;
814# return *$self->{Compress}->get_Strategy() ;
815#}
816
817
818sub tell
819{
820 my $self = shift ;
821
822 return *$self->{UnCompSize}->get32bit() ;
823}
824
825sub eof
826{
827 my $self = shift ;
828
829 return *$self->{Closed} ;
830}
831
832
833sub seek
834{
835 my $self = shift ;
836 my $position = shift;
837 my $whence = shift ;
838
839 my $here = $self->tell() ;
840 my $target = 0 ;
841
842 #use IO::Handle qw(SEEK_SET SEEK_CUR SEEK_END);
84330.000480.00016 use IO::Handle ;
# spent 55µs making 1 call to Exporter::import
844
845 if ($whence == IO::Handle::SEEK_SET) {
846 $target = $position ;
847 }
848 elsif ($whence == IO::Handle::SEEK_CUR || $whence == IO::Handle::SEEK_END) {
849 $target = $here + $position ;
850 }
851 else {
852 $self->croakError(*$self->{ClassName} . "::seek: unknown value, $whence, for whence parameter");
853 }
854
855 # short circuit if seeking to current offset
856 return 1 if $target == $here ;
857
858 # Outlaw any attempt to seek backwards
859 $self->croakError(*$self->{ClassName} . "::seek: cannot seek backwards")
860 if $target < $here ;
861
862 # Walk the file to the new offset
863 my $offset = $target - $here ;
864
865 my $buffer ;
866 defined $self->syswrite("\x00" x $offset)
867 or return 0;
868
869 return 1 ;
870}
871
872sub binmode
873{
874 1;
875# my $self = shift ;
876# return defined *$self->{FH}
877# ? binmode *$self->{FH}
878# : 1 ;
879}
880
881sub fileno
882{
883 my $self = shift ;
884 return defined *$self->{FH}
885 ? *$self->{FH}->fileno()
886 : undef ;
887}
888
889sub opened
890{
891 my $self = shift ;
892 return ! *$self->{Closed} ;
893}
894
895sub autoflush
896{
897 my $self = shift ;
898 return defined *$self->{FH}
899 ? *$self->{FH}->autoflush(@_)
900 : undef ;
901}
902
903sub input_line_number
904{
905 return undef ;
906}
907
908
909sub _notAvailable
910
# spent 60µs within IO::Compress::Base::_notAvailable which was called 6 times, avg 10µs/call: # once (20µs+0) at line 915 # once (9µs+0) at line 916 # once (8µs+0) at line 918 # once (8µs+0) at line 919 # once (8µs+0) at line 917 # once (7µs+0) at line 920
{
911122.7e-52.3e-6 my $name = shift ;
912 return sub { croak "$name Not Available: File opened only for output" ; } ;
913}
914
91511.6e-51.6e-5*read = _notAvailable('read');
# spent 20µs making 1 call to IO::Compress::Base::_notAvailable
91616.0e-66.0e-6*READ = _notAvailable('read');
# spent 9µs making 1 call to IO::Compress::Base::_notAvailable
91716.0e-66.0e-6*readline = _notAvailable('readline');
# spent 8µs making 1 call to IO::Compress::Base::_notAvailable
91816.0e-66.0e-6*READLINE = _notAvailable('readline');
# spent 8µs making 1 call to IO::Compress::Base::_notAvailable
91916.0e-66.0e-6*getc = _notAvailable('getc');
# spent 8µs making 1 call to IO::Compress::Base::_notAvailable
92016.0e-66.0e-6*GETC = _notAvailable('getc');
# spent 7µs making 1 call to IO::Compress::Base::_notAvailable
921
92211.0e-61.0e-6*FILENO = \&fileno;
92311.0e-61.0e-6*PRINT = \&print;
92411.0e-61.0e-6*PRINTF = \&printf;
925100*WRITE = \&syswrite;
92611.0e-61.0e-6*write = \&syswrite;
92711.0e-61.0e-6*SEEK = \&seek;
92811.0e-61.0e-6*TELL = \&tell;
92911.0e-61.0e-6*EOF = \&eof;
93011.0e-61.0e-6*CLOSE = \&close;
93111.0e-61.0e-6*BINMODE = \&binmode;
932
933#*sysread = \&_notAvailable;
934#*syswrite = \&_write;
935
93611.8e-51.8e-51;
937
938__END__
939
940=head1 NAME
941
942
943IO::Compress::Base - Base Class for IO::Compress modules
944
945
946=head1 SYNOPSIS
947
948 use IO::Compress::Base ;
949
950=head1 DESCRIPTION
951
952
953This module is not intended for direct use in application code. Its sole
954purpose if to to be sub-classed by IO::Compress modules.
955
956
957
958
959=head1 SEE ALSO
960
961L<Compress::Zlib>, L<IO::Compress::Gzip>, L<IO::Uncompress::Gunzip>, L<IO::Compress::Deflate>, L<IO::Uncompress::Inflate>, L<IO::Compress::RawDeflate>, L<IO::Uncompress::RawInflate>, L<IO::Compress::Bzip2>, L<IO::Uncompress::Bunzip2>, L<IO::Compress::Lzop>, L<IO::Uncompress::UnLzop>, L<IO::Compress::Lzf>, L<IO::Uncompress::UnLzf>, L<IO::Uncompress::AnyInflate>, L<IO::Uncompress::AnyUncompress>
962
963L<Compress::Zlib::FAQ|Compress::Zlib::FAQ>
964
965L<File::GlobMapper|File::GlobMapper>, L<Archive::Zip|Archive::Zip>,
966L<Archive::Tar|Archive::Tar>,
967L<IO::Zlib|IO::Zlib>
968
969
970
971
972
973=head1 AUTHOR
974
975This module was written by Paul Marquess, F<pmqs@cpan.org>.
976
977
978
979=head1 MODIFICATION HISTORY
980
981See the Changes file.
982
983=head1 COPYRIGHT AND LICENSE
984
985Copyright (c) 2005-2007 Paul Marquess. All rights reserved.
986
987This program is free software; you can redistribute it and/or
988modify it under the same terms as Perl itself.
989
990

Report produced by the NYTProf 2.07 Perl profiler, developed by Tim Bunce and Adam Kaplan.