deferred class BINARY_INPUT_STREAM
Summary
A binary input stream is an input stream that is binary safe (meaning that, except for failure modes, you can read back the very same sequence of bytes you wrote to that stream)
Direct parents
Inherit list: INPUT_STREAM
Known children
Inherit list: BINARY_FILE_READ
Overview
Features
{ANY}
{ANY}
{FILTER_INPUT_STREAM}
{FILTER}
{ANY}
{}
{ANY}
{}
{STREAM_HANDLER}
{FILTER}
{ANY}
{}
{RECYCLING_POOL}
  • recycle
    Do whatever needs to be done to free resources or recycle other objects when recycling this one
{}
  • dispose
    Action to be executed just before garbage collection reclaims an object.
{}
{ANY}
Skipping separators:
{ANY}
To read one number at a time:
{ANY}
To read one line or one word at a time:
{ANY}
Other features:
{ANY}
{}
{FILTER}
read_byte
deferred procedure
{ANY}
Read a byte and assign it to last_byte.
last_byte: INTEGER_32
deferred function
{ANY}
Last byte read with read_byte.
read_integer_16_native_endian
deferred procedure
{ANY}
Read in the same order as the machine running this code.
read_integer_16_big_endian
deferred procedure
{ANY}
Read a big endian value is the file.
read_integer_16_little_endian
deferred procedure
{ANY}
Read a little endian value is the file.
last_integer_16: INTEGER_32
deferred function
{ANY}
Last byte read with read_integer_16_*.
read_integer_32_native_endian
deferred procedure
{ANY}
Read in the same order as the machine running this code.
read_integer_32_big_endian
deferred procedure
{ANY}
Read a big endian value is the file.
read_integer_32_little_endian
deferred procedure
{ANY}
Read a little endian value is the file.
last_integer_32: INTEGER_32
deferred function
{ANY}
read_character
effective procedure
{ANY}
If read_character fail, end_of_input is set.
read_line_in (buffer: STRING)
effective procedure
{ANY}
Same job as read_line but storage is directly done in buffer.
read_available_in (buffer: STRING, limit: INTEGER_32)
effective procedure
{ANY}
Same job as read_available but storage is directly done in buffer.
unread_character
effective procedure
{ANY}
last_character: CHARACTER
effective function
{ANY}
detach
effective procedure
{ANY}
Shake off the filter.
filtered_read_character
deferred procedure
filtered_unread_character
deferred procedure
filtered_last_character: CHARACTER
deferred function
filtered_read_available_in (buffer: STRING, limit: INTEGER_32)
effective procedure
filtered_read_line_in (buffer: STRING)
effective procedure
writable attribute
The filter that uses this stream as backend
event_can_read: EVENT_DESCRIPTOR
effective function
{ANY}
writable attribute
{}
new_url: URL
effective function
{}
is_connected: BOOLEAN
deferred function
{ANY}
True if the stream is connected.
disconnect
deferred procedure
{ANY}
Try to disconnect the stream.
descriptor: INTEGER_32
effective function
{ANY}
Some OS-dependent descriptor.
has_descriptor: BOOLEAN
effective function
{ANY}
True if that stream can be associated to some OS-meaningful descriptor.
can_disconnect: BOOLEAN
deferred function
{ANY}
True if the stream can be safely disconnected (without data loss, etc.)
url: URL
frozen
effective function
{ANY}
The URL to this stream as resource
url_memory: URL
writable attribute
{}
stream_pointer: POINTER
effective function
Some Back-end-dependent pointer (FILE* in C, InputStream or OutputStream in Java)
has_stream_pointer: BOOLEAN
effective function
True if that stream can be associated to some Back-end-meaningful stream pointer.
filtered_descriptor: INTEGER_32
deferred function
Find the descriptor of the terminal stream...
filtered_has_descriptor: BOOLEAN
deferred function
True if the underlying terminal stream has a descriptor
filtered_stream_pointer: POINTER
deferred function
Find the pointer of the terminal stream...
filtered_has_stream_pointer: BOOLEAN
deferred function
True if the underlying terminal stream has a pointer
event_exception: EVENT_DESCRIPTOR
effective function
{ANY}
stream_exception: STREAM_EXCEPTION
writable attribute
{}
recycle
effective procedure
Do whatever needs to be done to free resources or recycle other objects when recycling this one
dispose
effective procedure
{}
Action to be executed just before garbage collection reclaims an object.
sequencer_descriptor (file: POINTER): INTEGER_32
{}
can_read_character: BOOLEAN
deferred function
{ANY}
Note that this state is usually temporary.
can_read_line: BOOLEAN
deferred function
{ANY}
can_unread_character: BOOLEAN
deferred function
{ANY}
valid_last_character: BOOLEAN
deferred function
{ANY}
end_of_input: BOOLEAN
deferred function
{ANY}
end_of_input means the previous attempt in character reading failed because the end has been reached.
is_filtered: BOOLEAN
deferred function
{ANY}
skip_separators
effective procedure
{ANY}
Skip all separators (see is_separator of class CHARACTER) and make the first non-separator available in last_character.
skip_separators_using (separators: STRING)
effective procedure
{ANY}
Same job as skip_separators using the separators set.
skip_remainder_of_line
effective procedure
{ANY}
Skip all the remainder of the line including the end of line delimiter itself.
read_integer
effective procedure
{ANY}
Read an integer according to the Eiffel syntax.
last_integer: INTEGER_32
writable attribute
{ANY}
Last integer read using read_integer.
valid_last_integer: BOOLEAN
writable attribute
{ANY}
Was the last call to read_integer successful ?
last_real: REAL_64
writable attribute
{ANY}
Last real read with read_real.
valid_last_real: BOOLEAN
writable attribute
{ANY}
Was the last call to read_real successful ?
read_real
effective procedure
{ANY}
Read a REAL and make the result available in last_real.
last_string: STRING
once function
{ANY}
Access to the unique common buffer to get for example the result computed by read_line, read_word, newline, etc.
read_line
effective procedure
{ANY}
Read a complete line ended by '%N' or end_of_input.%
read_available (limit: INTEGER_32)
effective procedure
{ANY}
Read as many characters as possible, as long as the stream does not block and up to the given limit.
read_word
effective procedure
{ANY}
Read a word using is_separator of class CHARACTER.
newline
effective procedure
{ANY}
Consume input until newline ('%N') is found.
reach_and_skip (keyword: STRING)
effective procedure
{ANY}
Try to skip enough characters in order to reach the keyword which is skipped too.
read_word_using (separators: STRING)
effective procedure
{ANY}
Same job as read_word using separators.
read_tail_in (str: STRING)
effective procedure
{ANY}
Read all remaining character of the stream in str.
io_getc (stream: POINTER): INTEGER_32
{}
io_ungetc (byte: CHARACTER, stream: POINTER)
{}
io_fread (buf: NATIVE_ARRAY[CHARACTER], size: INTEGER_32, stream: POINTER): INTEGER_32
{}
return size read or 0 if end of input (-1 on error => exception ?)
{}
set_filter (a_filter: FILTER)
effective procedure
Used by the filter itself to get attached