# Abstract stream class
class IOS
# close the stream
- meth close is abstract
+ fun close is abstract
end
# Abstract input streams
class IStream
-special IOS
+ super IOS
# Read a character. Return its ASCII value, -1 on EOF or timeout
- meth read_char: Int is abstract
+ fun read_char: Int is abstract
# Read at most i bytes
- meth read(i: Int): String
+ fun read(i: Int): String
do
- var s = new String.with_capacity(i)
+ var s = new Buffer.with_capacity(i)
while i > 0 and not eof do
var c = read_char
if c >= 0 then
i -= 1
end
end
- return s
+ return s.to_s
end
# Read a string until the end of the line.
- meth read_line: String
+ fun read_line: String
do
assert not eof
- var s = new String
+ var s = new Buffer
append_line_to(s)
- return s
+ return s.to_s
end
# Read all the stream until the eof.
- meth read_all: String
+ fun read_all: String
do
- var s = ""
+ var s = new Buffer
while not eof do
var c = read_char
if c >= 0 then s.add(c.ascii)
end
- return s
+ return s.to_s
end
# Read a string until the end of the line and append it to `s'.
- meth append_line_to(s: String)
+ fun append_line_to(s: Buffer)
do
- while true do
+ loop
var x = read_char
if x == -1 then
if eof then return
end
# Is there something to read.
- meth eof: Bool is abstract
+ fun eof: Bool is abstract
end
# Abstract output stream
class OStream
-special IOS
+ super IOS
# write a string
- meth write(s: String) is abstract
+ fun write(s: String) is abstract
# Can the stream be used to write
- meth is_writable: Bool is abstract
+ fun is_writable: Bool is abstract
end
# Input streams with a buffer
class BufferedIStream
-special IStream
- redef meth read_char
+ super IStream
+ redef fun read_char
do
assert not eof
if _buffer_pos >= _buffer.length then
return c.ascii
end
- redef meth read(i)
+ redef fun read(i)
do
- var s = new String.with_capacity(i)
+ var s = new Buffer.with_capacity(i)
var j = _buffer_pos
var k = _buffer.length
while i > 0 do
if j >= k then
fill_buffer
- if eof then return s
+ if eof then return s.to_s
j = _buffer_pos
k = _buffer.length
end
end
end
_buffer_pos = j
- return s
+ return s.to_s
end
- redef meth read_all
+ redef fun read_all
do
- var s = ""
+ var s = new Buffer
while not eof do
var j = _buffer_pos
var k = _buffer.length
_buffer_pos = j
fill_buffer
end
- return s
+ return s.to_s
end
- redef meth append_line_to(s)
+ redef fun append_line_to(s)
do
- while true do
+ loop
# First phase: look for a '\n'
var i = _buffer_pos
while i < _buffer.length and _buffer[i] != '\n' do i += 1
end
end
- redef meth eof do return _buffer_pos >= _buffer.length and end_reached
+ redef fun eof do return _buffer_pos >= _buffer.length and end_reached
# The buffer
- attr _buffer: String
+ var _buffer: nullable Buffer = null
# The current position in the buffer
- attr _buffer_pos: Int
+ var _buffer_pos: Int = 0
# Fill the buffer
- protected meth fill_buffer is abstract
+ protected fun fill_buffer is abstract
# Is the last fill_buffer reach the end
- protected meth end_reached: Bool is abstract
+ protected fun end_reached: Bool is abstract
# Allocate a `_buffer' for a given `capacity'.
- protected meth prepare_buffer(capacity: Int)
+ protected fun prepare_buffer(capacity: Int)
do
- _buffer = new String.with_capacity(capacity)
+ _buffer = new Buffer.with_capacity(capacity)
_buffer_pos = 0 # need to read
end
end
class IOStream
-special IStream
-special OStream
+ super IStream
+ super OStream
end
##############################################################"
class FDStream
-special IOS
+ super IOS
# File description
- attr _fd: Int
+ var _fd: Int
- redef meth close do native_close(_fd)
+ redef fun close do native_close(_fd)
- private meth native_close(i: Int): Int is extern "stream_FDStream_FDStream_native_close_1"
- private meth native_read_char(i: Int): Int is extern "stream_FDStream_FDStream_native_read_char_1"
- private meth native_read(i: Int, buf: NativeString, len: Int): Int is extern "stream_FDStream_FDStream_native_read_3"
- private meth native_write(i: Int, buf: NativeString, len: Int): Int is extern "stream_FDStream_FDStream_native_write_3"
+ private fun native_close(i: Int): Int is extern "stream_FDStream_FDStream_native_close_1"
+ private fun native_read_char(i: Int): Int is extern "stream_FDStream_FDStream_native_read_char_1"
+ private fun native_read(i: Int, buf: NativeString, len: Int): Int is extern "stream_FDStream_FDStream_native_read_3"
+ private fun native_write(i: Int, buf: NativeString, len: Int): Int is extern "stream_FDStream_FDStream_native_write_3"
init(fd: Int) do _fd = fd
end
class FDIStream
-special FDStream
-special IStream
- redef readable attr _eof: Bool
+ super FDStream
+ super IStream
+ redef readable var _eof: Bool = false
- redef meth read_char
+ redef fun read_char
do
var nb = native_read_char(_fd)
if nb == -1 then _eof = true
return nb
end
- redef init(fd: Int) do super
+ init(fd: Int) do end
end
class FDOStream
-special FDStream
-special OStream
- redef readable attr _is_writable: Bool
+ super FDStream
+ super OStream
+ redef readable var _is_writable: Bool
- redef meth write(s)
+ redef fun write(s)
do
var nb = native_write(_fd, s.to_cstring, s.length)
if nb < s.length then _is_writable = false
end
- redef init(fd: Int)
+ init(fd: Int)
do
- super
_is_writable = true
end
end
class FDIOStream
-special FDIStream
-special FDOStream
-special IOStream
- redef init(fd: Int)
+ super FDIStream
+ super FDOStream
+ super IOStream
+ init(fd: Int)
do
_fd = fd
_is_writable = true
nitlanguage / nit.git / blobdiff