Named types zu String und zurück?

[Ole Jansen]

Moin,

Irgendwie hab ich gerade ein Brett vorm Kopf:

Es gibt eine Reihe benamter Typen, z.B.

type bla = (Anton, Berta, Caesar);

Eigentlich braucht man die nicht. Zahlen würden völlig
ausreichen. Um die Anschaulichkeit der Quelltexte zu
verbessern ist es aber angenehmer wenn da "if bla=Caesar ..."
steht und nicht "if bla=2".
Neue Typen sollen später hinzu kommen und möglichst an einer
einzigen Stelle im Quelltext gepflegt werden.

Werden z.B. Daten z.B. aus einer INI-Datei eingelesen und
den Typen zugeordnet wären das mit z.B. Integern trivial.
So aber benötigt man Funktionen, welche Namen umwandeln können:


//liefert -1 zurück wenn keine Übereinstimmung, ansonsten Index
function String2bla(s:string):integer;

begin
result:=-1;
if Copy(s,1,5)='Anton' then result:=Anton;
if Copy(s,1,5)='Berta' then result:=Berta;
if Copy(s,1,6)='Caesar' then result:=Caesar;
end;

//Liefert Type Namen zurück, ansonsten leeren String

function bla2string(t:integer):string;

begin
if t=Anton then result:='Anton';
if t=Berta then result:='Berta';
if t=Caesar then result:='Caesar';
end;

(Wie) geht das eleganter? Gibt es eine Möglichkeit nach
Typnamen zu suchen analog zu FindComponent? (Delphi5)

Viele Grüße,

O.J.

[Stefan M. Huber]

Moin,

Servus. Such mal nach Run Time Type Information (RTTI) bzw. der Unit
TypInfo. Damit geht sowas, wenn ich's recht im Kopf hab.

Stefan

[Hans-Peter Diettrich]

Post by Ole Jansen
Moin,
Es gibt eine Reihe benamter Typen, z.B.
  type bla = (Anton, Berta, Caesar);
Eigentlich braucht man die nicht. Zahlen würden völlig
ausreichen.

Man braucht sie für Mengen (Sets) und Operationen darauf.

Post by Ole Jansen
//Liefert Type Namen zurück, ansonsten leeren String
function bla2string(t:integer):string;
  begin
    if t=Anton      then result:='Anton';
    if t=Berta      then result:='Berta';
    if t=Caesar     then result:='Caesar';
  end;

Das funktioniert nur für benannte Konstanten, nicht für Enum-Typen.

Post by Ole Jansen
(Wie) geht das eleganter? Gibt es eine Möglichkeit nach
Typnamen zu suchen analog zu FindComponent?  (Delphi5)

Benutze TypInfo.

DoDi

[Matthias Hanft]

Post by Ole Jansen
//Liefert Type Namen zurück, ansonsten leeren String
function bla2string(t:integer):string;
begin
if t=Anton then result:='Anton';
if t=Berta then result:='Berta';
if t=Caesar then result:='Caesar';
end;
(Wie) geht das eleganter?

Ich nehme an, du wolltest im Header "t:bla" statt "t:integer"
schreiben? Dann geht *das* zumindest mit

function bla2string(t:bla):string;
const
blanamen: array[bla] of string=('Anton', 'Berta', 'Caesar');
begin
result:=blanamen[t]
end;

Falls man dafür überhaupt eine Funktion schreiben mag :-)

Gruß Matthias.

[Heiko Rost]

Post by Ole Jansen
Es gibt eine Reihe benamter Typen, z.B.
type bla = (Anton, Berta, Caesar);
Eigentlich braucht man die nicht. Zahlen würden völlig
ausreichen. Um die Anschaulichkeit der Quelltexte zu
verbessern ist es aber angenehmer wenn da "if bla=Caesar ..."
steht und nicht "if bla=2".
Neue Typen sollen später hinzu kommen und möglichst an einer
einzigen Stelle im Quelltext gepflegt werden.
Werden z.B. Daten z.B. aus einer INI-Datei eingelesen und
den Typen zugeordnet wären das mit z.B. Integern trivial.

Falls für Deine Zwecke wirklich Zahlen ausreichend sind, kannst Du das
einfach per Typecasting machen. Wobei es dann empfehlenswert ist, in der
Type-Definition die gewünschten Werte mit anzugeben, damit sich das
Ergebnis von ord() nicht mehr ändert, wenn Du später evtl. tBla
erweitern willst.

program Project1;

type tBla = (Anton=1, Berta=2, Caesar=3);

var bla1 : tBla;
bla2 : tBla;
i : Integer;
begin
writeln('Typecasting Beispiel');
writeln();
Writeln('Wertebereich der Aufzählung von ',ord(low(tBla)),' bis ',ord(high(tBla)));
Write('Zuweisung zu einer anderen Variablen: ');
bla1 := Berta;
i := ord(bla1);
bla2 := tBla(i);
if bla1 = bla2 then writeln('Ok') else writeln('Oops');
writeln('ENTER...');
readln
end.

Gruß Heiko

[Peter Below]

Post by Ole Jansen
Moin,
Es gibt eine Reihe benamter Typen, z.B.
type bla = (Anton, Berta, Caesar);
Eigentlich braucht man die nicht. Zahlen würden völlig
ausreichen. Um die Anschaulichkeit der Quelltexte zu
verbessern ist es aber angenehmer wenn da "if bla=Caesar ..."
steht und nicht "if bla=2".
Neue Typen sollen später hinzu kommen und möglichst an einer
einzigen Stelle im Quelltext gepflegt werden.
Werden z.B. Daten z.B. aus einer INI-Datei eingelesen und
den Typen zugeordnet wären das mit z.B. Integern trivial.

Die gibt es, Unit TypInfo, GetEnumName und GetEnumValue. Wenn man auch
mit Strings fertig werden muß, die keinem Element der Enumeration
entsprechen, ist es nützlich, wenn man als erstes Element einen Dummy
definert:

type bla = (Unbekannt, Anton, Berta, Caesar);

function String2Bla(const s: string): bla;
var
I: integer;
begin
I:= GetEnumValue(Typeinfo(bla), s);
if I < 0 then
Result := Unbekannt
else
Result := bla(I);
end;

function Bla2String(aValue: bla): string;
begin
result := GetEnumName(Typeinfo(bla), Ord(aValue));
end;

[Ole Jansen]

Post by Peter Below

Post by Ole Jansen
Moin,
Es gibt eine Reihe benamter Typen, z.B.
type bla = (Anton, Berta, Caesar);
Eigentlich braucht man die nicht. Zahlen würden völlig
ausreichen. Um die Anschaulichkeit der Quelltexte zu
verbessern ist es aber angenehmer wenn da "if bla=Caesar ..."
steht und nicht "if bla=2".
Neue Typen sollen später hinzu kommen und möglichst an einer
einzigen Stelle im Quelltext gepflegt werden.
Werden z.B. Daten z.B. aus einer INI-Datei eingelesen und
den Typen zugeordnet wären das mit z.B. Integern trivial.

Die gibt es, Unit TypInfo, GetEnumName und GetEnumValue.

Danke für die Hilfe, das waren die fehlenden Stichworte.
Falls es interessiert: Bla2String('cAESAR') liefert auch
brav Caesar zurück usw.

Post by Peter Below
Wenn man auch
mit Strings fertig werden muß, die keinem Element der Enumeration
entsprechen, ist es nützlich, wenn man als erstes Element einen Dummy
definert

Auch eine gute Idee. Spart ein paar lästige Abfragen.

Viele Grüße,

O.J.