Prüfen ob Integer im Enumeration-Type enthalten ist

[Sir Rufo]

Gerade wenn die Bedeutung zwischen internem und externem System ausgetauscht werden muss, empfiehlt sich ein eigener DatenTyp um so auch typischer im Kontext zu bleiben.

Delphi-Quellcode:

unit Unit2;

interface

type
  TMeinBeispiel = record
  private const
    VALID_VALUES: array [0 .. 2] of Integer = ( 0, 1, 5 );
    class function GetValue( const Index: Integer ): TMeinBeispiel; static;
  public
    class function Values: TArray<TMeinBeispiel>; static;
    class property Eins: TMeinBeispiel index 0 read GetValue;
    class property Zwei: TMeinBeispiel index 1 read GetValue;
    class property Drei: TMeinBeispiel index 2 read GetValue;
  public
    class operator implicit( const a: Integer ): TMeinBeispiel;
    class operator implicit( const a: TMeinBeispiel ): Integer;

    class operator Equal( const a, b: TMeinBeispiel ): Boolean;
    class operator NotEqual( const a, b: TMeinBeispiel ): Boolean;
    // hier können noch weitere Operatoren definiert werden, je nach Belieben
  private
    FValue: Integer;
  public
    constructor Create( const Value: Integer );
    property Value: Integer read FValue;
  end;

implementation

uses
  System.SysUtils;

{ TMeinBeispiel }

constructor TMeinBeispiel.Create( const Value: Integer );
var
  LIdx: Integer;
begin
  for LIdx := Low( VALID_VALUES ) to High( VALID_VALUES ) do
    if Value = VALID_VALUES[LIdx]
    then
      begin
        FValue := Value;
        Exit;
      end;
  raise EConvertError.CreateFmt( '%d kein gültiger Wert für TMeinBeispiel', [Value] );
end;

class operator TMeinBeispiel.Equal( const a, b: TMeinBeispiel ): Boolean;
begin
  Result := a.FValue = b.FValue;
end;

class function TMeinBeispiel.GetValue( const Index: Integer ): TMeinBeispiel;
begin
  Result := TMeinBeispiel.VALID_VALUES[Index];
end;

class operator TMeinBeispiel.implicit( const a: Integer ): TMeinBeispiel;
begin
  Result := TMeinBeispiel.Create( a );
end;

class operator TMeinBeispiel.implicit( const a: TMeinBeispiel ): Integer;
begin
  Result := a.FValue;
end;

class operator TMeinBeispiel.NotEqual( const a, b: TMeinBeispiel ): Boolean;
begin
  Result := not( a = b );
end;

class function TMeinBeispiel.Values: TArray<TMeinBeispiel>;
var
  LIdx: Integer;
begin
  SetLength( Result, Length( TMeinBeispiel.VALID_VALUES ) );
  for LIdx := Low( TMeinBeispiel.VALID_VALUES ) to High( TMeinBeispiel.VALID_VALUES ) do
    begin
      Result[LIdx] := TMeinBeispiel.VALID_VALUES[LIdx];
    end;
end;

end.

Und man benutzt das dann einfach

Delphi-Quellcode:

procedure DoWithValue( AValue : TMeinBeispiel );
begin
  // irgendwas damit machen
end;

begin
  DoWithValue( 5 ); // <- Wert aus der Datenbank ist ein einfacher Integer
end.

Unzulässige Typen werden mit einer Exception direkt beim Umwandeln quittiert.