Access Violation durch Length(Array)?

[Bjoerk]

Zitat von Jumpy:

[..] aber ohne ist mir die ganze is/as-Casterei zu lästig (müsste bei meiner momentanen Coderenovierung zuviel anpacken).

Du meinst TObjectList? Bei einer TList ist das so nicht erforderlich. Ich hab' mal auf die Schnelle was zusammen gezimmert. Ich will Dir das nicht aufzuschwatzen, aber das sollte doch in deine App mit vergleichsweise wenig Aufwand einzubauen sein? Der Vorteil wäre eine saubere Speicherverwaltung und die leichte Handhabbarkeit. Satt des Array's halt eine Instanz der Klasse verwenden.

Delphi-Quellcode:

unit uCallItems;

interface

uses
  Classes, TTAPICallunits;

type
  TCallItem = class
  private
    FCall: TTApiCall;
    FHandle: Cardinal;
  public
    property Call: TTApiCall read FCall;
    property Handle: Cardinal read FHandle;
    constructor Create(const AHandle: Cardinal);
    destructor Destroy; override;
  end;

  TCallItems = class(TList)
  private
    function GetItem(Index: integer): TCallItem;
    procedure AddItem(const AItem: TCallItem);
    procedure DelItem(Index: integer);
  public
    procedure AddCall(const AHandle: Cardinal);
    procedure DelCall(const AHandle: Cardinal);
    function IndexOfHandle(const AHandle: Cardinal): integer;
    destructor Destroy; override;
    property CallItems[Index: integer]: TCallItem read GetItem; default;
  end;

implementation

constructor TCallItem.Create(const AHandle: Cardinal);
begin
  inherited Create;
  FHandle := AHandle;
  FCall := TTApiCall.Create(FHandle);
end;

destructor TCallItem.Destroy;
begin
  FCall.Free;
  inherited Destroy;
end;

destructor TCallItems.Destroy;
begin
  while Count > 0 do
    DelItem(Count - 1);
  inherited Destroy;
end;

function TCallItems.GetItem(Index: integer): TCallItem;
var
  PItem: ^TCallItem;
begin
  PItem := Items[Index];
  Result := PItem^;
end;

procedure TCallItems.AddItem(const AItem: TCallItem);
var
  PItem: ^TCallItem;
begin
  New(PItem);
  PItem^ := AItem;
  Add(PItem);
end;

procedure TCallItems.DelItem(Index: integer);
var
  PItem: ^TCallItem;
begin
  PItem := Items[Index];
  PItem^.Free;
  Dispose(PItem);
  Delete(Index);
end;

function TCallItems.IndexOfHandle(const AHandle: Cardinal): integer;
var
  PItem: ^TCallItem;
  I: integer;
begin
  Result := -1;
  for I := 0 to Count - 1 do
  begin
    PItem := Items[I];
    if PItem^.Handle = AHandle then
      Result := I;
  end;
end;

procedure TCallItems.DelCall(const AHandle: Cardinal);
var
  Index: Integer;
begin
  Index := IndexOfHandle(AHandle);
  if Index > -1 then
    DelItem(Index);
end;

procedure TCallItems.AddCall(const AHandle: Cardinal);
var
  Item: TCallItem;
begin
  If IndexOfHandle(AHandle) = -1 then
  begin
    Item := TCallItem.Create(AHandle);
    AddItem(Item);
  end;
end;

end.