← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/plugin/event_observer.cc

Merge trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/plugin/event_observer.cc
91
91
 
92
92
    EventObserverList()
93
93
    {
94
 
      uint32_t i;
95
 
 
96
 
      event_observer_lists.reserve(EventObserver::MAX_EVENT_COUNT);
97
 
      for (i=0; i < EventObserver::MAX_EVENT_COUNT; i++)
98
 
      {
99
 
        event_observer_lists[i]= NULL;
100
 
      }
 
94
                        // Initialize the list with NULL pointers.
 
95
                        event_observer_lists.assign(EventObserver::MAX_EVENT_COUNT, NULL);
101
96
    }
102
97
 
103
98
    ~EventObserverList()
104
99
    {
105
 
      clearAllObservers();
 
100
      for_each(event_observer_lists.begin(),
 
101
               event_observer_lists.end(),
 
102
               SafeDeletePtr());
 
103
                        event_observer_lists.clear();
106
104
    }
107
105
 
108
106
    /* Add the observer to the observer list for the even, positioning it if required.
144
142
      observers->insert(pair<uint32_t, EventObserver *>(event_pos, eventObserver) );
145
143
    }
146
144
 
147
 
    /* Remove all observer from all lists. */
148
 
    void clearAllObservers()
149
 
    {
150
 
      for_each(event_observer_lists.begin(),
151
 
               event_observer_lists.end(),
152
 
               DeletePtr());
153
 
      event_observer_lists.clear();
154
 
    }
155
 
 
156
145
 
157
146
    /* Get the observer list for an event type. Will return NULL if no observer exists.*/
158
147
    ObserverMap *getObservers(enum EventObserver::EventType event)
207
196
 
208
197
    observers= table_share.getTableObservers();
209
198
 
210
 
    if (observers == NULL) 
211
 
    {
212
 
      observers= new EventObserverList();
213
 
      table_share.setTableObservers(observers);
214
 
    } 
215
 
    else 
216
 
    {
217
 
      /* Calling registerTableEvents() for a table that already has
218
 
       * events registered on it is probably a programming error.
219
 
     */
220
 
      observers->clearAllObservers();
 
199
    if (observers != NULL) 
 
200
                {
 
201
                        errmsg_printf(ERRMSG_LVL_WARN,
 
202
                                                                        _("EventObserver::registerTableEvents(): Table already has events registered on it: probable programming error."));
 
203
                        table_share.setTableObservers(NULL);
 
204
      delete observers;
221
205
    }
222
206
 
 
207
                observers= new EventObserverList();
 
208
                table_share.setTableObservers(observers);
 
209
 
223
210
 
224
211
    for_each(all_event_plugins.begin(), all_event_plugins.end(),
225
212
             RegisterTableEventsIterate(table_share, *observers));
230
217
  /* Cleanup before freeing the TableShare object. */
231
218
  void EventObserver::deregisterTableEvents(TableShare &table_share)
232
219
  {
233
 
    if (all_event_plugins.empty())
 
220
   if (all_event_plugins.empty())
234
221
      return;
235
222
 
236
223
    EventObserverList *observers;
240
227
    if (observers) 
241
228
    {
242
229
      table_share.setTableObservers(NULL);
243
 
      observers->clearAllObservers();
244
230
      delete observers;
245
231
    }
246
232
  }
287
273
    {
288
274
      observers= new EventObserverList();
289
275
      session.setSchemaObservers(db, observers);
290
 
    }
 
276
   }
291
277
 
292
278
    for_each(all_event_plugins.begin(), all_event_plugins.end(),
293
279
             RegisterSchemaEventsIterate(db, *observers));
308
294
    if (observers) 
309
295
    {
310
296
      session.setSchemaObservers(db, NULL);
311
 
      observers->clearAllObservers();
312
297
      delete observers;
313
298
    }
314
299
  }
347
332
    EventObserverList *observers;
348
333
 
349
334
    observers= session.getSessionObservers();
350
 
 
351
 
    if (observers == NULL) 
352
 
    {
353
 
      observers= new EventObserverList();
354
 
      session.setSessionObservers(observers);
355
 
    }
356
 
 
357
 
    observers->clearAllObservers();
 
335
                if (observers) { // This should not happed
 
336
                        errmsg_printf(ERRMSG_LVL_WARN,
 
337
                                                                        _("EventObserver::registerSessionEvents(): Session already has events registered on it: probable programming error."));
 
338
                        session.setSessionObservers(NULL);
 
339
                        delete observers;
 
340
                }
 
341
 
 
342
        observers= new EventObserverList();
 
343
        session.setSessionObservers(observers);
358
344
 
359
345
    for_each(all_event_plugins.begin(), all_event_plugins.end(),
360
346
             RegisterSessionEventsIterate(session, *observers));
375
361
    if (observers) 
376
362
    {
377
363
      session.setSessionObservers(NULL);
378
 
      observers->clearAllObservers();
379
364
      delete observers;
380
365
    }
381
366
  }