Enumerado genérico como parámetro
 

Hola a todos,

En esta oportunidad lo que necesito es ver como se puede hacer para pasar por parámetro en una función un enumerado genérico.

Lo que quiero hacer es algo similar a lo que permite C#, o sea lo siguiente.

Lo que hace esta función es usar un parámetro del tipo enumerado, donde ese enumerado puede ser cualquiera que se defina. Digamos para que se entienda que teniendo en Delphi lo siguiente:

Código Delphi [-]
TEnum1 = (eValor1, eValor2, eValor3, eValor4);

TEnum2 = (Valor1, Valor2, Valor3, Valor4, Valor5, Valor6);

se pueda pasar cualquiera de los valores de los dos enumerados y no tener que hacer dos funciones, una para cada enumerado. Si tengo dos enumerados la cosa podría estar bien, pero si tengo muchos mas ya no funciona y se complica.

Espero que se entienda y cualquiercosa me consultan y aclaro lo que sea necesario.

Saludos,
El Rayo

Hola elrayo76.

Si habláramos de C++, es simple hacerlo usando template,
pero hasta la versión de Delphi que poseo, esto no es posible. Sin embargo hay muchas novedades en las versiones posteriores que ignoro.

Fijate si podes hacer algo con Generics Types, tal vez por ahí vayan los tiros...

Saludos :)

elrayo76,

:rolleyes:

Revisa este código:

Código Delphi [-]
unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type
  TForm1 = class(TForm)
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;

  TEnumA = (A1=10, A2=11, A3=12, A4=13, A5=14);
  TEnumB = (B1=20, B2=21, B3=22, B4=23, B5=24);
  TEnumC = (C1=30, C2=31, C3=32, C4=33, C5=34);
  TEnumD = (D1=40, D2=41, D3=42, D4=43, D5=44);
  TEnumE = (E1=50, E2=51, E3=52, E4=53, E5=54);

var
  Form1: TForm1;

implementation

{$R *.dfm}

function SumEnumValue(const EnumValue : Array of Variant) : Integer;
var
   i : Integer;

begin

   Result := 0;

   for i := Low(EnumValue) to High(EnumValue) do
      Result := Result + EnumValue[i];

end;

procedure TForm1.Button1Click(Sender: TObject);
var
   TotEnumValue : Integer;

begin

   TotEnumValue := SumEnumValue([A1,B1,C1,D1,E1,
                                 A2,B2,C2,D2,E2,
                                 A3,B3,C3,D3,E3,
                                 A4,B4,C4,D4,E4,
                                 A5,B5,C5,D5,E5
                                ]);

   MessageDlg(Format('Sumatoria EnumValues = %d',[TotEnumValue]),mtInformation,[mbOK],0);

end;

end.

El código anterior en Delphi 7 sobre Windows 7 Profesional x32, Ejemplifica como pasar a una función N cantidad de valores de tipo Enumerado por medio de un Arreglo Dinámico de tipo Variant, como se muestra en la siguiente imagen:



Espero sea útil :)

Nelson.

No es exactamente lo que necesito pero tendría que ver si me sirve... Lo que quiero hacer es poder pasar a la función solamente uno de los datos de cualquiera de todos los enumerados que pueda tener.

Si a alguien se le ocurre o conoce alguna otra forma de hacer lo que necesito se los agradecería.

Saludos,
El Rayo

elrayo76,

:rolleyes:

Revisa este código:

Código Delphi [-]
procedure TForm1.Button2Click(Sender: TObject);
var
   Sum1, Sum2, Sum3, Sum4 : Integer;
   SumMsg : String;

begin

   Sum1 := SumEnumValue([A1]);

   Sum2 := SumEnumValue([C5]);

   Sum3 := SumEnumValue([B3,E5]);

   Sum4 := SumEnumValue([]);

   SumMsg := 'Sum1 = %d ' + #13#10 + 'Sum2 = %d' + #13#10 + 'Sum3 = %d' + #13#10 + 'Sum4 = %d';

   MessageDlg(Format(SumMsg,[Sum1, Sum2, Sum3, Sum4]),mtInformation,[mbOK],0);

end;

El código anterior en Delphi 7 sobre Windows 7 Professional x32, es continuación del propuesto en el Msg #3 y Muestra como enviar 0, 1 ó N valores de tipo Enumerado por medio de un Arreglo Dinámico de tipo Variant, como se muestra en la siguiente imagen:



Pregunto:

1- ¿Que versión de Windows (XP, 7, 8, 8.1, 10, Otra) y de cuantos bits (x32, x64) usa tu aplicación?

2- ¿Que versión de Delphi usa tu aplicación?.

Espero sea útil :)

Nelson.

1- ¿Que versión de Windows (XP, 7, 8, 8.1, 10, Otra) y de cuantos bits (x32, x64) usa tu aplicación?

Windows 7 de 64 bits. Pero creo que esto no viene al acaso.

2- ¿Que versión de Delphi usa tu aplicación?.

En estoss momento estoy usando Delphi XE8, pero bien podría haber sido con XE6.

Igualmente creo que no conoces si existe alguna forma para pasar un parámetro de una función como un tipo enumerado genéricos (por genérico me refiero a que no le tenga que decir a la función que el parametro es TEnumA o TEnumB, sino que sea algo que le pueda pasar cualquier enumerado).

Igualmente gracias por la respuesta. Ya veré si lo resuelvo como tu me dices o buscaré alguna otra forma de hacerlo.

Saludos,
El Rayo

Hola elrayo76.

Hay una duda importante en el aire: ¿la función debe poder distinguir cuál es el tipo del valor pasado como parámetro? ¿Podrías darnos una idea de qué hará la función con él?

A diferencia de C, Delphi no permite que los tipos enumerados sean directamente compatibles con los tipos entero, pero los considera a ambos como ordinales. Eso los hace fácilmente intercambiables, por ejemplo, usando la función Ord:

Código Delphi [-]
// Llamamos a la función con un valor del tipo enumerado TOperation
FuncionMisteriosa (Ord (opRemove));

// Llamamos a la función con un valor del tipo enumerado TTypeKind
FuncionMisteriosa (Ord (tkClass));

La desventaja de esto es que la función debe declarar su parámetro de tipo entero, con lo cual se pierde la valiosa información sobre cuál era el tipo del valor pasado.

En caso de que la función deba discernir el tipo del valor, una alternativa viable es que la función sea un método con parámetro de tipo, también conocido como método genérico:

Código Delphi [-]
Procedure MetodoMisterioso <T> (Value :T);

En este caso la desventaja es que Delphi no cuenta por ahora con un tipo de restricción enumerated para los parámetros de tipo, por lo que el compilador admitiría cualquier tipo de dato para T.

NOTA: El enlace dado por ecfisa puede servirte como introducción al uso de genéricos en Delphi, fabulosa característica disponible desde la versión 2009.

Un cordial saludo.

Al González.

El enunciado y código de la pregunta parece orientado a C++ luego esta es la respuesta correcta.

En realidad un Template expande las funciones para cada clase, el programador escribe una función y el compilador escribe tantas como sean necesarias.


Saludos.

Para ver si con esto me pueden ayudar.

Lo que quiero hacer es poder obtener el nombre del dato del enumerado que se le pasa como parámetro a la función y no el valor del mismo. Se que con GetEnumName() se obtiene el nombre, pero lo que me falta es poder pasar genéricamente los enumerados para no tener que hacer cada vez que lo necesite una nueva función por cada enumerado.

Lo que haria es tener en los enumerados como cada uno de los datos los nombres de los campos de las tablas y pasarlos a una función para armar una sentencia SQL para la parte del Where. Esto además de otros datos que recibirá la función en cuestión.

Si lo pensamos abría que escribir la misma funcón para cada una de las tablas y eso es lo que no quiero hacer.

Saludos,
El Rayo

En ese caso, creo que la opción del método con parámetro de tipo sería lo más indicado. Aplicando la función TypeInfo sobre T para obtener el PTypeInfo que GetEnumName necesita. :) ^\||/

Gracias gente por sus respuestas...

Veré de hacerlo usando el TypeInfo. Si llego a lograr algo les comentare que solución le dí por si a alguien le puede servir.

Saludos,
El Rayo

elrayo76,

:rolleyes:

Revisa este código:

Código Delphi [-]
unit Unit1;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, TypInfo;

type
  TForm1 = class(TForm)
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;

  TEnum = record
  public
    class function AsString< T >(EnumValue : T): String; Static;
    class function AsInteger< T >(EnumValue : T): Integer; Static;
  end;

  TEnumA = (A1, A2, A3, A4, A5);
  TEnumB = (B1, B2, B3, B4, B5);
  TEnumC = (C1, C2, C3, C4, C5);
  TEnumD = (D1, D2, D3, D4, D5);
  TEnumE = (E1, E2, E3, E4, E5);

var
  Form1: TForm1;

implementation

{$R *.dfm}

// Obtiene el nombre del tipo enumerado genérico
class function TEnum.AsString< T >(EnumValue : T) : String;
begin
   Result := GetEnumName(TypeInfo(T), AsInteger(EnumValue));
end;

// Obtiene el valor del tipo enumerado genérico
class function TEnum.AsInteger< T >(EnumValue : T) : Integer;
begin
   case Sizeof(T) of
      1 : Result := pByte(@EnumValue)^;
      2 : Result := pWord(@EnumValue)^;
      4 : Result := pCardinal(@EnumValue)^;
   end;
end;

// Obtiene el nombre y valor de un tipo enumerado por medio de Genéricos
procedure TForm1.Button1Click(Sender: TObject);
begin

   MessageDlg(Format('EnumValue %s = %d',[TEnum.AsString< TEnumA >(A1), TEnum.AsInteger< TEnumA >(A1)]),mtInformation,[mbOK],0);
   MessageDlg(Format('EnumValue %s = %d',[TEnum.AsString< TEnumE >(E5), TEnum.AsInteger< TEnumE >(E5)]),mtInformation,[mbOK],0);

end;

end.

El código anterior en Delphi XE7 sobre Windows 7 x32, Permite obtener el nombre y valor de un tipo enumerado por medio de un tipo genérico, como se muestra en la siguiente imagen:



Notas:

1- El código esta basado en un ejemplo del Capítulo 3 (Understanding Generics) del libro Coding in Delphi de Nick Hodges.

2- Los tipos genéricos en Delphi no cuentan por el momento de un constraint que verifique que el tipo pasado corresponda a un tipo enumerado.

3- Hasta donde entiendo, no existe en Delphi el equivalente a System.enum de C#.

4- El código propuesto fue probado en Delphi XE4 bajo Windows 7 Professional x64, funcionando correctamente según lo esperado.

5- Si se le asignan valores a la enumeración, el método TEnum.AsInteger< T > falla, funciona correctamente con los valores por default de la enumeración.

Espero sea útil :)

Nelson.

De nada, elrayo76.

El ejemplo de Nelson me parece excelente, creo que es exactamente lo que necesitas. :) ^\||/

Cabe agregar que Antonio Castillo escribió un artículo muy relacionado con esto a principios del año anterior.

Ambas aportaciones me parecen muy valiosas.

Saludos.

Hola.

Leyendo un poco sobre la cuestión, encontre esta información delphi - how to get type of enum y al parecer hay limitantes con el uso de genericos y enumerados.

Según menciona el segundo mensaje del enlace, no se puede obtener información de tipo mediante TTypeInfo cuando las enumeraciones son discontinuas o no comienzan en cero. Sería interesante que quien tuviera una versión que soporte el uso de generics verificara dicha aserción.

Saludos :)

Gente, he visto todo lo que me pasaron para lo que necesito, pero igualmente sigo sin resolver el inconveniente.

El problema es que todo lo que dicen es solamente para obtener dle dato del enumerado su nombre. Lo que yo necesito es poder pasarle a una función ese dato que proviene de cualquier enumerado y dentro de la función utilizar cualquiera de las opciones que plantean para poder devolver el nombre del mismo.

es decir:

Código Delphi [-]
TEnum1 = (a1, b1, c1);
TEnum2 = (a2, b2, c2);

procedure ejemplo(const aValor: TEnum)
begin
  // Acá usaría por ejemplo la alternativa de Nelson para obtener el nombre del datos enumerado que le paso como parametro.
  // Donde digo enumerado en el parámetro debe permitir poner como valor cualquiera de los datos de los dos enumerados.
end;

Lo que se hace con el dato del enumerado dentro de la función es algo secundario pues todos me dieron distintas respuestas de como obtener lo que yo necesito. El tema es que nadie me dice como pasar genéricamente el dato del enumerado como parámetro de la función sin necesidad de tener que hacer nada extra antes de usar la función.

Saludos,
El Rayo

elrayo76,

:rolleyes:

Te comento:

1- No existe en Delphi el equivalente a System.enum de C#, por lo tanto no es posible pasar un parámetro de una función o procedimiento como un tipo enumerado genérico, sin embargo existen los tipos genéricos.

2- Te sugiero revisar el código propuesto en el Msg #12 (tipos genéricos), quizás lo puedas adaptar a tu aplicación.

Espero sea útil :)

Nelson.

En Object Pascal suele ser necesario hacer algo extra para conseguir ciertas cosas. Sin embargo, se compensa con un código más elegante, comprensible y seguro que el de otros lenguajes.

Es necesario que tu función sea un método, es decir, que esté declarada dentro de una clase o bien dentro de un tipo record, y además tener un parámetro de tipo (es esa letra T que ves entre símbolos de menor y mayor que, en el ejemplo de Nelson). Aprovecha estas nuevas capacidades de Delphi, son precisamente para resolver casos especiales como el tuyo.

Saludos.

Alberto,

^\||/

Nelson.

El tema es que no se puede porque has/han complicado tanto las cosas que ahora estás en un callejón sin salida. El problema es por un mal diseño de los tipos, no por el lenguaje. Delphi es así para obligarte a pensar las cosas bien desde un principio. Todo ordenado y cada animal en su jaula.

El hecho de tener un Tipo de Datos (piensa en un "Tipo" como si fueran jaulas de distinto tamaño para distintos animales) y ahora quieres meter un Elefante en la jaula de una tortuga [...]. Eso es la señal que estás haciendo las cosas mal. Lo siento, toca pensar las cosas de nuevo.

En C++ no hay "tamaños de jaulas", agrandas la jaula a voluntad y la disminuyes sobre la marcha...eah! todo junto y revuelto :p. Y esto mismo es lo que evita Delphi por el fuerte tipificado de datos. Te obliga a separar churras (TEnum1) de meninas (TEnum2).

¿te das cuenta que tienes la solución con un simple número entero y descripción? Así como se hacía en los años 80:
- del 0 al 100 son errores de base de datos (TEnum1)
- del 101 al 200 son errores de memoria (TEnum2)

Código Delphi [-]
procedure ( Enum : integer);
begin 
//  con un array de string donde el indice es el parámetro Enum, 
// y el texto es el otro valor que quieres, lo tienes solucionado
end;

Pero no, quieres tener 2 tipos de datos (que al final son números enteros de 0 hasta 255) para después, por técnicas complejas (como RunTime Type Information), volver a tener el nombre/texto de ese valor... WTF!! o mejor dicho: KISS (Keep It Simple Stupid!)


Todo esto viene porque los requerimientos que estás pidiendo, fuerzan a cambiar las especificaciones iniciales. YA No necesitas un Tipo enumerado, quizás una clase que tenga dos cosas como "código de error" y "Descripción", o quizás "valor" y "clase de error" ... Incluso puede que sirva un "Array de record"

Saludos

A las bravas, mira este ejemplo de casting forzado:

Código Delphi [-]
type
TEnum1 = (a1, b1, c1);
PEnum1 = ^TEnum1;
TEnum2 = (a2, b2, c2);
PEnum2 = ^TEnum2;

procedure ejemplo(const aValor: TEnum1);
var
 E1: TEnum1;
 E2: TEnum2;
begin
 E1:= (PEnum1(@aValor))^;
 E2:= (PEnum2(@aValor))^;
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
  ejemplo(a1);
end;

Usando el cast de punteros puedes forzar la conversión a cualquier cosa, como en C.

Saludos.