2 package IO::Compress::Gzip ;
11 use IO::Compress::RawDeflate 2.003 ;
13 use Compress::Raw::Zlib 2.003 ;
14 use IO::Compress::Base::Common 2.003 qw(:Status :Parse createSelfTiedObject);
15 use IO::Compress::Gzip::Constants 2.003 ;
16 use IO::Compress::Zlib::Extra 2.003 ;
20 if (defined &utf8::downgrade )
21 { *noUTF8 = \&utf8::downgrade }
28 our ($VERSION, @ISA, @EXPORT_OK, %EXPORT_TAGS, $GzipError);
33 @ISA = qw(Exporter IO::Compress::RawDeflate);
34 @EXPORT_OK = qw( $GzipError gzip ) ;
35 %EXPORT_TAGS = %IO::Compress::RawDeflate::DEFLATE_CONSTANTS ;
36 push @{ $EXPORT_TAGS{all} }, @EXPORT_OK ;
37 Exporter::export_ok_tags('all');
43 my $obj = createSelfTiedObject($class, \$GzipError);
45 $obj->_create(undef, @_);
51 my $obj = createSelfTiedObject(undef, \$GzipError);
52 return $obj->_def(@_);
58 # #return GZIP_MINIMUM_HEADER ;
59 # return $self->mkHeader(*$self->{Got});
68 $self->getZlibParams(),
71 'Minimal' => [0, 1, Parse_boolean, 0],
72 'Comment' => [0, 1, Parse_any, undef],
73 'Name' => [0, 1, Parse_any, undef],
74 'Time' => [0, 1, Parse_any, undef],
75 'TextFlag' => [0, 1, Parse_boolean, 0],
76 'HeaderCRC' => [0, 1, Parse_boolean, 0],
77 'OS_Code' => [0, 1, Parse_unsigned, $Compress::Raw::Zlib::gzip_os_code],
78 'ExtraField'=> [0, 1, Parse_any, undef],
79 'ExtraFlags'=> [0, 1, Parse_any, undef],
90 # gzip always needs crc32
91 $got->value('CRC32' => 1);
94 if $got->value('Merge') ;
96 my $strict = $got->value('Strict') ;
100 if (! $got->parsed('Time') ) {
101 # Modification time defaults to now.
102 $got->value('Time' => time) ;
105 # Check that the Name & Comment don't have embedded NULLs
106 # Also check that they only contain ISO 8859-1 chars.
107 if ($got->parsed('Name') && defined $got->value('Name')) {
108 my $name = $got->value('Name');
110 return $self->saveErrorString(undef, "Null Character found in Name",
112 if $strict && $name =~ /\x00/ ;
114 return $self->saveErrorString(undef, "Non ISO 8859-1 Character found in Name",
116 if $strict && $name =~ /$GZIP_FNAME_INVALID_CHAR_RE/o ;
119 if ($got->parsed('Comment') && defined $got->value('Comment')) {
120 my $comment = $got->value('Comment');
122 return $self->saveErrorString(undef, "Null Character found in Comment",
124 if $strict && $comment =~ /\x00/ ;
126 return $self->saveErrorString(undef, "Non ISO 8859-1 Character found in Comment",
128 if $strict && $comment =~ /$GZIP_FCOMMENT_INVALID_CHAR_RE/o;
131 if ($got->parsed('OS_Code') ) {
132 my $value = $got->value('OS_Code');
134 return $self->saveErrorString(undef, "OS_Code must be between 0 and 255, got '$value'")
135 if $value < 0 || $value > 255 ;
139 # gzip only supports Deflate at present
140 $got->value('Method' => Z_DEFLATED) ;
142 if ( ! $got->parsed('ExtraFlags')) {
143 $got->value('ExtraFlags' => 2)
144 if $got->value('Level') == Z_BEST_SPEED ;
145 $got->value('ExtraFlags' => 4)
146 if $got->value('Level') == Z_BEST_COMPRESSION ;
149 my $data = $got->value('ExtraField') ;
151 my $bad = IO::Compress::Zlib::Extra::parseExtraField($data, $strict, 1) ;
152 return $self->saveErrorString(undef, "Error with ExtraField Parameter: $bad", Z_DATA_ERROR)
155 $got->value('ExtraField', $data) ;
165 return pack("V V", *$self->{Compress}->crc32(),
166 *$self->{UnCompSize}->get32bit());
171 return ('IO::Uncompress::Gunzip',
172 \$IO::Uncompress::Gunzip::GunzipError);
179 my $filename = shift ;
181 my $defaultTime = (stat($filename))[9] ;
183 $params->value('Name' => $filename)
184 if ! $params->parsed('Name') ;
186 $params->value('Time' => $defaultTime)
187 if ! $params->parsed('Time') ;
196 # stort-circuit if a minimal header is requested.
197 return GZIP_MINIMUM_HEADER if $param->value('Minimal') ;
200 my $method = $param->valueOrDefault('Method', GZIP_CM_DEFLATED) ;
203 my $flags = GZIP_FLG_DEFAULT ;
204 $flags |= GZIP_FLG_FTEXT if $param->value('TextFlag') ;
205 $flags |= GZIP_FLG_FHCRC if $param->value('HeaderCRC') ;
206 $flags |= GZIP_FLG_FEXTRA if $param->wantValue('ExtraField') ;
207 $flags |= GZIP_FLG_FNAME if $param->wantValue('Name') ;
208 $flags |= GZIP_FLG_FCOMMENT if $param->wantValue('Comment') ;
211 my $time = $param->valueOrDefault('Time', GZIP_MTIME_DEFAULT) ;
214 my $extra_flags = $param->valueOrDefault('ExtraFlags', GZIP_XFL_DEFAULT);
217 my $os_code = $param->valueOrDefault('OS_Code', GZIP_OS_DEFAULT) ;
220 my $out = pack("C4 V C C",
223 $method, # Compression Method
225 $time, # Modification Time
226 $extra_flags, # Extra Flags
227 $os_code, # Operating System Code
231 if ($flags & GZIP_FLG_FEXTRA) {
232 my $extra = $param->value('ExtraField') ;
233 $out .= pack("v", length $extra) . $extra ;
237 if ($flags & GZIP_FLG_FNAME) {
238 my $name .= $param->value('Name') ;
239 $name =~ s/\x00.*$//;
241 # Terminate the filename with NULL unless it already is
242 $out .= GZIP_NULL_BYTE
244 substr($name, 1, -1) ne GZIP_NULL_BYTE ;
248 if ($flags & GZIP_FLG_FCOMMENT) {
249 my $comment .= $param->value('Comment') ;
250 $comment =~ s/\x00.*$//;
252 # Terminate the comment with NULL unless it already is
253 $out .= GZIP_NULL_BYTE
254 if ! length $comment or
255 substr($comment, 1, -1) ne GZIP_NULL_BYTE;
259 $out .= pack("v", crc32($out) & 0x00FF ) if $param->value('HeaderCRC') ;
279 IO::Compress::Gzip - Write RFC 1952 files/buffers
285 use IO::Compress::Gzip qw(gzip $GzipError) ;
288 my $status = gzip $input => $output [,OPTS]
289 or die "gzip failed: $GzipError\n";
291 my $z = new IO::Compress::Gzip $output [,OPTS]
292 or die "gzip failed: $GzipError\n";
295 $z->printf($format, $string);
297 $z->syswrite($string [, $length, $offset]);
301 $z->seek($position, $whence);
306 $z->input_line_number();
307 $z->newStream( [OPTS] );
318 printf $z $format, $string;
321 seek $z, $position, $whence
330 This module provides a Perl interface that allows writing compressed
331 data to files or buffer as defined in RFC 1952.
337 All the gzip headers defined in RFC 1952 can be created using
346 For reading RFC 1952 files/buffers, see the companion module
347 L<IO::Uncompress::Gunzip|IO::Uncompress::Gunzip>.
350 =head1 Functional Interface
352 A top-level function, C<gzip>, is provided to carry out
353 "one-shot" compression between buffers and/or files. For finer
354 control over the compression process, see the L</"OO Interface">
357 use IO::Compress::Gzip qw(gzip $GzipError) ;
359 gzip $input => $output [,OPTS]
360 or die "gzip failed: $GzipError\n";
364 The functional interface needs Perl5.005 or better.
367 =head2 gzip $input => $output [, OPTS]
370 C<gzip> expects at least two parameters, C<$input> and C<$output>.
372 =head3 The C<$input> parameter
374 The parameter, C<$input>, is used to define the source of
375 the uncompressed data.
377 It can take one of the following forms:
383 If the C<$input> parameter is a simple scalar, it is assumed to be a
384 filename. This file will be opened for reading and the input data
385 will be read from it.
389 If the C<$input> parameter is a filehandle, the input data will be
391 The string '-' can be used as an alias for standard input.
393 =item A scalar reference
395 If C<$input> is a scalar reference, the input data will be read
398 =item An array reference
400 If C<$input> is an array reference, each element in the array must be a
403 The input data will be read from each file in turn.
405 The complete array will be walked to ensure that it only
406 contains valid filenames before any data is compressed.
410 =item An Input FileGlob string
412 If C<$input> is a string that is delimited by the characters "<" and ">"
413 C<gzip> will assume that it is an I<input fileglob string>. The
414 input is the list of files that match the fileglob.
416 If the fileglob does not match any files ...
418 See L<File::GlobMapper|File::GlobMapper> for more details.
423 If the C<$input> parameter is any other type, C<undef> will be returned.
426 In addition, if C<$input> is a simple filename, the default values for
427 the C<Name> and C<Time> options will be sourced from that file.
429 If you do not want to use these defaults they can be overridden by
430 explicitly setting the C<Name> and C<Time> options or by setting the
431 C<Minimal> parameter.
435 =head3 The C<$output> parameter
437 The parameter C<$output> is used to control the destination of the
438 compressed data. This parameter can take one of these forms.
444 If the C<$output> parameter is a simple scalar, it is assumed to be a
445 filename. This file will be opened for writing and the compressed
446 data will be written to it.
450 If the C<$output> parameter is a filehandle, the compressed data
451 will be written to it.
452 The string '-' can be used as an alias for standard output.
455 =item A scalar reference
457 If C<$output> is a scalar reference, the compressed data will be
458 stored in C<$$output>.
462 =item An Array Reference
464 If C<$output> is an array reference, the compressed data will be
465 pushed onto the array.
467 =item An Output FileGlob
469 If C<$output> is a string that is delimited by the characters "<" and ">"
470 C<gzip> will assume that it is an I<output fileglob string>. The
471 output is the list of files that match the fileglob.
473 When C<$output> is an fileglob string, C<$input> must also be a fileglob
474 string. Anything else is an error.
478 If the C<$output> parameter is any other type, C<undef> will be returned.
486 When C<$input> maps to multiple files/buffers and C<$output> is a single
487 file/buffer the input files/buffers will be stored
488 in C<$output> as a concatenated series of compressed data streams.
495 =head2 Optional Parameters
497 Unless specified below, the optional parameters for C<gzip>,
498 C<OPTS>, are the same as those used with the OO interface defined in the
499 L</"Constructor Options"> section below.
503 =item C<< AutoClose => 0|1 >>
505 This option applies to any input or output data streams to
506 C<gzip> that are filehandles.
508 If C<AutoClose> is specified, and the value is true, it will result in all
509 input and/or output filehandles being closed once C<gzip> has
512 This parameter defaults to 0.
515 =item C<< BinModeIn => 0|1 >>
517 When reading from a file or filehandle, set C<binmode> before reading.
525 =item C<< Append => 0|1 >>
537 To read the contents of the file C<file1.txt> and write the compressed
538 data to the file C<file1.txt.gz>.
542 use IO::Compress::Gzip qw(gzip $GzipError) ;
544 my $input = "file1.txt";
545 gzip $input => "$input.gz"
546 or die "gzip failed: $GzipError\n";
549 To read from an existing Perl filehandle, C<$input>, and write the
550 compressed data to a buffer, C<$buffer>.
554 use IO::Compress::Gzip qw(gzip $GzipError) ;
557 my $input = new IO::File "<file1.txt"
558 or die "Cannot open 'file1.txt': $!\n" ;
560 gzip $input => \$buffer
561 or die "gzip failed: $GzipError\n";
563 To compress all files in the directory "/my/home" that match "*.txt"
564 and store the compressed data in the same directory
568 use IO::Compress::Gzip qw(gzip $GzipError) ;
570 gzip '</my/home/*.txt>' => '<*.gz>'
571 or die "gzip failed: $GzipError\n";
573 and if you want to compress each file one at a time, this will do the trick
577 use IO::Compress::Gzip qw(gzip $GzipError) ;
579 for my $input ( glob "/my/home/*.txt" )
581 my $output = "$input.gz" ;
582 gzip $input => $output
583 or die "Error compressing '$input': $GzipError\n";
591 The format of the constructor for C<IO::Compress::Gzip> is shown below
593 my $z = new IO::Compress::Gzip $output [,OPTS]
594 or die "IO::Compress::Gzip failed: $GzipError\n";
596 It returns an C<IO::Compress::Gzip> object on success and undef on failure.
597 The variable C<$GzipError> will contain an error message on failure.
599 If you are running Perl 5.005 or better the object, C<$z>, returned from
600 IO::Compress::Gzip can be used exactly like an L<IO::File|IO::File> filehandle.
601 This means that all normal output file operations can be carried out
603 For example, to write to a compressed file/buffer you can use either of
606 $z->print("hello world\n");
607 print $z "hello world\n";
609 The mandatory parameter C<$output> is used to control the destination
610 of the compressed data. This parameter can take one of these forms.
616 If the C<$output> parameter is a simple scalar, it is assumed to be a
617 filename. This file will be opened for writing and the compressed data
618 will be written to it.
622 If the C<$output> parameter is a filehandle, the compressed data will be
624 The string '-' can be used as an alias for standard output.
627 =item A scalar reference
629 If C<$output> is a scalar reference, the compressed data will be stored
634 If the C<$output> parameter is any other type, C<IO::Compress::Gzip>::new will
637 =head2 Constructor Options
639 C<OPTS> is any combination of the following options:
643 =item C<< AutoClose => 0|1 >>
645 This option is only valid when the C<$output> parameter is a filehandle. If
646 specified, and the value is true, it will result in the C<$output> being
647 closed once either the C<close> method is called or the C<IO::Compress::Gzip>
650 This parameter defaults to 0.
652 =item C<< Append => 0|1 >>
654 Opens C<$output> in append mode.
656 The behaviour of this option is dependent on the type of C<$output>.
662 If C<$output> is a buffer and C<Append> is enabled, all compressed data
663 will be append to the end if C<$output>. Otherwise C<$output> will be
664 cleared before any data is written to it.
668 If C<$output> is a filename and C<Append> is enabled, the file will be
669 opened in append mode. Otherwise the contents of the file, if any, will be
670 truncated before any compressed data is written to it.
674 If C<$output> is a filehandle, the file pointer will be positioned to the
675 end of the file via a call to C<seek> before any compressed data is written
676 to it. Otherwise the file pointer will not be moved.
680 This parameter defaults to 0.
686 =item C<< Merge => 0|1 >>
688 This option is used to compress input data and append it to an existing
689 compressed data stream in C<$output>. The end result is a single compressed
690 data stream stored in C<$output>.
694 It is a fatal error to attempt to use this option when C<$output> is not an
695 RFC 1952 data stream.
699 There are a number of other limitations with the C<Merge> option:
705 This module needs to have been built with zlib 1.2.1 or better to work. A
706 fatal error will be thrown if C<Merge> is used with an older version of
711 If C<$output> is a file or a filehandle, it must be seekable.
716 This parameter defaults to 0.
722 Defines the compression level used by zlib. The value should either be
723 a number between 0 and 9 (0 means no compression and 9 is maximum
724 compression), or one of the symbolic constants defined below.
729 Z_DEFAULT_COMPRESSION
731 The default is Z_DEFAULT_COMPRESSION.
733 Note, these constants are not imported by C<IO::Compress::Gzip> by default.
735 use IO::Compress::Gzip qw(:strategy);
736 use IO::Compress::Gzip qw(:constants);
737 use IO::Compress::Gzip qw(:all);
741 Defines the strategy used to tune the compression. Use one of the symbolic
742 constants defined below.
750 The default is Z_DEFAULT_STRATEGY.
757 =item C<< Minimal => 0|1 >>
759 If specified, this option will force the creation of the smallest possible
760 compliant gzip header (which is exactly 10 bytes long) as defined in
763 See the section titled "Compliance" in RFC 1952 for a definition
764 of the values used for the fields in the gzip header.
766 All other parameters that control the content of the gzip header will
767 be ignored if this parameter is set to 1.
769 This parameter defaults to 0.
771 =item C<< Comment => $comment >>
773 Stores the contents of C<$comment> in the COMMENT field in
775 By default, no comment field is written to the gzip file.
777 If the C<-Strict> option is enabled, the comment can only consist of ISO
778 8859-1 characters plus line feed.
780 If the C<-Strict> option is disabled, the comment field can contain any
781 character except NULL. If any null characters are present, the field
782 will be truncated at the first NULL.
784 =item C<< Name => $string >>
786 Stores the contents of C<$string> in the gzip NAME header field. If
787 C<Name> is not specified, no gzip NAME field will be created.
789 If the C<-Strict> option is enabled, C<$string> can only consist of ISO
792 If C<-Strict> is disabled, then C<$string> can contain any character
793 except NULL. If any null characters are present, the field will be
794 truncated at the first NULL.
796 =item C<< Time => $number >>
798 Sets the MTIME field in the gzip header to $number.
800 This field defaults to the time the C<IO::Compress::Gzip> object was created
801 if this option is not specified.
803 =item C<< TextFlag => 0|1 >>
805 This parameter controls the setting of the FLG.FTEXT bit in the gzip
806 header. It is used to signal that the data stored in the gzip file/buffer
811 =item C<< HeaderCRC => 0|1 >>
813 When true this parameter will set the FLG.FHCRC bit to 1 in the gzip header
814 and set the CRC16 header field to the CRC of the complete gzip header
815 except the CRC16 field itself.
817 B<Note> that gzip files created with the C<HeaderCRC> flag set to 1 cannot
818 be read by most, if not all, of the the standard gunzip utilities, most
819 notably gzip version 1.2.4. You should therefore avoid using this option if
820 you want to maximize the portability of your gzip files.
822 This parameter defaults to 0.
824 =item C<< OS_Code => $value >>
826 Stores C<$value> in the gzip OS header field. A number between 0 and 255 is
829 If not specified, this parameter defaults to the OS code of the Operating
830 System this module was built on. The value 3 is used as a catch-all for all
831 Unix variants and unknown Operating Systems.
833 =item C<< ExtraField => $data >>
835 This parameter allows additional metadata to be stored in the ExtraField in
836 the gzip header. An RFC 1952 compliant ExtraField consists of zero or more
837 subfields. Each subfield consists of a two byte header followed by the
840 The list of subfields can be supplied in any of the following formats
842 -ExtraField => [$id1, $data1,
846 -ExtraField => [ [$id1 => $data1],
850 -ExtraField => { $id1 => $data1,
855 Where C<$id1>, C<$id2> are two byte subfield ID's. The second byte of
856 the ID cannot be 0, unless the C<Strict> option has been disabled.
858 If you use the hash syntax, you have no control over the order in which
859 the ExtraSubFields are stored, plus you cannot have SubFields with
862 Alternatively the list of subfields can by supplied as a scalar, thus
864 -ExtraField => $rawdata
866 If you use the raw format, and the C<Strict> option is enabled,
867 C<IO::Compress::Gzip> will check that C<$rawdata> consists of zero or more
868 conformant sub-fields. When C<Strict> is disabled, C<$rawdata> can
869 consist of any arbitrary byte stream.
871 The maximum size of the Extra Field 65535 bytes.
873 =item C<< ExtraFlags => $value >>
875 Sets the XFL byte in the gzip header to C<$value>.
877 If this option is not present, the value stored in XFL field will be
878 determined by the setting of the C<Level> option.
880 If C<< Level => Z_BEST_SPEED >> has been specified then XFL is set to 2.
881 If C<< Level => Z_BEST_COMPRESSION >> has been specified then XFL is set to 4.
882 Otherwise XFL is set to 0.
886 =item C<< Strict => 0|1 >>
890 C<Strict> will optionally police the values supplied with other options
891 to ensure they are compliant with RFC1952.
893 This option is enabled by default.
895 If C<Strict> is enabled the following behaviour will be policed:
901 The value supplied with the C<Name> option can only contain ISO 8859-1
906 The value supplied with the C<Comment> option can only contain ISO 8859-1
907 characters plus line-feed.
911 The values supplied with the C<-Name> and C<-Comment> options cannot
912 contain multiple embedded nulls.
916 If an C<ExtraField> option is specified and it is a simple scalar,
917 it must conform to the sub-field structure as defined in RFC 1952.
921 If an C<ExtraField> option is specified the second byte of the ID will be
922 checked in each subfield to ensure that it does not contain the reserved
927 When C<Strict> is disabled the following behaviour will be policed:
933 The value supplied with C<-Name> option can contain
934 any character except NULL.
938 The value supplied with C<-Comment> option can contain any character
943 The values supplied with the C<-Name> and C<-Comment> options can contain
944 multiple embedded nulls. The string written to the gzip header will
945 consist of the characters up to, but not including, the first embedded
950 If an C<ExtraField> option is specified and it is a simple scalar, the
951 structure will not be checked. The only error is if the length is too big.
955 The ID header in an C<ExtraField> sub-field can consist of any two bytes.
976 Compresses and outputs the contents of the C<$data> parameter. This
977 has the same behaviour as the C<print> built-in.
979 Returns true if successful.
985 $z->printf($format, $data)
986 printf $z $format, $data
988 Compresses and outputs the contents of the C<$data> parameter.
990 Returns true if successful.
997 $z->syswrite $data, $length
998 $z->syswrite $data, $length, $offset
1000 Compresses and outputs the contents of the C<$data> parameter.
1002 Returns the number of uncompressed bytes written, or C<undef> if
1010 $z->write $data, $length
1011 $z->write $data, $length, $offset
1013 Compresses and outputs the contents of the C<$data> parameter.
1015 Returns the number of uncompressed bytes written, or C<undef> if
1024 $z->flush($flush_type);
1027 Flushes any pending compressed data to the output file/buffer.
1030 This method takes an optional parameter, C<$flush_type>, that controls
1031 how the flushing will be carried out. By default the C<$flush_type>
1032 used is C<Z_FINISH>. Other valid values for C<$flush_type> are
1033 C<Z_NO_FLUSH>, C<Z_SYNC_FLUSH>, C<Z_FULL_FLUSH> and C<Z_BLOCK>. It is
1034 strongly recommended that you only set the C<flush_type> parameter if
1035 you fully understand the implications of what it does - overuse of C<flush>
1036 can seriously degrade the level of compression achieved. See the C<zlib>
1037 documentation for details.
1040 Returns true on success.
1050 Returns the uncompressed file offset.
1061 Returns true if the C<close> method has been called.
1067 $z->seek($position, $whence);
1068 seek($z, $position, $whence);
1073 Provides a sub-set of the C<seek> functionality, with the restriction
1074 that it is only legal to seek forward in the output file/buffer.
1075 It is a fatal error to attempt to seek backward.
1077 Empty parts of the file/buffer will have NULL (0x00) bytes written to them.
1081 The C<$whence> parameter takes one the usual values, namely SEEK_SET,
1082 SEEK_CUR or SEEK_END.
1084 Returns 1 on success, 0 on failure.
1093 This is a noop provided for completeness.
1099 Returns true if the object currently refers to a opened file/buffer.
1103 my $prev = $z->autoflush()
1104 my $prev = $z->autoflush(EXPR)
1106 If the C<$z> object is associated with a file or a filehandle, this method
1107 returns the current autoflush setting for the underlying filehandle. If
1108 C<EXPR> is present, and is non-zero, it will enable flushing after every
1109 write/print operation.
1111 If C<$z> is associated with a buffer, this method has no effect and always
1114 B<Note> that the special variable C<$|> B<cannot> be used to set or
1115 retrieve the autoflush setting.
1117 =head2 input_line_number
1119 $z->input_line_number()
1120 $z->input_line_number(EXPR)
1123 This method always returns C<undef> when compressing.
1132 If the C<$z> object is associated with a file or a filehandle, this method
1133 will return the underlying file descriptor.
1135 If the C<$z> object is is associated with a buffer, this method will
1145 Flushes any pending compressed data and then closes the output file/buffer.
1149 For most versions of Perl this method will be automatically invoked if
1150 the IO::Compress::Gzip object is destroyed (either explicitly or by the
1151 variable with the reference to the object going out of scope). The
1152 exceptions are Perl versions 5.005 through 5.00504 and 5.8.0. In
1153 these cases, the C<close> method will be called automatically, but
1154 not until global destruction of all live objects when the program is
1157 Therefore, if you want your scripts to be able to run on all versions
1158 of Perl, you should call C<close> explicitly and not rely on automatic
1161 Returns true on success, otherwise 0.
1163 If the C<AutoClose> option has been enabled when the IO::Compress::Gzip
1164 object was created, and the object is associated with a file, the
1165 underlying file will also be closed.
1170 =head2 newStream([OPTS])
1174 $z->newStream( [OPTS] )
1176 Closes the current compressed data stream and starts a new one.
1178 OPTS consists of any of the the options that are available when creating
1181 See the L</"Constructor Options"> section for more details.
1184 =head2 deflateParams
1196 A number of symbolic constants are required by some methods in
1197 C<IO::Compress::Gzip>. None are imported by default.
1206 Imports C<gzip>, C<$GzipError> and all symbolic
1207 constants that can be used by C<IO::Compress::Gzip>. Same as doing this
1209 use IO::Compress::Gzip qw(gzip $GzipError :constants) ;
1213 Import all symbolic constants. Same as doing this
1216 use IO::Compress::Gzip qw(:flush :level :strategy) ;
1221 These symbolic constants are used by the C<flush> method.
1232 These symbolic constants are used by the C<Level> option in the constructor.
1237 Z_DEFAULT_COMPRESSION
1242 These symbolic constants are used by the C<Strategy> option in the constructor.
1273 L<Compress::Zlib>, 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>
1275 L<Compress::Zlib::FAQ|Compress::Zlib::FAQ>
1277 L<File::GlobMapper|File::GlobMapper>, L<Archive::Zip|Archive::Zip>,
1278 L<Archive::Tar|Archive::Tar>,
1279 L<IO::Zlib|IO::Zlib>
1282 For RFC 1950, 1951 and 1952 see
1283 F<http://www.faqs.org/rfcs/rfc1950.html>,
1284 F<http://www.faqs.org/rfcs/rfc1951.html> and
1285 F<http://www.faqs.org/rfcs/rfc1952.html>
1287 The I<zlib> compression library was written by Jean-loup Gailly
1288 F<gzip@prep.ai.mit.edu> and Mark Adler F<madler@alumni.caltech.edu>.
1290 The primary site for the I<zlib> compression library is
1291 F<http://www.zlib.org>.
1293 The primary site for gzip is F<http://www.gzip.org>.
1300 This module was written by Paul Marquess, F<pmqs@cpan.org>.
1304 =head1 MODIFICATION HISTORY
1306 See the Changes file.
1308 =head1 COPYRIGHT AND LICENSE
1310 Copyright (c) 2005-2007 Paul Marquess. All rights reserved.
1312 This program is free software; you can redistribute it and/or
1313 modify it under the same terms as Perl itself.