← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to include/my_bitmap.h

  • Committer: Stewart Smith
  • Date: 2008-07-13 06:56:15 UTC
  • mto: (210.1.1 drizzle)
  • mto: This revision was merged to the branch mainline in revision 211.
  • Revision ID: stewart@flamingspork.com-20080713065615-vzok75kgnnviokl9
Move MD5() into a UDF

Show diffs side-by-side

added added

removed removed

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