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 *
#	User	Rev	Content
1	tim	90	/***********************************************************************
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	tim	92	*
19	tim	90	***********************************************************************/
20			#include "event.h"
21			/***********************************************************************
22	tim	91	* Class TEventItem
23	tim	90	***********************************************************************/
24	tim	91	void TEventItem::Clear()
25			{
26			_handlers.clear();
27			}
28			TEventItem::TEventItem(TEventObject *object)
29			{
30			Clear();
31	tim	90
32	tim	91	_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	tim	92	}
63	tim	91
64	tim	92
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	tim	91	}
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	tim	92	}
171	tim	91
172	tim	92	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	tim	91	}
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	tim	92	TEvenPoster poster, void extra)
281	tim	91	{
282			TEventItems *items;
283
284			items = GetEventItemsByType(eventType);
285
286			if (items != NULL)
287			{
288	tim	92	items->Dispatch(eventType,poster, extra);
289	tim	91	}
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	tim	92	if (_table != NULL)
308			_table->AddItem(eventType, object, handler);
309	tim	91	}
310
311			void TEventObject::UnRegister(int eventType, TEventObject *object,
312			PEventHandler handler)
313			{
314	tim	92	if (_table != NULL)
315			_table->RemoveItem(eventType, object, handler);
316	tim	91	}
317
318			void TEventObject::UnRegister(int eventType, TEventObject *object)
319			{
320	tim	92	if (_table != NULL)
321			_table->RemoveItem(eventType, object);
322	tim	91	}
323
324			void TEventObject::UnRegister(TEventObject *object)
325			{
326	tim	92	if (_table != NULL)
327			_table->RemoveItem(object);
328	tim	91	}
329			/***********************************************************************
330	tim	92	* Class TEvenPoster
331	tim	91	***********************************************************************/
332	tim	92	void TEvenPoster::PostEvent(int eventType,
333			TEvenPoster poster, void extra)
334	tim	91	{
335	tim	92	if (_table != NULL)
336			_table->Dispatch(eventType, poster, extra);
337	tim	91	}
338
339	tim	92
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			}