← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_list.h

  • Committer: Lee Bieber
  • Date: 2011-02-21 19:38:08 UTC
  • mfrom: (2183.2.8 list2)
  • mto: This revision was merged to the branch mainline in revision 2188.
  • Revision ID: kalebral@gmail.com-20110221193808-aunmc8urhpbr16gf
Merge Olaf - Use List::begin() and Use List::iterator instead of List_iterator_fast

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_list.h
230
230
  inline bool is_empty() { return first == &end_of_list ; }
231
231
  inline list_node *last_ref() { return &end_of_list; }
232
232
  friend class base_list_iterator;
233
 
  friend class error_list;
234
 
  friend class error_list_iterator;
235
233
 
236
234
#ifdef LIST_EXTRA_DEBUG
237
235
  /*
293
291
protected:
294
292
  base_list *list;
295
293
  list_node **el,**prev,*current;
 
294
public:
296
295
  void sublist(base_list &ls, uint32_t elm)
297
296
  {
298
297
    ls.first= *el;
299
298
    ls.last= list->last;
300
299
    ls.elements= elm;
301
300
  }
302
 
public:
303
301
  base_list_iterator()
304
302
    :list(0), el(0), prev(0), current(0)
305
303
  {}
322
320
    el= &current->next;
323
321
    return current->info;
324
322
  }
325
 
  inline void *next_fast(void)
326
 
  {
327
 
    list_node *tmp;
328
 
    tmp= *el;
329
 
    el= &tmp->next;
330
 
    return tmp->info;
331
 
  }
332
323
  inline void *replace(void *element)
333
324
  {                                             // Return old element
334
325
    void *tmp=current->info;
370
361
  {
371
362
    return el == &list->last_ref()->next;
372
363
  }
373
 
  friend class error_list_iterator;
374
364
};
375
365
 
376
366
template <class T> class List_iterator;
414
404
template <class T> class List_iterator :public base_list_iterator
415
405
{
416
406
public:
417
 
  List_iterator(List<T> &a) : base_list_iterator(a) {}
 
407
  explicit List_iterator(List<T> &a) : base_list_iterator(a) {}
418
408
  List_iterator() : base_list_iterator() {}
419
409
  inline T* operator++(int) { return (T*) base_list_iterator::next(); }
420
410
  inline T *replace(T *a)   { return (T*) base_list_iterator::replace(a); }
422
412
  inline T** ref(void)      { return (T**) base_list_iterator::ref(); }
423
413
};
424
414
 
425
 
template <class T> class List_iterator_fast :public base_list_iterator
426
 
{
427
 
private:
428
 
  inline T *replace(T *);
429
 
  inline T *replace(List<T> &);
430
 
  inline void remove(void);
431
 
  inline void after(T *);
432
 
  inline T** ref(void);
433
 
 
434
 
public:
435
 
  inline List_iterator_fast(List<T> &a) : base_list_iterator(a) {}
436
 
  inline List_iterator_fast() : base_list_iterator() {}
437
 
  inline void init(List<T> &a) { base_list_iterator::init(a); }
438
 
  inline T* operator++(int) { return (T*) base_list_iterator::next_fast(); }
439
 
  void sublist(List<T> &list_arg, uint32_t el_arg)
440
 
  {
441
 
    base_list_iterator::sublist(list_arg, el_arg);
442
 
  }
443
 
};
444
 
 
445
415
/**
446
416
  Make a deep copy of each list element.
447
417