← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/my_bitmap.h

  • Committer: Brian Aker
  • Date: 2009-07-11 19:23:04 UTC
  • mfrom: (1089.1.14 merge)
  • Revision ID: brian@gaz-20090711192304-ootijyl5yf9jq9kd
Merge Brian

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysys/my_bitmap.h
 
1
/* Copyright (C) 2000 MySQL AB
 
2
 
 
3
   This program is free software; you can redistribute it and/or modify
 
4
   it under the terms of the GNU General Public License as published by
 
5
   the Free Software Foundation; version 2 of the License.
 
6
 
 
7
   This program is distributed in the hope that it will be useful,
 
8
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
9
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
10
   GNU General Public License for more details.
 
11
 
 
12
   You should have received a copy of the GNU General Public License
 
13
   along with this program; if not, write to the Free Software
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
15
 
 
16
#ifndef MYSYS_MY_BITMAP_H
 
17
#define MYSYS_MY_BITMAP_H
 
18
 
 
19
#include <pthread.h>
 
20
#include <string.h>
 
21
 
 
22
static const uint32_t MY_BIT_NONE= UINT32_MAX;
 
23
 
 
24
typedef uint32_t my_bitmap_map;
 
25
 
 
26
typedef struct st_bitmap
 
27
{
 
28
  my_bitmap_map *bitmap;
 
29
  uint32_t n_bits; /* number of bits occupied by the above */
 
30
  my_bitmap_map last_word_mask;
 
31
  my_bitmap_map *last_word_ptr;
 
32
  st_bitmap()
 
33
    : bitmap(NULL), n_bits(0), last_word_mask(0), last_word_ptr(NULL) {}
 
34
} MY_BITMAP;
 
35
 
 
36
void create_last_word_mask(MY_BITMAP *map);
 
37
bool bitmap_init(MY_BITMAP *map, my_bitmap_map *buf, uint32_t n_bits);
 
38
bool bitmap_is_clear_all(const MY_BITMAP *map);
 
39
bool bitmap_is_prefix(const MY_BITMAP *map, uint32_t prefix_size);
 
40
bool bitmap_is_set_all(const MY_BITMAP *map);
 
41
bool bitmap_is_subset(const MY_BITMAP *map1, const MY_BITMAP *map2);
 
42
bool bitmap_is_overlapping(const MY_BITMAP *map1,
 
43
                                     const MY_BITMAP *map2);
 
44
bool bitmap_test_and_set(MY_BITMAP *map, uint32_t bitmap_bit);
 
45
bool bitmap_test_and_clear(MY_BITMAP *map, uint32_t bitmap_bit);
 
46
uint32_t bitmap_set_next(MY_BITMAP *map);
 
47
uint32_t bitmap_get_first(const MY_BITMAP *map);
 
48
uint32_t bitmap_get_first_set(const MY_BITMAP *map);
 
49
uint32_t bitmap_bits_set(const MY_BITMAP *map);
 
50
void bitmap_free(MY_BITMAP *map);
 
51
void bitmap_set_above(MY_BITMAP *map, uint32_t from_byte, uint32_t use_bit);
 
52
void bitmap_set_prefix(MY_BITMAP *map, uint32_t prefix_size);
 
53
void bitmap_intersect(MY_BITMAP *map, const MY_BITMAP *map2);
 
54
void bitmap_subtract(MY_BITMAP *map, const MY_BITMAP *map2);
 
55
void bitmap_union(MY_BITMAP *map, const MY_BITMAP *map2);
 
56
void bitmap_xor(MY_BITMAP *map, const MY_BITMAP *map2);
 
57
void bitmap_invert(MY_BITMAP *map);
 
58
void bitmap_copy(MY_BITMAP *map, const MY_BITMAP *map2);
 
59
 
 
60
 
 
61
/* Fast, not thread safe, bitmap functions */
 
62
/* This one is a define because it gets used in an array decl */
 
63
#define bitmap_buffer_size(bits) ((bits+31)/32)*4
 
64
 
 
65
static inline uint32_t no_bytes_in_map(const MY_BITMAP *map)
 
66
{
 
67
  return ((map->n_bits + 7)/8);
 
68
}
 
69
 
 
70
static inline uint32_t no_words_in_map(const MY_BITMAP *map)
 
71
{
 
72
  return ((map->n_bits + 31)/32);
 
73
}
 
74
 
 
75
template <class T>
 
76
inline T bytes_word_aligned(T bytes)
 
77
{
 
78
  return (4*((bytes + 3)/4));
 
79
}
 
80
 
 
81
static inline void bitmap_set_bit(MY_BITMAP const *map, uint32_t bit)
 
82
{
 
83
  ((unsigned char *)map->bitmap)[bit / 8] |= (1 << ((bit) & 7));
 
84
}
 
85
 
 
86
static inline void bitmap_flip_bit(MY_BITMAP const *map, uint32_t bit)
 
87
{
 
88
  ((unsigned char *)map->bitmap)[bit / 8] ^= (1 << ((bit) & 7));
 
89
}
 
90
 
 
91
static inline void bitmap_clear_bit(MY_BITMAP const *map, uint32_t bit)
 
92
{
 
93
  ((unsigned char *)map->bitmap)[bit / 8] &= ~ (1 << ((bit) & 7));
 
94
}
 
95
 
 
96
static inline bool bitmap_is_set(const MY_BITMAP *map, uint32_t bit)
 
97
{
 
98
  return (bool)(((unsigned char *)map->bitmap)[bit / 8] &  (1 << ((bit) & 7)));
 
99
}
 
100
 
 
101
static inline bool bitmap_cmp(const MY_BITMAP *map1, const MY_BITMAP *map2)
 
102
{
 
103
  *(map1)->last_word_ptr|= (map1)->last_word_mask;
 
104
  *(map2)->last_word_ptr|= (map2)->last_word_mask;
 
105
  return memcmp((map1)->bitmap, (map2)->bitmap, 4*no_words_in_map((map1)))==0;
 
106
}
 
107
 
 
108
static inline void bitmap_clear_all(MY_BITMAP const *map)
 
109
{
 
110
   memset(map->bitmap, 0, 4*no_words_in_map(map));
 
111
}
 
112
 
 
113
static inline void bitmap_set_all(MY_BITMAP const *map)
 
114
{
 
115
   memset(map->bitmap, 0xFF, 4*no_words_in_map(map));
 
116
}
 
117
 
 
118
#endif /* MYSYS_MY_BITMAP_H */