"

 COPYRIGHT (c) 1999 by eXept Software AG

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

"{ NameSpace: Smalltalk }"

Stream subclass:#SplittingWriteStream

	instanceVariableNames:'outStream1 outStream2'

	classVariableNames:''

	poolDictionaries:''

	category:'Streams-Misc'

!

!SplittingWriteStream class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1999 by eXept Software AG

              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

"

    A stream duplicator - everything written onto a splittingWriteStream

    is written to two real streams.

    Useful, if you have to send something to two files/destinations

    simultaneously, and do not want to (or cannot) buffer it.

    Especially useful, to generate a checksum, 

    while sending something to a file 

    (if one of the output streams is a checksummer).

    Also, to duplicate some output to a Transcript.

    The second stream can be closed and nilled, if no longer needed.

    [author:]

        Claus Gittinger (cg@exept)

    [see also:]

        WriteStream

    [instance variables:]

        outStream1      <Stream>       actual output streams

        outStream2      <Stream>

    [class variables:]

"

!

examples

"

  writes to two files simultaneously:

                                                                [exBegin]

    |s1 s2 splitter|

    s1 := '/tmp/foo1' asFilename writeStream.

    s2 := '/tmp/foo2' asFilename writeStream.

    splitter := SplittingWriteStream on:s1 and:s2.

    splitter nextPutAll:'hello world'.

    splitter close.

                                                                [exEnd]

  generates a hash on the fly:

                                                                [exBegin]

    |s1 s2 splitter hash|

    s1 := '/tmp/foo1' asFilename writeStream.

    s2 := SHA1Stream new.

    splitter := SplittingWriteStream on:s1 and:s2.

    splitter nextPutAll:'hello world'.

    splitter close.

    hash := s2 hashValue. 

    self assert:(hash = (SHA1Stream hashValueOf:'hello world'))

                                                                [exEnd]

"

! !

!SplittingWriteStream class methodsFor:'instance creation'!

on:stream1 and:stream2

    ^ self basicNew setOutStream1:stream1 outStream2:stream2

! !

!SplittingWriteStream methodsFor:'accessing'!

outStream1

    "return the value of the instance variable 'outStream1' (automatically generated)"

    ^ outStream1

!

outStream1:aStream

    "set the value of the instance variable 'outStream1' (automatically generated)"

    outStream1 := aStream.

    "Modified (format): / 04-11-2018 / 21:53:51 / Claus Gittinger"

!

outStream2

    "return the value of the instance variable 'outStream2' (automatically generated)"

    ^ outStream2

!

outStream2:aStreamOrNil

    "set the value of the instance variable 'outStream2' (automatically generated)"

    outStream2 := aStreamOrNil.

    "Modified (format): / 04-11-2018 / 21:54:02 / Claus Gittinger"

! !

!SplittingWriteStream methodsFor:'private access'!

setOutStream1:stream1 outStream2:stream2

    outStream1 := stream1.

    outStream2 := stream2.

! !

!SplittingWriteStream methodsFor:'redirect messages'!

doesNotUnderstand:aMessage

    "if my superclass implements the message, it can be forwarded to both streams."

    |retVal|

    (outStream1 class canUnderstand:aMessage selector) ifTrue:[

        retVal := aMessage sendTo:outStream1.

        outStream2 notNil ifTrue:[

            aMessage sendTo:outStream2.

        ].

        ^ retVal

    ].

    ^ super doesNotUnderstand:aMessage.

    "

        |sp s1 s2|

        s1 := TextStream on:''.

        s2 := TextStream on:''.

        sp := SplittingWriteStream on:s1 and:s2.

        sp nextPutAllText:('ABC' allBold); closeRun.

        s2 contents inspect.

    "

    "Modified: / 04-11-2018 / 21:52:43 / Claus Gittinger"

! !

!SplittingWriteStream methodsFor:'writing'!

clear

    outStream1 isStream ifFalse:[ outStream1 clear ]. 

    outStream2 notNil ifTrue:[ 

        outStream2 isStream ifFalse:[ outStream2 clear ].

    ].

    "Modified: / 04-11-2018 / 21:51:20 / Claus Gittinger"

!

close

    outStream1 close.

    outStream2 notNil ifTrue:[ 

        outStream2 close.

    ]

    "Modified: / 04-11-2018 / 21:51:29 / Claus Gittinger"

!

contents

    ^ outStream1 contents 

!

cr

    outStream1 cr.

    outStream2 notNil ifTrue:[

        outStream2 cr.

    ]

    "Created: / 12-11-2018 / 14:35:52 / Claus Gittinger"

!

endEntry

    outStream1 endEntry.

    outStream2 notNil ifTrue:[

        outStream2 endEntry.

    ]

    "Modified: / 04-11-2018 / 21:52:55 / Claus Gittinger"

!

flush

    outStream1 flush.

    outStream2 notNil ifTrue:[

        outStream2 flush.

    ]

    "Modified: / 04-11-2018 / 21:53:09 / Claus Gittinger"

!

nextPut:something

    outStream1 nextPut:something.

    outStream2 notNil ifTrue:[

        outStream2 nextPut:something.

    ]

    "Modified: / 04-11-2018 / 21:53:16 / Claus Gittinger"

!

nextPutAll:something

    outStream1 nextPutAll:something.

    outStream2 notNil ifTrue:[

        outStream2 nextPutAll:something.

    ]

    "Modified: / 04-11-2018 / 21:53:25 / Claus Gittinger"

!

nextPutAll:aCollection startingAt:start to:stop

    "append the elements from first index to last index

     of the argument, aCollection onto the receiver (i.e. both outstreams)"

    outStream1 nextPutAll:aCollection startingAt:start to:stop.

    outStream2 notNil ifTrue:[

        outStream2 nextPutAll:aCollection startingAt:start to:stop.

    ]

    "Modified: / 04-11-2018 / 21:53:33 / Claus Gittinger"

    "Modified (comment): / 01-04-2019 / 17:12:42 / Claus Gittinger"

!

nextPutAllUnicode:aString

    outStream1 nextPutAllUnicode:aString.

    outStream2 notNil ifTrue:[

        outStream2 nextPutAllUnicode:aString.

    ]

    "Created: / 21-09-2017 / 11:58:13 / cg"

    "Modified: / 04-11-2018 / 21:53:40 / Claus Gittinger"

!

show:something

    outStream1 show:something.

    outStream2 notNil ifTrue:[

        outStream2 show:something.

    ]

    "Created: / 12-11-2018 / 14:35:45 / Claus Gittinger"

! !

!SplittingWriteStream class methodsFor:'documentation'!

version

    ^ '$Header$'

! !