Bug? in BRL.Stream / documentation

Archives Forums/BlitzMax Bug Reports/Bug? in BRL.Stream / documentation

n-Halbleiter

(Posted 2010) [#1]

Hey there!

I'm a bit concerned about a problem in the documentation or BRL.Stream: Under Tutorials -> BlitzMax Overview there is a small text (with sample code) about TStream, TStreamWrapper and TStreamFactory. The problem is the following:

Run the code (available in the documentation (not at the location the link directs to) or at the bottom of this post) and you will see: The text will not be converted to uppercase. So this whole thing is useless.

After tracking down the problem I found out that the implementations of 'Read[thing]' (except 'Bytes' which is not implemented in TStreamWrapper at all) just redirect to the stream's one. With this you can't just derive your own wrapper and use it like this (sometimes this would be really cool). So, the solution is just to comment this section out. The modified source of the TStreamWrapper Type would then look like this:

Type TStreamWrapper Extends TStream
	Field _stream:TStream

	Rem
	bbdoc: Set underlying stream
	about:
	Sets the stream to be 'wrapped'. All calls to TIO methods of this stream will be
	redirected to @stream.
	end rem
	Method SetStream( stream:TStream )
		_stream=stream
	End Method

	Method Eof()
		Return _stream.Eof()
	End Method

	Method Pos()
		Return _stream.Pos()
	End Method

	Method Size()
		Return _stream.Size()
	End Method
	
	Method Seek( pos )
		Return _stream.Seek( pos )
	End Method

	Method Flush()
		_stream.Flush
	End Method

	Method Close()
		_stream.Close
	End Method

	Method Read( buf:Byte Ptr,count )
		Return _stream.Read( buf,count )
	End Method

	Method Write( buf:Byte Ptr,count )
		Return _stream.Write( buf,count )
	End Method

	Rem
	Method ReadByte()
		Return _stream.ReadByte()
	End Method
	
	Method WriteByte( n )
		_stream.WriteByte n
	End Method
	
	Method ReadShort()
		Return _stream.ReadShort()
	End Method
	
	Method WriteShort( n )
		_stream.WriteShort n
	End Method
	
	Method ReadInt()
		Return _stream.ReadInt()
	End Method
	
	Method WriteInt( n )
		_stream.WriteInt n
	End Method
	
	Method ReadFloat:Float()
		Return _stream.ReadFloat()
	End Method
	
	Method WriteFloat( n:Float )
		_stream.WriteFloat n
	End Method
	
	Method ReadDouble:Double()
		Return _stream.ReadDouble()
	End Method
	
	Method WriteDouble( n:Double )
		_stream.WriteDouble n
	End Method
	
	Method ReadLine$()
		Return _stream.ReadLine()
	End Method
	
	Method WriteLine( t$ )
		Return _stream.WriteLine( t )
	End Method
	
	Method ReadString$( n )
		Return _stream.ReadString( n )
	End Method
	
	Method WriteString( t$ )
		_stream.WriteString t
	End Method
	
	Method ReadObject:Object()
		Return _stream.ReadObject()
	End Method
	
	Method WriteObject( obj:Object )
		_stream.WriteObject obj
	End Method
	End Rem
	
End Type

(just copied from MaxIDE so that you can easily replace it for testing.)

The code for the example:

Strict

Type TUpperStream Extends TStreamWrapper

	Method Read:Int( buf:Byte Ptr,count:Int )
		'Read data from the underlying stream
		count=Super.Read( buf,count )
		'Convert the data to uppercase
		For Local i=0 Until count
			If buf[i]>=Asc("a") And Buf[i]<=Asc("z")
				buf[i]=buf[i]-Asc("a")+Asc("A")
			EndIf
		Next
		'Done!
		Return count
	End Method

	Method Write:Int( buf:Byte Ptr,count:Int )
		'Copy the data to a new buffer, converting to uppercase as we go
		Local tmp:Byte[count]
		For Local i=0 Until count
			If buf[i]>=Asc("a") And buf[i]<=Asc("z")
				tmp[i]=buf[i]-Asc("a")+Asc("A")
			Else
				tmp[i]=buf[i]
			EndIf
		Next
		'Write the data to the underlying stream
		Return Super.Write( tmp,count )
	End Method

	Function Create:TUpperStream( stream:TStream )
		Local t:TUpperStream=New TUpperStream
		'SetStream is a TStreamWrapper method that sets the underlying stream.
		t.SetStream stream
		Return t
	End Function

End Type

Type TUpperStreamFactory Extends TStreamFactory

	Method CreateStream:TUpperStream( url:Object,proto:String,path:String,readable:Int,writeable:Int )
		If proto$<>"uppercase" Return
		Local stream:TStream=OpenStream( path,readable,writeable )
		If stream Return TUpperStream.Create( stream )
	End Method
	
End Type

New TUpperStreamFactory

'Exmaple of manually creating a TUpperStream:

'Create a tmp file and write some text to it.
Local tmp:TStream=WriteStream( "tmp" )
tmp.WriteLine "A little example..."
tmp.WriteLine "of our cool TUpperStream!"
tmp.Close()

'Open tmp file again, and wrap it with a TUpperStream
tmp:TStream=ReadStream( "tmp" ) 
Local upperizer:TUpperStream=TUpperStream.Create( tmp )

'Dump file contents
While Not upperizer.Eof()
	Print upperizer.ReadLine()
Wend

upperizer.Close()
tmp.Close()

Print ""

'Example of automatically creating a TUpperStream:
Local tmp2:TStream=WriteStream( "uppercase::tmp" )
tmp2.WriteLine "Another little example..."
tmp2.WriteLine "of our even cooler TUpperStream!"
tmp2.Close()

tmp2:TStream=ReadStream( "tmp" )
While Not tmp2.Eof()
	Print tmp2.ReadLine()
Wend
tmp2.Close()

With this small modification everything works how it should.

Thanks and out. :)