Zwei Versionen über „for“ vergleichen

[Hawkeye219]

Hallo,

Zitat:

Zitat von Uwe Raabe

Man kann das Ganze auch in einen Int64 packen, dann stehen 4 mal 16 Bit zur Verfügung...

die VCL stellt sogar einen passenden Typ dafür bereit: Int64Rec aus der Unit SysUtils.

Delphi-Quellcode:

var
  V1, V2 : Int64Rec;
begin
  V1.Words[0] := 0; // Buildnummer
  V1.Words[1] := 0; // Revisionsnummer
  V1.Words[2] := 0; // Nebenversionsnummer
  V1.Words[3] := 3; // Hauptversionsnummer

  V2.Words[0] := 1;
  V2.Words[1] := 0;
  V2.Words[2] := 0;
  V2.Words[3] := 2;

  if (Int64(V1) <= Int64(V2)) then
    ShowMessage ('V1 ist kleiner oder gleich V2');

Gruß Hawkeye

[Apollonius]

Die Buildnummer Hauptversionsnummer sollte dann allerdings nicht größer als High(Smallint) sein, sonst wird der Int64 negativ.

[xZise]

Zitat:

Zitat von inherited

Das Programm will ich sehen, das bei Version 255 ist :mrgreen:

Naja Version 255.X.Y.Z ist wirklich unrealistisch. Aber ich würde sagen dass X.Y.Z.255 relatistisch ist (wenn man z.B. das Datum da unterbringt oder so).

An Int (32 bit) dachte ich auch schon, aber dann muss man davon ausgehen, dass sie bei 255 "überläuft". Auch dachte ich, man müsse die if-Konstruktion eigentlich so ganz gut umsetzen können.

Wobei folgendes da ziemlich gut klingt:

Zitat:

Zitat von DeddyH

Könnte das nicht so funktionieren (ungetestet)?

Delphi-Quellcode:

Result := false;
i := 0;
while (i < Length(oldVersion)) and not Result do
  begin
    case Sign(newVersion[i] - oldVersion[i]) of
      -1: break;          //newVersion ist älter -> raus hier
       1: Result := true; //newVersion ist neuer
    end;
    inc(i);
  end;

MfG
xZise

[Hawkeye219]

Hallo Philip,

Zitat:

Zitat von Apollonius

Die Buildnummer sollte dann allerdings nicht größer als High(Smallint) sein, sonst wird der Int64 negativ.

Das Vorzeichen steckt auf Rechnern mit einer Intel-CPU in der Hauptversionsnummer (Words[3], Little-Endian).

Gruß Hawkeye

[Apollonius]

:oops: Das ist mir eigentlich bekant. Gut, dass du mitdenkst.

[himitsu]

@Hawkeye219: if UInt64(V1) <= UInt64(V2) then :angel:


PS: bei FNewVersion hätt ich gedacht, daß dieses True ist, wenn NewXYZ > XYZ wird und nicht bei <= :gruebel:
also insgesammt glaub ich, stümmt was bei der anfänglich genannten IF-Verschachtelung nicht

Delphi-Quellcode:

if NewMajor < Major then
  begin
    if (NewMajor = Major) and (NewMinor < Minor) then
    begin
      if (NewMinor = Minor) and (NewRelease < Release) then
      begin
        if (NewRelease = Release) and (NewBuild < Build) then
        begin
          FNewVersion := false;
        end else
          FNewVersion := true;
      end else
        FNewVersion := true;
    end else
      FNewVersion := true;
  end else
    FNewVersion := true;

oder seh ich das grad irgendwie falsch?

gekürzt:

Delphi-Quellcode:

isNewVersion := (NewMajor > Major) or
  ((NewMajor = Major) and ((NewMinor > Minor) or
  ((NewMinor = Minor) and ((NewRelease > Release) or
  ((NewRelease = Release) and (NewBuild > Build))))));

Selber nutze ich auch gern Records, welche sich dann auch mal ganz leicht nach LongWord, bzw. LargeInt/UInt64 casten lassen:

Delphi-Quellcode:

Type TSmallVersion = packed Record
    Build:        Word;
    Minor, Major: Byte;
  End;

  TVersion = packed Record
    Build, Release: Word;
    Minor, Major:   Word;
  End;

Oder wie wäre es mal mit den neuen Funktionalitäten von Delphi?
und dann einfach nur noch

Delphi-Quellcode:

Var NewVersion, Version: TVersion;

...
If NewVersion <= Version Then ...

Delphi-Quellcode:

Type TSmallVersion = packed Record
    Build:        Word;
    Minor, Major: Byte;

    Class Operator Implicit(Rec:   TSmallVersion): LongWord;
    Class Operator Implicit(Value: LongWord): TSmallVersion;
    Class Operator Implicit(Rec:   TSmallVersion): String;
    Class Operator Implicit(Value: String): TSmallVersion;

    Class Operator Explicit(Rec:   TSmallVersion): LongWord;
    Class Operator Explicit(Value: LongWord): TSmallVersion;
    Class Operator Explicit(Rec:   TSmallVersion): String;
    Class Operator Explicit(Value: String): TSmallVersion;

    Class Operator Equal             (Oper1, Oper2: TSmallVersion): Boolean;
    Class Operator NotEqual          (Oper1, Oper2: TSmallVersion): Boolean;
    Class Operator LessThan          (Oper1, Oper2: TSmallVersion): Boolean;
    Class Operator LessThanOrEqual   (Oper1, Oper2: TSmallVersion): Boolean;
    Class Operator GreaterThan       (Oper1, Oper2: TSmallVersion): Boolean;
    Class Operator GreaterThanOrEqual(Oper1, Oper2: TSmallVersion): Boolean;

    Class Operator Add       (Oper1, Oper2: TSmallVersion): TSmallVersion;
    Class Operator Subtract  (Oper1, Oper2: TSmallVersion): TSmallVersion;
    Class Operator BitwiseAnd(Oper1, Oper2: TSmallVersion): TSmallVersion;
    Class Operator BitwiseOr (Oper1, Oper2: TSmallVersion): TSmallVersion;
  End;

  TVersion = packed Record
    Build, Release: Word;
    Minor, Major:   Word;

    Class Operator Implicit(Rec:   TSmallVersion): UInt64;
    Class Operator Implicit(Value: LongWord): TSmallVersion;
    Class Operator Implicit(Rec:   TSmallVersion): String;
    Class Operator Implicit(Value: String): TSmallVersion;

    Class Operator Explicit(Rec:   TSmallVersion): UInt64;
    Class Operator Explicit(Value: UInt64): TSmallVersion;
    Class Operator Explicit(Rec:   TSmallVersion): String;
    Class Operator Explicit(Value: String): TSmallVersion;

    Class Operator Equal             (Oper1, Oper2: TSmallVersion): Boolean;
    Class Operator NotEqual          (Oper1, Oper2: TSmallVersion): Boolean;
    Class Operator LessThan          (Oper1, Oper2: TSmallVersion): Boolean;
    Class Operator LessThanOrEqual   (Oper1, Oper2: TSmallVersion): Boolean;
    Class Operator GreaterThan       (Oper1, Oper2: TSmallVersion): Boolean;
    Class Operator GreaterThanOrEqual(Oper1, Oper2: TSmallVersion): Boolean;

    Class Operator Add       (Oper1, Oper2: TSmallVersion): TSmallVersion;
    Class Operator Subtract  (Oper1, Oper2: TSmallVersion): TSmallVersion;
    Class Operator BitwiseAnd(Oper1, Oper2: TSmallVersion): TSmallVersion;
    Class Operator BitwiseOr (Oper1, Oper2: TSmallVersion): TSmallVersion;
  End;


// die Definitionen der Funktionen hab ich mir erstmal gesparrt

[xZise]

Zitat:

Zitat von himitsu

[...]
also insgesammt glaub ich, stümmt was bei der anfänglich genannten IF-Verschachtelung nicht[,...]

Doch doch: So wie ich es anfangs genannt habe passt das.

Wenn die Hauptversionsnummer größer ist, springt er ins else -> Result := true:

Delphi-Quellcode:

if NewMajor <= Major then
begin
  [...]
end else
  FNewVersion := true;

Ansonsten macht er das mit der Nebenversionsnummer, der Releasenummer oder der Buildnummer.

MfG
xZise

[himitsu]

Zitat:

Zitat von xZise

Doch doch: So wie ich es anfangs genannt habe passt das.

Wenn die Hauptversionsnummer größer ist, springt er ins else -> Result := true:

eben nicht richtig :warn:

Delphi-Quellcode:

// New     = 3.9.0.0
// Current = 4.8.0.0

if NewMajor{3} <= Major{4} {=true} then
  begin
    if NewMinor{9} <= Minor{8} {=false} then
    begin
      ...
    end else
      FNewVersion := true; {das Ergebnis}
  end else
    FNewVersion := true;

hiernach wäre die 4.8 kleiner als 3.9, da 8 < 9

Der nächste Versionsteil darf nur geprüft werden, wenn die vorherigen Teile gleich sind.

[inherited]

Ich mache das mit Versionen so:

Delphi-Quellcode:

  TVersion = packed record
    case Integer of
      0: (AsInt: Cardinal;);
      1: (AsArray: Array[0..3] of Byte;);
      2: (Major: Byte; Minor: Byte; Release: Byte; Build: Byte;);
  end;

[xZise]

Moin himitsu,
Stimmt :) Aber deine Funktion ergibt auch "wahr", da Major != NewMajor ist.

Zitat:

Zitat von himitsu

[...]

Delphi-Quellcode:

if NewMajor {3} < Major {4} {true} then
begin
  if (NewMajor {3} = Major {4} {false}) and (NewMinor &lt; Minor) then
  begin
    if (NewMinor = Minor) and (NewRelease &lt; Release) then
    begin
      if (NewRelease = Release) and (NewBuild &lt; Build) then
      begin
        FNewVersion := false;
      end else
        FNewVersion := true;
    end else
      FNewVersion := true;
  end else
    FNewVersion := true;
end else
  FNewVersion := true;

Um genau zu sein, ist die Überprüfung ob die Werte gleich sind obsolet, da sie eh nie durchkommen würden (wobei dadurch das nicht mehr gehen würde).

Mein Vorschlag:

Delphi-Quellcode:

FNewVersion := false;
if NewMajor = Major then
begin
  if NewMinor = Minor then
  begin
    if NewRelease = Release then
    begin
      if NewBuild > Build then
      begin
        FNewVersion := true;
      end;
    end
    else if NewRelease > Release then
      FNewVersion := true;
  end
  else if NewMinor > Minor then
    FNewVersion := true;
end
else if NewMajor > Major then 
  FNewVersion := true;

Zu Nikolai: Wie machst du den Vergleich?

Delphi-Quellcode:

var
  Ver, NewVer : TVersion;
begin
  if Ver... < NewVer... then
    FNewVersion := true
  else
    FNewVersion := false;
end;

MfG
xZise