BorlandTalk.com

Ivo Bauer · Guest

Hi,

Background: Delphi for Win32. I have my own implementation of what can
be called an "aspect concept" or "event pattern" in dotNET, IOW a
variation of observer pattern (thanks to Joanna Carter, Peter Morris
and others for providing a valuable feedback on this some time ago).

The current implementation of the subject (event broadcaster) class
holds a list of items, where each item holds a reference to the event
class type and reference to the instance of list of observers (event
interceptors) that are interested in this particular event class type.

type
TEventDescriptorClass = class of TEventDescriptor;
TEventDescriptor = class end;

TInterceptorList = class(TList)
...
end;

TRegisteredEvent = class
...
public
property Class: TEventDescriptorClass read FClass;
property List: TInterceptorList read FList;
end;

TEventBroadcaster = class { = subject }
private
FRegisteredEvents: TList; { of TRegisteredEvent }
public
...
procedure BeginInterceptEvent(AInterceptor:
TBaseEventInterceptor; AClass: TEventDescriptorClass);
procedure BroadcastEvent(ADescriptor: TEventDescriptor);
procedure EndInterceptEvent(AInterceptor: TBaseEventInterceptor;
AClass: TEventDescriptorClass);
end;

Now, when there are many registered event classes and interceptors
observing those events, the observer registration/unregistration and
mainly event broadcasting gets slower due to inefficient
implementation of TList.IndexOf() method that is used to locate a
specific item in the list.

I need to make this faster but don't want to diverge from OO rules.
I'm thinking about turning both registered event list and interceptor
lists into TStringList (with sorting and duplicate checking turned
on), that would also store a references (a pointer to something) as
string hashes of original memory addresses they are pointing to and
use them for faster searching (instead of direct memory addresses like
before):

function HashPointer(APointer: Pointer): string;
begin
Result := Format('%p', [APointer]);
end;

Registering a new event class reference along with the instance of
interceptor list would be done like this:

FRegisteredEvents.AddObject(HashPointer(Pointer(AClass)),
LEventInterceptors);

Registering a new interceptor for already registered event would be
done this way (LEventInterceptors is a TStringList instance retrieved
from a given item of registered event list):

LEventInterceptors.AddObject(HashPointer(Pointer(AInterceptor)),
AInterceptor);

Considering what has been written above, the searching for a specific
registered event (and hence also for its associated list of
interceptors) can be re-written like this:

function TEventBroadcaster.IndexOfRegisteredEvent(AClass:
TEventDescriptorClass): Integer;
begin
Result := FRegisteredEvents.IndexOf(HashPointer(Pointer(AClass)));
end;

What do you think about these modifications? What do others use to
speed up the execution time of TList.IndexOf() method?

Thanks in advance for your feedback.

--
Ivo Bauer [OZM Research]

Thomas Mueller · Guest

Hi Ivo,

Ivo Bauer wrote:

Ivo Bauer · Guest

Thomas Mueller napsal(a):

Thomas Mueller · Guest

Hi,

Ivo Bauer wrote:

Ivo Bauer · Guest

Hi Thomas,

Charles McAllister · Guest

FWIW, i use this code to search within a sorted list...

unit uFind;

interface

type
IFindable = interface
['{364D3ED9-800C-427D-9F3A-BCFCE8111604}']
function Count: Integer;
function FindCompare(Index: Integer): Integer;
end;

function Find(const AFindable: IFindable; out AIndex: Integer; AFindFirst: Boolean): Boolean;

implementation

function Find(const AFindable: IFindable; out AIndex: Integer; AFindFirst: Boolean): Boolean;
var
L, H, I, C: Integer;
begin
Result := False;
L := 0;
H := AFindable.Count - 1;
while L <= H do
begin
I := (L + H) shr 1;
C := AFindable.FindCompare(I);
if C < 0 then
L := I + 1
else
begin
H := I - 1;
if C = 0 then
begin
Result := True;
//if Duplicates <> dupAccept then L := I;
end;
end;
end;
if AFindFirst then
while (L > 0) and (AFindable.FindCompare(L - 1) = 0) do
Dec(L);
AIndex := L;
end;

....

so for instance, your class would support the IFindable interface like so...

type
TMyList = class(TInterfacedObject, IFindable)
protected
function FindCompare(Index: Integer): Integer;
public
function IndexOf(): Integer;
end;

....

function TMyList.IndexOf(): Integer;
begin
//first, store params in private fields

Find(Self, Result, True);
end;

function TMyList.FindCompare(Index: Integer): Integer;
begin
//Result := 0, 1, or -1 depending on list data and params from IndexOf
end;

....

I use a similar interface for QuickSorting, if you want to see that i can post it as well.

Charles McAllister · Guest

Charles McAllister wrote: