Vererbungs-Problem: class const überschreiben

[s.h.a.r.k]

So, gleich nochmal eine Frage

Und zwar habe ich im Moment folgende Typen, um Daten aus der Datenbank in meiner Anwendung zu halten. Diese haben den Sinn, dass ich auch den Variant-Wert Null darstellen kann, ohne dafür einen Wert aus String/Integer/Float dafür verbraten zu müssen.

Delphi-Quellcode:

VBasic = class(TObject)
private
  FValue : Variant;
  procedure SetValue(const AVar: Variant);
public
  const VarType = varUnknown;
  property Value : Variant read FValue write SetValue;
  constructor Create(); reintroduce;
  function IsNull(): Boolean;
end;

VInteger = class(VBasic)
  const VarType = varInteger;
end;

VString = class(VBasic)
  const VarType = varString;
end;

VFloat = class(VBasic)
  const VarType = varDouble;
end;

Hier noch die SetValue-Methode von VBasic:

Delphi-Quellcode:

procedure VBasic.SetValue(const AVar: Variant);
var
  b : Boolean;
begin
  if (VarIsClear(AVar) or VarIsNull(AVar)) then
    FValue := NULL
  else begin
    b := False;
    if (VarType = varUnknown) then // <-- scheinbar immer True
      b := True
    else if (VarType = varString) then
      b := (VarIsStr(AVar)) and (not VarSameValue(FValue, AVar))
    else if (VarType = varInteger) then
      b := (VarIsOrdinal(AVar)) and (not VarSameValue(FValue, AVar))
    else if (VarType = varDouble) then
      b := (VarIsNumeric(AVar)) and (not VarSameValue(FValue, AVar));

    if b then
      FValue := AVar
    else
      raise Exception.Create('Wert hat ungültiges Format.');
  end;
end;

An dieser Stelle merkt der Compiler an, dass beim zweiten If (9. Zeile) immer True heraus kommt und b somit immer True ist. Das Problem wird sein, dass die Konstante VarType, von z.B. VString, nicht die von VBasic überschreibt. Geht sowas eigentlich überhaupt? Oder gibt es evtl. einen anderen Ausweg?

[himitsu]

Klasseninterne Konstanten, Typen oder Variablen werden nicht überschrieben und demnach ist in VBasic das VarType immer varUnknown, da es von der Variable und nicht von der enthaltenen Klasse abhängt.

Da es nun eine unveränderliche Konstante ist, bemerkt Delphi daß (VarType = varUnknown) immer TRUE und
(VarType = varString) immer FALSE ergibt.

Einzige Lösung:
VarType muß als ReadOnly-Property oder als Funktion ausgelegt sein.
Die zugehörige Funktion als Virtual (oder Virtual Abstact) und dann in jeder Ableitung entsprechend überschrieben und mit passendem Result/Funktionsergebnis versehen werden.

[s.h.a.r.k]

Das Problem ist dabei allerdings dann dass ich die Konstante in statischem Kontext brauche, d.h. z.B. VString.VarType.

[himitsu]

Ist nicht möglich, da die Objekte in der Variable auch nicht statisch sind.

Dieses würde einer Class Var, Class Propery oder einer Class Function gleichen und diese hängen nur vom Typen der Variable (bzw. des Typnamens) ab und nicht vom Objekt in einer Variable.

VarType geht nicht anders zu lösen.

Aber für SetValue besteht die Lösung darin es als Virtual zu deklarieren in den Ableitungen dann entsprechend zu überschreiben.

Es ist eh unschön die Verarbeitung für die Ableitungen im Basistypen vorzunehmen.

Delphi-Quellcode:

VBasic = class(TObject)
private
  FValue : Variant;
  function GetVarType: TVarType; virtual;
  procedure SetValue(const AVar: Variant); virtual;
public
  property VarType: TVarType read GetVarType;
  property Value : Variant read FValue write SetValue;
  function IsNull: Boolean;
end;

VInteger = class(VBasic)
private
  function GetVarType: TVarType; override;
  procedure SetValue(const AVar: Variant); override;
end;

VString = class(VBasic)
private
  function GetVarType: TVarType; override;
  procedure SetValue(const AVar: Variant); override;
end;

VFloat = class(VBasic)
private
  function GetVarType: TVarType; override;
  procedure SetValue(const AVar: Variant); override;
end;



function VBasic.GetVarType: TVarType; 
begin
  Result := varUnknown;
end;

procedure VBasic.SetValue(const AVar: Variant);
begin
  if VarIsClear(AVar) or VarIsNull(AVar) then
    FValue := NULL
  else 
    FValue := AVar;
end;

function VInteger.GetVarType: TVarType; 
begin
  Result := varInteger;
end;

procedure VInteger.SetValue(const AVar: Variant);
begin
  if VarIsClear(AVar) or VarIsNull(AVar) then
    FValue := NULL
  else 
    if VarIsOrdinal(AVar) and not VarSameValue(FValue, AVar) then
      FValue := AVar
    else
      raise Exception.Create('Wert hat ungültiges Format.');
end;

...

[edit]
OK, es sollte möglich sein auch ein Klassen-Property zu überschreiben ... dieses wäre dann als VarType nutzbar

eventuell so:

Delphi-Quellcode:

VBasic = class(TObject)
private
  FValue : Variant;
  class function GetVarType: TVarType; virtual;
  procedure SetValue(const AVar: Variant); virtual;
public
  class property VarType: TVarType read GetVarType;
  property Value : Variant read FValue write SetValue;
  function IsNull: Boolean;
end;

VInteger = class(VBasic)
private
  class function GetVarType: TVarType; override;
  procedure SetValue(const AVar: Variant); override;
end;

VString = class(VBasic)
private
  class function GetVarType: TVarType; override;
  procedure SetValue(const AVar: Variant); override;
end;

VFloat = class(VBasic)
private
  class function GetVarType: TVarType; override;
  procedure SetValue(const AVar: Variant); override;
end;



class function VBasic.GetVarType: TVarType; 
begin
  Result := varUnknown;
end;

procedure VBasic.SetValue(const AVar: Variant);
begin
  if VarIsClear(AVar) or VarIsNull(AVar) then
    FValue := NULL
  else 
    FValue := AVar;
end;

class function VInteger.GetVarType: TVarType; 
begin
  Result := varInteger;
end;

procedure VInteger.SetValue(const AVar: Variant);
begin
  if VarIsClear(AVar) or VarIsNull(AVar) then
    FValue := NULL
  else 
    if VarIsOrdinal(AVar) and not VarSameValue(FValue, AVar) then
      FValue := AVar
    else
      raise Exception.Create('Wert hat ungültiges Format.');
end;

...

[s.h.a.r.k]

Super, danke

// edit

Zitat:

Es ist eh unschön die Verarbeitung für die Ableitungen im Basistypen vorzunehmen.

Jo, ich weiß. Nur wollte ich dieses Klassen-Zeug gar nicht so ausarten lassen und daher alles in eine Methode packen. Aber ich sehe schon, ein wenig mehr Schreibarbeit...