Liste ohne dahinterliegende Items

[Bjoerk]

Ich brauch für eine (sehr umfangreiche History) eine so oder ähnliches Konstruktion. Kann man das so machen?

Delphi-Quellcode:

  TMyLists = class
  private
    FPath: string;
    FValue: TMyList;
    FFileNames: TStringList;
    function GetMyLists(I: integer): TMyList;
  public
    function Count: integer;
    function Add(Value: TMyList) : integer;
    property MyLists[I: integer]: TMyList read GetMyLists;
    constructor Create;
    destructor Destroy; override;
  end;

..

constructor TMyLists.Create;
var
  S: string;
begin
  S := FormatDateTime('ddmmyyyyhhnnsszzz', Now);
  FPath := ExtractFileName(ParamStr(0)) + 'Temp\' + S;
  ForceDirectories(FPath);
  FValue := TMyList.Create;
  FFileNames := TStringList.Create;
end;

destructor TMyLists.Destroy;
begin
  DeletePath(FPath);
  FValue.Free;
  inherited Destroy;
end;

function TMyLists.Count: integer;
begin
  Result := FFileNames.Count;
end;

function TMyLists.GetMyLists(I: integer): TMyList;
begin
  FValue.LoadFromFile(FFileNames[I]);
  Result := FValue;
end;

function TMyLists.Add(Value: TMyList) : integer;
begin
  Result := Count;
  FFileNames.Add(FPath + IntToStr(Count));
  Value.SaveToFile(FFileNames[Count - 1]);
end;

[himitsu]

Joar, warum sollte man es nicht so machen können?
Oder funktioniert es nicht?

Nja, man könnte noch fragen, warum ein eigenes Tempverzeichnis
und ob es im Programmverzeichnis wirklich Schreibrechte gibt.

Da du Add von extern reingibst, könnte man auf die Idee kommen das auch beim Get zu machen, also Get(Value: TMyList; I: Integer) .

[Bjoerk]

Ok. Ich mach's mal ganz fertig und poste es dann. Wäre schön, wenn du dann kurz drüber schauen könntest. Ob ich's heut noch schaff weiß ich nicht,ich probier's..

[Sir Rufo]

Hoffentlich willst du immer nur ein Item bearbeiten und den Wert nirgendwo zwischenspeichern.

[himitsu]

Zitat von Sir Rufo:

Hoffentlich willst du immer nur ein Item bearbeiten und den Wert nirgendwo zwischenspeichern.

Darum auch der Vorschlag mit dem anderen "Get".

Man könnte aber auch mehrere StringLists intern verwalten.
z.B.:
- CreateList: TStrings => neue Liste erstellen
- LockList(var List: TStrings): Integer > Liste in Datei speichern und StringList freigeben
- UnlockList(LockedList: Integer): TStrings => StringList erstellen, aus Datei auslesen und Datei eventuell freigeben
- FreeList(var List: TStrings) => Liste Freigeben
- Free (im Destroy) => Dateien löschen und eventuell auch restliche Listen freigeben, welcher noch gelockt sind

gibt auch nocht tausend andere Wege

[Bjoerk]

Oje, ob das so stimmt?

Delphi-Quellcode:

type
  TGraphicHistoryStatusChanged = procedure(CanUndo, CanRedo: boolean) of object;

  TGraphicHistory = class
  private
    FCurrent: integer;
    FList: TGraphicList;
    FEnterValue: TGraphicList;
    FExitValue: TGraphicList;
    FEnabled: boolean;
    FOnHistoryStatusChanged: TGraphicHistoryStatusChanged;
    FItem: TGraphicList;
    FPath: string;
    FFileNames: TStringList;
    procedure SetCurrent(const Value: integer);
    procedure AddExitValue;
    function Changed: boolean;
    function GetItems(Index: integer): TGraphicList;
    property FItems[Index: integer]: TGraphicList read GetItems;
    property Current: integer read FCurrent write SetCurrent;
    function CanUndo: boolean;
    function CanRedo: boolean;
    function Count: integer;
  public
    property OnHistoryStatusChanged: TGraphicHistoryStatusChanged
      read FOnHistoryStatusChanged write FOnHistoryStatusChanged;
    property Enabled: boolean read FEnabled write FEnabled;
    procedure Enter;
    procedure Exit;
    procedure UnDo;
    procedure ReDo;
    procedure Clear;
    procedure Refresh(List: TGraphicList);
    constructor Create(Path: string; List: TGraphicList);
    destructor Destroy; override;
  end;

implementation

{ TGraphicHistory }

constructor TGraphicHistory.Create(Path: string; List: TGraphicList);
begin
  inherited Create;
  FEnterValue := TGraphicList.Create;
  FExitValue := TGraphicList.Create;
  FList := List;
  FEnabled := true;
  FCurrent := -1;
  FItem := TGraphicList.Create;
  FPath := Path;
  FFileNames := TStringList.Create;
end;

destructor TGraphicHistory.Destroy;
begin
  FEnterValue.Free;
  FExitValue.Free;
  FFileNames.Free;
  FItem.Free;
  inherited Destroy;
end;

function TGraphicHistory.GetItems(Index: integer): TGraphicList;
begin
  FItem.LoadFromFile(FFileNames[Index]);
  Result := FItem;
end;

procedure TGraphicHistory.Clear;
begin
  Current := -1;
  FEnterValue.Clear;
  FFileNames.Clear;
  Tui.RecycleFile(FPath, FOF_NOCONFIRMATION or FOF_SILENT);
end;

function TGraphicHistory.Count: integer;
begin
  Result := FFileNames.Count;
end;

procedure TGraphicHistory.AddExitValue;
begin
  FFileNames.Add(FPath + IntToStr(Count));
  FExitValue.SaveToFile(FFileNames[Count - 1]);
  FItem.Assign(FExitValue); // Last;
  Current := Count - 1;
end;

function TGraphicHistory.Changed: boolean;
begin
  Result := not FEnterValue.Compare(FExitValue);
end;

function TGraphicHistory.CanUndo: boolean;
begin
  Result := FEnabled and (Count > 1) and (FCurrent > 0);
end;

function TGraphicHistory.CanRedo: boolean;
begin
  Result := FEnabled and (Count > 1) and (FCurrent < Count - 1);
end;

procedure TGraphicHistory.UnDo;
begin
  if CanUnDo then
  begin
    Current := Current - 1;
    FList.Assign(FItems[FCurrent]);
  end;
end;

procedure TGraphicHistory.ReDo;
begin
  if CanReDo then
  begin
    Current := Current + 1;
    FList.Assign(FItems[FCurrent]);
  end;
end;

procedure TGraphicHistory.Refresh(List: TGraphicList);
begin
  Clear;
  FFileNames.Add(FPath + IntToStr(Count));
  List.SaveToFile(FFileNames[Count - 1]);
  FItem.Assign(List); // Last;
end;

procedure TGraphicHistory.Enter;
begin
  FEnterValue.Assign(FList);
end;

procedure TGraphicHistory.Exit;
begin
  FExitValue.Assign(FList);
  if Changed then
    AddExitValue;
end;

procedure TGraphicHistory.SetCurrent(const Value: integer);
begin
  FCurrent := Value;
  if Assigned(FOnHistoryStatusChanged) then
    FOnHistoryStatusChanged(CanUndo, CanRedo);
end;

[Bjoerk]

Jo läuft. Wenn man noch eine kleine Klasse vorschaltet wird‘s noch einfacher. Und wie Sir Rufo ja auch schon anmerkte es kann quasi immer nur einen geben, List[I].Assign(List[J]) geht z.B. nicht wie auch die Funktionalität dieser Klasse insgesamt stark eingeschränkt ist, für eine History aber eben völlig ausreichend und auch sinnvoll, wenn man dem User den RAM nicht "zumüllen" will, weil er z.B. gerade DIN A0 große Metafiles 20 fach gezoomt auf einem Paintbox.Canvas darstellt.

Delphi-Quellcode:

constructor TGraphicListFiles.Create(Path: string);
begin
  FItems := TGraphicList.Create;
  FPath := IncludeTrailingPathDelimiter(Path);
  if not SysUtils.DirectoryExists(FPath) then
    SysUtils.CreateDir(FPath);
end;

destructor TGraphicListFiles.Destroy;
begin
  FItems.Free;
  Clear;
  if SysUtils.DirectoryExists(FPath) then
    SysUtils.RemoveDir(FPath);
  inherited;
end;

procedure TGraphicListFiles.Clear;
var
  I: integer;
begin
  for I := 0 to FCount - 1 do
    if SysUtils.FileExists(FileName(I)) then
      SysUtils.DeleteFile(FileName(I));
  FCount := 0;
end;

function TGraphicListFiles.FileName(Index: integer): string;
begin
  Result := FPath + IntToStr(Index) + '.dat';
end;

function TGraphicListFiles.GetItems(Index: integer): TGraphicList; // ReadOnly;
begin
  FItems.LoadFromFile(FileName(Index));
  Result := FItems;
end;

function TGraphicListFiles.Add(Value: TGraphicList): integer; // WriteOnly;
begin
  Result := FCount;
  Value.SaveToFile(FileName(Result));
  Inc(FCount);
end;

[Sir Rufo]

Doch das würde schon gehen, wenn du ein Interface zurückgibst