afnix-sio






sio ‐ standard input/output module

The Standard Input/Outputmodule is an orginal implementation
that provides objects for i/o operations. Although input and
output files are the standard objects that one might expect,
the module facilities for directory access, path
manipulation and i/o event management. At the heart of this
module is the concept of stream associated with the
transcoding object which enable the passage between one
coding system to another. It is also this module which
provides the stream selector object.

     outputInputand
The afnix‐siomodule is based on facilities provided by two
base classes, namely, the InputStreamstream and the
OutputStreamstream. Both classes have associated predicates
with the name input‐stream‐pand output‐stream‐p. The base
class associated is the Streamclass those sole purpose is to
define the stream coding mode.

     classStreambase
The Streamclass is the base class for the InputStreamand
OutputStreamclasses. The Streamclass is used to define the
stream coding mode that affects how characters are read or
written. When a stream operates in byte mode, each character
is assumed to be encoded in one byte. In that case, the
input stream methods readand getuare equivalent and no
transformation is performed when writing characters. This
behavior is the default stream behavior. For certain stream,
like terminal, this behavior is changed depending on the
current localization settings. For instance, if the current
locale is operating with an UTF‐8codeset, the Terminalstream
coding mode is automatically adjusted to reflect this
situation. Since the US‐ASCIIcodeset is predominant and the
default steam coding mode is the byte mode, there should be
no conflict during the read and write operations.

     Streamtranscoding
The Streamclass provides the support for the transcoding of
different codesets. All ISO‐8859codesets are supported.
Since the engine operates internally with Unicode
characters, the transcoding operation takes care of changing
a character in one particular codeset into its equivalent
Unicode representation. This operation is done for an input
stream that operates in byte mode. For an output stream, the
opposite operation is done. An internal Unicode characters
representation is therefore mapped into a particular
codeset. Note that only the codeset characters can be
mapped.

Codeset   Description
DEFAULT   Default codeset, i.e US‐ASCII
ISO‐01    ISO‐8859‐1 codeset










                             ‐2‐


ISO‐02    ISO‐8859‐2 codeset
ISO‐03    ISO‐8859‐3 codeset
ISO‐04    ISO‐8859‐4 codeset
ISO‐05    ISO‐8859‐5 codeset
ISO‐06    ISO‐8859‐6 codeset
ISO‐07    ISO‐8859‐7 codeset
ISO‐08    ISO‐8859‐8 codeset
ISO‐09    ISO‐8859‐9 codeset
ISO‐10    ISO‐8859‐10 codeset
ISO‐11    ISO‐8859‐11 codeset
ISO‐13    ISO‐8859‐13 codeset
ISO‐14    ISO‐8859‐14 codeset
ISO‐15    ISO‐8859‐15 codeset
ISO‐16    ISO‐8859‐16 codeset
UTF‐08    Unicode UTF‐8 codeset


The set‐encoding‐modecan be used to set the stream encoding
codeset. The method operates either by enumeration or
string. The get‐encoding‐modereturns the stream encoding
mode. There are some time good reasons to force a stream
encoding mode. For example, a file encoded in UTF‐8 that is
read will require this call since the default stream mode is
to work in byte mode. It should be noted that there is a
difference between the enumeration and the string encoding
mode. The enumeration mode defines whether the stream
operates in byte or UTF‐8 mode. When the stream operates in
byte mode, it is also necessary to define the transcoding
mode with the set‐transcoding‐modemethod. For simplicity,
the string version of the set‐encoding‐modetakes care of
setting both the stream mode and the transcoding mode. It is
also worth to note that internally, the Streamclass is
derived from the Transcoderclass.

     Inputstream
The InputStreambase class has several method for reading and
testing for byte availability. Moreover, the class provides
a push‐back buffer. Reading bytes is in the form of three
methods. The readmethod without argument returns the next
available byte or the end‐of‐streameos. With an integer
argument, the readmethod returns a Bufferwith at most the
number of requested bytes. The readlnmethod returns the next
available line. When it is necessary to read characters
instead of bytes, the getuis more appropriate since it
returns an Unicode character.

     Outputstream
The OutputStreambase class provides the base methods to
write to an output stream. The writemethod takes literal
objects which are automatically converted to string
representation and then written to the output stream. Note
that for the case of a Bufferobject, it is the buffer itself
that take a stream argument and not the opposite.










                             ‐3‐


     predicateThevalid‐p
The input stream provides a general mechanism to test and
read for bytes. The base method is the valid‐ppredicate that
returns trueif a byte can be read from the stream. It is
important to understand its behavior which depends on the
stream type. Without argument, the valid‐ppredicate checks
for an available byte from the input stream. This predicate
will block if no byte is available. On the other end, for a
bounded stream like an input file, the method will not block
at the end of file. With one integer argument, the valid‐
ppredicate will timeout after the specified time specified
in milliseconds. This second behavior is particularly useful
with unbound stream like socket stream.

     predicateTheeos‐p
The eos‐ppredicate does not take argument. The predicate
behaves like not (valid‐p 0). However, there are more subtle
behaviors. For an input file, the predicate will return
trueif and only if a byte cannot be read. If a byte has been
pushed‐back and the end‐of‐streammarker is reached, the
method will return false. For an input terminal, the method
returns true if the user and entered the end‐of‐streambyte.
Once again, the method reacts to the contents of the push‐
back buffer. For certain input stream, like a tcp socket,
the method will return true when no byte can be read, that
is here, the connection has been closed. For an udp socket,
the method will return truewhen all datagram bytes have be
read.

     methodTheread
The readmethod is sometimes disturbing. Nevertheless, the
method is a blocking one and will return a byte when
completed. The noticeable exception is the returned byte
when an end‐of‐streammarker has been reached. The method
returns the ctrl‐dbyte. Since a binary file might contains
valid byte like ctrl‐dit is necessary to use the valid‐por
eos‐ppredicate to check for a file reading completion. This
remark apply also to bounded streams like a tcp socket. For
some type of streams like a udp socket, the method will
block when all datagram bytes have been consumed and no more
datagram has arrived. With this kind of stream, there is no
end‐of‐streamcondition and therefore care should be taken to
properly assert the stream content. This last remark is
especially true for the readlnmethod. The method will return
when the end‐of‐streammarker is reached, even if a newline
byte has not been read. With an udp socket, such behavior
will not happen.

     modeBufferread
The readmethod with an integer argument, returns a buffer
with at least the number of bytes specified as an argument.
This method is particularly useful when the contents has a
precise size. The method returns a Bufferobject which can
later be used to read, or transform bytes. Multi‐byte









                             ‐4‐


conversion to number should use such approach. The
readmethod does not necessarily returns the number of
requested bytes. Once the buffer is returned, the
lengthmethod can be used to check the buffer size. Note also
the existence of the to‐stringmethod which returns a string
representation of the buffer.

# try to read 256 bytes
const buf (is:read 256)
# get the buffer size
println (buf:length)
# get a string representation
println (buf:to‐string)


     Filestream
The afnix‐siomodule provides two classes for file access.
The InputFileclass open a file for input. The
OutputFileclass opens a file for output. The InputFileclass
is derived from the InputStreambase class. The
OutputFileclass is derived from the OutputStreamclass. By
default an output file is created if it does not exist. If
the file already exist, the file is truncated to 0. Another
constructor for the output file gives more control about
this behavior. It takes two boolean flags that defines the
truncate and append mode.

# load the module
interp:library "afnix‐sio"
# create an input file by name
const if (afnix:sio:InputFile "orig.txt")
# create an output file by name
const of (afnix:sio:OutputFile "copy.txt")


     Streaminformation
Both InputFileand OutputFilesupports the get‐namemethod
which returns the file name.

println (if:get‐name)
println (of:get‐name)

Predicates are also available for these classes. The input‐
file‐preturns true for an input file object.The output‐file‐
preturns true for an output file object.

afnix:sio:input‐stream‐p  if
afnix:sio:output‐stream‐p of
afnix:sio:input‐file‐p    if
afnix:sio:output‐file‐p   of


     writingReadingand
The readmethod reads a byte on an input stream. The









                             ‐5‐


writemethod writes one or more literal arguments on the
output stream. The writelnmethod writes one or more literal
arguments followed by a newline byte on the output stream.
The newlinemethod write a newline byte on the output stream.
The eos‐ppredicate returns true for an input stream, if the
stream is at the end. The valid‐ppredicate returns true if
an input stream is in a valid state. With these methods,
copying a file is a simple operation.

# load the module and open the files
interp:library "afnix‐sio"
const if (afnix:sio:InputFile "orig.txt")
const of (afnix:sio:OutputFile "copy.txt")
# loop in the input file and write
while (if:valid‐p) (of:write (if:read))

The use of the readlnmethod can be more effective. The
example below is a simple cat program which take the file
name an argument.

# cat a file on the output terminal
# usage: axi 0601.als file
# get the io module
interp:library "afnix‐sio"
# cat a file
const cat (name) {
  const f (afnix:sio:InputFile name)
  while (f:valid‐p) (println (f:readln))
  f:close
}
# get the file
if (== 0 (interp:argv:length)) {
  errorln "usage: axi 0601.als file"
} {
  cat (interp:argv:get 0)
}


     Multiplexing
I/O multiplexing is the ability to manipulate several
streams at the same time and process one at a time. Although
the use of threads reduce the needs for i/o multiplexing,
there is still situations where they are needed. In other
words, I/O multiplexing is identical to the valid‐
ppredicate, except that it works with several stream
objects.

     Selectorobject
I/O multiplexing is accomplished with the Selectorclass. The
constructor takes 0 or several stream arguments. The class
manages automatically to differentiate between
InputStreamstream and OutputStreamstreams. Once the class is
constructed, it is possible to get the first stream ready
for reading or writing or all of them. We assume in the









                             ‐6‐


following example that isand osare respectively an input and
an output stream.

# create a selector
const slt (afnix:sio:Selector is)
# at this stage the selector has one stream
# the add method can add more streams
slt:add os

The addmethod adds a new stream to the selector. The stream
must be either an InputStreamand OutputStreamstream or an
exception is raised. If the stream is both an input and an
output stream, the preference is given to the input stream.
If this preference is not acceptable, the input‐addor the
output‐addmethods might be preferable. The input‐
lengthmethod returns the number of input streams in this
selector. The output‐lengthmethod returns the number of
output streams in this selector. The input‐getmethod returns
the selector input stream by index. The output‐getmethod
returns the selector output stream by index.

     i/oWaitingfor
The waitand wait‐allmethods can be used to detect a status
change in the selector. Without argument both methods will
block indefinitely until one stream change. With one integer
argument, both method blocks until one stream change or the
integer argument timeout expires. The timeout is expressed
in milliseconds. Note that 0 indicates an immediate return.
The waitmethod returns the first stream which is ready
either for reading or writing depending whether it is an
input or output stream. The wait‐allmethod returns a vector
with all streams that have changed their status. The
waitmethod returns nilif the no stream have changed.
Similarly, the wait‐allmethod returns an empty vector.

# wait for a status change
const is (slt:wait)
# is is ready for reading ‐ make sure it is an input one
if (afnix:sio:input‐stream‐p is) (is:read)

A call to the waitmethod will always returns the first input
stream.

     Markingmode
When used with several input streams in a multi‐threaded
context, the selector behavior can becomes quite
complicated. For this reason, the selector can be configured
to operate in marking mode. In such mode, the selector can
be marked as ready by a thread independently of the bounded
streams. This is a useful mechanism which can be used to
cancel a select loop. The markmethod is designed to mark the
selector while the marked‐ppredicate returns true if the
stream has been marked.










                             ‐7‐


     Terminalstreams
Terminal streams are another kind of streams available in
the standard i/o module. The InputTerm, OutputTermand
ErrorTermclasses are low level classes used to read or write
from or to the standard streams. The basic methods to read
or write are the same as the file streams. Reading from the
input terminal is not a good idea, since the class does not
provide any formatting capability. One may prefer to use the
Terminalclass. The use of the output terminal or error
terminal streams is convenient when the interpreter standard
streams have been changed but one still need to print to the
terminal.

     Terminalclass
The Terminalclass combines an input stream and an output
stream with some line editing capabilities. When the class
is created, the constructed attempts to detect if the input
and output streams are bounded to a terminal (i.e tty). If
the line editing capabilities can be loaded (i.e non
canonical mode), the terminal is initialized for line
editing. Arrows, backspace, delete and other control
sequences are available when using the read‐linemethod. The
standard methods like reador readlndo not use the line
editing features. When using a terminal, the prompt can be
set to whatever the user wishes with the methods set‐
primary‐promptor set‐secondary‐prompt. A secondary prompt is
displayed when the read‐linemethod is called with the
boolean argument false.

const term (Terminal)
term:set‐primary‐prompt "demo:"
const line (term:read‐line)
errorln line


     errorUsingthe
The ErrorTermclass is the most frequently used class for
printing data on the standard error stream. The reserved
keywords erroror errorlnare available to write on the
interpreter error stream. If the interpreter error stream
has been changed, the use of the ErrorTermwill provide the
facility required to print directly on the terminal. The
catprogram can be rewritten to do exactly this.

# cat a file on the error terminal
# get the io module
interp:library "afnix‐sio"
# cat a file
const cat (name es) {
  const f (afnix:sio:InputFile name)
  while (f:valid‐p) (es:writeln (f:readln))
  f:close
}










                             ‐8‐


     Directory
The Directoryclass provides a facility to manipulate
directories. A directory object is created either by name or
without argument by considering the current working
directory. Once the directory object is created, it is
possible to retrieve its contents, create new directory or
remove empty one.

     directoryReadinga
A Directoryobject is created either by name or without
argument. With no argument, the current directory is opened.
When the current directory is opened, its full name is
computed internally and can be retrieved with the get‐
namemethod.

# print the current directory
const pwd (afnix:sio:Directory)
println   (pwd:get‐name)

Once the directory object is opened, it is possible to list
its contents. The get‐listmethod returns the full contents
of the directory object. The get‐filesmethod returns a list
of files in this directory. The get‐subdirsmethod returns a
list of sub directories in this directory.

# print a list of files
const pwd (afnix:sio:Directory)
const lsf (d:get‐files)
for (name) (lsf) (println name)


     removingCreatingand
The mkdirand rmdirmethods can be used to create or remove a
directory. Both methods take a string argument and construct
a full path name from the directory name and the argument.
This approach has the advantage of being file system
independent. If the directory already exists, the
mkdirmethods succeeds. The rmdirmethod requires the
directory to be empty.

const tmp (afnix:sio:Directory (
    afnix:sio:absolute‐path "tmp"))
const exp (tmp:mkdir "examples")
const lsf (exp:get‐files)
println   (lsf:length)
tmp:rmdir "examples"

The function absolute‐pathconstructs an absolute path name
from the argument list. If relative path needs to be
constructed, the function relative‐pathmight be used
instead.

     Logtee
The Logteeclass is a message logger facility associated with









                             ‐9‐


an output stream. When a message is added to the logger
object, the message is also sent to the output stream,
depending on the controlling flags. The name "logtee" comes
from the contraction of "logger" and "tee". One
particularity of the class is that without a stream, the
class behaves like a regular logger.

     loggerCreatinga
The Logteedefault constructor creates a standard logger
object without an output stream. The instance can also be
created by size or with an output stream or both. A third
method can also attach an information string.

# create a logger with the interpreter stream
const log (Logtee (interp:get‐output‐stream))
assert true (logger‐p log)


     Addingmessages
The process of adding messages is similar to the regular
logger. The only difference is that the message is placed on
the output stream if a control flag is set and the message
level is less or equal the report level. In the other word,
the control flag controls the message display ‐‐ the tee
operation ‐‐ while the report level filters some of the
messages.

log:add 2 "a level 2 message"

The set‐teemethod sets the control flag. The set‐report‐
levelmethod sets the report level. Note that the set‐report‐
leveland its associated get‐report‐levelmethod is part of
the base Loggerclass.

     Pathname
The Pathnameclass is a base class designed to ease the
manipulation of system path. It is particularly useful when
it come to manipulate directory component.

     pathCreatinga
A path name is created either by file name or by file and
directory name. In the first case, only the file name is
used. In the second case, the full path name is
characterized.

# create a new path name
const path (afnix:sio:Pathname "axi")


     directoryAddinga
The best way to add a directory path is to use the absolute‐
pathor the relative‐pathfunctions.

# adding a directory path









                            ‐10‐


const name (afnix:sio:absolute‐path "usr" "bin")
path:set‐directory‐name name


     pathGettingthe
The path information can be obtained individually or
globally. The get‐file‐nameand get‐directory‐namemethods
return respectively the file and directory name. The get‐
rootmethod returns the root component of the directory name.
The get‐fullmethod returns the full path name.



     Transcoder
The Transcoderclass is a codeset transcoder class. The class
is responsible to map a byte character in a given codeset
into its associated Unicode character. It should be noted
that not all characters can be transcoded.

     Predicate

     transcoder‐p

     Inheritance

     Object

     Constants

     DEFAULT
     The DEFAULTconstant is used by the set‐transcoding‐
     modemethod to specify the class transcoding mode. In
     default mode, each character is not transcoded. This
     mode is the identity mode.

     I8859‐01
     The I8859‐01constant is used by the set‐transcoding‐
     modemethod to specify the class transcoding mode that
     corresponds to the ISO‐8859‐6 codeset.

     I8859‐02
     The I8859‐02constant is used by the set‐transcoding‐
     modemethod to specify the class transcoding mode that
     corresponds to the ISO‐8859‐2 codeset.

     I8859‐03
     The I8859‐03constant is used by the set‐transcoding‐
     modemethod to specify the class transcoding mode that
     corresponds to the ISO‐8859‐3 codeset.

     I8859‐04
     The I8859‐04constant is used by the set‐transcoding‐
     modemethod to specify the class transcoding mode that
     corresponds to the ISO‐8859‐4 codeset.









                            ‐11‐


     I8859‐05
     The I8859‐05constant is used by the set‐transcoding‐
     modemethod to specify the class transcoding mode that
     corresponds to the ISO‐8859‐5 codeset.

     I8859‐06
     The I8859‐06constant is used by the set‐transcoding‐
     modemethod to specify the class transcoding mode that
     corresponds to the ISO‐8859‐6 codeset.

     I8859‐07
     The I8859‐07constant is used by the set‐transcoding‐
     modemethod to specify the class transcoding mode that
     corresponds to the ISO‐8859‐7 codeset.

     I8859‐08
     The I8859‐08constant is used by the set‐transcoding‐
     modemethod to specify the class transcoding mode that
     corresponds to the ISO‐8859‐8 codeset.

     I8859‐09
     The I8859‐09constant is used by the set‐transcoding‐
     modemethod to specify the class transcoding mode that
     corresponds to the ISO‐8859‐9 codeset.

     I8859‐10
     The I8859‐10constant is used by the set‐transcoding‐
     modemethod to specify the class transcoding mode that
     corresponds to the ISO‐8859‐10 codeset.

     I8859‐11
     The I8859‐11constant is used by the set‐transcoding‐
     modemethod to specify the class transcoding mode that
     corresponds to the ISO‐8859‐11 codeset.

     I8859‐13
     The I8859‐13constant is used by the set‐transcoding‐
     modemethod to specify the class transcoding mode that
     corresponds to the ISO‐8859‐13 codeset.

     I8859‐14
     The I8859‐14constant is used by the set‐transcoding‐
     modemethod to specify the class transcoding mode that
     corresponds to the ISO‐8859‐14 codeset.

     I8859‐15
     The I8859‐15constant is used by the set‐transcoding‐
     modemethod to specify the class transcoding mode that
     corresponds to the ISO‐8859‐15 codeset.

     I8859‐16
     The I8859‐16constant is used by the set‐transcoding‐
     modemethod to specify the class transcoding mode that
     corresponds to the ISO‐8859‐16 codeset.









                            ‐12‐


     Constructors

     Transcoder(none)
     The Transcoderconstructor creates a default transcoder
     that operates in default mode by using the identity
     function.

     Transcoder(constant)
     The Transcoderconstructor creates a transcoder with the
     argument mode.

     Methods

     noneset‐transcoding‐mode‐>
     The set‐transcoding‐modemethod sets the class
     transcoding mode.

     constantget‐transcoding‐mode‐>
     The get‐transcoding‐modemethod returns the class
     transcoding mode.

     Byte|Charactervalid‐p‐>
     The valid‐ppredicate returns true if character can be
     transcoded. If the argument is a byte, the method
     returns true if the byte can be transcoded to a
     character. If the argument is a character, the method
     returns true if the character can be transcoded to a
     byte.

     Byteencode‐>
     The encodemethod encodes a byte into a character. If
     the character cannot be encoded, an exception is
     raised.

     Characterdecode‐>
     The decodemethod decodes a character into a byte. If
     the character cannot be decoded, an exception is
     raised.

     Stream
The Streamclass is a base class for the standard streams.
The class is automatically constructed by a derived class
and provides the common methods for all streams.

     Predicate

     stream‐p

     Inheritance

     Transcoder

     Constants










                            ‐13‐


     BYTE
     The BYTEconstant is used by the set‐coding‐modemethod
     to specify the stream coding mode. In byte mode, each
     character is assumed to be coded with one byte. This
     value affects the getuand writemethods

     UTF‐8
     The UTF‐8constant is used by the set‐coding‐modemethod
     to specify the stream coding mode. In UTF‐8 mode, each
     character is assumed to be coded in the UTF‐8
     representation. This value affects the getuand
     writemethods

     Methods

     noneset‐encoding‐mode‐>
     The set‐encoding‐modemethod sets the stream coding mode
     that affects how characters are read or written. In the
     enumeration form, the method only sets the stream
     coding mode which is either byte or UTF‐8 mode. In the
     string mode, the method sets the stream encoding mode
     and the transcoding mode.

     constantget‐encoding‐mode‐>
     The get‐coding‐modemethod returns the stream coding
     mode which affects how characters are read or written.

     InputStream
The InputStreamclass is a base class for the standard i/o
module. The class is automatically constructed by a derived
class and provides the common methods for all input streams.
The input stream is associated with a timeout value which is
used for read operation. By default, timeout is infinite,
meaning that any read without data will be a blocking one.

     Predicate

     input‐stream‐p

     Inheritance

     Stream

     Methods

     none|Characterflush‐>
     The flushmethod the input stream buffer. In the first
     form, without argument, the input stream buffer is
     entirely flushed. In the second form, the input stream
     buffer is flushed until the character argument is
     found.

     Integerget‐timeout‐>
     The get‐timeoutmethod returns the input stream timeout.









                            ‐14‐


     A negative value is a blocking timeout.

     noneset‐timeout‐>
     The set‐timeoutmethod sets the input stream timeout. A
     negative value is a blocking timeout. Changing the
     stream timeout does not cancel any pending read
     operation.

     Byteread‐>
     The readmethod returns the next byte available from the
     input stream. If the stream has been closed or
     consumed, the end‐of‐streambyte is returned.

     Bufferread‐>
     The readmethod returns a buffer object with at most the
     number of bytes specified as an argument. The buffer
     lengthmethod should be used to check how many bytes
     have been placed in the buffer.

     Stringreadln‐>
     The readlnmethod returns the next line available from
     the input stream. If the stream has been closed or
     consumed, the end‐of‐streamcharacter is returned.

     Charactergetu‐>
     The getumethod returns the next available Unicode
     character from the input stream. If the stream has been
     closed or consumed, the end‐of‐streamcharacter is
     returned. During the read process, if the character
     decoding operation fails, an exception is raised.

     Booleanvalid‐p‐>
     The valid‐pmethod returns true if the input stream is
     in a valid state. By valid state, we mean that the
     input stream can return a byte with a call to the read
     method. With one argument, the method timeout after the
     specified time in milliseconds. If the timeout is null,
     the method returns immediately. With ‐1, the method
     blocks indefinitely if no byte is available.

     Booleaneos‐p‐>
     The eos‐ppredicate returns true if the input stream has
     been closed or all bytes consumed.

     Integerpushback‐>
     The pushbackmethod push‐back a byte, an Unicode
     character or a string in the input stream. Subsequent
     calls to read will return the last pushed bytes.
     Pushing a string is equivalent to push each encoded
     bytes of the string. The method returns the number of
     bytes pushed back.

     Integerconsume‐>
     The consumemethod consumes an input stream and places









                            ‐15‐


     the read characters into the stream buffer. The method
     returns the number of consumed characters. This method
     is generally used in conjonction with the to‐
     stringmethod.

     Integerget‐buffer‐length‐>
     The get‐buffer‐lengthmethod returns the length of the
     push‐back buffer.

     Stringto‐string‐>
     The to‐stringmethod returns a string representation of
     the input stream buffer.

     InputFile
The InputFileclass provide the facility for an input file
stream. An input file instance is created with a file name.
If the file does not exist or cannot be opened, an exception
is raised. The InputFileclass is derived from the
InputStreamclass.

     Predicate

     input‐file‐p

     Inheritance

     InputStreamNameable

     Constructors

     InputFile(String)
     The InputFileconstructor create an input file by name.
     If the file cannot be created, an exception is raised.
     The first argument is the file name to open.

     String)InputFile(String
     The InputFileconstructor create an input file by name
     and encoding mode. If the file cannot be created, an
     exception is raised. The first argument is the file
     name to open.The second argument is the encoding mode
     to use.

     Methods

     Booleanclose‐>
     The closemethod close the input file and returns true
     on success, false otherwise. In case of success,
     multiple calls return true.

     nonelseek‐>
     The lseekset the input file position to the integer
     argument. Note that the push‐back buffer is reset after
     this call.










                            ‐16‐


     Integerlength‐>
     The lengthmethod returns the length of the input file.
     The length is expressed in bytes.

     Integerget‐modification‐time‐>
     The get‐modification‐timemethod returns the
     modification time of the file. The returned argument is
     suitable for the Timeand Datesystem classes.

     InputMapped
The InputMappedclass is an input stream class that provides
the facility for reading a mapped input stream. The input
stream is mapped at construction given a file name, a size
and a file offset. An anonymous mapped input stream can also
be designed with a buffer object. Finally, without any
information an always valid null input stream is
constructed.

     Predicate

     input‐mapped‐p

     Inheritance

     InputStream

     Constructors

     InputMapped(none)
     The InputMappedconstructor create a null input stream.
     This stream acts as a null character generator.

     InputMapped(String|Buffer)
     The InputMappedconstructor create a mapped input stream
     by name or buffer. In the first form, a string is used
     as file name to be mapped an input stream. In the
     second form, a buffer is mapped as an input stream.

     IntegerInputMapped(String
     The InputMappedconstructor create a mapped input stream
     by name, size and offset. The string argument is the
     file name to map. The second argument is the desired
     mapped size. The third argument is the offset inside
     the file before mapping it.

     Methods

     nonelseek‐>
     The lseekset the input mapped file position to the
     integer argument. Note that the push‐back buffer is
     reset after this call.

     Integerlength‐>
     The lengthmethod returns the length of the input mapped









                            ‐17‐


     file. The length is expressed in bytes.

     InputString
The InputStringclass provide the facility for an input
string stream. The class is initialized or set with a string
and then behaves like a stream. This class is very useful to
handle generic stream method without knowing what kind of
stream is behind it.

     Predicate

     input‐string‐p

     Inheritance

     InputStream

     Constructors

     InputString(none)
     The InputStringconstructor creates an empty input
     string.

     InputString(String)
     The InputStringconstructor creates an input string by
     value.

     Methods

     Byteget‐>
     The getmethod returns the next available byte from the
     input stream but do not remove it.

     noneset‐>
     The setmethod sets the input string by first resetting
     the push‐back buffer and then initializing the input
     string with the argument value.

     InputTerm
The InputTermclass provide the facility for an input
terminal stream. The input terminal reads byte from the
standard input stream. No line editing facility is provided
with this class This is a low level class, and normally, the
Terminalclass should be used instead.

     Predicate

     input‐term‐p

     Inheritance

     InputStreamOutputStream











                            ‐18‐


     Constructors

     InputTerm(none)
     The InputTermconstructor creates a default input
     terminal.

     Methods

     noneset‐ignore‐eos‐>
     The set‐ignore‐eosmethod set the input terminal end‐of‐
     streamignore flag. When the flag is on, any character
     that match a ctrl‐dis changed to the end‐of‐stream
     mapped character returned by a read. This method is
     useful to prevent a reader to exit when the ctrl‐dbyte
     is generated.

     noneset‐mapped‐eos‐>
     The set‐mapped‐eosmethod set the input terminal end‐of‐
     streammapped character. By default the character is set
     to end‐of‐line. This method should be used in
     conjunction with the set‐ignore‐eosmethod.

     OutputStream
The OutputStreamclass is a base class for the standard i/o
module. The class is automatically constructed by a derived
class and provide the common methods for all output streams.

     Predicate

     output‐stream‐p

     Inheritance

     Stream

     Methods

     Integerwrite‐>
     The writemethod write one or more literal arguments on
     the output stream. This method returns the number of
     characters written.

     nonewriteln‐>
     The writelnmethod write one or more literal argument to
     the output stream and finish with a newline. This
     method return nil.

     noneerrorln‐>
     The errorlnmethod write one or more literal argument to
     the associated output error stream and finish with a
     newline. Most of the time, the output stream and error
     stream are the same except for an output terminal.

     nonenewline‐>









                            ‐19‐


     The newlinemethod writes a new line byte to the output
     stream. The method returns nil.

     nonewrite‐soh‐>
     The write‐sohmethod writes a start‐of‐headingcharacter
     to the output stream.

     nonewrite‐stx‐>
     The write‐stxmethod writes a start‐of‐
     transmissioncharacter to the output stream.

     nonewrite‐etx‐>
     The write‐etxmethod writes an end‐of‐
     transmissioncharacter to the output stream.

     nonewrite‐eos‐>
     The write‐eosmethod writes an end‐of‐streamcharacter to
     the output stream.

     OutputFile
The OutputFileclass provide the facility for an output file
stream. An output file instance is created with a file name.
If the file does not exist, it is created. If the file
cannot be created, an exception is raised. Once the file is
created, it is possible to write literals. The class is
derived from the OutputStreamclass. By default an output
file is created if it does not exist. If the file already
exist, the file is truncated to 0. Another constructor for
the output file gives more control about this behavior. It
takes two boolean flags that defines the truncate and append
mode. The t‐flagis the truncate flag. The a‐flagis the
append flag.

     Predicate

     output‐file‐p

     Inheritance

     OutputStreamNameable

     Constructors

     OutputFile(String)
     The OutputFileconstructor create an output file by
     name. If the file cannot be created, an exception is
     raised. The first argument is the file name to create.

     String)OutputFile(String
     The OutputFileconstructor create an output file by name
     and encoding mode. If the file cannot be created, an
     exception is raised. The first argument is the file
     name to create. The second argument is the encoding
     mode to use.









                            ‐20‐


     BooleanOutputFile(String
     The OutputFileconstructor create an output file by
     name. If the file cannot be created, an exception is
     raised. The first argument is the file name to create.
     The second argument is the truncate flag. If the file
     already exists and the truncate flag is set, the file
     is truncated to 0. The third argument is the append
     mode. If set to true, the file is open in append mode.

     Methods

     Booleanclose‐>
     The closemethod closes the output file and returns true
     on success, false otherwise. In case of success,
     multiple calls returns true.

     OutputString
The OutputStringclass provide the facility for an output
string stream. The class is initially empty and acts as a
buffer which accumulate the write method bytes. The to‐
stringmethod can be used to retrieve the buffer content.

     Predicate

     output‐string‐p

     Inheritance

     OutputStream

     Constructors

     OutputString(none)
     The OutputStringconstructor creates a default output
     string.

     OutputString(String)
     The OutputStringconstructor creates an output string by
     value. The output string stream is initialized with the
     string value.

     Methods

     noneflush‐>
     The flushmethod flushes the output stream by resetting
     the stream buffer.

     Integerlength‐>
     The lengthmethod returns the length of the output
     string buffer.

     Stringto‐string‐>
     The to‐stringmethod returns a string representation of
     the output string buffer.









                            ‐21‐


     OutputBuffer
The OutputBufferclass provide the facility for an output
byte stream. The class is initially empty and acts as a
buffer which accumulate the write method bytes. The to‐
stringmethod can be used to retrieve the buffer content as a
string. The formatmethod can be used to retrieve the buffer
content as an octet string. content.

     Predicate

     output‐buffer‐p

     Inheritance

     OutputStream

     Constructors

     OutputBuffer(none)
     The OutputBufferconstructor creates a default output
     buffer.

     OutputBuffer(String)
     The OutputBufferconstructor creates an output buffer by
     value. The output buffer stream is initialized with the
     string value.

     Methods

     noneflush‐>
     The flushmethod flushes the output stream by resetting
     the stream buffer.

     Integerlength‐>
     The lengthmethod returns the length of the output
     buffer.

     Stringto‐string‐>
     The to‐stringmethod returns a string representation of
     the output buffer.

     Stringformat‐>
     The formatmethod returns an octet string representation
     of the output buffer.

     OutputTerm
The OutputTermclass provide the facility for an output
terminal. The output terminal is defined as the standard
output stream. If the standard error stream needs to be
used, the ErrorTermclass is more appropriate.

     Predicate

     output‐term‐p









                            ‐22‐


     Inheritance

     OutputStream

     Constructors

     OutputTerm(none)
     The OutputTermconstructor creates a default output
     terminal

     ErrorTerm(none)
     The ErrorTermconstructor creates a default error
     terminal

     Terminal
The Terminalclass provides the facility for an i/o terminal
with line editing capability. The class combines the
InputTermand OutputTermmethods.

     Predicate

     terminal‐p

     Inheritance

     InputTermOutputTerm

     Constructors

     Terminal(none)
     The Terminalconstructor creates a default terminal
     which combines an input and output terminal with line
     editing capabilities.

     Methods

     noneset‐primary‐prompt‐>
     The set‐primary‐promptmethod sets the terminal primary
     prompt which is used when the read‐linemethod is
     called.

     noneset‐secondary‐prompt‐>
     The set‐secondary‐promptmethod sets the terminal
     secondary prompt which is used when the read‐linemethod
     is called.

     Stringget‐primary‐prompt‐>
     The get‐primary‐promptmethod returns the terminal
     primary prompt.

     Stringget‐secondary‐>
     The get‐secondary‐promptmethod returns the terminal
     secondary prompt.










                            ‐23‐


     Intercom
The Intercomclass is the interpreter communication class.
The class operates with two streams. One output stream is
used to send serialized data while the input stream is used
to deserialize data. The sendmethod can be used to send the
data, while the recvcan be used to receive them.

     Predicate

     intercom‐p

     Inheritance

     Object

     Constructors

     Intercom(none)
     The Intercomconstructor creates a default interpreter
     communication object. There is no stream attached to
     it.

     Intercom(InputStream|OutputStream)
     The Intercomconstructor creates an interpreter
     communication object with an input or an output stream.
     In the first form, the input stream object is used by
     the recvmethod to read data object. In the second form,
     the output stream object is used by the sendmethod to
     send data object.

     OutputStream)Intercom(InputStream
     The Intercomconstructor creates an interpreter
     communication object with an input and an output
     stream.

     Methods

     nonesend‐>
     The sendmethod serialize the object argument with the
     help of the output stream bound to the interpreter
     communication object. If there is no output stream,
     nothing is sent.

     Objectrecv‐>
     The recvmethod deserialize an object with the help of
     the input stream bound to the interpreter communication
     object. If there is no output stream, nilis returned.

     Objectrequest‐>
     The requestmethod perform an atomic send receive
     operation.

     noneset‐input‐stream‐>
     The set‐input‐streammethod binds an input stream to the









                            ‐24‐


     interpreter communication object.

     InputStreamget‐input‐stream‐>
     The get‐input‐streammethod returns the input stream
     bound to the interpreter communication object.

     noneset‐output‐stream‐>
     The set‐output‐streammethod binds an output stream to
     the interpreter communication object.

     OutputStreamget‐output‐stream‐>
     The get‐output‐streammethod returns the output stream
     bound to the interpreter communication object.

     InputOutput
The InputOutputclass implements an input‐output stream with
a buffer which holds character during the processing of
transit between the output stream to the input stream. The
theory of operation goes as follow. The internal buffer is
filled with characters with the help of the output stream.
The characters are consumed from the buffer with the help of
the input stream (read method). If the buffer becomes empty
the eos‐ppredicate returns true, the valid‐ppredicate false
and the readmethod will return the eoscharacter. The
InputOutput buffer can also be initialized with a buffer.
This provides a nice mechanism to use a buffer like an input
stream. The i/o operations implemented by this class are
non‐blocking. As a consequence, it is not possible to
suspend a thread with this class and have it awaken when
some characters are available in the input stream.

     Predicate

     input‐output‐p

     Inheritance

     InputStreamOutputStream

     Constructors

     InputOutput(none)
     The InputOutputconstructor creates a default
     input/output stream.

     InputOutput(String)
     The InputOutputconstructor creates an input/output
     stream initialized with the string argument. The string
     argument is used to fill the string buffer.

     Methods

     Byteget‐>
     The getmethod returns the next available byte from the









                            ‐25‐


     input stream but do not remove it.

     noneset‐>
     The setmethod sets the input string by first resetting
     the push‐back buffer and then initializing the input
     string with the argument value.

     Selector
The Selectorclass provides some facilities to perform i/o
multiplexing. The constructor takes 0 or several stream
arguments.The class manages automatically the
differentiation between the InputStreamand the
OutputStreamobjects. Once the class is constructed, it is
possible to get the first stream ready for reading or
writing or all of them. It is also possible to add more
steams after construction with the addmethod. When a call to
the waitmethod succeeds, the method returns the first
available stream. If the waitallmethod is called, the method
returns a vector with all ready steams. The selector can be
configured to operate in marking mode. In such mode, the
selector can be marked as ready by a thread independently of
the bounded streams. This is a useful mechanism which can be
used to cancel a select loop. The markmethod is designed to
mark the selector while the marked‐ppredicate returns true
if the stream has been marked.

     Predicate

     selector

     Inheritance

     Object

     Constructors

     Selector(none)
     The Selectorconstructor creates a default stream
     selector.

     [InputStream|OutputStream]*)Selector([Boolean]
     The Selectorconstructor creates a stream selector with
     0 or more stream arguments. If the first argument is a
     boolean, the selector is constructed marked mode.

     Methods

     noneadd‐>
     The addmethod adds an input or output stream to the
     selector. If the stream is both an input and an output
     stream, the preference is given to the input stream. If
     this preference is not acceptable, the input‐addor the
     output‐addmethods might be preferable.










                            ‐26‐


     noneinput‐add‐>
     The input‐addmethod adds an input stream to the
     selector.

     noneoutput‐add‐>
     The output‐addmethod adds an output stream to the
     selector.

     Streamwait‐>
     The waitmethod waits for a status change in the
     selector and returns the first stream that has change
     status. With one argument, the selector time‐out after
     the specified time in milliseconds. Note that at the
     time of the return, several streams may have changed
     status.

     Vectorwait‐all‐>
     The waitmethod waits for a status change in the
     selector and returns all streams that has change status
     in a vector object. With one argument, the selector
     time‐out after the specified time in milliseconds. If
     the selector has timed‐out, the vector is empty.

     InputStreaminput‐get‐>
     The input‐getmethod returns the input streams in the
     selector by index. If the index is out of bound, an
     exception is raised.

     OutputStreamoutput‐get‐>
     The output‐getmethod returns the output streams in the
     selector by index. If the index is out of bound, an
     exception is raised.

     Integerinput‐length‐>
     The input‐lengthmethod returns the number of input
     streams in the selector.

     Integeroutput‐length‐>
     The output‐lengthmethod returns the number of output
     streams in the selector.

     nonemark‐>
     The markmethod marks a selector object.

     Booleanmarked‐p‐>
     The marked‐ppredicate returns true if the selector has
     been marked.

     Logtee
The Logteeclass provides the facility of a logger object
associated with an output stream. When a message is added,
the message is written to the output stream depending on an
internal flag. By default the tee mode is false and can be
activated with the set‐teemethod.









                            ‐27‐


     Predicate

     logtee‐p

     Inheritance

     Logger

     Constructors

     Logtee(none)
     The Logteeconstructor creates a default logger without
     an output stream.

     Logtee(Integer)
     The Logteeconstructor creates a logger with a specific
     size without an output stream. terminal

     Logtee(OutputStream)
     The Logteeconstructor creates a logger with an output
     stream. The object is initialized to operate in write
     mode.

     OutputStream)Logtee(Integer
     The Logteeconstructor creates a logger with a specific
     size with an output stream. The first argument is the
     logger size. The second argument is the output stream.

     StringLogtee(Integer
     The Logteeconstructor creates a logger with a specific
     size, an information string and an output stream. The
     first argument is the logger size. The second argument
     is information string. The third argument is the output
     stream.

     Methods

     noneset‐tee‐stream‐>
     The set‐tee‐streammethod sets the tee output stream.
     This stream is different from the logger output stream

     OutputStreamget‐tee‐stream‐>
     The get‐tee‐streammethod returns the object output
     stream.

     noneset‐tee‐>
     The set‐teemethod sets the object tee flag. When the
     flag is true, the logger writes the added message on
     the output stream.

     Booleanget‐tee‐>
     The get‐teemethod returns the object tee flag. When the
     flag is true, the logger writes the added message on
     the output stream.









                            ‐28‐


     Pathname
The Pathnameclass is a base class designed to manipulate
system i/o paths. The class operates with a directory name
and a file name. Both names are kept separated to ease the
path manipulation. The path components can be extracted
individually. However, it shall be noted that the first
component has a special treatment to process the root
directory name.

     Predicate

     pathname‐p

     Inheritance

     Object

     Constructors

     Pathname(none)
     The Pathnameconstructor creates a default path name
     without file and directory names.

     Pathname(String)
     The Pathnameconstructor creates a path name with a file
     name. The first string argument is the file name.

     String)Pathname(String
     The Pathnameconstructor creates a pathname with a file
     and directory name. The first string argument is the
     file name. The second string argument is the directory
     name.

     Methods

     nonereset‐>
     The resetmethod reset the path name by removing all
     path and file information.

     Booleandir‐p‐>
     The dir‐ppredicate returns true if the path is a
     directory.

     Booleanfile‐p‐>
     The file‐ppredicate returns true if the path is a file.

     noneset‐file‐name‐>
     The set‐file‐namemethod set the path name file name.
     The string argument is the file name.

     Stringget‐file‐name‐>
     The get‐file‐namemethod returns the path name file
     name.










                            ‐29‐


     noneadd‐directory‐name‐>
     The add‐directory‐namemethod add the directory name to
     the directory path component. The string argument is
     the directory name.

     noneset‐directory‐name‐>
     The set‐directory‐namemethod set the directory name
     file name. The string argument is the directory name.

     Stringget‐directory‐name‐>
     The get‐directory‐namemethod returns the path name
     directory name.

     Integerlength‐>
     The lengthmethod returns the number of directory path
     elements.

     Stringget‐path‐>
     The get‐pathmethod returns a directory path element by
     index.

     Stringget‐root‐>
     The get‐rootmethod returns the root component of a
     directory name.

     Stringget‐full‐>
     The get‐fullmethod returns the full path name by
     combining the directory name with the file name.

     noneadd‐path‐>
     The add‐pathmethod add a new path component by name.
     The path is separated into individual component and
     added to the directory path unless it is a root path.
     If the file name is set, the file name is added as a
     directory component. If the path is a root path, a new
     path name is rebuilt. This last case is equivalent to a
     call to set‐file‐name.

     nonenormalize‐>
     The normalizemethod rebuild the path name by
     determining the full path nature if possible. In case
     of success, the path structure reflects the actual path
     type.

     Pathlist
The Pathlistclass is a base class designed to ease the
manipulation of a file search path. The class acts like a
list of search paths and various facilities are provided to
find a valid path for a given name. The path list can be
manipulated like any other list.

     Predicate

     pathlist‐p









                            ‐30‐


     Inheritance

     Object

     Constructors

     Pathlist(none)
     The Pathlistconstructor creates a default path list.

     Pathlist(Boolean|String)
     The Pathlistconstructor creates a path list with a
     local search flag or with an initial path component. In
     the first form, a boolean argument controls the local
     search flag. In the second for, a string argument is
     used as the initial path component.

     Methods

     nonereset‐>
     The resetmethod resets the path list by clearing the
     local search flag and removing all path components.

     Booleanlocal‐p‐>
     The local‐ppredicate returns true if the local search
     flag is set.

     noneset‐local‐search‐>
     The set‐local‐searchmethod sets the local search flag.

     Integerlength‐>
     The lengthmethod returns the number of directory path
     elements.

     Stringget‐path‐>
     The get‐pathmethod returns a directory path element by
     index.

     noneadd‐path‐>
     The add‐pathmethod add a new path component by name.
     The string argument is the name to add.

     Booleanfile‐p‐>
     The file‐ppredicate returns true if the file name
     argument can be resolved. If the local search flag is
     set, the local directory is check first.

     Stringresolve‐>
     The resolvemethod returns a string representation of
     the resolved file path. If the local search flag is set
     and the file name is found locally, the initial name
     argument is returned.

     Functions










                            ‐31‐


     Booleandir‐p‐>
     The dir‐pfunction returns true if the argument name is
     a directory name, false otherwise.

     Booleanfile‐p‐>
     The file‐pfunction returns true if the argument name is
     a regular file name, false otherwise.

     Stringtmp‐name‐>
     The tmp‐namefunction returns a name suitable for the
     use as a temporary file name. Without argument, a
     default prefix is used to build the name. An optional
     string prefix can control the original name.

     Stringtmp‐path‐>
     The tmp‐pathfunction returns a path suitable for the
     use as a temporary file name. Without argument, a
     default prefix is used to build the path. An optional
     string prefix can control the original name.

     Stringabsolute‐path‐>
     The absolute‐pathfunction returns an absolute path name
     from an argument list. Without argument, the command
     returns the root directory name. With one or several
     argument, the absolute path is computed from the root
     directory.

     Stringrelative‐path‐>
     The relative‐pathfunction returns a relative path name
     from an argument list. With one argument, the function
     returns it. With two or more arguments, the relative
     path is computed by joining each argument with the
     previous one.

     nonermfile‐>
     The rmfilefunction removes one or several files
     specified as the arguments. If one file fails to be
     removed, an exception is raised.

     nonemkdir‐>
     The mkdirfunction creates one or several directories
     specified as the arguments. If one directory fails to
     be created, an exception is raised.

     nonemhdir‐>
     The mhdirfunction creates hierarchically one or several
     directories specified as the arguments. If one
     directory fails to be created, an exception is raised.

     nonermdir‐>
     The rmdirfunction removes one or several directories
     specified as the arguments. If one directory fails to
     be removed, an exception is raised.










                            ‐32‐


     Stringget‐base‐name‐>
     The get‐base‐namefunction returns the base name from a
     path. The base name can be either a file name or a
     directory name. By definition, a path is made of a base
     path and a base name.

     Stringget‐base‐path‐>
     The get‐base‐pathfunction returns the base path from a
     path. The base path is a directory name. By definition,
     a path is made of a base path and a base name.

     Stringget‐extension‐>
     The get‐extensionfunction returns the extension from a
     path.

     Stringremove‐extension‐>
     The remove‐extensionfunction returns the extension from
     a path. In order to get a base file name from a path,
     the get‐base‐namefunction must be called first.

     Directory
The Directoryclass provides some facilities to access a
directory. By default, a directory object is constructed to
represent the current directory. With one argument, the
object is constructed from the directory name. Once the
object is constructed, it is possible to retrieve its
content.

     Predicate

     directory‐p

     Inheritance

     Object

     Constructors

     Directory(none)
     The Directoryconstructor creates a directory object
     those location is the current directory. If the
     directory cannot be opened, an exception is raised.

     Directory(String)
     The Directoryconstructor create a directory object by
     name. If the directory cannot be opened, an exception
     is raised. The first argument is the directory name to
     open.

     Methods

     Directorymkdir‐>
     The mkdirmethod creates a new directory in the current
     one. The full path is constructed by taking the









                            ‐33‐


     directory name and adding the argument. Once the
     directory is created, the method returns a directory
     object of the newly constructed directory. An exception
     is thrown if the directory cannot be created.

     nonermdir‐>
     The rmdirmethod removes an empty directory. The full
     path is constructed by taking the directory name and
     adding the argument. An exception is thrown if the
     directory cannot be removed.

     nonermfile‐>
     The rmfilemethod removes a file in the current
     directory. The full path is constructed by taking the
     directory name and adding the argument. An exception is
     thrown if the file cannot be removed.

     Stringget‐name‐>
     The get‐namemethod returns the directory name. If the
     default directory was created, the method returns the
     full directory path.

     Listget‐list‐>
     The get‐listmethod returns the directory contents. The
     method returns a list of strings. The list contains all
     valid names at the time of the call, including the
     current directory and the parent directory.

     Listget‐files‐>
     The get‐filesmethod returns the directory contents. The
     method returns a list of strings of files. The list
     contains all valid names at the time of the call.

     Listget‐subdirs‐>
     The get‐subdirsmethod returns the sub directories. The
     method returns a list of strings of sub‐directories.
     The list contains all valid names at the time of the
     call, including the current directory and the parent
     directory.

     Stringnext‐name‐>
     The next‐namemethod returns the next available name
     from the directory stream. This method is useful when
     operating with a large number of elements.

     Stringnext‐path‐>
     The next‐pathmethod returns the next available path
     name from the directory stream. This method is useful
     when operating with a large number of elements.

     Stringnext‐file‐name‐>
     The next‐file‐namemethod returns the next available
     file name from the directory stream. This method is
     useful when operating with a large number of elements.









                            ‐34‐


     Stringnext‐file‐path‐>
     The next‐file‐pathmethod returns the next available
     file path name from the directory stream. This method
     is useful when operating with a large number of
     elements.

     Stringnext‐dir‐name‐>
     The next‐dir‐namemethod returns the next available
     directory name from the directory stream. This method
     is useful when operating with a large number of
     elements.

     Stringnext‐dir‐path‐>
     The next‐dir‐pathmethod returns the next available
     directory path name from the directory stream. This
     method is useful when operating with a large number of
     elements.

     Logtee
The Logteeclass is a message logger facility associated with
an output stream. When a message is added to the logger
object, the message is also sent to the output stream,
depending on the controlling flags. The name "logtee" comes
from the contraction of "logger" and "tee". One
particularity of the class is that without a stream, the
class behaves like a regular logger.

     Predicate

     logtee‐p

     Inheritance

     Logger

     Constructors

     Logtee(none)
     The Logteeconstructor creates a default logger without
     an output stream

     Logtee(Integer)
     The Logteeconstructor creates a logger object with a
     specific size without an output stream.

     Logtee(Output)
     The Logteeconstructor creates a logger object with an
     output stream.

     Output)Logtee(Integer
     The Logteeconstructor creates a logger object with a
     specific size and an output stream. The first argument
     is the logger window size. The second argument is the
     output stream.









                            ‐35‐


     StringLogtee(Integer
     The Logteeconstructor creates a logger object with a
     specific size, an information string and an output
     stream. The first argument is the logger window size.
     The second argument is the logger information string.
     The third argument is the output stream.

     Methods

     noneset‐output‐stream‐>
     The set‐output‐streammethod attaches the output stream
     to the logtee object.

     Outputget‐output‐stream‐>
     The get‐output‐streammethod returns the logtee output
     stream.

     noneset‐tee‐>
     The set‐teemethod sets the logtee control flag. The
     control flag controls the message display to the output
     stream.

     Booleanget‐tee‐>
     The get‐teemethod returns the logtee output stream.

     NamedFifo
The NameFifoclass is a string vector designed to operate as
a stream fifo object. The class provides the facility to
read or write the fifo content from a stream. The stream can
be created by name for writing, in which case the named fifo
operates as a backup object.

     Predicate

     named‐fifo‐p

     Inheritance

     StrvecNameable

     Constructors

     NamedFifo(none)
     The NamedFifoconstructor creates a default named fifo
     without a backing name. In this case the fifo cannot be
     read or written by stream.

     NamedFifo(String)
     The NamedFifoconstructor creates a named fifo by name.
     The name is used as a file name for reading or writing
     the fifo.

     Boolean)NamedFifo(String
     The NamedFifoconstructor creates a named fifo by name.









                            ‐36‐


     The name is used as a file name for reading or writing
     the fifo.If the boolean argument is true, the fifo is
     read.

     Methods

     noneread‐>
     The readmethod reads the fifo file name and fill the
     fifo.

     nonewrite‐>
     The writemethod writes the fifo contents to the fifo
     file name.

     noneset‐name‐>
     The set‐namemethod sets the fifo file name.

     FileInfo
The FileInfois a file information class that holds the
primary information related to a file, such like its size or
its modification time. The file information is set at
construction but can be updated with the help of the
updatemethod.

     Predicate

     file‐info‐p

     Inheritance

     Nameable

     Constructors

     (String)
     The FileInfoconstructor creates a file information by
     name. The string argument is the file name to query.

     Methods

     Integerlength‐>
     The lengthmethod returns the file size information.

     Integerget‐modification‐time‐>
     The get‐modification‐timemethod returns the file
     modification time. The time can be used as an argument
     to the Timeor Dateobject.

     noneupdate‐>
     The updatemethod the file information data.