← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to server/sql_bitmap.h

  • Committer: Brian Aker
  • Date: 2008-07-13 22:21:51 UTC
  • Revision ID: brian@tangent.org-20080713222151-fv2tcpbsc829j2oc
Ulonglong to uint64_t

Show diffs side-by-side

added added

removed removed

Lines of Context:
server/sql_bitmap.h
46
46
  void set_all() { bitmap_set_all(&map); }
47
47
  void clear_all() { bitmap_clear_all(&map); }
48
48
  void intersect(Bitmap& map2) { bitmap_intersect(&map, &map2.map); }
49
 
  void intersect(ulonglong map2buff)
 
49
  void intersect(uint64_t map2buff)
50
50
  {
51
51
    MY_BITMAP map2;
52
 
    bitmap_init(&map2, (uint32 *)&map2buff, sizeof(ulonglong)*8, 0);
 
52
    bitmap_init(&map2, (uint32 *)&map2buff, sizeof(uint64_t)*8, 0);
53
53
    bitmap_intersect(&map, &map2);
54
54
  }
55
 
  /* Use highest bit for all bits above sizeof(ulonglong)*8. */
56
 
  void intersect_extended(ulonglong map2buff)
 
55
  /* Use highest bit for all bits above sizeof(uint64_t)*8. */
 
56
  void intersect_extended(uint64_t map2buff)
57
57
  {
58
58
    intersect(map2buff);
59
59
    if (map.n_bits > sizeof(uint64_t) * 8)
143
143
    *s=0;
144
144
    return buf;
145
145
  }
146
 
  ulonglong to_ulonglong() const
 
146
  uint64_t to_uint64_t() const
147
147
  {
148
148
    if (sizeof(buffer) >= 8)
149
149
      return uint8korr(buffer);
150
150
    assert(sizeof(buffer) >= 4);
151
 
    return (ulonglong) uint4korr(buffer);
 
151
    return (uint64_t) uint4korr(buffer);
152
152
  }
153
153
};
154
154
 
155
155
template <> class Bitmap<64>
156
156
{
157
 
  ulonglong map;
 
157
  uint64_t map;
158
158
public:
159
159
  Bitmap<64>() { map= 0; }
160
160
  explicit Bitmap<64>(uint prefix_to_set) { set_prefix(prefix_to_set); }
161
161
  void init() { }
162
162
  void init(uint prefix_to_set) { set_prefix(prefix_to_set); }
163
163
  uint length() const { return 64; }
164
 
  void set_bit(uint n) { map|= ((ulonglong)1) << n; }
165
 
  void clear_bit(uint n) { map&= ~(((ulonglong)1) << n); }
 
164
  void set_bit(uint n) { map|= ((uint64_t)1) << n; }
 
165
  void clear_bit(uint n) { map&= ~(((uint64_t)1) << n); }
166
166
  void set_prefix(uint n)
167
167
  {
168
168
    if (n >= length())
169
169
      set_all();
170
170
    else
171
 
      map= (((ulonglong)1) << n)-1;
 
171
      map= (((uint64_t)1) << n)-1;
172
172
  }
173
 
  void set_all() { map=~(ulonglong)0; }
174
 
  void clear_all() { map=(ulonglong)0; }
 
173
  void set_all() { map=~(uint64_t)0; }
 
174
  void clear_all() { map=(uint64_t)0; }
175
175
  void intersect(Bitmap<64>& map2) { map&= map2.map; }
176
 
  void intersect(ulonglong map2) { map&= map2; }
177
 
  void intersect_extended(ulonglong map2) { map&= map2; }
 
176
  void intersect(uint64_t map2) { map&= map2; }
 
177
  void intersect_extended(uint64_t map2) { map&= map2; }
178
178
  void subtract(Bitmap<64>& map2) { map&= ~map2.map; }
179
179
  void merge(Bitmap<64>& map2) { map|= map2.map; }
180
 
  my_bool is_set(uint n) const { return test(map & (((ulonglong)1) << n)); }
181
 
  my_bool is_prefix(uint n) const { return map == (((ulonglong)1) << n)-1; }
182
 
  my_bool is_clear_all() const { return map == (ulonglong)0; }
183
 
  my_bool is_set_all() const { return map == ~(ulonglong)0; }
 
180
  my_bool is_set(uint n) const { return test(map & (((uint64_t)1) << n)); }
 
181
  my_bool is_prefix(uint n) const { return map == (((uint64_t)1) << n)-1; }
 
182
  my_bool is_clear_all() const { return map == (uint64_t)0; }
 
183
  my_bool is_set_all() const { return map == ~(uint64_t)0; }
184
184
  my_bool is_subset(const Bitmap<64>& map2) const { return !(map & ~map2.map); }
185
185
  my_bool is_overlapping(const Bitmap<64>& map2) const { return (map & map2.map)!= 0; }
186
186
  my_bool operator==(const Bitmap<64>& map2) const { return map == map2.map; }
187
187
  char *print(char *buf) const { longlong2str(map,buf,16); return buf; }
188
 
  ulonglong to_ulonglong() const { return map; }
 
188
  uint64_t to_uint64_t() const { return map; }
189
189
};
190
190
 
191
191
 
192
192
/* An iterator to quickly walk over bits in unlonglong bitmap. */
193
193
class Table_map_iterator
194
194
{
195
 
  ulonglong bmp;
 
195
  uint64_t bmp;
196
196
  uint no;
197
197
public:
198
 
  Table_map_iterator(ulonglong t) : bmp(t), no(0) {}
 
198
  Table_map_iterator(uint64_t t) : bmp(t), no(0) {}
199
199
  int next_bit()
200
200
  {
201
201
    static const char last_bit[16]= {32, 0, 1, 0,