]> git.llucax.com Git - z.facultad/75.06/emufs.git/blobdiff - emufs/tipo2.h
bufford andando.
[z.facultad/75.06/emufs.git] / emufs / tipo2.h
index 3e55b7d0ddbb83de86e38e9cd50454d913e9c15c..0b310de8bdf53d8fc919c747bc66b2bbd43e632e 100644 (file)
  *----------------------------------------------------------------------------
  */
 
-/***************************************************************/
-/* Implementación del Tipo Archivo 2: Registros Variables, Sin */
-/* Bloques at all.                                             */
-/***************************************************************/
-
+/** \file
+ * Archivo con registros de longitud variable, sin bloques.
+ *
+ * <b>Interfaz del Archivo Tipo 2</b>
+ *
+ * La organizacion interna de un archivo de tipo 2, presenta registros de longitud variable,
+ * los cuales son grabados secuencialmente, o bien en gaps (espacios libres) que se presenten en
+ * el archivo de datos, pero no se encuentran contenidos por bloques.
+ *
+ * <b>Estructura Interna</b>: Un registro de este tipo, en disco, sera grabado de la siguiente forma:
+ *
+ * [ id_reg ][ reg_size ][ ///// reg_data ///// ]
+ * 
+ *
+ * \li EMUFS_REG_ID \c id_reg Id del registro
+ * \li EMUFS_REG_SIZE \c reg_size Size del registro
+ * \li char* \c reg_data Datos concretos del registro
+ *
+ * <b>Archivos Auxiliares:</b>
+  * Tendra tres archivos auxiliares que actuaran de Indice para localizar los registros,
+ * Indice de GAPS o FreeSpace y por ultimo Indice de ID's Libres (al borrarse regs se liberan ids).
+ *
+ * \li \c .FSC -- Indice de Gaps o Espacios Libres en el .DAT
+ * \li \c .IDX -- Indice de Posiciones Relativas u Offsets de los registros en el .DAT
+ * \li \c .DID -- Indice de Id's Libres para reutilizacion
+ *
+ */
 #ifndef _EMUFS_TIPO2_H_
 #define _EMUFS_TIPO2_H_
 
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
+#include <math.h>
 #include "emufs.h"
 
-EMUFS_REG_ID emufs_tipo2_grabar_registro(EMUFS *, void *, EMUFS_REG_SIZE);
-int emufs_tipo2_borrar_registro(EMUFS*, EMUFS_REG_ID);
-EMUFS_REG_ID emufs_tipo2_get_id(EMUFS *);
+/** Inicializa la estructura <em>EMUFS* efs</em> que recibe, asignando las funciones que permiten
+ * el uso del archivo tipo 2.
+ *
+ * \param efs Estructura que realiza el handling de archivos de cualquier tipo.
+ * \return \b int Indicador de exito de la operacion.
+ */
+int emufs_tipo2_inicializar(EMUFS* efs);
+
+/** Realiza la lectura de un registro en archivos del tipo 2 en base a su \em ID, devolviendo ademas el \em Size del
+ * registro leido.
+ *
+ * \param efs Estructura que realiza el handling de archivos de cualquier tipo.
+ * \param id_reg Id del registro a leer del archivo de datos.
+ * \param reg_size Size del registro leido que es devuelto a la funcion invocante.
+ * \param err Indicador de error en la operacion.
+ * \return \b void* Buffer con el registro leido.
+ */
+void *emufs_tipo2_leer_registro(EMUFS* efs, CLAVE clave, EMUFS_REG_SIZE* reg_size, int *err);
+
+/** Realiza la escritura de un registro en archivos del tipo 2 en base a su \em ID, devolviendo ademas el \em Size del
+ * registro leido.
+ *
+ * \param efs Estructura que realiza el handling de archivos de cualquier tipo.
+ * \param ptr Puntero a la region de memoria que contiene el registro a grabar.
+ * \param reg_size Size del registro a grabar en disco.
+  * \param err Indicador de error en la operacion.
+ * \return \b EMUFS_REG_ID Id del registro que fue grabado.
+ */
+EMUFS_REG_ID emufs_tipo2_grabar_registro(EMUFS *efs, void *ptr, EMUFS_REG_SIZE reg_size, int* err);
+
+/** Realiza el borrado de un registro en archivos del tipo 2 en base a su \em ID.
+ *
+ * \param efs Estructura que realiza el handling de archivos de cualquier tipo.
+ * \param id_reg Id del registro que se quiere eliminar.
+ * \return \b int Indicador de exito de la operacion.
+ */
+int emufs_tipo2_borrar_registro(EMUFS *efs, CLAVE k, INDICE_DATO dato);
+
+/** Devuelve el \em Size de un registro dado, en base a su \em ID.
+ *
+ * \param efs Estructura que realiza el handling de archivos de cualquier tipo.
+ * \param reg_pos Id del registro.
+ * \param reg_size Size del registro que se devuelve a la funcion invocante.
+ * \return \b int Indicador de exito de la operacion.
+ */
+int emufs_tipo2_get_regsize(EMUFS *efs, EMUFS_OFFSET reg_pos, EMUFS_REG_SIZE *reg_size);
+
+/** Realiza un fill con basura de una region dada dentro de un .dat del tipo2.
+ *
+ * \param efs Estructura que realiza el handling de archivos de cualquier tipo.
+ * \param reg_pos Offset donde comenzar el fill con basura.
+ * \param amount Cantidad de bytes a escribir en la region indicada.
+ * \return \b int Indicador de exito de la operacion.
+ */
+int emufs_tipo2_dummyfill(EMUFS *efs, EMUFS_OFFSET reg_pos, EMUFS_REG_SIZE amount);
+
+/** Método para modificar un registro */
+EMUFS_REG_ID emufs_tipo2_modificar_registro(EMUFS *efs, CLAVE k, void *data, EMUFS_REG_SIZE size, int *error, INDICE_DATO dato);
+
+/** Método para recolectar/obtener la estadisticas del archivo tipo 2
+ *
+ * \param efs Estructura que realiza el handling de archivos de cualquier tipo.
+ * \return \b EMUFS_Estadisticas Estructura que alberga las stats recolectadas.
+ */
+EMUFS_Estadisticas emufs_tipo2_leer_estadisticas(EMUFS *efs);
+
+/** Método para compactar un archivo tipo 2
+ *
+ * \param efs Estructura que realiza el handling de archivos de cualquier tipo.
+ */
+void emufs_tipo2_compactar(EMUFS *efs);
+
+/** Método para mover datos de un source a un dest, de a chunks
+ *
+ * \param datfile Stream en el cual se esta haciendo el movimiento.
+ * \param source Source desde donde mover los datos.
+ * \param destination Destino hacia donde mover los datos.
+ * \param mustmove_bytes Cantidad de bytes a mover.
+ */
+void emufs_tipo2_movedata(FILE * datfile,EMUFS_OFFSET *source, EMUFS_OFFSET *destination, EMUFS_BLOCK_SIZE mustmove_bytes);
+
+/** Método para sincronizar / actualiza un indice luego de una recompactacion
+ *
+ * \param efs Estructura que realiza el handling de archivos de cualquier tipo.
+ * \return \b int Indicador de exito de la opracion.
+ */
+int emufs_tipo2_updateidx(EMUFS *efs);
 
-/* int emufs_tipo2_leer_registro(EMUFS *, EMUFS_REG_ID , void *, EMUFS_REG_SIZE);
-   int emufs_tipo2_buscar_registro(EMUFS *, int); */
+/** Método para leer un registro con todo su bloque asociado. */
+void* emufs_tipo2_leer_registro_raw(EMUFS *emu, EMUFS_REG_ID id, EMUFS_REG_SIZE *size, int *pos);
 
 #endif /* _EMUFS_TIPO2_H_ */