[Summary view] [Print] [Text view]

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