[ Index ] |
PHP Cross Reference of Unnamed Project |
[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
title
Description
Body
title
Description
Body
title
Description
Body
title
Body
Generated: Tue Mar 17 22:47:18 2015 | Cross-referenced by PHPXref 0.7.1 |