← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_bitmap.h

  • Committer: Jay Pipes
  • Date: 2009-05-31 21:21:44 UTC
  • mto: This revision was merged to the branch mainline in revision 1046.
  • Revision ID: jpipes@serialcoder-20090531212144-dn18058mx55azhms
Yet more indentation and style cleanup

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_bitmap.h
26
26
  also be able to use 32 or 64 bits bitmaps very efficiently
27
27
*/
28
28
 
29
 
/// TODO: OMG FIX THIS
30
 
 
31
29
#include <mysys/my_bitmap.h>
 
30
#include <drizzled/definitions.h>
32
31
#include <drizzled/util/test.h>
33
 
 
34
 
template <uint32_t default_width> class Bitmap
35
 
{
36
 
  MY_BITMAP map;
37
 
  uint32_t buffer[(default_width+31)/32];
38
 
public:
39
 
  Bitmap() : map() { init(); }
40
 
  Bitmap(const Bitmap& from) : map() { *this=from; }
41
 
  explicit Bitmap(uint32_t prefix_to_set) : map(0) { init(prefix_to_set); }
42
 
  void init() { bitmap_init(&map, buffer, default_width, 0); }
43
 
  void init(uint32_t prefix_to_set) { init(); set_prefix(prefix_to_set); }
44
 
  uint32_t length() const { return default_width; }
45
 
  Bitmap& operator=(const Bitmap& map2)
46
 
  {
47
 
    init();
48
 
    memcpy(buffer, map2.buffer, sizeof(buffer));
49
 
    return *this;
50
 
  }
51
 
  void set_bit(uint32_t n) { bitmap_set_bit(&map, n); }
52
 
  void clear_bit(uint32_t n) { bitmap_clear_bit(&map, n); }
53
 
  void set_prefix(uint32_t n) { bitmap_set_prefix(&map, n); }
54
 
  void set_all() { bitmap_set_all(&map); }
55
 
  void clear_all() { bitmap_clear_all(&map); }
56
 
  void intersect(Bitmap& map2) { bitmap_intersect(&map, &map2.map); }
57
 
  void intersect(uint64_t map2buff)
58
 
  {
59
 
    MY_BITMAP map2;
60
 
    bitmap_init(&map2, (uint32_t *)&map2buff, sizeof(uint64_t)*8, 0);
61
 
    bitmap_intersect(&map, &map2);
62
 
  }
63
 
  /* Use highest bit for all bits above sizeof(uint64_t)*8. */
64
 
  void intersect_extended(uint64_t map2buff)
65
 
  {
66
 
    intersect(map2buff);
67
 
    if (map.n_bits > sizeof(uint64_t) * 8)
68
 
      bitmap_set_above(&map, sizeof(uint64_t),
69
 
                       test(map2buff & (1 << (sizeof(uint64_t) * 8 - 1))));
70
 
  }
71
 
  void subtract(Bitmap& map2) { bitmap_subtract(&map, &map2.map); }
72
 
  void merge(Bitmap& map2) { bitmap_union(&map, &map2.map); }
73
 
  bool is_set(uint32_t n) const { return bitmap_is_set(&map, n); }
74
 
  bool is_set() const { return !bitmap_is_clear_all(&map); }
75
 
  bool is_prefix(uint32_t n) const { return bitmap_is_prefix(&map, n); }
76
 
  bool is_clear_all() const { return bitmap_is_clear_all(&map); }
77
 
  bool is_set_all() const { return bitmap_is_set_all(&map); }
78
 
  bool is_subset(const Bitmap& map2) const { return bitmap_is_subset(&map, &map2.map); }
79
 
  bool is_overlapping(const Bitmap& map2) const { return bitmap_is_overlapping(&map, &map2.map); }
80
 
  bool operator==(const Bitmap& map2) const { return bitmap_cmp(&map, &map2.map); }
81
 
  bool operator!=(const Bitmap& map2) const { return !bitmap_cmp(&map, &map2.map); }
82
 
  Bitmap operator&=(uint32_t n)
83
 
  {
84
 
    if (bitmap_is_set(&map, n))
85
 
    {
86
 
      bitmap_clear_all(&map);
87
 
      bitmap_set_bit(&map, n);
88
 
    }
89
 
    else
90
 
      bitmap_clear_all(&map);
91
 
    return *this;
92
 
  }
93
 
  Bitmap operator&=(const Bitmap& map2)
94
 
  {
95
 
    bitmap_intersect(&map, &map2.map);
96
 
    return *this;
97
 
  }
98
 
  Bitmap operator&(uint32_t n)
99
 
  {
100
 
    Bitmap bm(*this);
101
 
    bm&= n;
102
 
    return bm;
103
 
  }
104
 
  Bitmap operator&(const Bitmap& map2)
105
 
  {
106
 
    Bitmap bm(*this);
107
 
    bm&= map2;
108
 
    return bm;
109
 
  }
110
 
  Bitmap operator|=(uint32_t n)
111
 
  {
112
 
    bitmap_set_bit(&map, n);
113
 
    return *this;
114
 
  }
115
 
  Bitmap operator|=(const Bitmap& map2)
116
 
  {
117
 
    bitmap_union(&map, &map2.map);
118
 
  }
119
 
  Bitmap operator|(uint32_t n)
120
 
  {
121
 
    Bitmap bm(*this);
122
 
    bm|= n;
123
 
    return bm;
124
 
  }
125
 
  Bitmap operator|(const Bitmap& map2)
126
 
  {
127
 
    Bitmap bm(*this);
128
 
    bm|= map2;
129
 
    return bm;
130
 
  }
131
 
  Bitmap operator~()
132
 
  {
133
 
    Bitmap bm(*this);
134
 
    bitmap_invert(&bm.map);
135
 
    return bm;
136
 
  }
137
 
  char *print(char *buf) const
138
 
  {
139
 
    char *s=buf;
140
 
    const unsigned char *e=(unsigned char *)buffer, *b=e+sizeof(buffer)-1;
141
 
    while (!*b && b>e)
142
 
      b--;
143
 
    if ((*s=_dig_vec_upper[*b >> 4]) != '0')
144
 
        s++;
145
 
    *s++=_dig_vec_upper[*b & 15];
146
 
    while (--b>=e)
147
 
    {
148
 
      *s++=_dig_vec_upper[*b >> 4];
149
 
      *s++=_dig_vec_upper[*b & 15];
150
 
    }
151
 
    *s=0;
152
 
    return buf;
153
 
  }
154
 
  uint64_t to_uint64_t() const
155
 
  {
156
 
    if (sizeof(buffer) >= 8)
157
 
      return uint8korr(buffer);
158
 
    assert(sizeof(buffer) >= 4);
159
 
    return (uint64_t) uint4korr(buffer);
160
 
  }
161
 
};
162
 
 
163
 
template <> class Bitmap<64>
164
 
{
165
 
  uint64_t map;
166
 
public:
167
 
  Bitmap<64>() : map(0) { }
168
 
  explicit Bitmap<64>(uint32_t prefix_to_set) : map(0) { set_prefix(prefix_to_set); }
169
 
  void init() { }
170
 
  void init(uint32_t prefix_to_set) { set_prefix(prefix_to_set); }
171
 
  uint32_t length() const { return 64; }
172
 
  void set_bit(uint32_t n) { map|= ((uint64_t)1) << n; }
173
 
  void clear_bit(uint32_t n) { map&= ~(((uint64_t)1) << n); }
174
 
  void set_prefix(uint32_t n)
175
 
  {
176
 
    if (n >= length())
177
 
      set_all();
178
 
    else
179
 
      map= (((uint64_t)1) << n)-1;
180
 
  }
181
 
  void set_all() { map=~(uint64_t)0; }
182
 
  void clear_all() { map=(uint64_t)0; }
183
 
  void intersect(Bitmap<64>& map2) { map&= map2.map; }
184
 
  void intersect(uint64_t map2) { map&= map2; }
185
 
  void intersect_extended(uint64_t map2) { map&= map2; }
186
 
  void subtract(Bitmap<64>& map2) { map&= ~map2.map; }
187
 
  void merge(Bitmap<64>& map2) { map|= map2.map; }
188
 
  bool is_set(uint32_t n) const { return test(map & (((uint64_t)1) << n)); }
189
 
  bool is_prefix(uint32_t n) const { return map == (((uint64_t)1) << n)-1; }
190
 
  bool is_clear_all() const { return map == (uint64_t)0; }
191
 
  bool is_set_all() const { return map == ~(uint64_t)0; }
192
 
  bool is_subset(const Bitmap<64>& map2) const { return !(map & ~map2.map); }
193
 
  bool is_overlapping(const Bitmap<64>& map2) const { return (map & map2.map)!= 0; }
194
 
  bool operator==(const Bitmap<64>& map2) const { return map == map2.map; }
195
 
  char *print(char *buf) const { int64_t2str(map,buf,16); return buf; }
196
 
  uint64_t to_uint64_t() const { return map; }
197
 
};
 
32
#include <drizzled/key_map.h>
198
33
 
199
34
 
200
35
typedef uint64_t table_map;          /* Used for table bits in join */
201
 
#if MAX_INDEXES <= 64
202
 
typedef Bitmap<64>  key_map;          /* Used for finding keys */
203
 
#else
204
 
typedef Bitmap<((MAX_INDEXES+7)/8*8)> key_map; /* Used for finding keys */
205
 
#endif
206
36
typedef uint32_t nesting_map;  /* Used for flags of nesting constructs */
207
37
 
208
38
/*
212
42
*/
213
43
typedef uint64_t nested_join_map; /* Needed by sql_select.h and table.h */
214
44
 
215
 
/* useful constants */#
216
 
extern const key_map key_map_empty;
217
 
extern key_map key_map_full;          /* Should be threaded as const */
218
 
extern const char *primary_key_name;
219
 
 
220
45
#endif /* _SQL_BITMAP_H_ */