4b8095343a8a4d232cb009f8aa663e9dc9009afe
[perl.git] / cpan / IO-Compress / lib / IO / Compress / Deflate.pm
1 package IO::Compress::Deflate ;
2
3 require 5.006 ;
4
5 use strict ;
6 use warnings;
7 use bytes;
8
9 require Exporter ;
10
11 use IO::Compress::RawDeflate 2.068 ();
12 use IO::Compress::Adapter::Deflate 2.068 ;
13
14 use IO::Compress::Zlib::Constants 2.068 ;
15 use IO::Compress::Base::Common  2.068 qw();
16
17
18 our ($VERSION, @ISA, @EXPORT_OK, %EXPORT_TAGS, %DEFLATE_CONSTANTS, $DeflateError);
19
20 $VERSION = '2.068';
21 $DeflateError = '';
22
23 @ISA    = qw(Exporter IO::Compress::RawDeflate);
24 @EXPORT_OK = qw( $DeflateError deflate ) ;
25 %EXPORT_TAGS = %IO::Compress::RawDeflate::DEFLATE_CONSTANTS ;
26
27 push @{ $EXPORT_TAGS{all} }, @EXPORT_OK ;
28 Exporter::export_ok_tags('all');
29
30
31 sub new
32 {
33     my $class = shift ;
34
35     my $obj = IO::Compress::Base::Common::createSelfTiedObject($class, \$DeflateError);
36     return $obj->_create(undef, @_);
37 }
38
39 sub deflate
40 {
41     my $obj = IO::Compress::Base::Common::createSelfTiedObject(undef, \$DeflateError);
42     return $obj->_def(@_);
43 }
44
45
46 sub bitmask($$$$)
47 {
48     my $into  = shift ;
49     my $value  = shift ;
50     my $offset = shift ;
51     my $mask   = shift ;
52
53     return $into | (($value & $mask) << $offset ) ;
54 }
55
56 sub mkDeflateHdr($$$;$)
57 {
58     my $method = shift ;
59     my $cinfo  = shift;
60     my $level  = shift;
61     my $fdict_adler = shift  ;
62
63     my $cmf = 0;
64     my $flg = 0;
65     my $fdict = 0;
66     $fdict = 1 if defined $fdict_adler;
67
68     $cmf = bitmask($cmf, $method, ZLIB_CMF_CM_OFFSET,    ZLIB_CMF_CM_BITS);
69     $cmf = bitmask($cmf, $cinfo,  ZLIB_CMF_CINFO_OFFSET, ZLIB_CMF_CINFO_BITS);
70
71     $flg = bitmask($flg, $fdict,  ZLIB_FLG_FDICT_OFFSET, ZLIB_FLG_FDICT_BITS);
72     $flg = bitmask($flg, $level,  ZLIB_FLG_LEVEL_OFFSET, ZLIB_FLG_LEVEL_BITS);
73
74     my $fcheck = 31 - ($cmf * 256 + $flg) % 31 ;
75     $flg = bitmask($flg, $fcheck, ZLIB_FLG_FCHECK_OFFSET, ZLIB_FLG_FCHECK_BITS);
76
77     my $hdr =  pack("CC", $cmf, $flg) ;
78     $hdr .= pack("N", $fdict_adler) if $fdict ;
79
80     return $hdr;
81 }
82
83 sub mkHeader 
84 {
85     my $self = shift ;
86     my $param = shift ;
87
88     my $level = $param->getValue('level');
89     my $strategy = $param->getValue('strategy');
90
91     my $lflag ;
92     $level = 6 
93         if $level == Z_DEFAULT_COMPRESSION ;
94
95     if (ZLIB_VERNUM >= 0x1210)
96     {
97         if ($strategy >= Z_HUFFMAN_ONLY || $level < 2)
98          {  $lflag = ZLIB_FLG_LEVEL_FASTEST }
99         elsif ($level < 6)
100          {  $lflag = ZLIB_FLG_LEVEL_FAST }
101         elsif ($level == 6)
102          {  $lflag = ZLIB_FLG_LEVEL_DEFAULT }
103         else
104          {  $lflag = ZLIB_FLG_LEVEL_SLOWEST }
105     }
106     else
107     {
108         $lflag = ($level - 1) >> 1 ;
109         $lflag = 3 if $lflag > 3 ;
110     }
111
112      #my $wbits = (MAX_WBITS - 8) << 4 ;
113     my $wbits = 7;
114     mkDeflateHdr(ZLIB_CMF_CM_DEFLATED, $wbits, $lflag);
115 }
116
117 sub ckParams
118 {
119     my $self = shift ;
120     my $got = shift;
121     
122     $got->setValue('adler32' => 1);
123     return 1 ;
124 }
125
126
127 sub mkTrailer
128 {
129     my $self = shift ;
130     return pack("N", *$self->{Compress}->adler32()) ;
131 }
132
133 sub mkFinalTrailer
134 {
135     return '';
136 }
137
138 #sub newHeader
139 #{
140 #    my $self = shift ;
141 #    return *$self->{Header};
142 #}
143
144 sub getExtraParams
145 {
146     my $self = shift ;
147     return $self->getZlibParams(),
148 }
149
150 sub getInverseClass
151 {
152     return ('IO::Uncompress::Inflate',
153                 \$IO::Uncompress::Inflate::InflateError);
154 }
155
156 sub getFileInfo
157 {
158     my $self = shift ;
159     my $params = shift;
160     my $file = shift ;
161     
162 }
163
164
165
166 1;
167
168 __END__
169
170 =head1 NAME
171
172 IO::Compress::Deflate - Write RFC 1950 files/buffers
173  
174  
175
176 =head1 SYNOPSIS
177
178     use IO::Compress::Deflate qw(deflate $DeflateError) ;
179
180     my $status = deflate $input => $output [,OPTS] 
181         or die "deflate failed: $DeflateError\n";
182
183     my $z = new IO::Compress::Deflate $output [,OPTS]
184         or die "deflate failed: $DeflateError\n";
185
186     $z->print($string);
187     $z->printf($format, $string);
188     $z->write($string);
189     $z->syswrite($string [, $length, $offset]);
190     $z->flush();
191     $z->tell();
192     $z->eof();
193     $z->seek($position, $whence);
194     $z->binmode();
195     $z->fileno();
196     $z->opened();
197     $z->autoflush();
198     $z->input_line_number();
199     $z->newStream( [OPTS] );
200     
201     $z->deflateParams();
202     
203     $z->close() ;
204
205     $DeflateError ;
206
207     # IO::File mode
208
209     print $z $string;
210     printf $z $format, $string;
211     tell $z
212     eof $z
213     seek $z, $position, $whence
214     binmode $z
215     fileno $z
216     close $z ;
217     
218
219 =head1 DESCRIPTION
220
221 This module provides a Perl interface that allows writing compressed
222 data to files or buffer as defined in RFC 1950.
223
224 For reading RFC 1950 files/buffers, see the companion module 
225 L<IO::Uncompress::Inflate|IO::Uncompress::Inflate>.
226
227 =head1 Functional Interface
228
229 A top-level function, C<deflate>, is provided to carry out
230 "one-shot" compression between buffers and/or files. For finer
231 control over the compression process, see the L</"OO Interface">
232 section.
233
234     use IO::Compress::Deflate qw(deflate $DeflateError) ;
235
236     deflate $input_filename_or_reference => $output_filename_or_reference [,OPTS] 
237         or die "deflate failed: $DeflateError\n";
238
239 The functional interface needs Perl5.005 or better.
240
241 =head2 deflate $input_filename_or_reference => $output_filename_or_reference [, OPTS]
242
243 C<deflate> expects at least two parameters,
244 C<$input_filename_or_reference> and C<$output_filename_or_reference>.
245
246 =head3 The C<$input_filename_or_reference> parameter
247
248 The parameter, C<$input_filename_or_reference>, is used to define the
249 source of the uncompressed data. 
250
251 It can take one of the following forms:
252
253 =over 5
254
255 =item A filename
256
257 If the <$input_filename_or_reference> parameter is a simple scalar, it is
258 assumed to be a filename. This file will be opened for reading and the
259 input data will be read from it.
260
261 =item A filehandle
262
263 If the C<$input_filename_or_reference> parameter is a filehandle, the input
264 data will be read from it.  The string '-' can be used as an alias for
265 standard input.
266
267 =item A scalar reference 
268
269 If C<$input_filename_or_reference> is a scalar reference, the input data
270 will be read from C<$$input_filename_or_reference>.
271
272 =item An array reference 
273
274 If C<$input_filename_or_reference> is an array reference, each element in
275 the array must be a filename.
276
277 The input data will be read from each file in turn. 
278
279 The complete array will be walked to ensure that it only
280 contains valid filenames before any data is compressed.
281
282 =item An Input FileGlob string
283
284 If C<$input_filename_or_reference> is a string that is delimited by the
285 characters "<" and ">" C<deflate> will assume that it is an 
286 I<input fileglob string>. The input is the list of files that match the 
287 fileglob.
288
289 See L<File::GlobMapper|File::GlobMapper> for more details.
290
291 =back
292
293 If the C<$input_filename_or_reference> parameter is any other type,
294 C<undef> will be returned.
295
296 =head3 The C<$output_filename_or_reference> parameter
297
298 The parameter C<$output_filename_or_reference> is used to control the
299 destination of the compressed data. This parameter can take one of
300 these forms.
301
302 =over 5
303
304 =item A filename
305
306 If the C<$output_filename_or_reference> parameter is a simple scalar, it is
307 assumed to be a filename.  This file will be opened for writing and the 
308 compressed data will be written to it.
309
310 =item A filehandle
311
312 If the C<$output_filename_or_reference> parameter is a filehandle, the
313 compressed data will be written to it.  The string '-' can be used as
314 an alias for standard output.
315
316 =item A scalar reference 
317
318 If C<$output_filename_or_reference> is a scalar reference, the
319 compressed data will be stored in C<$$output_filename_or_reference>.
320
321 =item An Array Reference
322
323 If C<$output_filename_or_reference> is an array reference, 
324 the compressed data will be pushed onto the array.
325
326 =item An Output FileGlob
327
328 If C<$output_filename_or_reference> is a string that is delimited by the
329 characters "<" and ">" C<deflate> will assume that it is an
330 I<output fileglob string>. The output is the list of files that match the
331 fileglob.
332
333 When C<$output_filename_or_reference> is an fileglob string,
334 C<$input_filename_or_reference> must also be a fileglob string. Anything
335 else is an error.
336
337 See L<File::GlobMapper|File::GlobMapper> for more details.
338
339 =back
340
341 If the C<$output_filename_or_reference> parameter is any other type,
342 C<undef> will be returned.
343
344 =head2 Notes
345
346 When C<$input_filename_or_reference> maps to multiple files/buffers and
347 C<$output_filename_or_reference> is a single
348 file/buffer the input files/buffers will be stored
349 in C<$output_filename_or_reference> as a concatenated series of compressed data streams.
350
351 =head2 Optional Parameters
352
353 Unless specified below, the optional parameters for C<deflate>,
354 C<OPTS>, are the same as those used with the OO interface defined in the
355 L</"Constructor Options"> section below.
356
357 =over 5
358
359 =item C<< AutoClose => 0|1 >>
360
361 This option applies to any input or output data streams to 
362 C<deflate> that are filehandles.
363
364 If C<AutoClose> is specified, and the value is true, it will result in all
365 input and/or output filehandles being closed once C<deflate> has
366 completed.
367
368 This parameter defaults to 0.
369
370 =item C<< BinModeIn => 0|1 >>
371
372 When reading from a file or filehandle, set C<binmode> before reading.
373
374 Defaults to 0.
375
376 =item C<< Append => 0|1 >>
377
378 The behaviour of this option is dependent on the type of output data
379 stream.
380
381 =over 5
382
383 =item * A Buffer
384
385 If C<Append> is enabled, all compressed data will be append to the end of
386 the output buffer. Otherwise the output buffer will be cleared before any
387 compressed data is written to it.
388
389 =item * A Filename
390
391 If C<Append> is enabled, the file will be opened in append mode. Otherwise
392 the contents of the file, if any, will be truncated before any compressed
393 data is written to it.
394
395 =item * A Filehandle
396
397 If C<Append> is enabled, the filehandle will be positioned to the end of
398 the file via a call to C<seek> before any compressed data is
399 written to it.  Otherwise the file pointer will not be moved.
400
401 =back
402
403 When C<Append> is specified, and set to true, it will I<append> all compressed 
404 data to the output data stream.
405
406 So when the output is a filehandle it will carry out a seek to the eof
407 before writing any compressed data. If the output is a filename, it will be opened for
408 appending. If the output is a buffer, all compressed data will be
409 appended to the existing buffer.
410
411 Conversely when C<Append> is not specified, or it is present and is set to
412 false, it will operate as follows.
413
414 When the output is a filename, it will truncate the contents of the file
415 before writing any compressed data. If the output is a filehandle
416 its position will not be changed. If the output is a buffer, it will be
417 wiped before any compressed data is output.
418
419 Defaults to 0.
420
421 =back
422
423 =head2 Examples
424
425 To read the contents of the file C<file1.txt> and write the compressed
426 data to the file C<file1.txt.1950>.
427
428     use strict ;
429     use warnings ;
430     use IO::Compress::Deflate qw(deflate $DeflateError) ;
431
432     my $input = "file1.txt";
433     deflate $input => "$input.1950"
434         or die "deflate failed: $DeflateError\n";
435
436 To read from an existing Perl filehandle, C<$input>, and write the
437 compressed data to a buffer, C<$buffer>.
438
439     use strict ;
440     use warnings ;
441     use IO::Compress::Deflate qw(deflate $DeflateError) ;
442     use IO::File ;
443
444     my $input = new IO::File "<file1.txt"
445         or die "Cannot open 'file1.txt': $!\n" ;
446     my $buffer ;
447     deflate $input => \$buffer 
448         or die "deflate failed: $DeflateError\n";
449
450 To compress all files in the directory "/my/home" that match "*.txt"
451 and store the compressed data in the same directory
452
453     use strict ;
454     use warnings ;
455     use IO::Compress::Deflate qw(deflate $DeflateError) ;
456
457     deflate '</my/home/*.txt>' => '<*.1950>'
458         or die "deflate failed: $DeflateError\n";
459
460 and if you want to compress each file one at a time, this will do the trick
461
462     use strict ;
463     use warnings ;
464     use IO::Compress::Deflate qw(deflate $DeflateError) ;
465
466     for my $input ( glob "/my/home/*.txt" )
467     {
468         my $output = "$input.1950" ;
469         deflate $input => $output 
470             or die "Error compressing '$input': $DeflateError\n";
471     }
472
473 =head1 OO Interface
474
475 =head2 Constructor
476
477 The format of the constructor for C<IO::Compress::Deflate> is shown below
478
479     my $z = new IO::Compress::Deflate $output [,OPTS]
480         or die "IO::Compress::Deflate failed: $DeflateError\n";
481
482 It returns an C<IO::Compress::Deflate> object on success and undef on failure. 
483 The variable C<$DeflateError> will contain an error message on failure.
484
485 If you are running Perl 5.005 or better the object, C<$z>, returned from 
486 IO::Compress::Deflate can be used exactly like an L<IO::File|IO::File> filehandle. 
487 This means that all normal output file operations can be carried out 
488 with C<$z>. 
489 For example, to write to a compressed file/buffer you can use either of 
490 these forms
491
492     $z->print("hello world\n");
493     print $z "hello world\n";
494
495 The mandatory parameter C<$output> is used to control the destination
496 of the compressed data. This parameter can take one of these forms.
497
498 =over 5
499
500 =item A filename
501
502 If the C<$output> parameter is a simple scalar, it is assumed to be a
503 filename. This file will be opened for writing and the compressed data
504 will be written to it.
505
506 =item A filehandle
507
508 If the C<$output> parameter is a filehandle, the compressed data will be
509 written to it.
510 The string '-' can be used as an alias for standard output.
511
512 =item A scalar reference 
513
514 If C<$output> is a scalar reference, the compressed data will be stored
515 in C<$$output>.
516
517 =back
518
519 If the C<$output> parameter is any other type, C<IO::Compress::Deflate>::new will
520 return undef.
521
522 =head2 Constructor Options
523
524 C<OPTS> is any combination of the following options:
525
526 =over 5
527
528 =item C<< AutoClose => 0|1 >>
529
530 This option is only valid when the C<$output> parameter is a filehandle. If
531 specified, and the value is true, it will result in the C<$output> being
532 closed once either the C<close> method is called or the C<IO::Compress::Deflate>
533 object is destroyed.
534
535 This parameter defaults to 0.
536
537 =item C<< Append => 0|1 >>
538
539 Opens C<$output> in append mode. 
540
541 The behaviour of this option is dependent on the type of C<$output>.
542
543 =over 5
544
545 =item * A Buffer
546
547 If C<$output> is a buffer and C<Append> is enabled, all compressed data
548 will be append to the end of C<$output>. Otherwise C<$output> will be
549 cleared before any data is written to it.
550
551 =item * A Filename
552
553 If C<$output> is a filename and C<Append> is enabled, the file will be
554 opened in append mode. Otherwise the contents of the file, if any, will be
555 truncated before any compressed data is written to it.
556
557 =item * A Filehandle
558
559 If C<$output> is a filehandle, the file pointer will be positioned to the
560 end of the file via a call to C<seek> before any compressed data is written
561 to it.  Otherwise the file pointer will not be moved.
562
563 =back
564
565 This parameter defaults to 0.
566
567 =item C<< Merge => 0|1 >>
568
569 This option is used to compress input data and append it to an existing
570 compressed data stream in C<$output>. The end result is a single compressed
571 data stream stored in C<$output>. 
572
573 It is a fatal error to attempt to use this option when C<$output> is not an
574 RFC 1950 data stream.
575
576 There are a number of other limitations with the C<Merge> option:
577
578 =over 5 
579
580 =item 1
581
582 This module needs to have been built with zlib 1.2.1 or better to work. A
583 fatal error will be thrown if C<Merge> is used with an older version of
584 zlib.  
585
586 =item 2
587
588 If C<$output> is a file or a filehandle, it must be seekable.
589
590 =back
591
592 This parameter defaults to 0.
593
594 =item -Level 
595
596 Defines the compression level used by zlib. The value should either be
597 a number between 0 and 9 (0 means no compression and 9 is maximum
598 compression), or one of the symbolic constants defined below.
599
600    Z_NO_COMPRESSION
601    Z_BEST_SPEED
602    Z_BEST_COMPRESSION
603    Z_DEFAULT_COMPRESSION
604
605 The default is Z_DEFAULT_COMPRESSION.
606
607 Note, these constants are not imported by C<IO::Compress::Deflate> by default.
608
609     use IO::Compress::Deflate qw(:strategy);
610     use IO::Compress::Deflate qw(:constants);
611     use IO::Compress::Deflate qw(:all);
612
613 =item -Strategy 
614
615 Defines the strategy used to tune the compression. Use one of the symbolic
616 constants defined below.
617
618    Z_FILTERED
619    Z_HUFFMAN_ONLY
620    Z_RLE
621    Z_FIXED
622    Z_DEFAULT_STRATEGY
623
624 The default is Z_DEFAULT_STRATEGY.
625
626 =item C<< Strict => 0|1 >>
627
628 This is a placeholder option.
629
630 =back
631
632 =head2 Examples
633
634 TODO
635
636 =head1 Methods 
637
638 =head2 print
639
640 Usage is
641
642     $z->print($data)
643     print $z $data
644
645 Compresses and outputs the contents of the C<$data> parameter. This
646 has the same behaviour as the C<print> built-in.
647
648 Returns true if successful.
649
650 =head2 printf
651
652 Usage is
653
654     $z->printf($format, $data)
655     printf $z $format, $data
656
657 Compresses and outputs the contents of the C<$data> parameter.
658
659 Returns true if successful.
660
661 =head2 syswrite
662
663 Usage is
664
665     $z->syswrite $data
666     $z->syswrite $data, $length
667     $z->syswrite $data, $length, $offset
668
669 Compresses and outputs the contents of the C<$data> parameter.
670
671 Returns the number of uncompressed bytes written, or C<undef> if
672 unsuccessful.
673
674 =head2 write
675
676 Usage is
677
678     $z->write $data
679     $z->write $data, $length
680     $z->write $data, $length, $offset
681
682 Compresses and outputs the contents of the C<$data> parameter.
683
684 Returns the number of uncompressed bytes written, or C<undef> if
685 unsuccessful.
686
687 =head2 flush
688
689 Usage is
690
691     $z->flush;
692     $z->flush($flush_type);
693
694 Flushes any pending compressed data to the output file/buffer.
695
696 This method takes an optional parameter, C<$flush_type>, that controls
697 how the flushing will be carried out. By default the C<$flush_type>
698 used is C<Z_FINISH>. Other valid values for C<$flush_type> are
699 C<Z_NO_FLUSH>, C<Z_SYNC_FLUSH>, C<Z_FULL_FLUSH> and C<Z_BLOCK>. It is
700 strongly recommended that you only set the C<flush_type> parameter if
701 you fully understand the implications of what it does - overuse of C<flush>
702 can seriously degrade the level of compression achieved. See the C<zlib>
703 documentation for details.
704
705 Returns true on success.
706
707 =head2 tell
708
709 Usage is
710
711     $z->tell()
712     tell $z
713
714 Returns the uncompressed file offset.
715
716 =head2 eof
717
718 Usage is
719
720     $z->eof();
721     eof($z);
722
723 Returns true if the C<close> method has been called.
724
725 =head2 seek
726
727     $z->seek($position, $whence);
728     seek($z, $position, $whence);
729
730 Provides a sub-set of the C<seek> functionality, with the restriction
731 that it is only legal to seek forward in the output file/buffer.
732 It is a fatal error to attempt to seek backward.
733
734 Empty parts of the file/buffer will have NULL (0x00) bytes written to them.
735
736 The C<$whence> parameter takes one the usual values, namely SEEK_SET,
737 SEEK_CUR or SEEK_END.
738
739 Returns 1 on success, 0 on failure.
740
741 =head2 binmode
742
743 Usage is
744
745     $z->binmode
746     binmode $z ;
747
748 This is a noop provided for completeness.
749
750 =head2 opened
751
752     $z->opened()
753
754 Returns true if the object currently refers to a opened file/buffer. 
755
756 =head2 autoflush
757
758     my $prev = $z->autoflush()
759     my $prev = $z->autoflush(EXPR)
760
761 If the C<$z> object is associated with a file or a filehandle, this method
762 returns the current autoflush setting for the underlying filehandle. If
763 C<EXPR> is present, and is non-zero, it will enable flushing after every
764 write/print operation.
765
766 If C<$z> is associated with a buffer, this method has no effect and always
767 returns C<undef>.
768
769 B<Note> that the special variable C<$|> B<cannot> be used to set or
770 retrieve the autoflush setting.
771
772 =head2 input_line_number
773
774     $z->input_line_number()
775     $z->input_line_number(EXPR)
776
777 This method always returns C<undef> when compressing. 
778
779 =head2 fileno
780
781     $z->fileno()
782     fileno($z)
783
784 If the C<$z> object is associated with a file or a filehandle, C<fileno>
785 will return the underlying file descriptor. Once the C<close> method is
786 called C<fileno> will return C<undef>.
787
788 If the C<$z> object is associated with a buffer, this method will return
789 C<undef>.
790
791 =head2 close
792
793     $z->close() ;
794     close $z ;
795
796 Flushes any pending compressed data and then closes the output file/buffer. 
797
798 For most versions of Perl this method will be automatically invoked if
799 the IO::Compress::Deflate object is destroyed (either explicitly or by the
800 variable with the reference to the object going out of scope). The
801 exceptions are Perl versions 5.005 through 5.00504 and 5.8.0. In
802 these cases, the C<close> method will be called automatically, but
803 not until global destruction of all live objects when the program is
804 terminating.
805
806 Therefore, if you want your scripts to be able to run on all versions
807 of Perl, you should call C<close> explicitly and not rely on automatic
808 closing.
809
810 Returns true on success, otherwise 0.
811
812 If the C<AutoClose> option has been enabled when the IO::Compress::Deflate
813 object was created, and the object is associated with a file, the
814 underlying file will also be closed.
815
816 =head2 newStream([OPTS])
817
818 Usage is
819
820     $z->newStream( [OPTS] )
821
822 Closes the current compressed data stream and starts a new one.
823
824 OPTS consists of any of the options that are available when creating
825 the C<$z> object.
826
827 See the L</"Constructor Options"> section for more details.
828
829 =head2 deflateParams
830
831 Usage is
832
833     $z->deflateParams
834
835 TODO
836
837 =head1 Importing 
838
839 A number of symbolic constants are required by some methods in 
840 C<IO::Compress::Deflate>. None are imported by default.
841
842 =over 5
843
844 =item :all
845
846 Imports C<deflate>, C<$DeflateError> and all symbolic
847 constants that can be used by C<IO::Compress::Deflate>. Same as doing this
848
849     use IO::Compress::Deflate qw(deflate $DeflateError :constants) ;
850
851 =item :constants
852
853 Import all symbolic constants. Same as doing this
854
855     use IO::Compress::Deflate qw(:flush :level :strategy) ;
856
857 =item :flush
858
859 These symbolic constants are used by the C<flush> method.
860
861     Z_NO_FLUSH
862     Z_PARTIAL_FLUSH
863     Z_SYNC_FLUSH
864     Z_FULL_FLUSH
865     Z_FINISH
866     Z_BLOCK
867
868 =item :level
869
870 These symbolic constants are used by the C<Level> option in the constructor.
871
872     Z_NO_COMPRESSION
873     Z_BEST_SPEED
874     Z_BEST_COMPRESSION
875     Z_DEFAULT_COMPRESSION
876
877 =item :strategy
878
879 These symbolic constants are used by the C<Strategy> option in the constructor.
880
881     Z_FILTERED
882     Z_HUFFMAN_ONLY
883     Z_RLE
884     Z_FIXED
885     Z_DEFAULT_STRATEGY
886
887     
888     
889
890 =back
891
892 =head1 EXAMPLES
893
894 =head2 Apache::GZip Revisited
895
896 See L<IO::Compress::FAQ|IO::Compress::FAQ/"Apache::GZip Revisited">
897
898 =head2 Working with Net::FTP
899
900 See L<IO::Compress::FAQ|IO::Compress::FAQ/"Compressed files and Net::FTP">
901
902 =head1 SEE ALSO
903
904 L<Compress::Zlib>, L<IO::Compress::Gzip>, L<IO::Uncompress::Gunzip>, L<IO::Uncompress::Inflate>, L<IO::Compress::RawDeflate>, L<IO::Uncompress::RawInflate>, L<IO::Compress::Bzip2>, L<IO::Uncompress::Bunzip2>, L<IO::Compress::Lzma>, L<IO::Uncompress::UnLzma>, L<IO::Compress::Xz>, L<IO::Uncompress::UnXz>, L<IO::Compress::Lzop>, L<IO::Uncompress::UnLzop>, L<IO::Compress::Lzf>, L<IO::Uncompress::UnLzf>, L<IO::Uncompress::AnyInflate>, L<IO::Uncompress::AnyUncompress>
905
906 L<IO::Compress::FAQ|IO::Compress::FAQ>
907
908 L<File::GlobMapper|File::GlobMapper>, L<Archive::Zip|Archive::Zip>,
909 L<Archive::Tar|Archive::Tar>,
910 L<IO::Zlib|IO::Zlib>
911
912 For RFC 1950, 1951 and 1952 see 
913 F<http://www.faqs.org/rfcs/rfc1950.html>,
914 F<http://www.faqs.org/rfcs/rfc1951.html> and
915 F<http://www.faqs.org/rfcs/rfc1952.html>
916
917 The I<zlib> compression library was written by Jean-loup Gailly
918 F<gzip@prep.ai.mit.edu> and Mark Adler F<madler@alumni.caltech.edu>.
919
920 The primary site for the I<zlib> compression library is
921 F<http://www.zlib.org>.
922
923 The primary site for gzip is F<http://www.gzip.org>.
924
925 =head1 AUTHOR
926
927 This module was written by Paul Marquess, F<pmqs@cpan.org>. 
928
929 =head1 MODIFICATION HISTORY
930
931 See the Changes file.
932
933 =head1 COPYRIGHT AND LICENSE
934
935 Copyright (c) 2005-2014 Paul Marquess. All rights reserved.
936
937 This program is free software; you can redistribute it and/or
938 modify it under the same terms as Perl itself.
939