"{ Package: 'stx:goodies/xtreams/substreams' }"

"{ NameSpace: Xtreams }"

ReadSubstream subclass:#MatchReadSubstream

	instanceVariableNames:'substreamAtEnd pattern patternStart inclusive hasReread reread

		buffer backtrack'

	classVariableNames:''

	poolDictionaries:''

	category:'Xtreams-Substreams'

!

MatchReadSubstream comment:'This is a substream bounded by a string pattern. The algorithm used doesn''t need to peek or step back to detect the pattern, so it can be used on non-positionable streams.

Instance Variables

	substreamAtEnd	<Boolean> is this substream at end

	pattern	<String> the bounding pattern

	patternStart	<Integer>

	inclusive	<Boolean> is the boundary part of the substream contents

	hasReread	<Boolean>

	reread	<Object>

	buffer	<RingBuffer> read-ahead buffer (to be able to stop before pattern if inclusive is false)

	backtrack	<Array> backtracking table for pattern

'

!

!MatchReadSubstream class methodsFor:'instance creation'!

on: aSource pattern: aPattern backtrack: aBacktrack inclusive: aBoolean

	^self new on: aSource pattern: aPattern backtrack: aBacktrack inclusive: aBoolean

! !

!MatchReadSubstream methodsFor:'accessing'!

get

	buffer hasDataToRead ifTrue: [^buffer get].

	substreamAtEnd ifTrue: [Incomplete zero raise].

	self gobble.

	buffer hasDataToRead ifFalse: [Incomplete zero raise].

	^buffer get

!

read: anInteger into: aSequenceableCollection at: startIndex

	| count amount |

	count := 0.

	[count < anInteger and: [buffer hasDataToRead or: [substreamAtEnd not]]] whileTrue:

		[buffer hasDataToRead ifFalse: [self gobble].

		buffer hasDataToRead ifFalse: [(Incomplete on: aSequenceableCollection count: count at: startIndex) raise].

		amount := buffer readSize min: (anInteger - count).

		buffer read: amount into: aSequenceableCollection at: startIndex + count.

		count := count + amount].

	count < anInteger ifTrue: [(Incomplete on: aSequenceableCollection count: count at: startIndex) raise].

	^anInteger

! !

!MatchReadSubstream methodsFor:'initialize-release'!

close

	super close.

	buffer recycle

!

on: aSource pattern: aPattern backtrack: aBacktrack inclusive: aBoolean

	self on: aSource.

	pattern := aPattern.

	buffer := RingBuffer new: pattern size class: self contentsSpecies.

	hasReread := false.

	backtrack := aBacktrack.

	patternStart := 1.

	inclusive := aBoolean.

	substreamAtEnd := false

!

subseekend

	[buffer hasDataToRead or: [substreamAtEnd not]] whileTrue:

		[buffer hasDataToRead ifFalse: [self gobble].

		buffer readSkip: buffer readSize]

! !

!MatchReadSubstream methodsFor:'private'!

gobble

	| object match patternStop progress |

	patternStop := patternStart.

	[hasReread

		ifTrue: [hasReread := false. object := reread. reread := nil]

		ifFalse: [object := source get].

	[(match := object = (pattern at: patternStop)) ifTrue: [patternStop := patternStop + 1].

	match and: [patternStop <= pattern size]]

		whileTrue: [object := source get]]

			on: Incomplete do: [:incomplete |

				sourceAtEnd := substreamAtEnd := true].

	"A full pattern match"

	patternStop > pattern size ifTrue: [

		inclusive ifTrue: [buffer write: pattern size from: pattern at: 1].

		substreamAtEnd := true.

		^self].

	"No match at all, write out the object we just read"

	progress := patternStop - patternStart.

	(patternStart = 1 and: [progress = 0]) ifTrue: [

		sourceAtEnd ifFalse: [buffer put: object].

		patternStart := 1.

		^self].

	"Partial match, write out the part of the pattern previously matched and keep the object we just read to be re-read next time"

	hasReread := true.

	reread := object.

	buffer write: progress from: pattern at: patternStart.

	patternStart := backtrack at: patternStop

!

streamingInsert: anInteger into: aWriteStream

	| count amount |

	count := 0.

	[count < anInteger and: [buffer hasDataToRead or: [substreamAtEnd not]]] whileTrue:

		[buffer hasDataToRead ifFalse: [self gobble].

		buffer hasDataToRead ifFalse: [(Incomplete count: count) raise].

		amount := buffer readSize min: (anInteger - count).

		aWriteStream insert: amount from: buffer.

		count := count + amount].

	count < anInteger ifTrue: [(Incomplete count: count) raise]

!

streamingInsertInto: aWriteStream

	| amount |

	[buffer hasDataToRead or: [substreamAtEnd not]] whileTrue:

		[buffer hasDataToRead ifFalse: [self gobble].

		amount := buffer readSize.

		aWriteStream insert: amount from: buffer]

!

streamingWrite: anInteger into: aWriteStream

	| count amount |

	count := 0.

	[count < anInteger and: [buffer hasDataToRead or: [substreamAtEnd not]]] whileTrue:

		[buffer hasDataToRead ifFalse: [self gobble].

		buffer hasDataToRead ifFalse: [(Incomplete count: count) raise].

		amount := buffer readSize min: (anInteger - count).

		aWriteStream write: amount from: buffer.

		count := count + amount].

	count < anInteger ifTrue: [(Incomplete count: count) raise].

	^anInteger

!

streamingWriteInto: aWriteStream

	| amount count |

	count := 0.

	[buffer hasDataToRead or: [substreamAtEnd not]] whileTrue:

		[buffer hasDataToRead ifFalse: [self gobble].

		amount := buffer readSize.

		aWriteStream write: amount from: buffer.

		count := count + amount ].

	^count

! !

!MatchReadSubstream methodsFor:'seeking'!

-= anInteger

	^anInteger isZero

		ifTrue:	[self subseekend. 0]

		ifFalse:	[super -= anInteger]

! !

!MatchReadSubstream methodsFor:'testing'!

isPositionable

	^false

! !

!MatchReadSubstream class methodsFor:'documentation'!

version_SVN

    ^ '$Id$'

! !