← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_list.h

  • Committer: Brian Aker
  • Date: 2010-12-08 22:35:56 UTC
  • mfrom: (1819.9.158 update-innobase)
  • Revision ID: brian@tangent.org-20101208223556-37mi4omqg7lkjzf3
Merge in Stewart's changes, 1.3 changes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_list.h
21
21
#define DRIZZLED_SQL_LIST_H
22
22
 
23
23
 
 
24
#include <cstdlib>
 
25
#include <cassert>
24
26
#include <utility>
25
27
#include <algorithm>
26
 
#include <drizzled/sql_alloc.h>
 
28
#include "drizzled/memory/sql_alloc.h"
 
29
 
 
30
namespace drizzled
 
31
{
27
32
 
28
33
/** Struct to handle simple linked lists. */
29
34
typedef struct st_sql_list {
83
88
  @note We never call a destructor for instances of this class.
84
89
*/
85
90
 
86
 
struct list_node :public Sql_alloc
 
91
struct list_node : public memory::SqlAlloc
87
92
{
88
93
  list_node *next;
89
94
  void *info;
100
105
 
101
106
extern list_node end_of_list;
102
107
 
103
 
class base_list :public Sql_alloc
 
108
class base_list :public memory::SqlAlloc
104
109
{
105
110
protected:
106
111
  list_node *first,**last;
119
124
    relies on this behaviour. This logic is quite tricky: please do not use
120
125
    it in any new code.
121
126
  */
122
 
  inline base_list(const base_list &tmp) :Sql_alloc()
 
127
  inline base_list(const base_list &tmp) :memory::SqlAlloc()
123
128
  {
124
129
    elements= tmp.elements;
125
130
    first= tmp.first;
126
131
    last= elements ? tmp.last : &first;
127
132
  }
128
 
  /**
129
 
    Construct a deep copy of the argument in memory root mem_root.
130
 
    The elements themselves are copied by pointer. If you also
131
 
    need to copy elements by value, you should employ
132
 
    list_copy_and_replace_each_value after creating a copy.
133
 
  */
134
 
  base_list(const base_list &rhs, MEM_ROOT *mem_root);
135
 
  inline base_list(bool error __attribute__((unused))) { }
 
133
  inline base_list(bool) { }
136
134
  inline bool push_back(void *info)
137
135
  {
138
136
    if (((*last)=new list_node(info, &end_of_list)))
143
141
    }
144
142
    return 1;
145
143
  }
146
 
  inline bool push_back(void *info, MEM_ROOT *mem_root)
 
144
  inline bool push_back(void *info, memory::Root *mem_root)
147
145
  {
148
146
    if (((*last)=new (mem_root) list_node(info, &end_of_list)))
149
147
    {
248
246
      check_list()
249
247
        name  Name to print to trace file
250
248
 
251
 
    RETURN 
 
249
    RETURN
252
250
      1  The list is Ok.
253
251
      0  List invariants are not met.
254
252
  */
304
302
    ls.elements= elm;
305
303
  }
306
304
public:
307
 
  base_list_iterator() 
 
305
  base_list_iterator()
308
306
    :list(0), el(0), prev(0), current(0)
309
307
  {}
310
308
 
311
 
  base_list_iterator(base_list &list_par) 
 
309
  base_list_iterator(base_list &list_par)
312
310
  { init(list_par); }
313
311
 
314
312
  inline void init(base_list &list_par)
386
384
public:
387
385
  inline List() :base_list() {}
388
386
  inline List(const List<T> &tmp) :base_list(tmp) {}
389
 
  inline List(const List<T> &tmp, MEM_ROOT *mem_root) :
 
387
  inline List(const List<T> &tmp, memory::Root *mem_root) :
390
388
    base_list(tmp, mem_root) {}
391
389
  inline bool push_back(T *a) { return base_list::push_back(a); }
392
 
  inline bool push_back(T *a, MEM_ROOT *mem_root)
 
390
  inline bool push_back(T *a, memory::Root *mem_root)
393
391
  { return base_list::push_back(a, mem_root); }
394
392
  inline bool push_front(T *a) { return base_list::push_front(a); }
395
393
  inline T* head() {return (T*) base_list::head(); }
430
428
template <class T> class List_iterator_fast :public base_list_iterator
431
429
{
432
430
protected:
433
 
  inline T *replace(T *a __attribute__((unused)))   { return (T*) 0; }
434
 
  inline T *replace(List<T> &a __attribute__((unused))) { return (T*) 0; }
 
431
  inline T *replace(T *)   { return (T*) 0; }
 
432
  inline T *replace(List<T> &) { return (T*) 0; }
435
433
  inline void remove(void)  { }
436
 
  inline void after(T *a __attribute__((unused)))   { }
 
434
  inline void after(T *)   { }
437
435
  inline T** ref(void)      { return (T**) 0; }
438
436
 
439
437
public:
449
447
};
450
448
 
451
449
 
452
 
/*
453
 
  A simple intrusive list which automaticly removes element from list
454
 
  on delete (for Session element)
455
 
*/
456
 
 
457
 
struct ilink
458
 
{
459
 
  struct ilink **prev,*next;
460
 
  static void *operator new(size_t size)
461
 
  {
462
 
    return (void*)malloc((uint)size);
463
 
  }
464
 
  static void operator delete(void* ptr_arg,
465
 
                              size_t size __attribute__((unused)))
466
 
  {
467
 
     free((unsigned char*)ptr_arg);
468
 
  }
469
 
 
470
 
  inline ilink()
471
 
  {
472
 
    prev=0; next=0;
473
 
  }
474
 
  inline void unlink()
475
 
  {
476
 
    /* Extra tests because element doesn't have to be linked */
477
 
    if (prev) *prev= next;
478
 
    if (next) next->prev=prev;
479
 
    prev=0 ; next=0;
480
 
  }
481
 
  virtual ~ilink() { unlink(); }                /*lint -e1740 */
482
 
};
483
 
 
484
 
 
485
 
/* Needed to be able to have an I_List of char* strings in mysqld.cc. */
486
 
 
487
 
class i_string: public ilink
488
 
{
489
 
public:
490
 
  const char* ptr;
491
 
  i_string():ptr(0) { }
492
 
  i_string(const char* s) : ptr(s) {}
493
 
};
494
 
 
495
 
/* needed for linked list of two strings for replicate-rewrite-db */
496
 
class i_string_pair: public ilink
497
 
{
498
 
public:
499
 
  const char* key;
500
 
  const char* val;
501
 
  i_string_pair():key(0),val(0) { }
502
 
  i_string_pair(const char* key_arg, const char* val_arg) : 
503
 
    key(key_arg),val(val_arg) {}
504
 
};
505
 
 
506
 
 
507
 
template <class T> class I_List_iterator;
508
 
 
509
 
/*
510
 
  WARNING: copy constructor of this class does not create a usable
511
 
  copy, as its members may point at each other.
512
 
*/
513
 
 
514
 
class base_ilist
515
 
{
516
 
public:
517
 
  struct ilink *first,last;
518
 
  inline void empty() { first= &last; last.prev= &first; }
519
 
  base_ilist() { empty(); }
520
 
  inline bool is_empty() {  return first == &last; }
521
 
  inline void append(ilink *a)
522
 
  {
523
 
    first->prev= &a->next;
524
 
    a->next=first; a->prev= &first; first=a;
525
 
  }
526
 
  inline void push_back(ilink *a)
527
 
  {
528
 
    *last.prev= a;
529
 
    a->next= &last;
530
 
    a->prev= last.prev;
531
 
    last.prev= &a->next;
532
 
  }
533
 
  inline struct ilink *get()
534
 
  {
535
 
    struct ilink *first_link=first;
536
 
    if (first_link == &last)
537
 
      return 0;
538
 
    first_link->unlink();                       // Unlink from list
539
 
    return first_link;
540
 
  }
541
 
  inline struct ilink *head()
542
 
  {
543
 
    return (first != &last) ? first : 0;
544
 
  }
545
 
  friend class base_list_iterator;
546
 
};
547
 
 
548
 
 
549
 
class base_ilist_iterator
550
 
{
551
 
  base_ilist *list;
552
 
  struct ilink **el,*current;
553
 
public:
554
 
  base_ilist_iterator(base_ilist &list_par) :list(&list_par),
555
 
    el(&list_par.first),current(0) {}
556
 
  void *next(void)
557
 
  {
558
 
    /* This is coded to allow push_back() while iterating */
559
 
    current= *el;
560
 
    if (current == &list->last) return 0;
561
 
    el= &current->next;
562
 
    return current;
563
 
  }
564
 
};
565
 
 
566
 
 
567
 
template <class T>
568
 
class I_List :private base_ilist
569
 
{
570
 
public:
571
 
  I_List() :base_ilist()        {}
572
 
  inline void empty()           { base_ilist::empty(); }
573
 
  inline bool is_empty()        { return base_ilist::is_empty(); } 
574
 
  inline void append(T* a)      { base_ilist::append(a); }
575
 
  inline void push_back(T* a)   { base_ilist::push_back(a); }
576
 
  inline T* get()               { return (T*) base_ilist::get(); }
577
 
  inline T* head()              { return (T*) base_ilist::head(); }
578
 
#ifndef _lint
579
 
  friend class I_List_iterator<T>;
580
 
#endif
581
 
};
582
 
 
583
 
 
584
 
template <class T> class I_List_iterator :public base_ilist_iterator
585
 
{
586
 
public:
587
 
  I_List_iterator(I_List<T> &a) : base_ilist_iterator(a) {}
588
 
  inline T* operator++(int) { return (T*) base_ilist_iterator::next(); }
589
 
};
590
 
 
591
450
/**
592
451
  Make a deep copy of each list element.
593
452
 
606
465
template <typename T>
607
466
inline
608
467
void
609
 
list_copy_and_replace_each_value(List<T> &list, MEM_ROOT *mem_root)
 
468
list_copy_and_replace_each_value(List<T> &list, memory::Root *mem_root)
610
469
{
611
470
  /* Make a deep copy of each element */
612
471
  List_iterator<T> it(list);
615
474
    it.replace(el->clone(mem_root));
616
475
}
617
476
 
618
 
/* sql_list.cc */
619
 
void free_list(I_List <i_string_pair> *list);
620
 
void free_list(I_List <i_string> *list);
621
 
 
622
 
 
623
 
#endif // DRIZZLED_SQL_LIST_H
 
477
} /* namespace drizzled */
 
478
 
 
479
#endif /* DRIZZLED_SQL_LIST_H */