ext/Compress/Zlib/lib/IO/Compress/RawDeflate.pm

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