← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/plugin/event_observer.cc

  • Committer: lbieber
  • Date: 2010-09-11 16:33:45 UTC
  • mfrom: (1757.1.2 build)
  • Revision ID: lbieber@orisndriz03-20100911163345-na1t8m18at9thsjl
Merge Vijay - added utf 8 tamil test case suite and test case for creating a database in tamil
Merge Brian - Small set of refactoring (includes one case of memset on a table object).

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/plugin/event_observer.cc
28
28
 
29
29
#include "drizzled/session.h"
30
30
#include "drizzled/table_list.h"
31
 
#include "drizzled/table/instance.h"
 
31
#include "drizzled/table_share.h"
32
32
#include "drizzled/module/registry.h"
33
33
#include "drizzled/plugin/event_observer.h"
34
34
#include <drizzled/util/functors.h>
36
36
 
37
37
 
38
38
 
 
39
using namespace std;
 
40
 
39
41
namespace drizzled
40
42
{
41
43
 
44
46
 
45
47
/*============================*/
46
48
  // Basic plugin registration stuff.
47
 
  EventObserverVector all_event_plugins;
48
 
 
49
 
  const EventObserverVector &EventObserver::getEventObservers(void)
50
 
  {
51
 
    return all_event_plugins;
52
 
  }
 
49
  static vector<EventObserver *> all_event_plugins;
53
50
 
54
51
  //---------
55
52
  bool EventObserver::addPlugin(EventObserver *handler)
63
60
  void EventObserver::removePlugin(EventObserver *handler)
64
61
  {
65
62
    if (handler != NULL)
66
 
      all_event_plugins.erase(std::find(all_event_plugins.begin(), all_event_plugins.end(), handler));
 
63
      all_event_plugins.erase(find(all_event_plugins.begin(), all_event_plugins.end(), handler));
67
64
  }
68
65
 
69
66
 
79
76
  {
80
77
 
81
78
  public:
82
 
    typedef std::multimap<uint32_t, EventObserver *> ObserverMap;
 
79
    typedef multimap<uint32_t, EventObserver *> ObserverMap;
83
80
 
84
81
  private:
85
82
    /* A list of lists indexed by event type. */
86
 
    std::vector<ObserverMap *> event_observer_lists;
 
83
    vector<ObserverMap *> event_observer_lists;
87
84
 
88
85
  public:
89
86
 
90
87
    EventObserverList()
91
88
    {
92
 
                        // Initialize the list with NULL pointers.
93
 
                        event_observer_lists.assign(EventObserver::MAX_EVENT_COUNT, NULL);
 
89
      uint32_t i;
 
90
 
 
91
      event_observer_lists.reserve(EventObserver::MAX_EVENT_COUNT);
 
92
      for (i=0; i < EventObserver::MAX_EVENT_COUNT; i++)
 
93
      {
 
94
        event_observer_lists[i]= NULL;
 
95
      }
94
96
    }
95
97
 
96
98
    ~EventObserverList()
97
99
    {
98
 
      std::for_each(event_observer_lists.begin(),
99
 
                    event_observer_lists.end(),
100
 
                    SafeDeletePtr());
101
 
      event_observer_lists.clear();
 
100
      clearAllObservers();
102
101
    }
103
102
 
104
103
    /* Add the observer to the observer list for the even, positioning it if required.
129
128
      {
130
129
        if (observers->find(event_pos) != observers->end())
131
130
        {
132
 
          errmsg_printf(error::WARN,
 
131
          errmsg_printf(ERRMSG_LVL_WARN,
133
132
                        _("EventObserverList::addEventObserver() Duplicate event position %d for event '%s' from EventObserver plugin '%s'"),
134
133
                        position,
135
134
                        EventObserver::eventName(event), 
137
136
        }
138
137
      }
139
138
 
140
 
      observers->insert(std::pair<uint32_t, EventObserver *>(event_pos, eventObserver) );
 
139
      observers->insert(pair<uint32_t, EventObserver *>(event_pos, eventObserver) );
 
140
    }
 
141
 
 
142
    /* Remove all observer from all lists. */
 
143
    void clearAllObservers()
 
144
    {
 
145
      for_each(event_observer_lists.begin(),
 
146
               event_observer_lists.end(),
 
147
               DeletePtr());
 
148
      event_observer_lists.clear();
141
149
    }
142
150
 
143
151
 
166
174
  /* For each EventObserver plugin call its registerTableEventsDo() meathod so that it can
167
175
   * register what events, if any, it is interested in on this table.
168
176
   */ 
169
 
  class RegisterTableEventsIterate : public std::unary_function<EventObserver *, void>
 
177
  class RegisterTableEventsIterate : public unary_function<EventObserver *, void>
170
178
  {
171
179
    TableShare &table_share;
172
180
    EventObserverList &observers;
194
202
 
195
203
    observers= table_share.getTableObservers();
196
204
 
197
 
    if (observers != NULL) 
198
 
                {
199
 
                        errmsg_printf(error::WARN,
200
 
                                                                        _("EventObserver::registerTableEvents(): Table already has events registered on it: probable programming error."));
201
 
                        table_share.setTableObservers(NULL);
202
 
      delete observers;
 
205
    if (observers == NULL) 
 
206
    {
 
207
      observers= new EventObserverList();
 
208
      table_share.setTableObservers(observers);
 
209
    } 
 
210
    else 
 
211
    {
 
212
      /* Calling registerTableEvents() for a table that already has
 
213
       * events registered on it is probably a programming error.
 
214
     */
 
215
      observers->clearAllObservers();
203
216
    }
204
217
 
205
 
                observers= new EventObserverList();
206
 
                table_share.setTableObservers(observers);
207
 
 
208
218
 
209
 
    std::for_each(all_event_plugins.begin(), all_event_plugins.end(),
210
 
                  RegisterTableEventsIterate(table_share, *observers));
 
219
    for_each(all_event_plugins.begin(), all_event_plugins.end(),
 
220
             RegisterTableEventsIterate(table_share, *observers));
211
221
 
212
222
  }
213
223
 
215
225
  /* Cleanup before freeing the TableShare object. */
216
226
  void EventObserver::deregisterTableEvents(TableShare &table_share)
217
227
  {
218
 
   if (all_event_plugins.empty())
 
228
    if (all_event_plugins.empty())
219
229
      return;
220
230
 
221
231
    EventObserverList *observers;
225
235
    if (observers) 
226
236
    {
227
237
      table_share.setTableObservers(NULL);
 
238
      observers->clearAllObservers();
228
239
      delete observers;
229
240
    }
230
241
  }
238
249
  /* For each EventObserver plugin call its registerSchemaEventsDo() meathod so that it can
239
250
   * register what events, if any, it is interested in on the schema.
240
251
   */ 
241
 
  class RegisterSchemaEventsIterate : public std::unary_function<EventObserver *, void>
 
252
  class RegisterSchemaEventsIterate : public unary_function<EventObserver *, void>
242
253
  {
243
254
    const std::string &db;
244
255
    EventObserverList &observers;
271
282
    {
272
283
      observers= new EventObserverList();
273
284
      session.setSchemaObservers(db, observers);
274
 
   }
 
285
    }
275
286
 
276
 
    std::for_each(all_event_plugins.begin(), all_event_plugins.end(),
277
 
                  RegisterSchemaEventsIterate(db, *observers));
 
287
    for_each(all_event_plugins.begin(), all_event_plugins.end(),
 
288
             RegisterSchemaEventsIterate(db, *observers));
278
289
 
279
290
  }
280
291
 
292
303
    if (observers) 
293
304
    {
294
305
      session.setSchemaObservers(db, NULL);
 
306
      observers->clearAllObservers();
295
307
      delete observers;
296
308
    }
297
309
  }
304
316
  /* For each EventObserver plugin call its registerSessionEventsDo() meathod so that it can
305
317
   * register what events, if any, it is interested in on this session.
306
318
   */ 
307
 
  class RegisterSessionEventsIterate : public std::unary_function<EventObserver *, void>
 
319
  class RegisterSessionEventsIterate : public unary_function<EventObserver *, void>
308
320
  {
309
321
    Session &session;
310
322
    EventObserverList &observers;
330
342
    EventObserverList *observers;
331
343
 
332
344
    observers= session.getSessionObservers();
333
 
                if (observers) { // This should not happed
334
 
                        errmsg_printf(error::WARN,
335
 
                                                                        _("EventObserver::registerSessionEvents(): Session already has events registered on it: probable programming error."));
336
 
                        session.setSessionObservers(NULL);
337
 
                        delete observers;
338
 
                }
339
 
 
340
 
        observers= new EventObserverList();
341
 
        session.setSessionObservers(observers);
342
 
 
343
 
  std::for_each(all_event_plugins.begin(), all_event_plugins.end(),
344
 
                RegisterSessionEventsIterate(session, *observers));
 
345
 
 
346
    if (observers == NULL) 
 
347
    {
 
348
      observers= new EventObserverList();
 
349
      session.setSessionObservers(observers);
 
350
    }
 
351
 
 
352
    observers->clearAllObservers();
 
353
 
 
354
    for_each(all_event_plugins.begin(), all_event_plugins.end(),
 
355
             RegisterSessionEventsIterate(session, *observers));
345
356
 
346
357
  }
347
358
 
359
370
    if (observers) 
360
371
    {
361
372
      session.setSessionObservers(NULL);
 
373
      observers->clearAllObservers();
362
374
      delete observers;
363
375
    }
364
376
  }
366
378
 
367
379
  /* Event observer list iterator: */
368
380
  //----------
369
 
  class EventIterate : public std::unary_function<std::pair<uint32_t, EventObserver *>, bool>
 
381
  class EventIterate : public unary_function<pair<uint32_t, EventObserver *>, bool>
370
382
  {
371
383
    EventData &data;
372
384
 
373
385
  public:
374
386
    EventIterate(EventData &data_arg) :
375
 
      std::unary_function<std::pair<uint32_t, EventObserver *>, bool>(),
 
387
      unary_function<pair<uint32_t, EventObserver *>, bool>(),
376
388
      data(data_arg)
377
389
    {}
378
390
 
383
395
      {
384
396
        /* TRANSLATORS: The leading word "EventObserver" is the name
385
397
          of the plugin api, and so should not be translated. */
386
 
        errmsg_printf(error::ERROR,
 
398
        errmsg_printf(ERRMSG_LVL_ERROR,
387
399
                      _("EventIterate event handler '%s' failed for event '%s'"),
388
400
                      handler.second->getName().c_str(), handler.second->eventName(data.event));
389
401
 
403
415
  {
404
416
    EventObserverList::ObserverMap *eventObservers;
405
417
 
406
 
    if (observerList == NULL)
407
 
      return false; // Nobody was interested in the event. :(
408
 
 
409
418
    eventObservers = observerList->getObservers(event);
410
419
 
411
420
    if (eventObservers == NULL)
413
422
 
414
423
    /* Use find_if instead of foreach so that we can collect return codes */
415
424
    EventObserverList::ObserverMap::iterator iter=
416
 
      std::find_if(eventObservers->begin(), eventObservers->end(),
417
 
                   EventIterate(*this)); 
 
425
      find_if(eventObservers->begin(), eventObservers->end(),
 
426
              EventIterate(*this)); 
418
427
    /* If iter is == end() here, that means that all of the plugins returned
419
428
     * false, which in this case means they all succeeded. Since we want to 
420
429
     * return false on success, we return the value of the two being !=.
446
455
  //--------
447
456
  bool TableEventData::callEventObservers()
448
457
  {
449
 
    observerList= table.getMutableShare()->getTableObservers();
 
458
    observerList= table.s->getTableObservers();
450
459
 
451
460
    return EventData::callEventObservers();
452
461
  }
453
462
 
454
463
  /*==========================================================*/
455
464
  /* Static meathods called by drizzle to notify interested plugins 
456
 
   * of a schema event.
 
465
   * of a schema event,
457
466
 */
458
 
  bool EventObserver::beforeDropTable(Session &session, const drizzled::identifier::Table &table)
 
467
  bool EventObserver::beforeDropTable(Session &session, const drizzled::TableIdentifier &table)
459
468
  {
460
469
    if (all_event_plugins.empty())
461
470
      return false;
464
473
    return eventData.callEventObservers();
465
474
  }
466
475
 
467
 
  bool EventObserver::afterDropTable(Session &session, const drizzled::identifier::Table &table, int err)
 
476
  bool EventObserver::afterDropTable(Session &session, const drizzled::TableIdentifier &table, int err)
468
477
  {
469
478
    if (all_event_plugins.empty())
470
479
      return false;
473
482
    return eventData.callEventObservers();
474
483
  }
475
484
 
476
 
  bool EventObserver::beforeRenameTable(Session &session, const drizzled::identifier::Table &from, const drizzled::identifier::Table &to)
 
485
  bool EventObserver::beforeRenameTable(Session &session, const drizzled::TableIdentifier &from, const drizzled::TableIdentifier &to)
477
486
  {
478
487
    if (all_event_plugins.empty())
479
488
      return false;
482
491
    return eventData.callEventObservers();
483
492
  }
484
493
 
485
 
  bool EventObserver::afterRenameTable(Session &session, const drizzled::identifier::Table &from, const drizzled::identifier::Table &to, int err)
 
494
  bool EventObserver::afterRenameTable(Session &session, const drizzled::TableIdentifier &from, const drizzled::TableIdentifier &to, int err)
486
495
  {
487
496
    if (all_event_plugins.empty())
488
497
      return false;
493
502
 
494
503
  /*==========================================================*/
495
504
  /* Static meathods called by drizzle to notify interested plugins 
496
 
   * of a table event.
497
 
   *
498
 
   * A quick test is done first to see if there are any interested observers.
 
505
   * of a table event,
499
506
 */
500
507
  bool EventObserver::beforeInsertRecord(Table &table, unsigned char *buf)
501
508
  {
502
 
    if (all_event_plugins.empty() || !TableEventData::hasEvents(table))
 
509
    if (all_event_plugins.empty())
503
510
      return false;
504
511
 
505
512
    BeforeInsertRecordEventData eventData(*(table.in_use), table, buf);
508
515
 
509
516
  bool EventObserver::afterInsertRecord(Table &table, const unsigned char *buf, int err)
510
517
  {
511
 
    if (all_event_plugins.empty() || !TableEventData::hasEvents(table))
 
518
    if (all_event_plugins.empty())
512
519
      return false;
513
520
 
514
521
    AfterInsertRecordEventData eventData(*(table.in_use), table, buf, err);
517
524
 
518
525
  bool EventObserver::beforeDeleteRecord(Table &table, const unsigned char *buf)
519
526
  {
520
 
    if (all_event_plugins.empty() || !TableEventData::hasEvents(table))
 
527
    if (all_event_plugins.empty())
521
528
      return false;
522
529
 
523
530
    BeforeDeleteRecordEventData eventData(*(table.in_use), table, buf);
526
533
 
527
534
  bool EventObserver::afterDeleteRecord(Table &table, const unsigned char *buf, int err)
528
535
  {
529
 
    if (all_event_plugins.empty() || !TableEventData::hasEvents(table))
 
536
    if (all_event_plugins.empty())
530
537
      return false;
531
538
 
532
539
    AfterDeleteRecordEventData eventData(*(table.in_use), table, buf, err);
535
542
 
536
543
  bool EventObserver::beforeUpdateRecord(Table &table, const unsigned char *old_data, unsigned char *new_data)
537
544
  {
538
 
    if (all_event_plugins.empty() || !TableEventData::hasEvents(table))
 
545
    if (all_event_plugins.empty())
539
546
      return false;
540
547
 
541
548
    BeforeUpdateRecordEventData eventData(*(table.in_use), table, old_data, new_data);
544
551
 
545
552
  bool EventObserver::afterUpdateRecord(Table &table, const unsigned char *old_data, unsigned char *new_data, int err)
546
553
  {
547
 
    if (all_event_plugins.empty() || !TableEventData::hasEvents(table))
 
554
    if (all_event_plugins.empty())
548
555
      return false;
549
556
 
550
557
    AfterUpdateRecordEventData eventData(*(table.in_use), table, old_data, new_data, err);
553
560
 
554
561
  /*==========================================================*/
555
562
  /* Static meathods called by drizzle to notify interested plugins 
556
 
   * of a session event.
557
 
   *
558
 
   * A quick test is done first to see if there are any interested observers.
559
 
*/
 
563
   * of a session event,
 
564
 */
560
565
  bool EventObserver::beforeCreateDatabase(Session &session, const std::string &db)
561
566
  {
562
 
    if (all_event_plugins.empty() || !SessionEventData::hasEvents(session))
 
567
    if (all_event_plugins.empty())
563
568
      return false;
564
569
 
565
570
    BeforeCreateDatabaseEventData eventData(session, db);
568
573
 
569
574
  bool EventObserver::afterCreateDatabase(Session &session, const std::string &db, int err)
570
575
  {
571
 
    if (all_event_plugins.empty() || !SessionEventData::hasEvents(session))
 
576
    if (all_event_plugins.empty())
572
577
      return false;
573
578
 
574
579
    AfterCreateDatabaseEventData eventData(session, db, err);
577
582
 
578
583
  bool EventObserver::beforeDropDatabase(Session &session, const std::string &db)
579
584
  {
580
 
    if (all_event_plugins.empty() || !SessionEventData::hasEvents(session))
 
585
    if (all_event_plugins.empty())
581
586
      return false;
582
587
 
583
588
    BeforeDropDatabaseEventData eventData(session, db);
586
591
 
587
592
  bool EventObserver::afterDropDatabase(Session &session, const std::string &db, int err)
588
593
  {
589
 
    if (all_event_plugins.empty() || !SessionEventData::hasEvents(session))
 
594
    if (all_event_plugins.empty())
590
595
      return false;
591
596
 
592
597
    AfterDropDatabaseEventData eventData(session, db, err);
593
598
    return eventData.callEventObservers();
594
599
  }
595
600
 
596
 
  bool EventObserver::connectSession(Session &session)
597
 
  {
598
 
    if (all_event_plugins.empty() || !SessionEventData::hasEvents(session))
599
 
      return false;
600
 
 
601
 
    ConnectSessionEventData eventData(session);
602
 
    return eventData.callEventObservers();
603
 
  }
604
 
 
605
 
  bool EventObserver::disconnectSession(Session &session)
606
 
  {
607
 
    if (all_event_plugins.empty() || !SessionEventData::hasEvents(session))
608
 
      return false;
609
 
 
610
 
    DisconnectSessionEventData eventData(session);
611
 
    return eventData.callEventObservers();
612
 
  }
613
 
 
614
 
  bool EventObserver::beforeStatement(Session &session)
615
 
  {
616
 
    if (all_event_plugins.empty() || !SessionEventData::hasEvents(session))
617
 
      return false;
618
 
 
619
 
    BeforeStatementEventData eventData(session);
620
 
    return eventData.callEventObservers();
621
 
  }
622
 
 
623
 
  bool EventObserver::afterStatement(Session &session)
624
 
  {
625
 
    if (all_event_plugins.empty() || !SessionEventData::hasEvents(session))
626
 
      return false;
627
 
 
628
 
    AfterStatementEventData eventData(session);
629
 
    return eventData.callEventObservers();
630
 
  }
631
 
 
632
601
 
633
602
} /* namespace plugin */
634
603
} /* namespace drizzled */