Reusar unidad en Delphi

[martin.lazzeri]

Hola Gente!

Estoy desarrollando un proyecto para una materia, tenemos que usar diferentes estructuras de datos, como por ejemplo arboles, listas simples y doblemente enlazadas.

Por ejemplo aca les dejo la libreria de arbol:

Código Delphi [-]
unit Arbol;

interface

const
      posNula = -1;
      valorNulo = 0;
      claveNula = 'AAAAAA';
      ruta = 'C:\Users\Martin\Desktop\prog2\Veterinaria\Arbol\';

type

      TipoPosicion = integer;
      tipoclave = string[6];

      RegistroDatosArbol = record
                                  Clave : TipoClave;
                                  Padre : TipoPosicion;
                                  HijoDerecho : TipoPosicion;
                                  HijoIzquierdo : TipoPosicion;
                           end;

      TipoArchivoDatos = file of RegistroDatosArbol;

      RegistroControlArbol = record
                                    Raiz : TipoPosicion;
                                    Cantidad : integer;
                                    Borrado : TipoPosicion;
                             end;
      TipoArchivoControl = file of RegistroControlArbol;

      TipoArbol = record
                           D : TipoArchivoDatos;
                           C : TipoArchivoControl;
                  end;
var
      Me : TipoArbol;

// Operaciones de la libreria
Procedure CrearArbol(var Me : TipoArbol; archivoDatos : string; archivoControl : string );
Procedure AbrirArbol (var Me : TipoArbol);
Procedure CerrarArbol (var Me : TipoArbol);
Function Raiz(var Me : TipoArbol) : TipoPosicion;
Function Padre(var Me: TipoArbol; pos : TipoPosicion) : TipoPosicion;
Procedure CapturarNodo(var Me : TipoArbol; pos : TipoPosicion; var regDatos : RegistroDatosArbol);
Procedure ModificarNodo(var Me : TipoArbol; pos : TipoPosicion; regDatos : RegistroDatosArbol);
Procedure InsertarNodo(var Me: TipoArbol; pos : TipoPosicion; regDatos : RegistroDatosArbol);
Function Buscar(var Me: TipoArbol; clave: TipoClave; var pos: TipoPosicion) : boolean;

implementation

Procedure CrearArbol(var Me : TipoArbol; archivoDatos : string; archivoControl : string );
var
    registroControlAux : RegistroControlArbol;
begin
      {$I-}
      assign(Me.D, ruta + archivoDatos);
      assign(Me.C, ruta + archivoControl);

      // Abro el archivo de datos para solo lectura
      reset (Me.D);

      // Verifico que no haya errores
      if(IORESULT <> 0)
        then
            rewrite (Me.D); // Creo el archivo, ya que no existía y se abre para escritura

      //Abro el archivo de control para solo lectura
      reset (Me.C);

      //Verifico que no haya errores
      if(IORESULT <> 0)
        then
            begin
                  rewrite (Me.C); //Creo el archivo, ya que no existía y se abre para escritura

                  //A continuación inicializo los campos del registro
                  registroControlAux.Raiz := posNula;
                  registroControlAux.Cantidad := 0;
                  registroControlAux.Borrado := posNula;
                  write (Me.C, registroControlAux); //Escribo la información en el archivo
            end;
      //A continuación cierro los dos archivos
      close (Me.D);
      close (Me.C);
      {$I+}
end;

Procedure AbrirArbol (var Me : TipoArbol);
begin
      reset (Me.D);
      reset (Me.C);
end;

Procedure CerrarArbol (var Me : TipoArbol);
begin
      close (Me.D);
      close (Me.C);
end;

Function Raiz(var Me : TipoArbol) : TipoPosicion;
var
    registroControlAux : RegistroControlArbol;
begin
      seek(Me.C, valorNulo);
      read(Me.C, registroControlAux);
      Raiz := registroControlAux.Raiz;
end;

Function Padre(var Me : TipoArbol; pos : TipoPosicion) : TipoPosicion;
var
    registroDatosAux : RegistroDatosArbol;
begin
      seek(Me.D, pos);
      read(Me.D, registroDatosAux);
      Padre := registroDatosAux.Padre;
end;

Procedure CapturarNodo(var Me : TipoArbol; pos : TipoPosicion; var regDatos : RegistroDatosArbol);
begin
      seek(Me.D, pos);
      read(Me.D, regDatos);
end;

Procedure ModificarNodo(var Me : TipoArbol; pos : TipoPosicion; regDatos : RegistroDatosArbol);
var
    registroDatosAux : RegistroDatosArbol;
begin
      seek(Me.D, pos);
      read(Me.D, registroDatosAux);

      registroDatosAux.Padre := regDatos.Padre;
      registroDatosAux.HijoDerecho := regDatos.HijoDerecho;
      registroDatosAux.HijoIzquierdo := regDatos.HijoIzquierdo;
      registroDatosAux.Clave := regDatos.Clave;

      seek(Me.D, pos);
      write(Me.D, registroDatosAux);
end;

Procedure InsertarNodo(var Me: TipoArbol; pos : TipoPosicion; regDatos : RegistroDatosArbol);
var
    registroControlAux: RegistroControlArbol;
    posNueva: TipoPosicion;
    registroDatosAux, padre: RegistroDatosArbol;
begin
      Seek(Me.C, valorNulo);
      Read(Me.C, registroControlAux);

    if (registroControlAux.Borrado = posNula)
      then
          posNueva := FileSize(Me.D)
      else
          begin
                posNueva := registroControlAux.Borrado; //Tengo uno borrado, entonces lo recupero
                Seek(Me.D, posNueva);
                Read(Me.D, registroDatosAux);
                registroControlAux.Borrado := registroDatosAux.HijoDerecho //Para que pongamos siempre ese
          end;

    if (registroControlAux.Raiz = posNula) then //Significa que esta vacio
      begin
            registroControlAux.Raiz := posNueva;
            regDatos.Padre := posNula;    //
            regDatos.HijoIzquierdo := posNula;  // Para darle los nuevos enlaces que sino vienen con basura
            regDatos.HijoDerecho := posNula;  //
            registroControlAux.Cantidad := registroControlAux.Cantidad + 1;
      end
    else
         begin
              Seek(Me.D, pos);
              Read(Me.D, padre);
              if (regDatos.Clave <= padre.Clave)
                then //Para engancharlo
                    padre.HijoIzquierdo := posNueva
                else
                    Padre.HijoDerecho := posNueva;

              regDatos.HijoIzquierdo := posNula;
              regDatos.HijoDerecho := posNula;
              regDatos.Padre := pos;

              Seek(Me.D, pos);
              Write(Me.D, padre);
              registroControlAux.Cantidad := registroControlAux.Cantidad + 1;
          end;

    Seek(Me.C, 0);
    Write(Me.C, registroControlAux);
    Seek(Me.D, posNueva);
    Write(Me.D, regDatos);
end;


{Procedure InsertarNodo(var Me: TipoArbol; pos : TipoPosicion; regDatos : RegistroDatosArbol);
var
    registroControlAux : RegistroControlArbol;
    registroDatosAux : RegistroDatosArbol;
    posNueva : TipoPosicion;

begin
      seek(Me.C, valorNulo);
      read(Me.C, registroControlAux);

      if(registroControlAux.Borrado = posNula)
        then
            posNueva := filesize(Me.D)
        else
            begin
                  posNueva := registroControlAux.Borrado;
                  seek(Me.D, posNueva);
                  read(Me.D, registroDatosAux);
                  registroControlAux.Borrado := registroDatosAux.Padre;
            end;


      if(registroControlAux.Raiz = posNula)
        then // Inserto en árbol vacío
            begin
                  registroControlAux.Raiz := posNueva;
                  regDatos.HijoIzquierdo := posNula;
                  regDatos.HijoDerecho := posNula;
                  regDatos.Clave := claveNula;
            end
        else
            begin
                  seek(Me.D, pos);
                  read(Me.D, registroDatosAux);
                  if(regDatos.Clave <= registroDatosAux.Clave)
                    then
                        registroDatosAux.HijoIzquierdo := posNueva
                    else
                        registroDatosAux.HijoDerecho := posNueva;

                  regDatos.Padre := pos;
                  regDatos.HijoDerecho := posNula;
                  regDatos.HijoIzquierdo := posNula;
            end;

        seek(Me.D, pos);
        write(Me.D, registroDatosAux);

        registroControlAux.Cantidad := registroControlAux.Cantidad + 1;

        //Actualizo el archivo de control

        seek(Me.C, valorNulo);
        write(Me.C, registroControlAux);

        //Actualizo el archivo de datos

        seek(Me.D, posNueva);
        write(Me.D, regDatos);
end;    }

Function ArbolVacio(var Me: TipoArbol) : boolean;
var
    registroControlAux: RegistroControlArbol;
begin
      Seek(Me.C, valorNulo);
      Read(Me.C, registroControlAux);
      ArbolVacio := (registroControlAux.Raiz = posNula);
end;

Function HijoIzquierdo(var Me: TipoArbol; pos: TipoPosicion) : TipoPosicion;
var
    registroDatosAux: RegistroDatosArbol;
begin
      Seek(Me.D, pos);
      Read(Me.D, registroDatosAux);
      HijoIzquierdo := registroDatosAux.HijoIzquierdo;
end;

Function HijoDerecho(var Me: TipoArbol; pos: TipoPosicion) : TipoPosicion;
var
    registroDatosAux: RegistroDatosArbol;
begin
      Seek(Me.D, pos);
      Read(Me.D, registroDatosAux);
      HijoDerecho := registroDatosAux.HijoDerecho;
end;

Function Buscar(var Me: TipoArbol; clave: TipoClave; var pos: TipoPosicion) : boolean;
var
    registroControlAux : RegistroControlArbol;
    registroDatosAux :  RegistroDatosArbol;
    posicionPadre: TipoPosicion;
    encontre: boolean;
begin
      Seek(Me.C, valorNulo);
      Read(Me.C, registroControlAux);
      pos:= posNula;
      posicionPadre:= posNula;
      encontre := false;

      while( not(encontre) and (pos <> -1)) do
      begin
            Seek(Me.D, pos);
            Read(Me.D, registroDatosAux);
            if (clave = registroDatosAux.Clave)
              then
                    encontre := true
              else
                    begin
                          posicionPadre:= pos;
                          if (clave < registroDatosAux.Clave)
                            then
                                  pos := registroDatosAux.HijoIzquierdo
                            else
                                  pos:= registroDatosAux.HijoDerecho
                    end;
      end;

      //Para saber donde deberia estar
      if (not (encontre))
        then
            pos:= posicionPadre;

      Buscar := encontre;
end;

end.

Esta libreria, por ejemplo deberia usarla desde otra unidad donde modelo un ingreso de mascotas al sistema. El sistema modela una veterinaria.

El tema es que mi TipoDatoMascota es un registro con datos propios (nombre mascota, peso, edad, etc) y tengo que vincularlo de alguna forma con el registro de datos del arbol. Lo hice agregano una propiedad a ese registro de tipo RegistroDatoArbol, hasta ahi todo bien, el tema es que cuando quiero insertar un nuevo nodo con la libreria de arbol, lo inserta, pero no estoy pudiendo traer los datos propios de la mascota. Como la idea es reusar la libreria, creo que no es una buena opcion declarar los tipos propios de la mascota dentro del registro TipoDatosArbol, ya que esta misma libreria deberia usarla con otras unidades con otros datos totalmente distinto.

¿Alguien sabe como puedo modelar esta especie de genericidad?

Muchas gracias.