Provided by: afnix_2.2.0-2ubuntu1_amd64 bug

NAME

       sio - standard input/output module

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.

       Input and output streams
       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.

       Stream base class
       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.

       Stream transcoding
       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.

       Input stream
       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.

       Output stream
       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.

       The valid-p predicate
       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.

       The eos-p predicate
       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.

       The read method
       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.

       Buffer read mode
       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)

       File stream
       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")

       Stream information
       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

       Reading and writing
       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.

       Selector object
       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.

       Waiting for i/o event
       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.

       Marking mode
       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.

       Terminal streams
       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.

       Terminal class
       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

       Using the error terminal
       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.

       Reading a directory
       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)

       Creating and removing directories
       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.

       Creating a logger
       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)

       Adding messages
       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.

       Path name
       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.

       Creating a path name
       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")

       Adding a directory path
       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

       Getting the path information
       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.

STANDARD INPUT/OUTPUT REFERENCE

       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

       Constants

              DEFAULT
              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.

       Constructors

              Transcoder (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.

       Methods

              set-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

       Constants

              BYTE
              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

       Methods

              set-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

       Methods

              flush -> 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.

              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

       Constructors

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

       Methods

              close -> 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

       Constructors

              InputMapped (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 (String Integer Integer)
              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.

       Methods

              lseek -> 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

       Constructors

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

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

       Methods

              get -> 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

       Constructors

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

       Methods

              set-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

       Methods

              write -> 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

       Constructors

              OutputFile (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 (String String)
              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 (String Boolean Boolean)
              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.

       Methods

              close -> 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

       Constructors

              OutputString (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.

       Methods

              flush -> 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

       Constructors

              OutputBuffer (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.

       Methods

              flush -> 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

       Constructors

              OutputTerm (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

       Constructors

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

       Methods

              set-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

       Constructors

              Intercom (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 (InputStream OutputStream)
              The  Intercom constructor creates an interpreter communication object with an input
              and an output stream.

       Methods

              send -> 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

       Constructors

              InputOutput (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.

       Methods

              get -> 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

       Constructors

              Selector (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.

       Methods

              add -> 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

       Constructors

              Logtee (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 (Integer OutputStream)
              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 (Integer String OutputStream)
              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.

       Methods

              set-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

       Constructors

              Pathname (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 (String String)
              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.

       Methods

              reset -> 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

       Constructors

              Pathlist (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.

       Methods

              reset -> 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.

       Functions

              dir-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

       Constructors

              Directory (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.

       Methods

              mkdir -> 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

       Constructors

              Logtee (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 (Integer Output)
              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 (Integer String Output)
              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.

       Methods

              set-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

       Constructors

              NamedFifo (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 (String Boolean)
              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.

       Methods

              read -> 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.

       Methods

              length -> 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.