← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_list.h

  • Committer: Olaf van der Spek
  • Date: 2011-02-24 11:23:15 UTC
  • mto: (2198.2.3 drizzle-staging)
  • mto: This revision was merged to the branch mainline in revision 2199.
  • Revision ID: olafvdspek@gmail.com-20110224112315-s239qde5dtxv6dmq
Remove inline keyword
Use List::iterator::operator*

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_list.h
35
35
  unsigned char *first;
36
36
  unsigned char **next;
37
37
 
38
 
  inline void clear()
 
38
  void clear()
39
39
  {
40
40
    elements=0;
41
41
    first=0;
47
47
    return elements;
48
48
  }
49
49
 
50
 
  inline void link_in_list(unsigned char *element,unsigned char **next_ptr)
 
50
  void link_in_list(unsigned char *element,unsigned char **next_ptr)
51
51
  {
52
52
    elements++;
53
53
    (*next)=element;
54
54
    next= next_ptr;
55
55
    *next=0;
56
56
  }
57
 
  inline void save_and_clear(struct st_sql_list *save)
 
57
  void save_and_clear(struct st_sql_list *save)
58
58
  {
59
59
    *save= *this;
60
60
    clear();
61
61
  }
62
 
  inline void push_front(struct st_sql_list *save)
 
62
  void push_front(struct st_sql_list *save)
63
63
  {
64
64
    *save->next= first;                         /* link current list last */
65
65
    first= save->first;
66
66
    elements+= save->elements;
67
67
  }
68
 
  inline void push_back(struct st_sql_list *save)
 
68
  void push_back(struct st_sql_list *save)
69
69
  {
70
70
    if (save->first)
71
71
    {
115
115
  uint32_t elements;
116
116
public:
117
117
 
118
 
  inline void clear() { elements=0; first= &end_of_list; last=&first;}
119
 
  inline base_list() { clear(); }
 
118
  void clear() { elements=0; first= &end_of_list; last=&first;}
 
119
  base_list() { clear(); }
120
120
  /**
121
121
    This is a shallow copy constructor that implicitly passes the ownership
122
122
    from the source list to the new instance. The old instance is not
126
126
    relies on this behaviour. This logic is quite tricky: please do not use
127
127
    it in any new code.
128
128
  */
129
 
  inline base_list(const base_list &tmp) :memory::SqlAlloc()
 
129
  base_list(const base_list &tmp) :memory::SqlAlloc()
130
130
  {
131
131
    elements= tmp.elements;
132
132
    first= tmp.first;
133
133
    last= elements ? tmp.last : &first;
134
134
  }
135
 
  inline base_list(bool) { }
136
 
  inline bool push_back(void *info)
 
135
  base_list(bool) { }
 
136
  bool push_back(void *info)
137
137
  {
138
138
    if (((*last)=new list_node(info, &end_of_list)))
139
139
    {
143
143
    }
144
144
    return 1;
145
145
  }
146
 
  inline bool push_back(void *info, memory::Root *mem_root)
 
146
  bool push_back(void *info, memory::Root *mem_root)
147
147
  {
148
148
    if (((*last)=new (mem_root) list_node(info, &end_of_list)))
149
149
    {
153
153
    }
154
154
    return 1;
155
155
  }
156
 
  inline bool push_front(void *info)
 
156
  bool push_front(void *info)
157
157
  {
158
158
    list_node *node=new list_node(info,first);
159
159
    if (node)
176
176
    delete *prev;
177
177
    *prev=node;
178
178
  }
179
 
  inline void concat(base_list *list)
 
179
  void concat(base_list *list)
180
180
  {
181
181
    if (!list->is_empty())
182
182
    {
185
185
      elements+= list->elements;
186
186
    }
187
187
  }
188
 
  inline void *pop(void)
 
188
  void *pop()
189
189
  {
190
190
    if (first == &end_of_list) return 0;
191
191
    list_node *tmp=first;
194
194
      last= &first;
195
195
    return tmp->info;
196
196
  }
197
 
  inline void disjoin(base_list *list)
 
197
  void disjoin(base_list *list)
198
198
  {
199
199
    list_node **prev= &first;
200
200
    list_node *node= first;
209
209
    *prev= *last;
210
210
    last= prev;
211
211
  }
212
 
  inline void prepand(base_list *list)
 
212
  void prepand(base_list *list)
213
213
  {
214
214
    if (!list->is_empty())
215
215
    {
221
221
  /**
222
222
    Swap two lists.
223
223
  */
224
 
  inline void swap(base_list &rhs)
 
224
  void swap(base_list &rhs)
225
225
  {
226
226
    std::swap(first, rhs.first);
227
227
    std::swap(last, rhs.last);
228
228
    std::swap(elements, rhs.elements);
229
229
  }
230
 
  inline void **head_ref() { return first != &end_of_list ? &first->info : 0; }
231
 
  inline bool is_empty() { return first == &end_of_list ; }
 
230
  bool is_empty() { return first == &end_of_list ; }
232
231
  friend class base_list_iterator;
233
232
 
234
233
#ifdef LIST_EXTRA_DEBUG
307
306
  {
308
307
  }
309
308
 
310
 
  inline void *next(void)
 
309
  void *next()
311
310
  {
312
311
    prev=el;
313
312
    current= *el;
314
313
    el= &current->next;
315
314
    return current->info;
316
315
  }
317
 
  inline void *replace(void *element)
318
 
  {                                             // Return old element
319
 
    void *tmp=current->info;
320
 
    assert(current->info != 0);
321
 
    current->info=element;
322
 
    return tmp;
323
 
  }
324
316
  void *replace(base_list &new_list)
325
317
  {
326
318
    void *ret_value=current->info;
329
321
      *new_list.last=current->next;
330
322
      current->info=new_list.first->info;
331
323
      current->next=new_list.first->next;
332
 
      if ((list->last == &current->next) && (new_list.elements > 1))
333
 
        list->last= new_list.last;
 
324
      if (list->last == &current->next && new_list.elements > 1)
 
325
        list->last= new_list.last;
334
326
      list->elements+=new_list.elements-1;
335
327
    }
336
328
    return ret_value;                           // return old element
337
329
  }
338
 
  inline void remove(void)                      // Remove current
 
330
  void remove()                 // Remove current
339
331
  {
340
332
    list->remove(prev);
341
333
    el=prev;
347
339
    current=current->next;
348
340
    el= &current->next;
349
341
  }
350
 
  inline void **ref(void)                       // Get reference pointer
351
 
  {
352
 
    return &current->info;
353
 
  }
354
 
  inline bool is_last(void)
355
 
  {
356
 
    return el == &end_of_list.next;
357
 
  }
358
342
};
359
343
 
360
344
template <class T> class List_iterator;
361
345
 
362
 
template <class T> class List :public base_list
 
346
template <class T> class List : public base_list
363
347
{
364
348
public:
365
349
  typedef List_iterator<T> iterator;
366
350
 
367
351
  friend class List_iterator<T>;
368
352
 
369
 
  inline List() {}
370
 
  inline List(const List<T> &tmp) : base_list(tmp) {}
371
 
  inline List(const List<T> &tmp, memory::Root *mem_root) : base_list(tmp, mem_root) {}
372
 
  inline bool push_back(T *a) { return base_list::push_back(a); }
373
 
  inline bool push_back(T *a, memory::Root *mem_root)
374
 
  { return base_list::push_back(a, mem_root); }
375
 
  inline bool push_front(T *a) { return base_list::push_front(a); }
376
 
  inline T& front() {return *static_cast<T*>(first->info); }
377
 
  inline T* pop()  {return static_cast<T*>(base_list::pop()); }
378
 
  inline void concat(List<T> *list) { base_list::concat(list); }
379
 
  inline void disjoin(List<T> *list) { base_list::disjoin(list); }
380
 
  inline void prepand(List<T> *list) { base_list::prepand(list); }
381
 
  void delete_elements(void)
 
353
  List() {}
 
354
  List(const List<T> &tmp) : base_list(tmp) {}
 
355
  List(const List<T> &tmp, memory::Root *mem_root) : base_list(tmp, mem_root) {}
 
356
  bool push_back(T *a) { return base_list::push_back(a); }
 
357
  bool push_back(T *a, memory::Root *mem_root) { return base_list::push_back(a, mem_root); }
 
358
  bool push_front(T *a) { return base_list::push_front(a); }
 
359
  T& front() {return *static_cast<T*>(first->info); }
 
360
  T* pop()  {return static_cast<T*>(base_list::pop()); }
 
361
  void concat(List<T> *list) { base_list::concat(list); }
 
362
  void disjoin(List<T> *list) { base_list::disjoin(list); }
 
363
  void prepand(List<T> *list) { base_list::prepand(list); }
 
364
  void delete_elements()
382
365
  {
383
366
    list_node *element,*next;
384
367
    for (element=first; element != &end_of_list; element=next)
405
388
  }
406
389
};
407
390
 
408
 
 
409
 
template <class T> class List_iterator :public base_list_iterator
 
391
template <class T> class List_iterator : public base_list_iterator
410
392
{
411
393
public:
412
394
  List_iterator(List<T>& a, list_node** b) : base_list_iterator(a, b) {};
413
395
  List_iterator() {};
414
 
 T *operator++(int) { return (T*) base_list_iterator::next(); }
415
 
 void replace(T *a)   { base_list_iterator::replace(a); }
416
 
 T *replace(List<T> &a) { return (T*) base_list_iterator::replace(a); }
417
 
 T** ref(void)      { return (T**) base_list_iterator::ref(); }
 
396
  T *operator++(int) { return (T*) base_list_iterator::next(); }
 
397
  T *replace(T *a)   { T* old = (T*) current->info; current->info= a; return old; }
 
398
  void replace(List<T> &a) { base_list_iterator::replace(a); }
 
399
  T** ref() { return (T**) &current->info; }
 
400
 
 
401
  T& operator*()
 
402
  {
 
403
    return *(T*)current->info;
 
404
  }
418
405
};
419
406
 
420
 
/**
421
 
  Make a deep copy of each list element.
422
 
 
423
 
  @note A template function and not a template method of class List
424
 
  is employed because of explicit template instantiation:
425
 
  in server code there are explicit instantiations of List<T> and
426
 
  an explicit instantiation of a template requires that any method
427
 
  of the instantiated class used in the template can be resolved.
428
 
  Evidently not all template arguments have clone() method with
429
 
  the right signature.
430
 
 
431
 
  @return You must query the error state in Session for out-of-memory
432
 
  situation after calling this function.
433
 
*/
434
 
 
435
 
template <typename T>
436
 
void list_copy_and_replace_each_value(List<T> &list, memory::Root *mem_root)
437
 
{
438
 
  /* Make a deep copy of each element */
439
 
  typename List<T>::iterator it(list.begin());
440
 
  T *el;
441
 
  while ((el= it++))
442
 
    it.replace(el->clone(mem_root));
443
 
}
444
 
 
445
407
} /* namespace drizzled */
446
408
 
447
409
#endif /* DRIZZLED_SQL_LIST_H */