Anterior | Superior | Siguiente

Guía de referencia básica de Ada 95

Ficheros uniformes.

Estructura.

Un fichero uniforme o de componentes homogéneos es una secuencia arbitrariamente larga de elementos del mismo tipo. Por la forma en que se puede acceder a sus componentes se distinguen ficheros secuenciales y ficheros de acceso directo.

Librerías para manejar ficheros uniformes.

Los elementos necesarios para manejar ficheros de componentes homogéneos de forma secuencial se encuentran en el paquete genérico "Sequential_Io"; para manejarlos con acceso directo se emplea el paquete genérico "Direct_Io".

with Sequential_Io,Direct_Io;

Ambos paquetes son genéricos por lo que para poder usar ficheros de componentes uniformes hace falta especificar el tipo de los componentes; en consecuencia, no se pueden incluir en una cláusula use, antes de ser instanciados.

Declaración.

Para poder usar ficheros uniformes se ha de definir previamente el tipo de sus componentes (a menos que sea de un tipo predefinido). Supongamos que existe un tipo llamado TPersona. Una vez definido el tipo, se han de definir instancias de los paquetes de manejo de ficheros, según el tipo de acceso que se vaya a utilizar.

package FichTPersona_Sec is new Sequential_Io(TPersona); -- Acceso secuencial
package FichTPersona_Dir is new Direct_Io(TPersona); -- Acceso directo
use FichTPersona_Sec, FichTPersona_Dir;

Ahora se pueden declarar variables de tipo fichero directo o secuencial:

Fichero1 : FichTPersona_Sec.File_Type;
Fichero2 : FichTPersona_Dir.File_Type;

Creación, apertura y cierre.

Antes de poder hacer transacciones con una variable fichero debe asociarse con un fichero externo, esto se puede hacer con los procedimientos Create y Open. El primero sirve para crear y abrir un fichero y el segundo para abrir un fichero que ya existe.

procedure Create(File : in out File_Type;
                 Mode : in File_Mode := Out_File; --Inout_File para ficheros de acceso directo
                 Name : in String := "";
                 Form : in String := "");

procedure Open  (File : in out File_Type;
                 Mode : in File_Mode;
                 Name : in String;
                 Form : in String := "");

Ambas operaciones admiten hasta cuatro parámetros:

File es la variable fichero (fichero lógico).
Mode es el modo de apertura del fichero (puede tomar los valores: In_File , Out_File y Append_File o Inout_File , según sea, secuencial o directo).
    In_File abre el fichero en modo lectura.
    Out_File abre el fichero en modo escritura (si el fichero ya existe, se vacía). Es el modo por defecto en Create para ficheros secuenciales.
    Append_File abre un fichero de acceso secuencial en modo escritura para añadir información al final de un fichero existente.
    Inout_File abre un fichero de acceso directo y permite hacer lecturas y escrituras. Es el modo por defecto en Create para ficheros directos.
Name es una ristra de caracteres (String) que representa el nombre del fichero externo.
Form generalmente no se usa, es un parámetro que depende del sistema y puede servir para cosas como proteger el fichero con una palabra clave.

Create(Fichero1, Name => "c:\temp\unfichero.dat");
Open(Fichero2, In_File, "c:\temp\otrofichero.dat");

La primera línea del ejemplo crea un fichero físico tomando como nombre "c:\temp\unfichero.dat" y lo abre en modo escritura asociándolo a la variable Fichero1; la segunda línea abre en modo lectura un fichero existente llamado "c:\temp\otrofichero.dat" y lo asocia a Fichero2.

Los errores que pudieran producirse al intentar abrir un fichero pueden controlarse mediante excepciones.

Si en Create se da como nombre del fichero físico la ristra vacía, se crea un fichero temporal que se destruye al acabar la ejecución del programa.

Las funciones Is_Open (de tipo Boolean), Mode (de tipo File_Mode) y Name (de tipo String) sirven para saber, respectivamente, si un fichero está abierto, en qué modo y con qué fichero externo está asociado; todas ellas requieren un parámetro de tipo File_Type.

Una vez que se ha terminado de trabajar con un fichero se debe cerrar con la operación Close a la que se pasa como parámetro una variable de tipo File_Type.

Operaciones de entrada/salida.

Para realizar lecturas desde ficheros y escrituras hacia ficheros se han de declarar previamente variables del tipo de los componentes del fichero.

Persona_1,Persona_2,Persona_3 : TPersona;

Las operaciones de entrada/salida se realizan con las operaciones Read y Write.

procedure Read(File : in out File_Type; Item : out Element_Type; From : in Positive_Count);
procedure Read(File : in out File_Type; Item : out Element_Type);

Read lee un elemento de un fichero y avanza una posición:

File es la variable fichero.
Item es la variable, del tipo de los componentes del fichero, en la que se lee el elemento.
From es la posición en el fichero desde donde se quiere leer el dato. Sólo es aplicable a ficheros de acceso directo. Si no se especifica se lee de la posición actual en el fichero. El tipo Positive_Count está definido en el paquete Direct_IO.

procedure Write(File : in out File_Type; Item : in Element_Type; To : in Positive_Count);
procedure Write(File : in out File_Type; Item : in Element_Type);

Write escribe un elemento en un fichero y avanza una posición:

File es la variable fichero.
Item es la variable, del tipo de los componentes del fichero, cuyo contenido se escribe en el fichero
To es la posición en el fichero donde se quiere escribir el dato. Sólo es aplicable a ficheros de acceso directo. Si no se especifica se escribe en la posición actual en el fichero. El tipo Positive_Count está definido en el paquete Direct_IO.

Operaciones relacionadas con la estructura de los ficheros.

Existe una operación para controlar la marca de fin de fichero:

End_Of_File(Fichero1) --es una función que devuelve True si se ha alcanzado
--el final de fichero1 y False en caso contrario.

El tamaño, en número de componentes, de un fichero de acceso directo se obtiene mediante la función "Size", que devuelve un número comprendido entre 0 y el máximo tamaño posible definido en la implementación del compilador de Ada que se esté usando. El tipo que devuelve, Count, está definido en el paquete Direct_IO.

function Size(File : in File_Type) return Count;

Se puede saltar a una posición específica de un fichero de acceso directo utilizando el procedimiento "Set_Index".

procedure Set_Index(File : in out File_Type; To : in Positive_Count);

La posición actual en un fichero de acceso directo se puede averiguar mediante la función "Index", que devuelve un valor comprendido entre 1 y el máximo tamaño posible definido en la implementación.

function Index(File : in File_Type) return Positive_Count;

Otras operaciones con ficheros.

La eliminación de un fichero se realiza mediante el procedimiento Delete, que borra el fichero externo asociado al parámetro File_type que se le pase.

Delete(fichero1);

Anterior | Superior | Siguiente