Properites mit Enums zusammenfassen

[Rollo62]

Man könnte auch die Elements selbst gruppieren und mit einem RecordHelper versehen, so in der Art:

Delphi-Quellcode:

TBla = (
         // Group Available   1000-1999
         a_Available = 1000, b_Available, c_Available
         // Group Supported   2000-2999
         a_Supported = 2000, b_Supported, c_Supported
       );

TBla_Helper = record helper for TBla
        function IsAvailable : Boolean;
        function IsSupported : Boolean;
    end;

  TBlaSet = set of TBla;

[uligerhardt]

Sowas?

Delphi-Quellcode:

type
  TBla = (a, b, c);
  TBlaSet = set of TBla;

  TBlub = (l, m, o, p);
  TBlubSet = set of TBlub;

  TPropGroup<E, S >= class
  strict protected
    FActive: E;

    function GetActive: E; virtual; abstract;
    procedure SetActive(Value: E); virtual; abstract;
    function GetAvailable: S; virtual; abstract;
    function GetSupported: S; virtual; abstract;
  public
    property Active: E read GetActive write SetActive;
    property Supported: S read GetSupported;
    property Available: S read GetAvailable;
  end;

  TBlaGroup = class(TPropGroup<TBla, TBlaSet>)
  strict protected
    function GetActive: TBla; override;
    procedure SetActive(Value: TBla); override;
    function GetAvailable: TBlaSet; override;
    function GetSupported: TBlaSet; override;
  end;

  TBlubGroup = class(TPropGroup<TBlub, TBlubSet>)
  strict protected
    function GetActive: TBlub; override;
    procedure SetActive(Value: TBlub); override;
    function GetAvailable: TBlubSet; override;
    function GetSupported: TBlubSet; override;
  end;

  TForm1 = class(TForm)
    ButtonTest: TButton;
    procedure ButtonTestClick(Sender: TObject);
  strict private
    FBlaGroup: TBlaGroup;
    FBlubGroup: TBlubGroup;
  public
    property BlaGroup: TBlaGroup read FBlaGroup;
    property BlubGroup: TBlubGroup read FBlubGroup;
  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
  end;

Delphi-Quellcode:

{ TForm1 }

constructor TForm1.Create(AOwner: TComponent);
begin
  inherited;
  FBlaGroup := TBlaGroup.Create;
  FBlubGroup := TBlubGroup.Create;
end;

destructor TForm1.Destroy;
begin
  FBlaGroup.Free;
  FBlubGroup.Free;
  inherited;
end;

procedure TForm1.ButtonTestClick(Sender: TObject);
var
  bla: TBla;
  blas: TBlaSet;
  blub: TBlub;
  blubs: TBlubSet;
begin
  bla := BlaGroup.Active;
  blas := BlaGroup.Available;
  blub := BlubGroup.Active;
  blubs := BlubGroup.Available;
end;

{ TBlaGroup }

function TBlaGroup.GetActive: TBla;
begin
  Result := FActive;
end;

procedure TBlaGroup.SetActive(Value: TBla);
begin
  FActive := Value;
end;

function TBlaGroup.GetAvailable: TBlaSet;
begin
  Result := [a, b];
end;

function TBlaGroup.GetSupported: TBlaSet;
begin
  Result := [b, c];
end;

{ TBlubGroup }

function TBlubGroup.GetActive: TBlub;
begin
  Result := FActive;
end;

procedure TBlubGroup.SetActive(Value: TBlub);
begin
  FActive := Value;
end;

function TBlubGroup.GetAvailable: TBlubSet;
begin
  Result := [l, m];
end;

function TBlubGroup.GetSupported: TBlubSet;
begin
  Result := [o, p];
end;

Du bezahlst halt mit dynamischer Speicherallozierung und virtuellen Funktionsaufrufen.

[freimatz]

Danke Ja sowas in der Art. (Das von Rollo62 funktioniert vielleicht auch, aber sicher nicht für diesen Anwendungszweck.
Erster Knackpunkt war Dein Vorschlag den Aufzählungstyp und die Menge separat anzugeben. Da Delphi keine Contrains auf Enums kenn kann das nur so gehen. Eine "ESet = set of E" geht nicht.
Mein letzter Stand ist der:

Delphi-Quellcode:

type
  TBla = (a, b, c);
  TBlaSet = set of TBla;

  TBlub = (l, m, o, p);
  TBlubSet = set of TBlub;

  TPropGroup<E, S> = class

  private
    FActive   : E;
    FSupported: S;
    FAvailable: S;

    procedure SetActive(Value: E);
    function GetActive(): E;
    function GetSupported(): S;
    function GetAvailable(): S;

  public
    property Active   : E read GetActive write SetActive;
    property Supported: S read GetSupported;
    property Available: S read GetAvailable;
  end;

  TClient = class
  strict protected
    FBla: TPropGroup<TBla, TBlaSet>;

    function GetBla(): TPropGroup<TBla, TBlaSet>;

  public
    property Bla: TPropGroup<TBla, TBlaSet> read GetBla;
  end;

Letzendlich werde ich es aber wohl lassen. Mit dem Package wo das rein sollte ist Delphi eh schon überfordert. Und ich befürchte mit noch mehr Generics wirds noch schlimmer.

[uligerhardt]

Zitat von freimatz:

Da Delphi keine Contrains auf Enums kenn kann das nur so gehen. Eine "ESet = set of E" geht nicht.

Jo. Unelegant, aber anders geht's wohl nicht.

Zitat von freimatz:

Delphi-Quellcode:

  TClient = class
  strict protected
    FBla: TPropGroup<TBla, TBlaSet>;

    function GetBla(): TPropGroup<TBla, TBlaSet>;

  public
    property Bla: TPropGroup<TBla, TBlaSet> read GetBla;
  end;

Letzendlich werde ich es aber wohl lassen. Mit dem Package wo das rein sollte ist Delphi eh schon überfordert. Und ich befürchte mit noch mehr Generics wirds noch schlimmer.

Ich würde explizit einen Typ pro Enum anlegen: TBlaPropGroup = TPropGroup<TBla, TBlaSet>
Was ich so verstanden habe, reduziert das potentiell den Codebloat durch Generics etwas. Und lesbarer ist's vielleicht auch.