← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/plugin/event_observer.cc

  • Committer: Brian Aker
  • Date: 2010-10-21 17:52:54 UTC
  • mto: This revision was merged to the branch mainline in revision 1885.
  • Revision ID: brian@tangent.org-20101021175254-l9nv1iio8713xtzc
Switched columns to use AllFields.

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/definition/table.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
 
63
65
  void EventObserver::removePlugin(EventObserver *handler)
64
66
  {
65
67
    if (handler != NULL)
66
 
      all_event_plugins.erase(std::find(all_event_plugins.begin(), all_event_plugins.end(), handler));
 
68
      all_event_plugins.erase(find(all_event_plugins.begin(), all_event_plugins.end(), handler));
67
69
  }
68
70
 
69
71
 
79
81
  {
80
82
 
81
83
  public:
82
 
    typedef std::multimap<uint32_t, EventObserver *> ObserverMap;
 
84
    typedef multimap<uint32_t, EventObserver *> ObserverMap;
83
85
 
84
86
  private:
85
87
    /* A list of lists indexed by event type. */
86
 
    std::vector<ObserverMap *> event_observer_lists;
 
88
    vector<ObserverMap *> event_observer_lists;
87
89
 
88
90
  public:
89
91
 
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
      for_each(event_observer_lists.begin(),
 
101
               event_observer_lists.end(),
 
102
               SafeDeletePtr());
 
103
                        event_observer_lists.clear();
102
104
    }
103
105
 
104
106
    /* Add the observer to the observer list for the even, positioning it if required.
137
139
        }
138
140
      }
139
141
 
140
 
      observers->insert(std::pair<uint32_t, EventObserver *>(event_pos, eventObserver) );
 
142
      observers->insert(pair<uint32_t, EventObserver *>(event_pos, eventObserver) );
141
143
    }
142
144
 
143
145
 
166
168
  /* For each EventObserver plugin call its registerTableEventsDo() meathod so that it can
167
169
   * register what events, if any, it is interested in on this table.
168
170
   */ 
169
 
  class RegisterTableEventsIterate : public std::unary_function<EventObserver *, void>
 
171
  class RegisterTableEventsIterate : public unary_function<EventObserver *, void>
170
172
  {
171
173
    TableShare &table_share;
172
174
    EventObserverList &observers;
206
208
                table_share.setTableObservers(observers);
207
209
 
208
210
 
209
 
    std::for_each(all_event_plugins.begin(), all_event_plugins.end(),
210
 
                  RegisterTableEventsIterate(table_share, *observers));
 
211
    for_each(all_event_plugins.begin(), all_event_plugins.end(),
 
212
             RegisterTableEventsIterate(table_share, *observers));
211
213
 
212
214
  }
213
215
 
238
240
  /* For each EventObserver plugin call its registerSchemaEventsDo() meathod so that it can
239
241
   * register what events, if any, it is interested in on the schema.
240
242
   */ 
241
 
  class RegisterSchemaEventsIterate : public std::unary_function<EventObserver *, void>
 
243
  class RegisterSchemaEventsIterate : public unary_function<EventObserver *, void>
242
244
  {
243
245
    const std::string &db;
244
246
    EventObserverList &observers;
273
275
      session.setSchemaObservers(db, observers);
274
276
   }
275
277
 
276
 
    std::for_each(all_event_plugins.begin(), all_event_plugins.end(),
277
 
                  RegisterSchemaEventsIterate(db, *observers));
 
278
    for_each(all_event_plugins.begin(), all_event_plugins.end(),
 
279
             RegisterSchemaEventsIterate(db, *observers));
278
280
 
279
281
  }
280
282
 
304
306
  /* For each EventObserver plugin call its registerSessionEventsDo() meathod so that it can
305
307
   * register what events, if any, it is interested in on this session.
306
308
   */ 
307
 
  class RegisterSessionEventsIterate : public std::unary_function<EventObserver *, void>
 
309
  class RegisterSessionEventsIterate : public unary_function<EventObserver *, void>
308
310
  {
309
311
    Session &session;
310
312
    EventObserverList &observers;
340
342
        observers= new EventObserverList();
341
343
        session.setSessionObservers(observers);
342
344
 
343
 
  std::for_each(all_event_plugins.begin(), all_event_plugins.end(),
344
 
                RegisterSessionEventsIterate(session, *observers));
 
345
    for_each(all_event_plugins.begin(), all_event_plugins.end(),
 
346
             RegisterSessionEventsIterate(session, *observers));
345
347
 
346
348
  }
347
349
 
366
368
 
367
369
  /* Event observer list iterator: */
368
370
  //----------
369
 
  class EventIterate : public std::unary_function<std::pair<uint32_t, EventObserver *>, bool>
 
371
  class EventIterate : public unary_function<pair<uint32_t, EventObserver *>, bool>
370
372
  {
371
373
    EventData &data;
372
374
 
373
375
  public:
374
376
    EventIterate(EventData &data_arg) :
375
 
      std::unary_function<std::pair<uint32_t, EventObserver *>, bool>(),
 
377
      unary_function<pair<uint32_t, EventObserver *>, bool>(),
376
378
      data(data_arg)
377
379
    {}
378
380
 
403
405
  {
404
406
    EventObserverList::ObserverMap *eventObservers;
405
407
 
406
 
    if (observerList == NULL)
407
 
      return false; // Nobody was interested in the event. :(
408
 
 
409
408
    eventObservers = observerList->getObservers(event);
410
409
 
411
410
    if (eventObservers == NULL)
413
412
 
414
413
    /* Use find_if instead of foreach so that we can collect return codes */
415
414
    EventObserverList::ObserverMap::iterator iter=
416
 
      std::find_if(eventObservers->begin(), eventObservers->end(),
417
 
                   EventIterate(*this)); 
 
415
      find_if(eventObservers->begin(), eventObservers->end(),
 
416
              EventIterate(*this)); 
418
417
    /* If iter is == end() here, that means that all of the plugins returned
419
418
     * false, which in this case means they all succeeded. Since we want to 
420
419
     * return false on success, we return the value of the two being !=.
453
452
 
454
453
  /*==========================================================*/
455
454
  /* Static meathods called by drizzle to notify interested plugins 
456
 
   * of a schema event.
 
455
   * of a schema event,
457
456
 */
458
457
  bool EventObserver::beforeDropTable(Session &session, const drizzled::TableIdentifier &table)
459
458
  {
493
492
 
494
493
  /*==========================================================*/
495
494
  /* 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.
 
495
   * of a table event,
499
496
 */
500
497
  bool EventObserver::beforeInsertRecord(Table &table, unsigned char *buf)
501
498
  {
502
 
    if (all_event_plugins.empty() || !TableEventData::hasEvents(table))
 
499
    if (all_event_plugins.empty())
503
500
      return false;
504
501
 
505
502
    BeforeInsertRecordEventData eventData(*(table.in_use), table, buf);
508
505
 
509
506
  bool EventObserver::afterInsertRecord(Table &table, const unsigned char *buf, int err)
510
507
  {
511
 
    if (all_event_plugins.empty() || !TableEventData::hasEvents(table))
 
508
    if (all_event_plugins.empty())
512
509
      return false;
513
510
 
514
511
    AfterInsertRecordEventData eventData(*(table.in_use), table, buf, err);
517
514
 
518
515
  bool EventObserver::beforeDeleteRecord(Table &table, const unsigned char *buf)
519
516
  {
520
 
    if (all_event_plugins.empty() || !TableEventData::hasEvents(table))
 
517
    if (all_event_plugins.empty())
521
518
      return false;
522
519
 
523
520
    BeforeDeleteRecordEventData eventData(*(table.in_use), table, buf);
526
523
 
527
524
  bool EventObserver::afterDeleteRecord(Table &table, const unsigned char *buf, int err)
528
525
  {
529
 
    if (all_event_plugins.empty() || !TableEventData::hasEvents(table))
 
526
    if (all_event_plugins.empty())
530
527
      return false;
531
528
 
532
529
    AfterDeleteRecordEventData eventData(*(table.in_use), table, buf, err);
535
532
 
536
533
  bool EventObserver::beforeUpdateRecord(Table &table, const unsigned char *old_data, unsigned char *new_data)
537
534
  {
538
 
    if (all_event_plugins.empty() || !TableEventData::hasEvents(table))
 
535
    if (all_event_plugins.empty())
539
536
      return false;
540
537
 
541
538
    BeforeUpdateRecordEventData eventData(*(table.in_use), table, old_data, new_data);
544
541
 
545
542
  bool EventObserver::afterUpdateRecord(Table &table, const unsigned char *old_data, unsigned char *new_data, int err)
546
543
  {
547
 
    if (all_event_plugins.empty() || !TableEventData::hasEvents(table))
 
544
    if (all_event_plugins.empty())
548
545
      return false;
549
546
 
550
547
    AfterUpdateRecordEventData eventData(*(table.in_use), table, old_data, new_data, err);
553
550
 
554
551
  /*==========================================================*/
555
552
  /* 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
 
*/
 
553
   * of a session event,
 
554
 */
560
555
  bool EventObserver::beforeCreateDatabase(Session &session, const std::string &db)
561
556
  {
562
 
    if (all_event_plugins.empty() || !SessionEventData::hasEvents(session))
 
557
    if (all_event_plugins.empty())
563
558
      return false;
564
559
 
565
560
    BeforeCreateDatabaseEventData eventData(session, db);
568
563
 
569
564
  bool EventObserver::afterCreateDatabase(Session &session, const std::string &db, int err)
570
565
  {
571
 
    if (all_event_plugins.empty() || !SessionEventData::hasEvents(session))
 
566
    if (all_event_plugins.empty())
572
567
      return false;
573
568
 
574
569
    AfterCreateDatabaseEventData eventData(session, db, err);
577
572
 
578
573
  bool EventObserver::beforeDropDatabase(Session &session, const std::string &db)
579
574
  {
580
 
    if (all_event_plugins.empty() || !SessionEventData::hasEvents(session))
 
575
    if (all_event_plugins.empty())
581
576
      return false;
582
577
 
583
578
    BeforeDropDatabaseEventData eventData(session, db);
586
581
 
587
582
  bool EventObserver::afterDropDatabase(Session &session, const std::string &db, int err)
588
583
  {
589
 
    if (all_event_plugins.empty() || !SessionEventData::hasEvents(session))
 
584
    if (all_event_plugins.empty())
590
585
      return false;
591
586
 
592
587
    AfterDropDatabaseEventData eventData(session, db, err);
595
590
 
596
591
  bool EventObserver::connectSession(Session &session)
597
592
  {
598
 
    if (all_event_plugins.empty() || !SessionEventData::hasEvents(session))
 
593
    if (all_event_plugins.empty())
599
594
      return false;
600
595
 
601
596
    ConnectSessionEventData eventData(session);
604
599
 
605
600
  bool EventObserver::disconnectSession(Session &session)
606
601
  {
607
 
    if (all_event_plugins.empty() || !SessionEventData::hasEvents(session))
 
602
    if (all_event_plugins.empty())
608
603
      return false;
609
604
 
610
605
    DisconnectSessionEventData eventData(session);
613
608
 
614
609
  bool EventObserver::beforeStatement(Session &session)
615
610
  {
616
 
    if (all_event_plugins.empty() || !SessionEventData::hasEvents(session))
 
611
    if (all_event_plugins.empty())
617
612
      return false;
618
613
 
619
614
    BeforeStatementEventData eventData(session);
622
617
 
623
618
  bool EventObserver::afterStatement(Session &session)
624
619
  {
625
 
    if (all_event_plugins.empty() || !SessionEventData::hasEvents(session))
 
620
    if (all_event_plugins.empty())
626
621
      return false;
627
622
 
628
623
    AfterStatementEventData eventData(session);