← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/plugin/event_observer.cc

  • Committer: Andrew Hutchings
  • Date: 2011-02-01 10:23:22 UTC
  • mto: (2136.1.1 build)
  • mto: This revision was merged to the branch mainline in revision 2137.
  • Revision ID: andrew@linuxjedi.co.uk-20110201102322-oxztcyrjzg3c7yta
Fix counters cleanup

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/plugin/event_observer.cc
21
21
 * 2010-05-12
22
22
 */
23
23
 
24
 
#include <config.h>
 
24
#include "config.h"
25
25
 
26
26
#include <string>
27
27
#include <vector>
28
28
 
29
 
#include <drizzled/session.h>
30
 
#include <drizzled/table_list.h>
31
 
#include <drizzled/table/instance.h>
32
 
#include <drizzled/module/registry.h>
33
 
#include <drizzled/plugin/event_observer.h>
 
29
#include "drizzled/session.h"
 
30
#include "drizzled/table_list.h"
 
31
#include "drizzled/table/instance.h"
 
32
#include "drizzled/module/registry.h"
 
33
#include "drizzled/plugin/event_observer.h"
34
34
#include <drizzled/util/functors.h>
35
35
#include <algorithm>
36
36
 
37
 
namespace drizzled {
38
 
namespace plugin {
39
 
 
 
37
 
 
38
 
 
39
namespace drizzled
 
40
{
 
41
 
 
42
namespace plugin
 
43
{
 
44
 
 
45
/*============================*/
 
46
  // Basic plugin registration stuff.
40
47
  EventObserverVector all_event_plugins;
41
48
 
42
 
  const EventObserverVector &EventObserver::getEventObservers()
 
49
  const EventObserverVector &EventObserver::getEventObservers(void)
43
50
  {
44
51
    return all_event_plugins;
45
52
  }
46
53
 
 
54
  //---------
47
55
  bool EventObserver::addPlugin(EventObserver *handler)
48
56
  {
49
57
    if (handler != NULL)
51
59
    return false;
52
60
  }
53
61
 
 
62
  //---------
54
63
  void EventObserver::removePlugin(EventObserver *handler)
55
64
  {
56
65
    if (handler != NULL)
88
97
    {
89
98
      std::for_each(event_observer_lists.begin(),
90
99
                    event_observer_lists.end(),
91
 
                    DeletePtr());
 
100
                    SafeDeletePtr());
92
101
      event_observer_lists.clear();
93
102
    }
94
103
 
118
127
      /* If positioned then check if the position is already taken. */
119
128
      if (position) 
120
129
      {
121
 
        if (observers->count(event_pos))
 
130
        if (observers->find(event_pos) != observers->end())
122
131
        {
123
 
          errmsg_printf(error::WARN,
 
132
          errmsg_printf(ERRMSG_LVL_WARN,
124
133
                        _("EventObserverList::addEventObserver() Duplicate event position %d for event '%s' from EventObserver plugin '%s'"),
125
134
                        position,
126
135
                        EventObserver::eventName(event), 
187
196
 
188
197
    if (observers != NULL) 
189
198
                {
190
 
                        errmsg_printf(error::WARN,
 
199
                        errmsg_printf(ERRMSG_LVL_WARN,
191
200
                                                                        _("EventObserver::registerTableEvents(): Table already has events registered on it: probable programming error."));
192
201
                        table_share.setTableObservers(NULL);
193
202
      delete observers;
209
218
   if (all_event_plugins.empty())
210
219
      return;
211
220
 
212
 
    EventObserverList *observers= table_share.getTableObservers();
 
221
    EventObserverList *observers;
 
222
 
 
223
    observers= table_share.getTableObservers();
213
224
 
214
225
    if (observers) 
215
226
    {
251
262
  {
252
263
    if (all_event_plugins.empty())
253
264
      return;
254
 
    EventObserverList *observers= session.getSchemaObservers(db);
 
265
 
 
266
    EventObserverList *observers;
 
267
 
 
268
    observers= session.getSchemaObservers(db);
 
269
 
255
270
    if (observers == NULL) 
256
 
      observers= session.setSchemaObservers(db, new EventObserverList());
 
271
    {
 
272
      observers= new EventObserverList();
 
273
      session.setSchemaObservers(db, observers);
 
274
   }
257
275
 
258
276
    std::for_each(all_event_plugins.begin(), all_event_plugins.end(),
259
277
                  RegisterSchemaEventsIterate(db, *observers));
262
280
 
263
281
  //----------
264
282
  /* Cleanup before freeing the Session object. */
265
 
  void EventObserver::deregisterSchemaEvents(EventObserverList *observers)
 
283
  void EventObserver::deregisterSchemaEvents(Session &session, const std::string &db)
266
284
  {
 
285
    if (all_event_plugins.empty())
 
286
      return;
 
287
 
 
288
    EventObserverList *observers;
 
289
 
 
290
    observers= session.getSchemaObservers(db);
 
291
 
 
292
    if (observers) 
 
293
    {
 
294
      session.setSchemaObservers(db, NULL);
267
295
      delete observers;
268
 
   }
 
296
    }
 
297
  }
269
298
 
270
299
  /*========================================================*/
271
300
  /*             Session Event Observer handling:           */
302
331
 
303
332
    observers= session.getSessionObservers();
304
333
                if (observers) { // This should not happed
305
 
                        errmsg_printf(error::WARN,
 
334
                        errmsg_printf(ERRMSG_LVL_WARN,
306
335
                                                                        _("EventObserver::registerSessionEvents(): Session already has events registered on it: probable programming error."));
307
336
                        session.setSessionObservers(NULL);
308
337
                        delete observers;
318
347
 
319
348
  //----------
320
349
  /* Cleanup before freeing the session object. */
321
 
  void EventObserver::deregisterSessionEvents(EventObserverList *observers)
 
350
  void EventObserver::deregisterSessionEvents(Session &session)
322
351
  {
 
352
    if (all_event_plugins.empty())
 
353
      return;
 
354
 
 
355
    EventObserverList *observers;
 
356
 
 
357
    observers= session.getSessionObservers();
 
358
 
 
359
    if (observers) 
 
360
    {
 
361
      session.setSessionObservers(NULL);
323
362
      delete observers;
 
363
    }
324
364
  }
325
365
 
326
366
 
343
383
      {
344
384
        /* TRANSLATORS: The leading word "EventObserver" is the name
345
385
          of the plugin api, and so should not be translated. */
346
 
        errmsg_printf(error::ERROR,
 
386
        errmsg_printf(ERRMSG_LVL_ERROR,
347
387
                      _("EventIterate event handler '%s' failed for event '%s'"),
348
388
                      handler.second->getName().c_str(), handler.second->eventName(data.event));
349
389
 
390
430
    return EventData::callEventObservers();
391
431
  }
392
432
 
393
 
  bool SessionEventData::hasEvents(Session &in_session)
394
 
  {
395
 
    return (in_session.getSessionObservers() != NULL);
396
 
  }
397
 
 
398
433
  //--------
399
434
  bool SchemaEventData::callEventObservers()
400
435
  {
416
451
    return EventData::callEventObservers();
417
452
  }
418
453
 
419
 
  bool TableEventData::hasEvents(Table &in_table)
420
 
  {
421
 
    return (in_table.getMutableShare()->getTableObservers() != NULL);
422
 
  }
423
 
 
424
454
  /*==========================================================*/
425
455
  /* Static meathods called by drizzle to notify interested plugins 
426
456
   * of a schema event.