BorlandTalk.com

Ivo Bauer · Guest

Hi all,

This post is somehow lengthy, but I will appreciate if you could read
it entirely. :-)

I have an application/system in which I need to maintain a history of
all events that occurs during system's lifetime. I have a class
hierarchy of all defined system events - all of them are direct or
indirect descendants of TBaseEvent class:

TBaseEvent = class
protected
function GetDescription: string; virtual; abstract;
public
property Description: string read GetDescription;
end;

TBaseEvent descendants add their own properties that are relevant only
to a specific event type/class. I use class inheritance extensively
here to group together a set of events that describe the same specific
part of a system, in order to avoid reintroducing the same properties
in a bunch of event classes.

Now, whenever the event occurs in my system, I create an instance of
TEventInstance class (pun not intended) and pass it a reference to a
specific event class to create and the instance ID. TEventInstance is
responsible for managing lifetime of FEvent instance it holds:

TEventClass = class of TBaseEvent;

TEventInstance = class
private
FEvent: TBaseEvent;
FID: TGUID;
FTimeStamp: TDateTime;
FWasRead: Boolean;
public
constructor Create(AEventClass: TEventClass; AInstanceID: TGUID);
property Event: TBaseEvent read FEvent;
property ID: TGUID read FID;
property TimeStamp: TDateTime read FTimeStamp write FTimeStamp;
property WasRead: Boolean read FWasRead write FWasRead;
end;

Once the TEventInstance instance is created, the event manager class
can set up additional properties such as TimeStamp to remember when
exactly this event occured, or WasRead property that indicates whether
or not user has seen and acknowledged the instance of this event.

I'm slowly approaching my problem: There could be two "types" of
events with regard to how they occur in the system:

1) Explicit events - they are invoked explicitely by the user, such as
changing of certain system properties, user-issued commands etc. When
such event occurs, the event manager class should set the WasRead
property of the event instance to True because if it was the user who
invoked this event, it apparently indicates that the same user also
acknowledged the occurence of this event.

2) Implicit events - they are autogenerated by the system or any of
its internal subsystems. Due to their nature, the WasRead property of
given event instance has to be set to False and the user
confirmation/acknowledgement is required.

Now, here's my problem: I'm not sure how to design the event manager
class, or more precisely, its part that is responsible for setting the
value of WasRead property of newly instantiated event instance. The
explicit/implicit attribute of each event type/class is fixed, in
other words if given event class is said to be explicit, it cannot
become implicit under any condition, and vice versa.

Should I introduce this explicit/implicit attribute directly in the
TBaseEvent class and let their descendants to determine the actual
value of this attribute? I also thought about creating of
TBaseExplicitEvent and TBaseImplicitEvent as a direct descendants of
TBaseEvent and have all concrete event classes to descend from these
two intermediate classes, but I dismissed this idea after a while
because the class inheritance should be designed around the
functionality and not around the way how the classes are used.

I ended up with the simple array of class references that is held
privately by the event manager class. This array is populated in the
constructor with references to all classes that are considered to be
implicit - there are far less implicit events defined than explicit
ones in the system, so this array is short and the searching for a
particular class reference is fast. Now when the new event instance is
being instantiated, the event manager class searches the array for
given class reference. If it's found in the array, it's determined to
be implicit. If it's not in the array, the event instance is
considered to be explicit.

What do you thing about this design? Would you leave it that way or
rather change some part of it? I appreacite your insights.

--
Ivo Bauer [OZM Research]

Gerard · Guest

Hi IVO,

What I would do:
- Make WasRead attribute false for the ancestor TBaseEvent class on
creation.
- I would let whatever code or class acknowledges the event set it's
wasread property to true.

If its a TEventReader class, for example, it's ReadEvent procedure could
be like

TEventReader.ReadEvent(aEvent: TEvent);
begin
...
aEvent.WasRead := True;
end;

Just my 2 € cents.

Regards,

Gerard.

Bob Dawson · Guest

"Ivo Bauer" wrote

Questions:

Ivo Bauer · Guest

Hi Gerard,

Thanks for the reply.

Ivo Bauer · Guest

Hi Bob,

Thanks for the reply. For the sake of clarity, I slightly changed the
terminology, so

TBaseEvent = class that holds the required information related to
certain type of event

TEventDescriptor (previously TEventInstance) = class that describes a
specific occurence of specific event, holds a reference to TBaseEvent
class instance, timestamp of occurence, etc.

Bob Dawson · Guest

"Ivo Bauer" wrote

Ivo Bauer · Guest

Bob Dawson napsal(a):

Bob Dawson · Guest

"Ivo Bauer" wrote