sio - standard input/output module

       sio - standard input/output module

       The  Standard  Input/Output module 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.

       Inputandoutputstreams
       The afnix-sio module is based on facilities provided by two base classes, namely, the InputStream  stream
       and  the  OutputStream  stream.  Both classes have associated predicates with the name input-stream-p and
       output-stream-p. The base class associated is the Stream class those sole purpose is to define the stream
       coding mode.

       Streambaseclass
       The Stream class is the base class for the InputStream and OutputStream classes. The Stream class 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
       read and getu are 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-8 codeset,
       the Terminal stream coding mode is automatically adjusted to reflect this situation. Since  the  US-ASCII
       codeset  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 Stream class provides the support for the transcoding of different codesets.  All  ISO-8859  codesets
       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
       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-mode can be used to set the stream encoding  codeset.  The  method  operates  either  by
       enumeration  or  string. The get-encoding-mode returns 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-mode method. For simplicity, the string version of
       the set-encoding-mode takes care of setting both the stream mode and the transcoding  mode.  It  is  also
       worth to note that internally, the Stream class is derived from the Transcoder class.

       Inputstream
       The  InputStream  base  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  read  method
       without  argument  returns the next available byte or the end-of-streameos. With an integer argument, the
       read method returns a Buffer with at most the number of requested bytes. The readln  method  returns  the
       next  available  line.  When  it  is  necessary  to  read  characters  instead of bytes, the getu is more
       appropriate since it returns an Unicode character.

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

       Thevalid-ppredicate
       The  input stream provides a general mechanism to test and read for bytes. The base method is the valid-p
       predicate that returns true if 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-p predicate 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-p predicate will timeout after the specified time specified in  milliseconds.
       This second behavior is particularly useful with unbound stream like socket stream.

       Theeos-ppredicate
       The  eos-p  predicate  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 true if and only if a byte cannot
       be read. If a byte has been pushed-back and the end-of-stream marker is reached, the method  will  return
       false.  For  an  input  terminal, the method returns true if the user and entered the end-of-stream byte.
       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 true when all datagram bytes have be read.

       Thereadmethod
       The read method 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-stream marker has been
       reached. The method returns the ctrl-d byte. Since a binary file might contains valid byte like ctrl-d it
       is necessary to use the valid-p or eos-p predicate 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-stream condition and therefore care should be taken  to  properly  assert  the
       stream  content.  This  last remark is especially true for the readln method. The method will return when
       the end-of-stream marker is reached, even if a newline byte has not been read. With an udp  socket,  such
       behavior will not happen.

       Bufferreadmode
       The read method 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 Buffer object which can later be used to read, or transform  bytes.  Multi-byte  conversion  to  number
       should  use  such  approach.  The read method does not necessarily returns the number of requested bytes.
       Once the buffer is returned, the length method can be used to  check  the  buffer  size.  Note  also  the
       existence of the to-string method 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-sio module provides two classes for file access. The InputFile class open a file for input. The
       OutputFile class opens a file for output. The InputFile class is derived from the InputStream base class.
       The  OutputFile  class is derived from the OutputStream class. 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 InputFile and OutputFile supports the get-name method which returns the file name.

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

       Predicates  are  also  available  for  these  classes.  The  input-file-p  returns true for an input file
       object.The output-file-p returns 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

       Readingandwriting
       The read method reads a byte on an input stream. The write method writes one or more literal arguments on
       the output stream. The writeln method writes one or more literal arguments followed by a newline byte  on
       the  output  stream.  The  newline  method write a newline byte on the output stream. The eos-p predicate
       returns true for an input stream, if the stream is at the end. The valid-p predicate 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 readln method 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-p predicate, except that it works
       with several stream objects.

       Selectorobject
       I/O multiplexing is accomplished with the Selector class. The  constructor  takes  0  or  several  stream
       arguments.  The  class manages automatically to differentiate between InputStream stream and OutputStream
       streams. 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 following example that is and os are 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 add method adds a new stream  to  the  selector.  The  stream  must  be  either  an  InputStream  and
       OutputStream  stream  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-add  or  the
       output-add  methods  might  be preferable. The input-length method returns the number of input streams in
       this selector. The output-length method returns the number of output streams in this selector. The input-
       get method returns the selector input stream by index. The output-get method returns the selector  output
       stream by index.

       Waitingfori/oevent
       The  wait  and  wait-all  methods 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 wait method returns the first  stream  which
       is  ready  either  for reading or writing depending whether it is an input or output stream. The wait-all
       method returns a vector with all streams that have changed their status. The wait method returns  nil  if
       the no stream have changed. Similarly, the wait-all method 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 wait method 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 mark method is designed to mark the selector
       while the marked-p predicate returns true if the stream has been marked.

       Terminalstreams
       Terminal streams are another kind of streams  available  in  the  standard  i/o  module.  The  InputTerm,
       OutputTerm  and  ErrorTerm  classes  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 Terminal class. 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  Terminal  class  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-line method. The standard methods like read or readln do 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-prompt or set-secondary-prompt. A secondary prompt is displayed  when  the  read-line
       method is called with the boolean argument false.

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

       Usingtheerrorterminal
       The ErrorTerm class is the most frequently used class for printing data on the standard error stream. The
       reserved  keywords  error  or  errorln  are  available  to  write on the interpreter error stream. If the
       interpreter error stream has been changed, the use of the ErrorTerm will provide the facility required to
       print directly on the terminal. The cat program 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
       }

       Directory
       The Directory class 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.

       Readingadirectory
       A Directory object 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-name method.

       # 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-list method returns the
       full  contents  of  the directory object. The get-files method returns a list of files in this directory.
       The get-subdirs method 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)

       Creatingandremovingdirectories
       The mkdir and rmdir methods 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 mkdir methods  succeeds.
       The rmdir method 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-path  constructs  an  absolute path name from the argument list. If relative path
       needs to be constructed, the function relative-path might be used instead.

       Logtee
       The Logtee class 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.

       Creatingalogger
       The  Logtee  default  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-tee method sets the control flag. The set-report-level method sets the report  level.  Note  that
       the set-report-level and its associated get-report-level method is part of the base Logger class.

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

       Creatingapathname
       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")

       Addingadirectorypath
       The best way to add a directory path is to use the absolute-path or the relative-path functions.

       # adding a directory path
       const name (afnix:sio:absolute-path "usr" "bin")
       path:set-directory-name name

       Gettingthepathinformation
       The  path  information can be obtained individually or globally. The get-file-name and get-directory-name
       methods return respectively the file and directory name. The get-root method returns the  root  component
       of the directory name. The get-full method returns the full path name.

Transcoder
       The Transcoder class 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

       ConstantsDEFAULT
              The DEFAULT constant is used by the set-transcoding-mode method to specify the  class  transcoding
              mode. In default mode, each character is not transcoded. This mode is the identity mode.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

       Methodsset-transcoding-mode->none(constant)
              The set-transcoding-mode method sets the class transcoding mode.

              get-transcoding-mode->constant(none)
              The get-transcoding-mode method returns the class transcoding mode.

              valid-p->Byte|Character(Boolean)
              The valid-p predicate 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.

              encode->Byte(Character)
              The encode method encodes a byte into  a  character.  If  the  character  cannot  be  encoded,  an
              exception is raised.

              decode->Character(Byte)
              The  decode  method  decodes  a  character  into  a  byte.  If the character cannot be decoded, an
              exception is raised.

       Stream
       The Stream class 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

       ConstantsBYTE
              The BYTE constant is used by the set-coding-mode method to specify the stream coding mode. In byte
              mode,  each  character is assumed to be coded with one byte. This value affects the getu and write
              methods

              UTF-8
              The UTF-8 constant is used by the set-coding-mode method 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 getu and write methods

       Methodsset-encoding-mode->none(constant|String)
              The set-encoding-mode method 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.

              get-encoding-mode->constant(none)
              The get-coding-mode method returns the stream coding mode which affects how characters are read or
              written.

       InputStream
       The InputStream class 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

       Methodsflush->none|Character(none)
              The flush method 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.

              get-timeout->Integer(none)
              The get-timeout method returns the input stream timeout. A negative value is a blocking timeout.

              set-timeout->none(Integer)
              The set-timeout method sets the input stream timeout. A negative  value  is  a  blocking  timeout.
              Changing the stream timeout does not cancel any pending read operation.

              read->Byte(none)
              The  read  method  returns  the  next byte available from the input stream. If the stream has been
              closed or consumed, the end-of-stream byte is returned.

              read->Buffer(Integer)
              The read method returns a buffer object with at most the number of bytes specified as an argument.
              The buffer length method should be used to check how many bytes have been placed in the buffer.

              readln->String(none)
              The readln method returns the next line available from the input stream. If the  stream  has  been
              closed or consumed, the end-of-stream character is returned.

              getu->Character(none)
              The  getu method returns the next available Unicode character from the input stream. If the stream
              has been closed or consumed, the end-of-stream character is returned. During the read process,  if
              the character decoding operation fails, an exception is raised.

              valid-p->Boolean(none|Integer)
              The  valid-p  method 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.

              eos-p->Boolean(none)
              The eos-p predicate returns true if the input stream has been closed or all bytes consumed.

              pushback->Integer(Byte|Character|String)
              The pushback method 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.

              consume->Integer(none)
              The consume method consumes an input stream and places 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-string method.

              get-buffer-length->Integer(none)
              The get-buffer-length method returns the length of the push-back buffer.

              to-string->String(none)
              The to-string method returns a string representation of the input stream buffer.

       InputFile
       The InputFile class 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 InputFile class
       is derived from the InputStream class.

       Predicate

              input-file-p

       Inheritance

              InputStreamNameable

       ConstructorsInputFile(String)
              The InputFile constructor 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.

              InputFile(StringString)
              The  InputFile  constructor  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.

       Methodsclose->Boolean(none)
              The  close  method  close  the input file and returns true on success, false otherwise. In case of
              success, multiple calls return true.

              lseek->none(Integer)
              The lseek set the input file position to the integer argument. Note that the push-back  buffer  is
              reset after this call.

              length->Integer(none)
              The length method returns the length of the input file. The length is expressed in bytes.

              get-modification-time->Integer(none)
              The  get-modification-time method returns the modification time of the file. The returned argument
              is suitable for the Time and Date system classes.

       InputMapped
       The InputMapped class 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

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

              InputMapped(String|Buffer)
              The  InputMapped  constructor 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.

              InputMapped(StringIntegerInteger)
              The  InputMapped  constructor  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.

       Methodslseek->none(Integer)
              The  lseek  set  the  input  mapped file position to the integer argument. Note that the push-back
              buffer is reset after this call.

              length->Integer(none)
              The length method returns the length of the input mapped file. The length is expressed in bytes.

       InputString
       The InputString class 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

       ConstructorsInputString(none)
              The InputString constructor creates an empty input string.

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

       Methodsget->Byte(none)
              The get method returns the next available byte from the input stream but do not remove it.

              set->none(String)
              The set method sets the input string by first resetting the push-back buffer and then initializing
              the input string with the argument value.

       InputTerm
       The InputTerm class 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 Terminal class should be used instead.

       Predicate

              input-term-p

       Inheritance

              InputStreamOutputStream

       ConstructorsInputTerm(none)
              The InputTerm constructor creates a default input terminal.

       Methodsset-ignore-eos->none(Boolean)
              The  set-ignore-eos  method set the input terminal end-of-stream ignore flag. When the flag is on,
              any character that match a ctrl-d is 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-d byte is generated.

              set-mapped-eos->none(Byte)
              The  set-mapped-eos  method  set the input terminal end-of-stream mapped character. By default the
              character is set to end-of-line. This method should be used in conjunction with the set-ignore-eos
              method.

       OutputStream
       The OutputStream class 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

       Methodswrite->Integer(Literal+)
              The write method write one or more literal arguments on the output stream. This method returns the
              number of characters written.

              writeln->none(Literal+)
              The  writeln  method  write  one  or  more literal argument to the output stream and finish with a
              newline. This method return nil.

              errorln->none(Literal+)
              The errorln method 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.

              newline->none(none)
              The newline method writes a new line byte to the output stream. The method returns nil.

              write-soh->none(none)
              The write-soh method writes a start-of-heading character to the output stream.

              write-stx->none(none)
              The write-stx method writes a start-of-transmission character to the output stream.

              write-etx->none(none)
              The write-etx method writes an end-of-transmission character to the output stream.

              write-eos->none(none)
              The write-eos method writes an end-of-stream character to the output stream.

       OutputFile
       The OutputFile class 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
       OutputStream class. 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-flag  is  the
       truncate flag. The a-flag is the append flag.

       Predicate

              output-file-p

       Inheritance

              OutputStreamNameable

       ConstructorsOutputFile(String)
              The  OutputFile  constructor  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.

              OutputFile(StringString)
              The OutputFile constructor 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.

              OutputFile(StringBooleanBoolean)
              The OutputFile constructor 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.

       Methodsclose->Boolean(none)
              The  close  method closes the output file and returns true on success, false otherwise. In case of
              success, multiple calls returns true.

       OutputString
       The OutputString class 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-string method can be  used  to  retrieve
       the buffer content.

       Predicate

              output-string-p

       Inheritance

              OutputStream

       ConstructorsOutputString(none)
              The OutputString constructor creates a default output string.

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

       Methodsflush->none(none)
              The flush method flushes the output stream by resetting the stream buffer.

              length->Integer(none)
              The length method returns the length of the output string buffer.

              to-string->String(none)
              The to-string method returns a string representation of the output string buffer.

       OutputBuffer
       The OutputBuffer class 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-string method can be used to retrieve
       the buffer content as a string. The format method can be used to retrieve the buffer content as an  octet
       string. content.

       Predicate

              output-buffer-p

       Inheritance

              OutputStream

       ConstructorsOutputBuffer(none)
              The OutputBuffer constructor creates a default output buffer.

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

       Methodsflush->none(none)
              The flush method flushes the output stream by resetting the stream buffer.

              length->Integer(none)
              The length method returns the length of the output buffer.

              to-string->String(none)
              The to-string method returns a string representation of the output buffer.

              format->String(none)
              The format method returns an octet string representation of the output buffer.

       OutputTerm
       The OutputTerm class 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 ErrorTerm class is more
       appropriate.

       Predicate

              output-term-p

       Inheritance

              OutputStream

       ConstructorsOutputTerm(none)
              The OutputTerm constructor creates a default output terminal

              ErrorTerm(none)
              The ErrorTerm constructor creates a default error terminal

       Terminal
       The Terminal class provides the facility for an i/o terminal with  line  editing  capability.  The  class
       combines the InputTerm and OutputTerm methods.

       Predicate

              terminal-p

       Inheritance

              InputTermOutputTerm

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

       Methodsset-primary-prompt->none(String)
              The set-primary-prompt method sets the terminal primary prompt which is used  when  the  read-line
              method is called.

              set-secondary-prompt->none(String)
              The  set-secondary-prompt  method  sets the terminal secondary prompt which is used when the read-
              line method is called.

              get-primary-prompt->String(none)
              The get-primary-prompt method returns the terminal primary prompt.

              get-secondary->String(none)
              The get-secondary-prompt method returns the terminal secondary prompt.

       Intercom
       The Intercom class 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
       send method can be used to send the data, while the recv can be used to receive them.

       Predicate

              intercom-p

       Inheritance

              Object

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

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

              Intercom(InputStreamOutputStream)
              The Intercom constructor creates an interpreter communication object with an input and  an  output
              stream.

       Methodssend->none(Object)
              The  send  method  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.

              recv->Object(none)
              The recv method deserialize an object with the help of the input stream bound to  the  interpreter
              communication object. If there is no output stream, nil is returned.

              request->Object(Object)
              The request method perform an atomic send receive operation.

              set-input-stream->none(InputStream)
              The set-input-stream method binds an input stream to the interpreter communication object.

              get-input-stream->InputStream(none)
              The  get-input-stream  method  returns  the  input  stream  bound to the interpreter communication
              object.

              set-output-stream->none(OutputStream)
              The set-output-stream method binds an output stream to the interpreter communication object.

              get-output-stream->OutputStream(none)
              The get-output-stream method returns the output stream  bound  to  the  interpreter  communication
              object.

       InputOutput
       The  InputOutput  class  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-p predicate returns true, the valid-p predicate false and the read method  will  return  the  eos
       character.  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

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

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

       Methodsget->Byte(none)
              The get method returns the next available byte from the input stream but do not remove it.

              set->none(String)
              The set method sets the input string by first resetting the push-back buffer and then initializing
              the input string with the argument value.

       Selector
       The Selector class provides some facilities to perform i/o  multiplexing.  The  constructor  takes  0  or
       several  stream arguments.The class manages automatically the differentiation between the InputStream and
       the OutputStream objects. 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 add
       method. When a call to the wait method succeeds, the method returns the first available  stream.  If  the
       waitall  method  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 mark method is designed to mark the selector while the marked-p predicate returns true  if  the
       stream has been marked.

       Predicate

              selector

       Inheritance

              Object

       ConstructorsSelector(none)
              The Selector constructor creates a default stream selector.

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

       Methodsadd->none(InputStream|OutputStream)
              The add method 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-add or the output-add methods might be preferable.

              input-add->none(InputStream)
              The input-add method adds an input stream to the selector.

              output-add->none(OutputStream)
              The output-add method adds an output stream to the selector.

              wait->Stream(none|Integer)
              The wait method 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.

              wait-all->Vector(none|Integer)
              The wait method 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.

              input-get->InputStream(Integer)
              The input-get method returns the input streams in the selector by index. If the index  is  out  of
              bound, an exception is raised.

              output-get->OutputStream(Integer)
              The  output-get method returns the output streams in the selector by index. If the index is out of
              bound, an exception is raised.

              input-length->Integer(none)
              The input-length method returns the number of input streams in the selector.

              output-length->Integer(none)
              The output-length method returns the number of output streams in the selector.

              mark->none(none)
              The mark method marks a selector object.

              marked-p->Boolean(none)
              The marked-p predicate returns true if the selector has been marked.

       Logtee
       The Logtee class 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-tee method.

       Predicate

              logtee-p

       Inheritance

              Logger

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

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

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

              Logtee(IntegerOutputStream)
              The  Logtee  constructor  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.

              Logtee(IntegerStringOutputStream)
              The Logtee constructor 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.

       Methodsset-tee-stream->none(OutputStream)
              The set-tee-stream method sets the tee output stream. This stream is  different  from  the  logger
              output stream

              get-tee-stream->OutputStream(none)
              The get-tee-stream method returns the object output stream.

              set-tee->none(Boolean)
              The  set-tee  method  sets the object tee flag. When the flag is true, the logger writes the added
              message on the output stream.

              get-tee->Boolean(none)
              The get-tee method returns the object tee flag. When the flag is true, the logger writes the added
              message on the output stream.

       Pathname
       The Pathname class 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

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

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

              Pathname(StringString)
              The Pathname constructor 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.

       Methodsreset->none(none)
              The reset method reset the path name by removing all path and file information.

              dir-p->Boolean(none)
              The dir-p predicate returns true if the path is a directory.

              file-p->Boolean(none)
              The file-p predicate returns true if the path is a file.

              set-file-name->none(String)
              The set-file-name method set the path name file name. The string argument is the file name.

              get-file-name->String(none)
              The get-file-name method returns the path name file name.

              add-directory-name->none(String)
              The  add-directory-name  method add the directory name to the directory path component. The string
              argument is the directory name.

              set-directory-name->none(String)
              The set-directory-name method set the directory  name  file  name.  The  string  argument  is  the
              directory name.

              get-directory-name->String(none)
              The get-directory-name method returns the path name directory name.

              length->Integer(none)
              The length method returns the number of directory path elements.

              get-path->String(Integer)
              The get-path method returns a directory path element by index.

              get-root->String(none)
              The get-root method returns the root component of a directory name.

              get-full->String(none)
              The get-full method returns the full path name by combining the directory name with the file name.

              add-path->none(String)
              The  add-path  method  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.

              normalize->none(none)
              The normalize method 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  Pathlist  class  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

       Inheritance

              Object

       ConstructorsPathlist(none)
              The Pathlist constructor creates a default path list.

              Pathlist(Boolean|String)
              The  Pathlist  constructor  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.

       Methodsreset->none(none)
              The  reset  method  resets  the  path list by clearing the local search flag and removing all path
              components.

              local-p->Boolean(none)
              The local-p predicate returns true if the local search flag is set.

              set-local-search->none(Boolean)
              The set-local-search method sets the local search flag.

              length->Integer(none)
              The length method returns the number of directory path elements.

              get-path->String(Integer)
              The get-path method returns a directory path element by index.

              add-path->none(String)
              The add-path method add a new path component by name. The string argument is the name to add.

              file-p->Boolean(String)
              The file-p predicate returns true if the file name argument can be resolved. If the  local  search
              flag is set, the local directory is check first.

              resolve->String(String)
              The  resolve method 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.

       Functionsdir-p->Boolean(String)
              The dir-p function returns true if the argument name is a directory name, false otherwise.

              file-p->Boolean(String)
              The file-p function returns true if the argument name is a regular file name, false otherwise.

              tmp-name->String(String?)
              The tmp-name function 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.

              tmp-path->String(String?)
              The tmp-path function 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.

              absolute-path->String(String+)
              The absolute-path function 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.

              relative-path->String(String+)
              The relative-path function 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.

              rmfile->none(String+)
              The  rmfile function removes one or several files specified as the arguments. If one file fails to
              be removed, an exception is raised.

              mkdir->none(String+)
              The mkdir function creates one or several directories specified as the arguments. If one directory
              fails to be created, an exception is raised.

              mhdir->none(String+)
              The mhdir function creates hierarchically one or several directories specified as  the  arguments.
              If one directory fails to be created, an exception is raised.

              rmdir->none(String+)
              The rmdir function removes one or several directories specified as the arguments. If one directory
              fails to be removed, an exception is raised.

              get-base-name->String(String)
              The  get-base-name  function 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.

              get-base-path->String(String)
              The get-base-path function 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.

              get-extension->String(String)
              The get-extension function returns the extension from a path.

              remove-extension->String(String)
              The  remove-extension function returns the extension from a path. In order to get a base file name
              from a path, the get-base-name function must be called first.

       Directory
       The Directory class 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

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

              Directory(String)
              The Directory constructor 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.

       Methodsmkdir->Directory(String)
              The  mkdir  method  creates  a  new  directory in the current one. The full path is constructed by
              taking the 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.

              rmdir->none(String)
              The rmdir method 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.

              rmfile->none(String)
              The  rmfile method 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.

              get-name->String(none)
              The get-name method returns the directory name. If the default directory was created,  the  method
              returns the full directory path.

              get-list->List(none)
              The get-list method 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.

              get-files->List(none)
              The get-files method 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.

              get-subdirs->List(none)
              The  get-subdirs  method 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.

              next-name->String(none)
              The  next-name  method  returns  the next available name from the directory stream. This method is
              useful when operating with a large number of elements.

              next-path->String(none)
              The next-path method returns the next available path name from the directory stream.  This  method
              is useful when operating with a large number of elements.

              next-file-name->String(none)
              The  next-file-name  method  returns  the next available file name from the directory stream. This
              method is useful when operating with a large number of elements.

              next-file-path->String(none)
              The next-file-path method returns the next available file path name  from  the  directory  stream.
              This method is useful when operating with a large number of elements.

              next-dir-name->String(none)
              The next-dir-name method returns the next available directory name from the directory stream. This
              method is useful when operating with a large number of elements.

              next-dir-path->String(none)
              The next-dir-path method 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  Logtee  class 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

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

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

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

              Logtee(IntegerOutput)
              The Logtee constructor 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.

              Logtee(IntegerStringOutput)
              The  Logtee constructor 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.

       Methodsset-output-stream->none(Output)
              The set-output-stream method attaches the output stream to the logtee object.

              get-output-stream->Output(none)
              The get-output-stream method returns the logtee output stream.

              set-tee->none(Boolean)
              The  set-tee method sets the logtee control flag. The control flag controls the message display to
              the output stream.

              get-tee->Boolean(none)
              The get-tee method returns the logtee output stream.

       NamedFifo
       The NameFifo class 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

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

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

              NamedFifo(StringBoolean)
              The  NamedFifo  constructor  creates  a  named  fifo  by name. The name is used as a file name for
              reading or writing the fifo.If the boolean argument is true, the fifo is read.

       Methodsread->none(none)
              The read method reads the fifo file name and fill the fifo.

              write->none(none)
              The write method writes the fifo contents to the fifo file name.

              set-name->none(String)
              The set-name method sets the fifo file name.

       FileInfo
       The FileInfo is 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 update method.

       Predicate

              file-info-p

       Inheritance

              Nameable

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

       Methodslength->Integer(none)
              The length method returns the file size information.

              get-modification-time->Integer(none)
              The  get-modification-time  method  returns the file modification time. The time can be used as an
              argument to the Time or Date object.

              update->none(none)
              The update method the file information data.

AFNIX Module                                          AFNIX                                               sio(3)