Reading File Content

Submitted by Martin Seiler on Mon, 02/26/2007 - 22:21.

Category: Tutorial
Level: Beginner

In this tutorial I'll briefly explain how one can load the content of an ASCII file into a single string.

The deferred class FILE cannot be used directly as it is deferred.

The descendant PLAIN_TEXT_FILE is what we're actually looking for.

Contents

1 Basic steps
2 Opening a file
3 Reading from a file
4 Closing a file
5 Better error handling

Basic steps

The basic steps are the following:

   local
      l_file: PLAIN_TEXT_FILE
      l_content: STRING
   do
      create l_file.make_create_read_write (a_path)
      l_file.read_stream (l_file.count)
      l_content := l_file.last_string.twin
      l_file.close
   end

Let's have a brief look at each single line:

Opening a file

We instantiate the class and open the file directly for read. Doing it like that has the advantage that it is just one line.

create l_file.make_create_read_write (a_path)

Note: It might happen that the postcondition is violated if you don't have the permission to do the file operation for the path specified. We will later take this into account.

Reading from a file

l_file.read_stream (l_file.count)

There are several other read methods available. For example you can use read_line to read a single line of a given file.

l_content := l_file.last_string.twin

As the command/query separation principle is implemented, the result is always stored in last_.... Reading an integer from an ASCII file would look the following:\

l_file.read_integer
l_integer := l_file.last_integer

Note that we perform a call to twin for instances of type string as there is only one buffer per file object and it is overwritten by the next read command. If we do a twin we make sure that we don't have any surprising side effects later. So in general I recommend to do it for all non expanded types.

Closing a file

l_file.close

Last but not least we close the file to free system resources. However, if we simply set the reference to Void this will do job as well, as the garbage collector calls dispose before he collects the object, which in turn calls close if the file is still open.

Better error handling

The creation feature we used so far initializes the object and tries to open the file right away. If the files does not exist an attempt to create it will be made. Which may possibly fail if you don't have the proper rights to do so. Still, the file will be empty and this is maybe not what the original intention of the programmer was.

To get more control over the whole process I recommend a different, more sophisticated way of achieving the same:

local
  l_file: PLAIN_TEXT_FILE
do
  create l_file.make (a_path)
    -- We perform several checks until we make a real attempt to open the file.
  if not l_file.exists then
    print ("error: '" + a_path + "' does not exist%N")
  else
    if not l_file.is_readable then
      print ("error: '" + a_path + "' is not readable.%N")
    else
      l_file.open_read
      l_file.read_stream (l_file.count)
      Result := l_file.last_string.twin
      l_file.close
    end
  end
end

This feature checks several possible error conditions and prints error messages. The pattern will be the same in most cases, but the error handling will most likely depend on you application. So you could write a feature suited for your application with proper error handling and then simply reuse that feature whenever you need to open a file. If you don't want to copy paste the code all the time and just change the two error handling lines a more fine tuned class could implement the [1] pattern implemented by using [2].

eiffelroom