[Summary view] [Print] [Text view]

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