← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/plugin/event_observer.cc

  • Committer: Stewart Smith
  • Date: 2010-11-03 03:30:27 UTC
  • mto: (1902.1.1 build) (1910.1.2 build)
  • mto: This revision was merged to the branch mainline in revision 1903.
  • Revision ID: stewart@flamingspork.com-20101103033027-lskb6gxwwforfz71
fix docs warning: underline/overline too short for replace.rst

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/plugin/event_observer.cc
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
 
413
415
 
414
416
    /* Use find_if instead of foreach so that we can collect return codes */
415
417
    EventObserverList::ObserverMap::iterator iter=
416
 
      std::find_if(eventObservers->begin(), eventObservers->end(),
417
 
                   EventIterate(*this)); 
 
418
      find_if(eventObservers->begin(), eventObservers->end(),
 
419
              EventIterate(*this)); 
418
420
    /* If iter is == end() here, that means that all of the plugins returned
419
421
     * false, which in this case means they all succeeded. Since we want to 
420
422
     * return false on success, we return the value of the two being !=.