"

 COPYRIGHT (c) 2002 by eXept Software AG

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

"{ Package: 'stx:libbasic2' }"

Stream subclass:#CompressionStream

	instanceVariableNames:'onStream hitEOF binary position readLimit mode inputBytes

		outputBytes zstream'

	classVariableNames:'BlockSize'

	poolDictionaries:''

	category:'System-Compress'

!

!CompressionStream class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 2002 by eXept Software AG

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

!

documentation

"

    Abstract superclass of streams that compress or deconpress data

    [author:]

    [instance variables:]

    [class variables:]

    [see also:]

"

! !

!CompressionStream class methodsFor:'initialization'!

initialize

    BlockSize := 6.

! !

!CompressionStream class methodsFor:'instance creation'!

readOpenOn:aStream

    "open to read data from an compressed stream"

    ^ self basicNew openWithMode:#readonly on:aStream

!

writeOpenOn:aStream

    "open to write data compressed to stream"

    ^ self basicNew openWithMode:#writeonly on:aStream

! !

!CompressionStream methodsFor:'accessing'!

binary

    "switch to binary mode - default is text

    "

    binary := true.

!

text

    "switch to text mode - default is text"

    binary := false.

! !

!CompressionStream methodsFor:'error handling'!

errorNotOpen

    "report an error, that the stream has not been opened"

    self zerror:'not open'.

!

errorReadOnly

    "report an error, that the stream is a readOnly stream"

    self zerror:'is readonly'

!

errorWriteOnly

    "report an error, that the stream is a writeOnly stream"

    self zerror:'is writeonly'

!

invalidArgument

    "called if a method is invoked with invalid parameters"

    self zerror:'invalid arguments'.

!

pastEndRead

    self zerror:'end of stream'.

    ^ nil

    "Modified: / 18-11-2006 / 15:37:08 / cg"

!

zerror:anError

    |error|

    zstream isNil ifTrue:[

    ] ifFalse:[

    ].

    StreamError raiseErrorString:(self class name , ': ', error).

! !

!CompressionStream methodsFor:'finalization'!

executor

     - all we need is the memory handle"

!

finalize

    "the compressin-stream was garbage collected;

     close the underlying zip-stream"

    self closeZStream.

!

finalizeCopy:aZStream

    "used for finalization to close the underlying zip-stream"

    zstream := aZStream.

! !

!CompressionStream methodsFor:'low level'!

    "read the next available bytes into a collection, a string or byteArray;

     returns the size read"

    |start count avail|

    avail := readLimit - position.

    avail > 0 ifFalse:[^ 0].

    count := aCollection size - offset + 1.

	^ 0

    ].

    position := position + count.

%{  unsigned char * _dstPt;

    if( __isBytes(aCollection) ) {

	_dstPt = (unsigned char *) (__ByteArrayInstPtr(aCollection)->ba_element);

    } else if (__isString(aCollection)) {

	_dstPt = (unsigned char *) (__stringVal( aCollection));

    } else

	_dstPt = (unsigned char *) 0;

    if( _dstPt )

    {

	int             _loop, _count, _offset;

	unsigned char * _srcPt;

	OBJ             _srcObj = __INST( outputBytes );

	_offset = __intVal( offset );

	_dstPt  = _dstPt + _offset - 1;

	_srcPt  = (unsigned char *) __externalBytesAddress( _srcObj );

	_srcPt += __intVal( start );

	_count  = __intVal( count );

	for( _loop = 0; _loop < _count; ++_loop )

	    * _dstPt++ = * _srcPt++;

	RETURN(__MKSMALLINT(_count));

    }

%}.

    ^ self zerror:'invalid argument'

!

zclose

    "low level close of the zip stream"

    ^ self subclassResponsibility

!

zdeflate

    "low level - deflate

     returns false if the deflate operation is finished otherwise true"

    ^ self subclassResponsibility

!

zdeflateInit

    "low level - deflateInit

     initialize the deflate mode, write header"

    ^ self subclassResponsibility

!

zget_avail_out

    "low level - get the number of available out bytes"

    ^ self subclassResponsibility

!

zinflate

    "low level - inflate

     returns nil if at uncompress is finished, or the number of

     available bytes in the output-buffer"

    ^ self subclassResponsibility

!

zinflateInit

    "low level - inflateInit

     initialize the inflate mode, read and check header"

    ^ self subclassResponsibility

!

zopen

    "low level - opens the zip stream

     create the resources"

    ^ self subclassResponsibility

!

zset_avail_in:count

    "set the 'avail_in' and compute the crc"

    ^ self subclassResponsibility

! !

!CompressionStream methodsFor:'private'!

closeZStream

    "close the zip-stream"

    onStream := mode := nil.

    hitEOF   := true.

    zstream ifNotNil:[

	self unregisterForFinalization.

	self zclose.

	zstream := nil.

    ].

!

contentsSpecies

    "return the kind of object to be returned by sub-collection builders"

    binary == true ifTrue:[^ ByteArray].

    ^ String

!

onStreamPutBytes:count from:data

    "write compressed data to the (output) stream"

    onStream nextPutBytes:count from:data startingAt:1

! !

!CompressionStream methodsFor:'queries'!

atEnd

    "return true if the end of the compressed input stream has been reached"

    ^ self canReadWithoutBlocking not

!

canReadWithoutBlocking

    "returns true if data are available for reading;

     false if the stream is at end.

     updates the readLimit and position"

    |n|

    mode == #readonly ifFalse:[

    ].

    hitEOF == true ifTrue:[^ false].

    position >= readLimit ifTrue:[

    ].

    ^ true

!

isBinary

    "return true, if the stream is in binary (as opposed to text-) mode.

     The default when created is false"

    ^ binary

!

isOpen

    "return true, if this stream is open"

    ^ onStream notNil

!

isReadable

    "return true, if this stream can be read from"

    ^ mode == #readonly

!

isWritable

    "return true, if this stream can be written to"

    ^ mode == #writeonly

! !

!CompressionStream methodsFor:'reading'!

contents

    "return the entire contents of and close the stream"

    |species stream bfsize buffer count|

    mode == #readonly ifFalse:[

    ].

    bfsize := outputBytes size.

    species := self contentsSpecies.

    buffer  := species new:bfsize.

    stream  := WriteStream on:(species new:bfsize).

    [self canReadWithoutBlocking] whileTrue:[

    ].

    self close.

    ^ stream contents

!

next

    "return the next element, a character or byte (textmode)

     return nil, if there are no more elements"

    |byte|

    self canReadWithoutBlocking ifFalse:[

	"there is no more element; the stream is at end"

	^ nil

    ].

    position := position + 1.

    byte := outputBytes at:position.

    binary ifTrue:[^ byte ].

    ^ Character value:byte

!

next:n

    "return the next count elements of the stream as a collection.

     Redefined to return a String or ByteArray and for optimization"

    |data count offset species|

    species := self contentsSpecies.

    self canReadWithoutBlocking ifFalse:[

	^ species new

    ].

    data := species new:n.

    offset := 1.

    [self canReadWithoutBlocking] whileTrue:[

	count  := self z_nextAvailableInto:data startingAt:offset.

	offset := count + offset.

	offset > n ifTrue:[^ data]

    ].

    ^ data copyFrom:1 to:(offset - 1)

!

    "skip count objects, return the receiver

     redefined for optimization"

    |n avail|

    n := count.

    n <= 0 ifTrue:[

    ].

    [self canReadWithoutBlocking] whileTrue:[

    ].

! !

!CompressionStream methodsFor:'startup & release'!

close

    "close the zip-stream"

    hitEOF := true.

    zstream notNil ifTrue:[

	self flush.

	self closeZStream.

    ].

!

openWithMode:aMode on:aStream

    "open the zip-stream on a stream

     can be reimplemented to do some additional stuff (e.g. gzip header) like

     in the ZipStream

    "

    ^ self streamOpenWithMode:aMode on:aStream.

!

streamOpenWithMode:aMode on:aStream