Clases que dependen de un tipo de datos

[[Lepe]]

La idea es hacer una lista doblemente enlazada en memoria en la que se puede guardar cualquier cosa, y poder enlazar cada registro en memoria, con cualquier cosa (Tag de un Twincontrol, o con cada elemento de un Tstring)

Es para evitar el uso del Tstring.AddObject, ya que al usar ese método, tenemos que encargarnos de crear / liberar cada objeto y hacer un casting cada vez que queremos acceder a dicho elemento.


Estoy creando una clase que al tiempo de crearla, se debe decir el tipo de dato que va a contener, por ejemplo:

type pTMemory = record
   anterior, siguiente : Pointer;
   datos : TRecordFile;
end;

TListaEnlazada = class
private

  FFile : File of TRecordFile ;
  Fdatos: TRecordFile ;

  FnumReg: Integer;
  FLista : ptMemory;
  FLast   : ptMemory;
  FnActual : Integer;
  Factual  : pTMemory;
  FBeforeAdd:TBeforeAdd;
  FAfterAdd:TAfterAdd;
    FBeforeDelete: TBeforeDelete;
    FAfterDelete:TAfterDelete;
public
    procedure LoadFromFile(const FileName :string);
    procedure SaveToFile (const FileName:string);
    constructor Create;
    destructor  Free;

    procedure Anade(Value:TrecordFile);
    function AlPrimero: TRecordFile;
    function AlSiguiente: TRecordFile;
    function AlAnterior: TRecordFile;
    function AlUltimo: TRecordFile;
    function Borra(indice:Integer):Boolean;
    function Mover(desde, Al :Integer):Integer;

end;

Como veis Creo un descriptor de ficheros del tipo File of TRecordFile.

Lo que quiero es que al crear la clase se pudiera hacer esto:

L := TLIstaEnlazada.Create(TRecordFile);

Haciendo independiente la clase del tipo de registro usado.

¿Se puede hacer?

Gracias infinitas por vuestra ayuda

[delphi.com.ar]

Sin ahondar demasiado en tu pregunta... ¿Es esto lo que buscas?:

type
  TRecordFileClass = class of TRecordFile;

  TListaEnlazada = class
  private
    ... 
  public
    constructor Create(RecordClass: TRecordFileClass);
  end;

Saludos!

[[Lepe]]

po si, po si, tiene muy buena pinta la respuesta delphi.com.ar

Lo pruebo y comento el resultado.

Muchas gracias

[[Lepe]]

Con mucho acongojo tengo que informar que no compila

type
TRecordFileClass = class of TRecordFile;

el portero de discoteca (en este caso el compilador) dice:
Type Class Required

--------------------------------

Intentaré plantear la pregunta de otra forma.

El usuario final de la clase haría algo así como esto:

Crea 2 tipos de datos (registros), Templeado y TFactura

{private declaration en su forma correspondiente }
      Eclass : TlistaEnlazada;
      Fclass : TlistaEnlazada;
end;

implementation

procedure TFrmMain.FrmMainCreate(Sender: Tobject);
var E : TEmpleado;
      F : TFactura;
begin
  Eclass := TlistaEnlazada.Create(E);
  Fclass := TlistaEnlazada.Create(F);
end;

A partir de aquí ya podria usar su Eclass para añadir empleados
y Fclass para añadir las facturas por ejemplo.

Mi pregunta es: ¿Como debería de estar declarada la clase ListaEnlazada?

He estado mirando la ayuda de Delphi sobre el tema, pero parte
de las Clases Tobject o Tedit, así que el bosque no me deja ver
el árbol.

Creo que se complica la cosa, gracias a dios no sé hasta que punto

Saludos y Gracias por adelantado.

[roman]

No puedes hacer esto:

type
  TRecordFileClass = class of TRecordFile;

pues, tal como te lo dijo el compilador, TRecordFile tiene que ser una clase.

¿Para qué usar records si puedes usar clases?

Por otra parte no entiendo bien cómo quieres lograr la genericidad. Una vez que usas clases puedes agregar cualquier objeto como se hace con un TObjectList y posteriormente hacer el "casting" cuando tengas que acceder a cada objeto.

Si deseas a toda costa evitar el "casting" puedes definir una clase base para tu lista enlazada que se encargue de todo el manejo (las listas enlazadas sólo requieren un apuntador al objeto que guardan así que pedes hacerla independiente del tipo de objeto):

type
  TListaEnlazada = class
  protected
    function GetObject(Index: Integer):TObject;

  public
    property Objects[Index: Integer]: TObject read GetObject;
  end;

Después, si necesitas específicamente una lista de facturas crearías un descendiente de TListaEnlazada en donde redefinirías la propiedad Objects:

type
  TListaFacturas = class
  private
    function GetFactura(Index: Integer):TFactura;

  public
    property Objects[Index: Integer]: TFactura read GetFactura;
  end;

GetFactura simplemente devuelve el Objects[Index] de la clase base pero haciendo el "casting":

Result := TFactura(inherited Objects[Index]);

El punto aquí es que una vez que la lista base está hecha, los descendientes son muy sencillos de hacer (mera rutina).

Desde luego que lo mejor sería oder declarar algo así como

property Objects[Index]: TVariantObject;

donde VariantObject puediera cambiarse durante la ejecución. Pero me temo que con Delphi no podrás hacerlo.

// Saludos

[delphi.com.ar]

Ups... no me había dado cuenta que se trataba de un record....

Si quieres puedes tener un dato del tipo Pointer o un parámetro no tipado, para recibir cualquier puntero a un record.. pero creo que solo complicarías las cosas.


Saludos!

[[Lepe]]

Posteado originalmente por roman
¿Para qué usar records si puedes usar clases?

¿Porque soy novato y no se me ocurría otra forma de hacerlo ?
La verdad, queria empezar desde cero para despues ir subiendo de nivel, pero ya veo que no me queda más remedio que meterme de lleno en el asunto con los Tobjects para comprender como funciona.

Posteado originalmente por roman
Por otra parte no entiendo bien cómo quieres lograr la genericidad. Una vez que usas clases puedes agregar cualquier objeto como se hace con un TObjectList y posteriormente hacer el "casting" cuando tengas que acceder a cada objeto.

TObjectList mmm a este señor no lo conozco, tendré que hacerle una visita desde el F1 de delphi antes de continuar con mi listaEnlazada .... parece que es lo mismo que yo estoy haciendo, pero ya está hecho, ¡¡ cachis, se me han adelantado los de Borland !! ya no me llevo el premio nobel . En serio, lo miraré detenidamente porque es el siguiente nivel que deseo aprender.

Posteado originalmente por roman
GetFactura simplemente devuelve el Objects[Index] de la clase base pero haciendo el "casting":

Result := TFactura(inherited Objects[Index]);

De lo que se deduce, que el casting no lo puedo eliminar, es más, resulta indispensable.

Parece que he partido de un planteamiento incorrecto
Desde luego me habeis enseñado donde está el camino, ahora me toca recorrerlo

¡¡ Muchas gracias por vuestras indicaciones !!