FAS/src/event.cpp

/***********************************************************************
*           Copyright (C) 2002-2003 by Gezelter's Group
*This program is free software; you can redistribute it and/or modify
*it under the terms of the GNU General Public License as published by
*the Free Software Foundation version 2 of the License.
*
*This program is distributed in the hope that it will be useful,
*but WITHOUT ANY WARRANTY; without even the implied warranty of
*MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*GNU General Public License for more details.
*
************************************************************************
*Author: Teng Lin               Email:  tlin@nd.edu
*Date: 08/13/2002               Version: 1.0
*
************************************************************************
*Description:
*
***********************************************************************/
#include "event.h"
/***********************************************************************
* Class TEventItem
***********************************************************************/
void TEventItem::Clear()
{
  _handlers.clear();
}
TEventItem::TEventItem(TEventObject *object)
{
  Clear();

  _object = object;
}

TEventItem::~TEventItem()
{
  Clear();
}

void TEventItem::AddHandler(PEventHandler handler)
{
  vector<PEventHandler>::iterator i;

  i = find(_handlers.begin(), _handlers.end(), handler);

  if (i == _handlers.end())
  {
    _handlers.push_back(handler);
  }
}

void TEventItem::RemoveHandler(PEventHandler handler)
{
  vector<PEventHandler>::iterator i;

  i = find(_handlers.begin(), _handlers.end(), handler);

  if (i != _handlers.end())
  {
    _handlers.erase(i);
  }
}


void TEventItem::ExecuteHandler(int eventType, TEvenPoster *poster, void *extra)
{
  PEventHandler handler;
  switch (_object->GetEventObjectType())
  {
    case TEventObjectType::BaseEventObject :
      CallHandler<TEventObject>(_object, _handlers, eventType, poster, extra);
      break;
    default:
      ;
  }
}
/***********************************************************************
* Class TEventItems
***********************************************************************/
void TEventItems::Clear()
{
  for(int i=0; i<_items.size(); i++)
  {
    if (_items[i] != NULL)
    {
      delete _items[i];
    }
  }

  _items.clear();
}

TEventItems::TEventItems(int eventType)
{
  Clear();
  SetType(eventType);
}

TEventItems::~TEventItems()
{
  Clear();
}

void TEventItems::AddItem(TEventObject *object, PEventHandler handler)
{
  TEventItem * item;

  item = GetEventItem(object);

  if (item != NULL)
  {
    item->AddHandler(handler);
  }
  else
  {
    item = new TEventItem(object);
    if(item != NULL)
    {
      item->AddHandler(handler);
      _items.push_back(item);
    }
    else
    {
     //Memory allocation fail
    }
  }
}

void TEventItems::RemoveItem(TEventObject *object, PEventHandler handler)
{
  TEventItem * item;

  item = GetEventItem(object);

  if (item !=NULL)
  {
    item->RemoveHandler(handler);
    if (item->Count() == 0)
      _items.erase(find(_items.begin(), _items.end(), item));
  }
}

void TEventItems::RemoveItem(TEventObject *object)
{
  vector<TEventItem *>::iterator i;

  i = find_if(_items.begin(), _items.end(), TMatchEventItem(object));

  if (i != _items.end())
  {
    delete *i;
    _items.erase(i);
  }
}

TEventItem *TEventItems::GetEventItem(TEventObject *object)
{
  vector<TEventItem *>::iterator i;

  i = find_if(_items.begin(), _items.end(), TMatchEventItem(object));

  if (i != _items.end())
  {
    return *i;
  }
  else
  {
    return NULL;
  }
}

void TEventItems::Dispatch(int eventType, TEvenPoster *poster, void *extra)
{
  for(int i=0; i < Count(); i++)
    _items[i]->ExecuteHandler(eventType, poster, extra);
}

/***********************************************************************
* Class TEventTable
***********************************************************************/
void TEventTable::Clear()
{
  for(int i=0; i<_table.size(); i++)
  {
    if (_table[i] != NULL)
      delete _table[i];
  }

  _table.clear();
}

TEventTable::TEventTable()
{
  Clear();
}

TEventTable::~TEventTable()
{
  Clear();
}

void TEventTable::AddItem(int eventType,
                          TEventObject *object, PEventHandler handler)
{
  TEventItems *items;

  items = GetEventItemsByType(eventType);


  if (items == NULL)
  {
    items = new TEventItems(eventType);
    if (items != NULL)
    {
      items->AddItem(object, handler);
      _table.push_back(items);
    }
    else
    {
    //Error
    }
  }
  else
  {
    items->AddItem(object, handler);
  }

}

void TEventTable::RemoveItem(int eventType,
                              TEventObject *object, PEventHandler handler)
{
  TEventItems *items;

  items = GetEventItemsByType(eventType);

  if (items != NULL)
  {
    items->RemoveItem(object, handler);

  }
}

void TEventTable::RemoveItem(int eventType, TEventObject *object)
{
  TEventItems *items;

  items = GetEventItemsByType(eventType);

  if (items != NULL)
  {
    items->RemoveItem(object);
  }
}

void TEventTable::RemoveItem(TEventObject *object)
{
  for(int i=0; i<_table.size(); i++)
    RemoveItem(_table[i]->_eventType, object);
}

TEventItems *TEventTable::GetEventItemsByType(int eventType)
{
  vector<TEventItems*>::iterator i;


  i = find_if(_table.begin(), _table.end(), TMatchEventItems(eventType));

  if(i == _table.end())
  {
    return NULL;
  }
  else
  {
    return *i;
  }
}

void TEventTable::Dispatch(int eventType,
                            TEvenPoster *poster, void *extra)
{
  TEventItems *items;

  items = GetEventItemsByType(eventType);

  if (items != NULL)
  {
    items->Dispatch(eventType,poster, extra);
  }
  else
  {
    return;
  }
}

/***********************************************************************
* Class TEventObject
***********************************************************************/
TEventObject::~TEventObject()
{
  UnRegister(this);
}

void TEventObject::Register(int eventType, TEventObject *object,
                            PEventHandler handler)
{
  if (_table != NULL)
    _table->AddItem(eventType, object, handler);
}

void TEventObject::UnRegister(int eventType, TEventObject *object,
                              PEventHandler handler)
{
  if (_table != NULL)
    _table->RemoveItem(eventType, object, handler);
}

void TEventObject::UnRegister(int eventType, TEventObject *object)
{
  if (_table != NULL)
    _table->RemoveItem(eventType, object);
}

void TEventObject::UnRegister(TEventObject *object)
{
  if (_table != NULL)
    _table->RemoveItem(object);
}
/***********************************************************************
* Class TEvenPoster
***********************************************************************/
void TEvenPoster::PostEvent(int eventType,
                                TEvenPoster *poster, void *extra)
{
  if (_table != NULL)
    _table->Dispatch(eventType, poster, extra);
}


template<class T> CallHandler(T *object, const vector<PEventHandler>& handlers,
                      int eventType, TEvenPoster *poster, void *extra)
{
  PEventHandler handler;

  for(int i=0; i<handlers.size(); i++)
  {
    handler = handlers[i];
    (object->*handler)(eventType, poster, extra);
  }
}
Revision:	92
Committed:	Tue Aug 20 23:26:55 2002 UTC (21 years, 10 months ago) by tim
File size:	7288 byte(s)
Log Message:	* empty log message *
#	Content
1	/***********************************************************************
2	* Copyright (C) 2002-2003 by Gezelter's Group
3	*This program is free software; you can redistribute it and/or modify
4	*it under the terms of the GNU General Public License as published by
5	*the Free Software Foundation version 2 of the License.
6	*
7	*This program is distributed in the hope that it will be useful,
8	*but WITHOUT ANY WARRANTY; without even the implied warranty of
9	*MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10	*GNU General Public License for more details.
11	*
12	************************************************************************
13	*Author: Teng Lin Email: tlin@nd.edu
14	*Date: 08/13/2002 Version: 1.0
15	*
16	************************************************************************
17	*Description:
18	*
19	***********************************************************************/
20	#include "event.h"
21	/***********************************************************************
22	* Class TEventItem
23	***********************************************************************/
24	void TEventItem::Clear()
25	{
26	_handlers.clear();
27	}
28	TEventItem::TEventItem(TEventObject *object)
29	{
30	Clear();
31
32	_object = object;
33	}
34
35	TEventItem::~TEventItem()
36	{
37	Clear();
38	}
39
40	void TEventItem::AddHandler(PEventHandler handler)
41	{
42	vector<PEventHandler>::iterator i;
43
44	i = find(_handlers.begin(), _handlers.end(), handler);
45
46	if (i == _handlers.end())
47	{
48	_handlers.push_back(handler);
49	}
50	}
51
52	void TEventItem::RemoveHandler(PEventHandler handler)
53	{
54	vector<PEventHandler>::iterator i;
55
56	i = find(_handlers.begin(), _handlers.end(), handler);
57
58	if (i != _handlers.end())
59	{
60	_handlers.erase(i);
61	}
62	}
63
64
65	void TEventItem::ExecuteHandler(int eventType, TEvenPoster poster, void extra)
66	{
67	PEventHandler handler;
68	switch (_object->GetEventObjectType())
69	{
70	case TEventObjectType::BaseEventObject :
71	CallHandler<TEventObject>(_object, _handlers, eventType, poster, extra);
72	break;
73	default:
74	;
75	}
76	}
77	/***********************************************************************
78	* Class TEventItems
79	***********************************************************************/
80	void TEventItems::Clear()
81	{
82	for(int i=0; i<_items.size(); i++)
83	{
84	if (_items[i] != NULL)
85	{
86	delete _items[i];
87	}
88	}
89
90	_items.clear();
91	}
92
93	TEventItems::TEventItems(int eventType)
94	{
95	Clear();
96	SetType(eventType);
97	}
98
99	TEventItems::~TEventItems()
100	{
101	Clear();
102	}
103
104	void TEventItems::AddItem(TEventObject *object, PEventHandler handler)
105	{
106	TEventItem * item;
107
108	item = GetEventItem(object);
109
110	if (item != NULL)
111	{
112	item->AddHandler(handler);
113	}
114	else
115	{
116	item = new TEventItem(object);
117	if(item != NULL)
118	{
119	item->AddHandler(handler);
120	_items.push_back(item);
121	}
122	else
123	{
124	//Memory allocation fail
125	}
126	}
127	}
128
129	void TEventItems::RemoveItem(TEventObject *object, PEventHandler handler)
130	{
131	TEventItem * item;
132
133	item = GetEventItem(object);
134
135	if (item !=NULL)
136	{
137	item->RemoveHandler(handler);
138	if (item->Count() == 0)
139	_items.erase(find(_items.begin(), _items.end(), item));
140	}
141	}
142
143	void TEventItems::RemoveItem(TEventObject *object)
144	{
145	vector<TEventItem *>::iterator i;
146
147	i = find_if(_items.begin(), _items.end(), TMatchEventItem(object));
148
149	if (i != _items.end())
150	{
151	delete *i;
152	_items.erase(i);
153	}
154	}
155
156	TEventItem TEventItems::GetEventItem(TEventObject object)
157	{
158	vector<TEventItem *>::iterator i;
159
160	i = find_if(_items.begin(), _items.end(), TMatchEventItem(object));
161
162	if (i != _items.end())
163	{
164	return *i;
165	}
166	else
167	{
168	return NULL;
169	}
170	}
171
172	void TEventItems::Dispatch(int eventType, TEvenPoster poster, void extra)
173	{
174	for(int i=0; i < Count(); i++)
175	_items[i]->ExecuteHandler(eventType, poster, extra);
176	}
177
178	/***********************************************************************
179	* Class TEventTable
180	***********************************************************************/
181	void TEventTable::Clear()
182	{
183	for(int i=0; i<_table.size(); i++)
184	{
185	if (_table[i] != NULL)
186	delete _table[i];
187	}
188
189	_table.clear();
190	}
191
192	TEventTable::TEventTable()
193	{
194	Clear();
195	}
196
197	TEventTable::~TEventTable()
198	{
199	Clear();
200	}
201
202	void TEventTable::AddItem(int eventType,
203	TEventObject *object, PEventHandler handler)
204	{
205	TEventItems *items;
206
207	items = GetEventItemsByType(eventType);
208
209
210	if (items == NULL)
211	{
212	items = new TEventItems(eventType);
213	if (items != NULL)
214	{
215	items->AddItem(object, handler);
216	_table.push_back(items);
217	}
218	else
219	{
220	//Error
221	}
222	}
223	else
224	{
225	items->AddItem(object, handler);
226	}
227
228	}
229
230	void TEventTable::RemoveItem(int eventType,
231	TEventObject *object, PEventHandler handler)
232	{
233	TEventItems *items;
234
235	items = GetEventItemsByType(eventType);
236
237	if (items != NULL)
238	{
239	items->RemoveItem(object, handler);
240
241	}
242	}
243
244	void TEventTable::RemoveItem(int eventType, TEventObject *object)
245	{
246	TEventItems *items;
247
248	items = GetEventItemsByType(eventType);
249
250	if (items != NULL)
251	{
252	items->RemoveItem(object);
253	}
254	}
255
256	void TEventTable::RemoveItem(TEventObject *object)
257	{
258	for(int i=0; i<_table.size(); i++)
259	RemoveItem(_table[i]->_eventType, object);
260	}
261
262	TEventItems *TEventTable::GetEventItemsByType(int eventType)
263	{
264	vector<TEventItems*>::iterator i;
265
266
267	i = find_if(_table.begin(), _table.end(), TMatchEventItems(eventType));
268
269	if(i == _table.end())
270	{
271	return NULL;
272	}
273	else
274	{
275	return *i;
276	}
277	}
278
279	void TEventTable::Dispatch(int eventType,
280	TEvenPoster poster, void extra)
281	{
282	TEventItems *items;
283
284	items = GetEventItemsByType(eventType);
285
286	if (items != NULL)
287	{
288	items->Dispatch(eventType,poster, extra);
289	}
290	else
291	{
292	return;
293	}
294	}
295
296	/***********************************************************************
297	* Class TEventObject
298	***********************************************************************/
299	TEventObject::~TEventObject()
300	{
301	UnRegister(this);
302	}
303
304	void TEventObject::Register(int eventType, TEventObject *object,
305	PEventHandler handler)
306	{
307	if (_table != NULL)
308	_table->AddItem(eventType, object, handler);
309	}
310
311	void TEventObject::UnRegister(int eventType, TEventObject *object,
312	PEventHandler handler)
313	{
314	if (_table != NULL)
315	_table->RemoveItem(eventType, object, handler);
316	}
317
318	void TEventObject::UnRegister(int eventType, TEventObject *object)
319	{
320	if (_table != NULL)
321	_table->RemoveItem(eventType, object);
322	}
323
324	void TEventObject::UnRegister(TEventObject *object)
325	{
326	if (_table != NULL)
327	_table->RemoveItem(object);
328	}
329	/***********************************************************************
330	* Class TEvenPoster
331	***********************************************************************/
332	void TEvenPoster::PostEvent(int eventType,
333	TEvenPoster poster, void extra)
334	{
335	if (_table != NULL)
336	_table->Dispatch(eventType, poster, extra);
337	}
338
339
340	template<class T> CallHandler(T *object, const vector<PEventHandler>& handlers,
341	int eventType, TEvenPoster poster, void extra)
342	{
343	PEventHandler handler;
344
345	for(int i=0; i<handlers.size(); i++)
346	{
347	handler = handlers[i];
348	(object->*handler)(eventType, poster, extra);
349	}
350	}