"

 COPYRIGHT (c) 1989 by Claus Gittinger

 COPYRIGHT (c) 2015 Jan Vrany

	      All Rights Reserved

 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:libbasic' }"

"{ NameSpace: Smalltalk }"

PeekableStream subclass:#PositionableStream

	instanceVariableNames:'collection position readLimit writeLimit'

	classVariableNames:'ZeroPosition InvalidPositionErrorSignal'

	poolDictionaries:''

	category:'Streams'

!

!PositionableStream class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1989 by Claus Gittinger

 COPYRIGHT (c) 2015 Jan Vrany

	      All Rights Reserved

 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

"

    Instances of PositionableStream allow positioning the read pointer.

    The PositionableStream class also adds methods for source-chunk reading

    and writing, and for filing-in/out of source code.

    This is an abstract class.

    Compatibility Notice:

        In previous versions of ST/X, streams started with a 1-position (i.e. as in collections),

        while ST-80 has always been using 0-based postions for streams and 1-based positions for collections.

        THIS CERTAINLY IS BAD.

        Although this is confusing ST/X has been changed to now also uses 0-based stream positioning.

    [caveat:]

        Basing capabilities like readability/writability/positionability/peekability on inheritance makes

        the class hierarchy ugly and leads to strange and hard to teach redefinitions (aka. NonPositionableStream

        below PositionableStream or ExternalReadStream under WriteStream)

    [author:]

        Claus Gittinger

"

! !

!PositionableStream class methodsFor:'initialization'!

initialize

    ZeroPosition := 0.        "/ changed with stx rel5.1; 

                              "/ rel6.2: no longer used (i.e. 0 has now ben hardcoded)

                              "/ class variable to be eliminated.

    InvalidPositionErrorSignal isNil ifTrue:[

        InvalidPositionErrorSignal := PositionOutOfBoundsError.

        InvalidPositionErrorSignal notifierString:'position out of bounds: '.

    ]

! !

!PositionableStream class methodsFor:'instance creation'!

on:aCollection

    "return a new PositionableStream streaming on aCollection"

    ^ (self basicNew) on:aCollection

!

on:aCollection from:first to:last

    "return a new PositionableStream streaming on aCollection

     from first to last"

    ^ (self basicNew) on:aCollection from:first to:last

!

with:aCollection

    "return a new PositionableStream streaming on aCollection,

     the stream is positioned to the end of the collection."

    ^ (self basicNew) with:aCollection

! !

!PositionableStream class methodsFor:'Signal constants'!

invalidPositionErrorSignal

    "return the signal raised if positioning is attempted to an

     invalid position (i.e. before the begin of the stream or after

     the end)"

    ^ PositionOutOfBoundsError

! !

!PositionableStream class methodsFor:'constants'!

zeroPosition

    "return the number, which marks the initial position.

     Compatibility Notice:

        In previous versions of ST/X, streams started with a 1-position (i.e. as in collections),

        while ST-80 has always been using 0-based postions for streams and 1-based positions for collections.

     Although this is confusing ST/X has been changed to now also use 0-based stream positioning.

    "

    ^ 0

    "Modified: / 13-07-2006 / 20:36:54 / cg"

! !

!PositionableStream class methodsFor:'testing'!

isAbstract

    ^ self == PositionableStream

! !

!PositionableStream methodsFor:'Compatibility-Dolphin'!

endChunk

    self nextPutChunkSeparator

! !

!PositionableStream methodsFor:'Compatibility-ST/V'!

skipTo:anElement

    "ST/V compatibility:

     skip for the element given by the argument, anElement;

     return nil if not found, self otherwise. 

     On a successful match, the next read will return the element after anElement."

    ^ self skipThrough:anElement

    "

     |s|

     s := ReadStream on:'12345678901234567890'.

     s skipTo:$5.

     s copyFrom:1 to:(s position).    

     s upToEnd      

    "

! !

!PositionableStream methodsFor:'Compatibility-Squeak'!

back

        "Go back one element and return it."

        self position = 0 ifTrue: [self positionError].

        self skip: -1.

        ^ self peek

    "Created: / 03-10-2014 / 03:06:31 / Jan Vrany <jan.vrany@fit.cvut.cz>"

!

peekBack

        "Return the element at the previous position, without changing position.  Use indirect messages in case self is a StandardFileStream."

        | element |

        element := self back.

        self skip: 1.

        ^ element

    "Created: / 03-10-2014 / 03:06:26 / Jan Vrany <jan.vrany@fit.cvut.cz>"

!

upToAnyOf: aCollection 

        "Answer a subcollection from the current access position to the 

        occurrence (if any, but not inclusive) of any object in the collection. If 

        no matching object is found, answer the entire rest of the receiver."

        ^self upToAnyOf: aCollection do: [:matchingObject | ]

    "Created: / 21-04-2015 / 17:25:51 / Jan Vrany <jan.vrany@fit.cvut.cz>"

!

upToAnyOf: subcollection do: aBlock

        "Answer a subcollection from the current access position to the occurrence (if any, but not inclusive) of any object in the collection.

        Evaluate aBlock with this occurence as argument.

        If no matching object is found, don't evaluate aBlock and answer the entire rest of the receiver."

        ^self collection species new: 1000 streamContents: [ :stream |

                | ch |

                [ self atEnd or: [ (subcollection includes: (ch := self next)) and: [aBlock value: ch. true] ] ] 

                        whileFalse: [ stream nextPut: ch ] ]

    "Created: / 21-04-2015 / 17:26:06 / Jan Vrany <jan.vrany@fit.cvut.cz>"

! !

!PositionableStream methodsFor:'accessing'!

collection

    "return the underlying collection buffer.

     Notice, that this buffer may become invalid after being retrieved,

     if more data is written to the stream (because a bigger buffer might be

     allocated). Therefore, it should be only used in special situations,

     where an already filed buffer needs to be backpatched later

     (eg. before being sent out to some external stream or socket)"

    ^ collection

!

contents

    "return the entire contents of the stream"

    ^ collection

!

peekForAll:aCollection

    "return true and advance if the next elements are the same

     as aCollection. 

     otherwise stay and let the position unchanged"

    |oldPos|

    oldPos := self position.

    (self next:(aCollection size)) = aCollection ifTrue:[

	^ true

    ].

    self position:oldPos.

    ^ false

    "Created: 1.3.1997 / 15:11:25 / cg"

!

readLimit

    "return the read-limit; that's the position at which EOF is returned"

    ^ readLimit

    "Created: / 30.10.1998 / 16:47:04 / cg"

!

readLimit:aNumber

    "set the read-limit; that's the position at which EOF is returned"

    readLimit := aNumber

!

setCollection:newCollection

    collection := newCollection

!

writeLimit:aNumber

    "set the writeLimit; that's the position after which writing is prohibited"

    writeLimit := aNumber

    "

     |s|

     s := WriteStream on:String new.

     s nextPutAll:'hello world'.

     s contents.

     |s|

     s := WriteStream on:String new.

     s writeLimit:5.

     s nextPutAll:'hello world'.

     s contents.

    "

    "Modified: / 04-06-2007 / 17:21:55 / cg"

! !

!PositionableStream methodsFor:'misc functions'!

copy:numberOfBytes into:aWriteStream

    "read from the receiver, and write numberOfBytes data to another aWriteStream.

     Return the number of bytes which have been transferred.

     Redefined here to avoid intermediate buffers/garbage."

    |endPosition cnt|

    collection notNil ifTrue:[

        endPosition := (position+numberOfBytes) min:readLimit.

        aWriteStream nextPutAll:collection startingAt:position+1 to:endPosition.

        cnt := endPosition - position.

        position := endPosition.

        ^ cnt.

    ].

    ^ super copy:numberOfBytes into:aWriteStream.

    "

      'hello world' readStream copy:5 into:'/tmp/mist' asFilename writeStream.

      'hello world' readStream 

                        copy:5 into:Transcript;

                        copy:20 into:Transcript.

      'hello world' readStream copy:5 into:'' writeStream inspect.

      #[1 2 3 4 5 6 7] readStream copy:2 into:'/tmp/mist' asFilename writeStream binary.

      #[1 2 3 4 5 6 7] readStream copy:3 into:#[] writeStream.

    "

    "

     |rs ws cnt|

     ws := #() writeStream.

     rs := #( 1 2 3 4 a nil true) readWriteStream.

     rs next.

     cnt := rs copyToEndInto:ws bufferSize:0.

     Transcript show:cnt; show:' '; showCR:ws contents.

    "

!

copy:numberOfBytes into:aWriteStream bufferSize:bufferSize

    "read from the receiver, and write numberOfBytes data to another aWriteStream.

     Return the number of bytes which have been transferred.

     Redefined here to avoid intermediate buffers/garbage.

     bufferSize does not matter here."

    collection notNil ifTrue:[

        ^ self copy:numberOfBytes into:aWriteStream.

    ].

    ^ super copy:numberOfBytes into:aWriteStream bufferSize:bufferSize.

!

copyToEndInto:aWriteStream

    "read from the receiver, and write all data up to the end to another stream.

     Return the number of bytes which have been transferred.

     Redefined here to avoid intermediate buffers/garbage."

    |cnt|

    collection notNil ifTrue:[

        aWriteStream nextPutAll:collection startingAt:position+1 to:readLimit.

        cnt := readLimit - position.

        position := readLimit.

        ^ cnt.

    ].

    ^ super copyToEndInto:aWriteStream.

    "

     |rs ws cnt|

     ws := #() writeStream.

     rs := #( 1 2 3 4 a nil true) readWriteStream.

     rs next.

     cnt := rs copyToEndInto:ws bufferSize:0.

     Transcript show:cnt; show:' '; showCR:ws contents.

    "

!

copyToEndInto:aWriteStream bufferSize:bufferSize

    "read from the receiver, and write all data up to the end to another stream.

     Return the number of bytes which have been transferred.

     Redefined here to avoid intermediate buffers/garbage.

     bufferSize does not matter here."

    collection notNil ifTrue:[

        ^ self copyToEndInto:aWriteStream.

    ].

    ^ super copyToEndInto:aWriteStream bufferSize:bufferSize.

    "

     |rs ws cnt|

     ws := #() writeStream.

     rs := #( 1 2 3 4 a nil true) readWriteStream.

     rs next.

     cnt := rs copyToEndInto:ws bufferSize:0.

     Transcript show:cnt; show:' '; showCR:ws contents.

    "

! !

!PositionableStream methodsFor:'non homogenous reading'!

nextBytes:numBytes into:aCollection startingAt:initialIndex

    "return the next numBytes from the stream. If the end is

     reached before, only that many bytes are copyied into the

     collection.

     Returns the number of bytes that have been actually read.

     The receiver must support reading of binary bytes.

     Notice: this method is provided here for protocol completeness

             with externalStreams - it is normally not used with other

             streams."

    |max|

    (collection isByteCollection

     and:[aCollection isByteCollection]) ifTrue:[

        "do it the fast way"

        max := (readLimit - position) min: numBytes.

        aCollection

            replaceBytesFrom:initialIndex 

            to:(initialIndex + max - 1)

            with:collection 

            startingAt:position+1.

        position := position + max.

        ^ max

    ].

    "do it the hard way"

    ^ super nextBytes:numBytes into:aCollection startingAt:initialIndex

    "

     |s n buffer|

     buffer := ByteArray new:10.

     s := ReadStream on:#[1 2 3 4 5 6 7 8 9].

     s next:3.

     n := s nextBytes:9 into:buffer startingAt:1.

     Transcript showCR:('n = %1; buffer = <%2>' bindWith:n with:buffer)

    "

! !

!PositionableStream methodsFor:'positioning'!

backStep

    "move backward read position by one"

    self position:(self position - 1)

!

match: subCollection

    "Set the access position of the receiver to be past the next occurrence of the subCollection. 

     Answer whether subCollection is found.  

     No wildcards, and case does matter."

    | pattern startMatch |

    pattern := ReadStream on: subCollection.

    startMatch := nil.

    [pattern atEnd] whileFalse: [

        self atEnd ifTrue: [^ false].

        (self next) = (pattern next) 

            ifTrue: [pattern position = 1 ifTrue: [startMatch := self position]]

            ifFalse: [

                pattern position: 0.

                startMatch ifNotNil: [

                    self position: startMatch.

                    startMatch := nil

                ]

            ]

    ].

    ^ true

    "

     'abc def ghi' readStream match:'def'; upToEnd

    "

!

position

    "return the read position (0-based)"

    ^ position

!

position0Based

    <resource: #obsolete>

    "return the read position 0-based"

    ^ self position

!

position0Based:index0Based

    <resource: #obsolete>

    "set the read (or write) position"

    self position:index0Based

!

position1Based

    <resource: #obsolete>

    "return the read position 1-based"

    ^ self position + 1

!

position1Based:index1Based

    <resource: #obsolete>

    "set the read (or write) position"

    self position:(index1Based - 1)