← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/my_bitmap.h

Merge of Monty

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
  /*
 
33
     mutex will be acquired for the duration of each bitmap operation if
 
34
     thread_safe flag in bitmap_init was set.  Otherwise, we optimize by not
 
35
     acquiring the mutex
 
36
   */
 
37
  pthread_mutex_t *mutex;
 
38
} MY_BITMAP;
 
39
 
 
40
void create_last_word_mask(MY_BITMAP *map);
 
41
bool bitmap_init(MY_BITMAP *map, my_bitmap_map *buf, uint32_t n_bits,
 
42
                           bool thread_safe);
 
43
bool bitmap_is_clear_all(const MY_BITMAP *map);
 
44
bool bitmap_is_prefix(const MY_BITMAP *map, uint32_t prefix_size);
 
45
bool bitmap_is_set_all(const MY_BITMAP *map);
 
46
bool bitmap_is_subset(const MY_BITMAP *map1, const MY_BITMAP *map2);
 
47
bool bitmap_is_overlapping(const MY_BITMAP *map1,
 
48
                                     const MY_BITMAP *map2);
 
49
bool bitmap_test_and_set(MY_BITMAP *map, uint32_t bitmap_bit);
 
50
bool bitmap_test_and_clear(MY_BITMAP *map, uint32_t bitmap_bit);
 
51
bool bitmap_fast_test_and_clear(MY_BITMAP *map, uint32_t bitmap_bit);
 
52
bool bitmap_fast_test_and_set(MY_BITMAP *map, uint32_t bitmap_bit);
 
53
uint32_t bitmap_set_next(MY_BITMAP *map);
 
54
uint32_t bitmap_get_first(const MY_BITMAP *map);
 
55
uint32_t bitmap_get_first_set(const MY_BITMAP *map);
 
56
uint32_t bitmap_bits_set(const MY_BITMAP *map);
 
57
void bitmap_free(MY_BITMAP *map);
 
58
void bitmap_set_above(MY_BITMAP *map, uint32_t from_byte, uint32_t use_bit);
 
59
void bitmap_set_prefix(MY_BITMAP *map, uint32_t prefix_size);
 
60
void bitmap_intersect(MY_BITMAP *map, const MY_BITMAP *map2);
 
61
void bitmap_subtract(MY_BITMAP *map, const MY_BITMAP *map2);
 
62
void bitmap_union(MY_BITMAP *map, const MY_BITMAP *map2);
 
63
void bitmap_xor(MY_BITMAP *map, const MY_BITMAP *map2);
 
64
void bitmap_invert(MY_BITMAP *map);
 
65
void bitmap_copy(MY_BITMAP *map, const MY_BITMAP *map2);
 
66
 
 
67
uint32_t bitmap_lock_set_next(MY_BITMAP *map);
 
68
void bitmap_lock_clear_bit(MY_BITMAP *map, uint32_t bitmap_bit);
 
69
 
 
70
/* Fast, not thread safe, bitmap functions */
 
71
/* This one is a define because it gets used in an array decl */
 
72
#define bitmap_buffer_size(bits) ((bits+31)/32)*4
 
73
 
 
74
static inline uint32_t no_bytes_in_map(const MY_BITMAP *map)
 
75
{
 
76
  return ((map->n_bits + 7)/8);
 
77
}
 
78
 
 
79
static inline uint32_t no_words_in_map(const MY_BITMAP *map)
 
80
{
 
81
  return ((map->n_bits + 31)/32);
 
82
}
 
83
 
 
84
template <class T>
 
85
inline T bytes_word_aligned(T bytes)
 
86
{
 
87
  return (4*((bytes + 3)/4));
 
88
}
 
89
 
 
90
static inline void bitmap_set_bit(MY_BITMAP const *map, uint32_t bit)
 
91
{
 
92
  ((unsigned char *)map->bitmap)[bit / 8] |= (1 << ((bit) & 7));
 
93
}
 
94
 
 
95
static inline void bitmap_flip_bit(MY_BITMAP const *map, uint32_t bit)
 
96
{
 
97
  ((unsigned char *)map->bitmap)[bit / 8] ^= (1 << ((bit) & 7));
 
98
}
 
99
 
 
100
static inline void bitmap_clear_bit(MY_BITMAP const *map, uint32_t bit)
 
101
{
 
102
  ((unsigned char *)map->bitmap)[bit / 8] &= ~ (1 << ((bit) & 7));
 
103
}
 
104
 
 
105
static inline bool bitmap_is_set(const MY_BITMAP *map, uint32_t bit)
 
106
{
 
107
  return (bool)(((unsigned char *)map->bitmap)[bit / 8] &  (1 << ((bit) & 7)));
 
108
}
 
109
 
 
110
static inline bool bitmap_cmp(const MY_BITMAP *map1, const MY_BITMAP *map2)
 
111
{
 
112
  *(map1)->last_word_ptr|= (map1)->last_word_mask;
 
113
  *(map2)->last_word_ptr|= (map2)->last_word_mask;
 
114
  return memcmp((map1)->bitmap, (map2)->bitmap, 4*no_words_in_map((map1)))==0;
 
115
}
 
116
 
 
117
static inline void bitmap_clear_all(MY_BITMAP const *map)
 
118
{
 
119
   memset(map->bitmap, 0, 4*no_words_in_map(map));
 
120
}
 
121
 
 
122
static inline void bitmap_set_all(MY_BITMAP const *map)
 
123
{
 
124
   memset(map->bitmap, 0xFF, 4*no_words_in_map(map));
 
125
}
 
126
 
 
127
#endif /* MYSYS_MY_BITMAP_H */