← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/my_bitmap.h

  • Committer: Monty Taylor
  • Date: 2008-11-16 23:47:43 UTC
  • mto: (584.1.10 devel)
  • mto: This revision was merged to the branch mainline in revision 589.
  • Revision ID: monty@inaugust.com-20081116234743-c38gmv0pa2kdefaj
Broke out cached_item.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysys/my_bitmap.h
18
18
 
19
19
#define MY_BIT_NONE (~(uint) 0)
20
20
 
21
 
#include <m_string.h>
 
21
#include <mystrings/m_string.h>
22
22
 
23
 
typedef uint32 my_bitmap_map;
 
23
typedef uint32_t my_bitmap_map;
24
24
 
25
25
typedef struct st_bitmap
26
26
{
27
27
  my_bitmap_map *bitmap;
28
 
  uint n_bits; /* number of bits occupied by the above */
 
28
  uint32_t n_bits; /* number of bits occupied by the above */
29
29
  my_bitmap_map last_word_mask;
30
30
  my_bitmap_map *last_word_ptr;
31
31
  /*
33
33
     thread_safe flag in bitmap_init was set.  Otherwise, we optimize by not
34
34
     acquiring the mutex
35
35
   */
36
 
#ifdef THREAD
37
36
  pthread_mutex_t *mutex;
38
 
#endif
39
37
} MY_BITMAP;
40
38
 
41
39
#ifdef  __cplusplus
42
40
extern "C" {
43
41
#endif
44
42
extern void create_last_word_mask(MY_BITMAP *map);
45
 
extern my_bool bitmap_init(MY_BITMAP *map, my_bitmap_map *buf, uint n_bits,
46
 
                           my_bool thread_safe);
47
 
extern my_bool bitmap_is_clear_all(const MY_BITMAP *map);
48
 
extern my_bool bitmap_is_prefix(const MY_BITMAP *map, uint prefix_size);
49
 
extern my_bool bitmap_is_set_all(const MY_BITMAP *map);
50
 
extern my_bool bitmap_is_subset(const MY_BITMAP *map1, const MY_BITMAP *map2);
51
 
extern my_bool bitmap_is_overlapping(const MY_BITMAP *map1,
 
43
extern bool bitmap_init(MY_BITMAP *map, my_bitmap_map *buf, uint32_t n_bits,
 
44
                           bool thread_safe);
 
45
extern bool bitmap_is_clear_all(const MY_BITMAP *map);
 
46
extern bool bitmap_is_prefix(const MY_BITMAP *map, uint32_t prefix_size);
 
47
extern bool bitmap_is_set_all(const MY_BITMAP *map);
 
48
extern bool bitmap_is_subset(const MY_BITMAP *map1, const MY_BITMAP *map2);
 
49
extern bool bitmap_is_overlapping(const MY_BITMAP *map1,
52
50
                                     const MY_BITMAP *map2);
53
 
extern my_bool bitmap_test_and_set(MY_BITMAP *map, uint bitmap_bit);
54
 
extern my_bool bitmap_test_and_clear(MY_BITMAP *map, uint bitmap_bit);
55
 
extern my_bool bitmap_fast_test_and_set(MY_BITMAP *map, uint bitmap_bit);
56
 
extern uint bitmap_set_next(MY_BITMAP *map);
57
 
extern uint bitmap_get_first(const MY_BITMAP *map);
58
 
extern uint bitmap_get_first_set(const MY_BITMAP *map);
59
 
extern uint bitmap_bits_set(const MY_BITMAP *map);
 
51
extern bool bitmap_test_and_set(MY_BITMAP *map, uint32_t bitmap_bit);
 
52
extern bool bitmap_test_and_clear(MY_BITMAP *map, uint32_t bitmap_bit);
 
53
extern bool bitmap_fast_test_and_clear(MY_BITMAP *map, uint32_t bitmap_bit);
 
54
extern bool bitmap_fast_test_and_set(MY_BITMAP *map, uint32_t bitmap_bit);
 
55
extern uint32_t bitmap_set_next(MY_BITMAP *map);
 
56
extern uint32_t bitmap_get_first(const MY_BITMAP *map);
 
57
extern uint32_t bitmap_get_first_set(const MY_BITMAP *map);
 
58
extern uint32_t bitmap_bits_set(const MY_BITMAP *map);
60
59
extern void bitmap_free(MY_BITMAP *map);
61
 
extern void bitmap_set_above(MY_BITMAP *map, uint from_byte, uint use_bit);
62
 
extern void bitmap_set_prefix(MY_BITMAP *map, uint prefix_size);
 
60
extern void bitmap_set_above(MY_BITMAP *map, uint32_t from_byte, uint32_t use_bit);
 
61
extern void bitmap_set_prefix(MY_BITMAP *map, uint32_t prefix_size);
63
62
extern void bitmap_intersect(MY_BITMAP *map, const MY_BITMAP *map2);
64
63
extern void bitmap_subtract(MY_BITMAP *map, const MY_BITMAP *map2);
65
64
extern void bitmap_union(MY_BITMAP *map, const MY_BITMAP *map2);
67
66
extern void bitmap_invert(MY_BITMAP *map);
68
67
extern void bitmap_copy(MY_BITMAP *map, const MY_BITMAP *map2);
69
68
 
70
 
extern uint bitmap_lock_set_next(MY_BITMAP *map);
71
 
extern void bitmap_lock_clear_bit(MY_BITMAP *map, uint bitmap_bit);
 
69
extern uint32_t bitmap_lock_set_next(MY_BITMAP *map);
 
70
extern void bitmap_lock_clear_bit(MY_BITMAP *map, uint32_t bitmap_bit);
72
71
#ifdef NOT_USED
73
 
extern uint bitmap_lock_bits_set(const MY_BITMAP *map);
74
 
extern my_bool bitmap_lock_is_set_all(const MY_BITMAP *map);
75
 
extern uint bitmap_lock_get_first(const MY_BITMAP *map);
76
 
extern uint bitmap_lock_get_first_set(const MY_BITMAP *map);
77
 
extern my_bool bitmap_lock_is_subset(const MY_BITMAP *map1,
 
72
extern uint32_t bitmap_lock_bits_set(const MY_BITMAP *map);
 
73
extern bool bitmap_lock_is_set_all(const MY_BITMAP *map);
 
74
extern uint32_t bitmap_lock_get_first(const MY_BITMAP *map);
 
75
extern uint32_t bitmap_lock_get_first_set(const MY_BITMAP *map);
 
76
extern bool bitmap_lock_is_subset(const MY_BITMAP *map1,
78
77
                                     const MY_BITMAP *map2);
79
 
extern my_bool bitmap_lock_is_prefix(const MY_BITMAP *map, uint prefix_size);
80
 
extern my_bool bitmap_lock_is_set(const MY_BITMAP *map, uint bitmap_bit);
81
 
extern my_bool bitmap_lock_is_clear_all(const MY_BITMAP *map);
82
 
extern my_bool bitmap_lock_cmp(const MY_BITMAP *map1, const MY_BITMAP *map2);
 
78
extern bool bitmap_lock_is_prefix(const MY_BITMAP *map, uint32_t prefix_size);
 
79
extern bool bitmap_lock_is_set(const MY_BITMAP *map, uint32_t bitmap_bit);
 
80
extern bool bitmap_lock_is_clear_all(const MY_BITMAP *map);
 
81
extern bool bitmap_lock_cmp(const MY_BITMAP *map1, const MY_BITMAP *map2);
83
82
extern void bitmap_lock_set_all(MY_BITMAP *map);
84
83
extern void bitmap_lock_clear_all(MY_BITMAP *map);
85
 
extern void bitmap_lock_set_bit(MY_BITMAP *map, uint bitmap_bit);
86
 
extern void bitmap_lock_flip_bit(MY_BITMAP *map, uint bitmap_bit);
87
 
extern void bitmap_lock_set_prefix(MY_BITMAP *map, uint prefix_size);
 
84
extern void bitmap_lock_set_bit(MY_BITMAP *map, uint32_t bitmap_bit);
 
85
extern void bitmap_lock_flip_bit(MY_BITMAP *map, uint32_t bitmap_bit);
 
86
extern void bitmap_lock_set_prefix(MY_BITMAP *map, uint32_t prefix_size);
88
87
extern void bitmap_lock_intersect(MY_BITMAP *map, const MY_BITMAP *map2);
89
88
extern void bitmap_lock_subtract(MY_BITMAP *map, const MY_BITMAP *map2);
90
89
extern void bitmap_lock_union(MY_BITMAP *map, const MY_BITMAP *map2);
96
95
#define no_bytes_in_map(map) (((map)->n_bits + 7)/8)
97
96
#define no_words_in_map(map) (((map)->n_bits + 31)/32)
98
97
#define bytes_word_aligned(bytes) (4*((bytes + 3)/4))
99
 
#define _bitmap_set_bit(MAP, BIT) (((uchar*)(MAP)->bitmap)[(BIT) / 8] \
 
98
#define _bitmap_set_bit(MAP, BIT) (((unsigned char*)(MAP)->bitmap)[(BIT) / 8] \
100
99
                                  |= (1 << ((BIT) & 7)))
101
 
#define _bitmap_flip_bit(MAP, BIT) (((uchar*)(MAP)->bitmap)[(BIT) / 8] \
 
100
#define _bitmap_flip_bit(MAP, BIT) (((unsigned char*)(MAP)->bitmap)[(BIT) / 8] \
102
101
                                  ^= (1 << ((BIT) & 7)))
103
 
#define _bitmap_clear_bit(MAP, BIT) (((uchar*)(MAP)->bitmap)[(BIT) / 8] \
 
102
#define _bitmap_clear_bit(MAP, BIT) (((unsigned char*)(MAP)->bitmap)[(BIT) / 8] \
104
103
                                  &= ~ (1 << ((BIT) & 7)))
105
 
#define _bitmap_is_set(MAP, BIT) (uint) (((uchar*)(MAP)->bitmap)[(BIT) / 8] \
 
104
#define _bitmap_is_set(MAP, BIT) (uint) (((unsigned char*)(MAP)->bitmap)[(BIT) / 8] \
106
105
                                         & (1 << ((BIT) & 7)))
107
106
/*
108
 
  WARNING!
109
 
 
110
 
  The below symbols are inline functions in DEBUG builds and macros in
111
 
  non-DEBUG builds. The latter evaluate their 'bit' argument twice.
112
 
 
113
107
  NEVER use an increment/decrement operator with the 'bit' argument.
114
 
  It would work with DEBUG builds, but fails later in production builds!
115
108
 
116
109
  FORBIDDEN: bitmap_set_bit($my_bitmap, (field++)->field_index);
117
110
*/
118
 
#ifndef DBUG_OFF
119
 
static inline void
120
 
bitmap_set_bit(MY_BITMAP *map,uint bit)
121
 
{
122
 
  DBUG_ASSERT(bit < (map)->n_bits);
123
 
  _bitmap_set_bit(map,bit);
124
 
}
125
 
static inline void
126
 
bitmap_flip_bit(MY_BITMAP *map,uint bit)
127
 
{
128
 
  DBUG_ASSERT(bit < (map)->n_bits);
129
 
  _bitmap_flip_bit(map,bit);
130
 
}
131
 
static inline void
132
 
bitmap_clear_bit(MY_BITMAP *map,uint bit)
133
 
{
134
 
  DBUG_ASSERT(bit < (map)->n_bits);
135
 
  _bitmap_clear_bit(map,bit);
136
 
}
137
 
static inline uint
138
 
bitmap_is_set(const MY_BITMAP *map,uint bit)
139
 
{
140
 
  DBUG_ASSERT(bit < (map)->n_bits);
141
 
  return _bitmap_is_set(map,bit);
142
 
}
143
 
#else
144
111
#define bitmap_set_bit(MAP, BIT) _bitmap_set_bit(MAP, BIT)
145
112
#define bitmap_flip_bit(MAP, BIT) _bitmap_flip_bit(MAP, BIT)
146
113
#define bitmap_clear_bit(MAP, BIT) _bitmap_clear_bit(MAP, BIT)
147
114
#define bitmap_is_set(MAP, BIT) _bitmap_is_set(MAP, BIT)
148
 
#endif
149
115
 
150
 
static inline my_bool bitmap_cmp(const MY_BITMAP *map1, const MY_BITMAP *map2)
 
116
static inline bool bitmap_cmp(const MY_BITMAP *map1, const MY_BITMAP *map2)
151
117
{
152
118
  *(map1)->last_word_ptr|= (map1)->last_word_mask;
153
119
  *(map2)->last_word_ptr|= (map2)->last_word_mask;
169
135
*/
170
136
 
171
137
#define bit_is_set(I,B)   (sizeof(I) * CHAR_BIT > (B) ?                 \
172
 
                           (((I) & (ULL(1) << (B))) == 0 ? 0 : 1) : -1)
 
138
                           (((I) & (1UL << (B))) == 0 ? 0 : 1) : -1)
173
139
#define bit_do_set(I,B)   (sizeof(I) * CHAR_BIT > (B) ?         \
174
 
                           ((I) |= (ULL(1) << (B)), 1) : -1)
 
140
                           ((I) |= (1UL << (B)), 1) : -1)
175
141
#define bit_do_clear(I,B) (sizeof(I) * CHAR_BIT > (B) ?         \
176
 
                           ((I) &= ~(ULL(1) << (B)), 0) : -1)
 
142
                           ((I) &= ~(1UL << (B)), 0) : -1)
177
143
 
178
144
#ifdef  __cplusplus
179
145
}