← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/my_bitmap.c

  • Committer: Brian Aker
  • Date: 2008-07-13 18:27:33 UTC
  • Revision ID: brian@tangent.org-20080713182733-3u1et5nrmofi8a8n
my_bool cleanup.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysys/my_bitmap.c
96
96
}
97
97
 
98
98
 
99
 
my_bool bitmap_init(MY_BITMAP *map, my_bitmap_map *buf, uint n_bits,
100
 
                    my_bool thread_safe __attribute__((unused)))
 
99
bool bitmap_init(MY_BITMAP *map, my_bitmap_map *buf, uint n_bits,
 
100
                    bool thread_safe __attribute__((unused)))
101
101
{
102
102
  DBUG_ENTER("bitmap_init");
103
103
  if (!buf)
158
158
    !=0  bit was set
159
159
*/
160
160
 
161
 
my_bool bitmap_fast_test_and_set(MY_BITMAP *map, uint bitmap_bit)
 
161
bool bitmap_fast_test_and_set(MY_BITMAP *map, uint bitmap_bit)
162
162
{
163
163
  uchar *value= ((uchar*) map->bitmap) + (bitmap_bit / 8);
164
164
  uchar bit= 1 << ((bitmap_bit) & 7);
181
181
    !=0  bit was set
182
182
*/
183
183
 
184
 
my_bool bitmap_test_and_set(MY_BITMAP *map, uint bitmap_bit)
 
184
bool bitmap_test_and_set(MY_BITMAP *map, uint bitmap_bit)
185
185
{
186
 
  my_bool res;
 
186
  bool res;
187
187
  DBUG_ASSERT(map->bitmap && bitmap_bit < map->n_bits);
188
188
  bitmap_lock(map);
189
189
  res= bitmap_fast_test_and_set(map, bitmap_bit);
204
204
    !=0  bit was set
205
205
*/
206
206
 
207
 
my_bool bitmap_fast_test_and_clear(MY_BITMAP *map, uint bitmap_bit)
 
207
bool bitmap_fast_test_and_clear(MY_BITMAP *map, uint bitmap_bit)
208
208
{
209
209
  uchar *byte= (uchar*) map->bitmap + (bitmap_bit / 8);
210
210
  uchar bit= 1 << ((bitmap_bit) & 7);
214
214
}
215
215
 
216
216
 
217
 
my_bool bitmap_test_and_clear(MY_BITMAP *map, uint bitmap_bit)
 
217
bool bitmap_test_and_clear(MY_BITMAP *map, uint bitmap_bit)
218
218
{
219
 
  my_bool res;
 
219
  bool res;
220
220
  DBUG_ASSERT(map->bitmap && bitmap_bit < map->n_bits);
221
221
  bitmap_lock(map);
222
222
  res= bitmap_fast_test_and_clear(map, bitmap_bit);
253
253
}
254
254
 
255
255
 
256
 
my_bool bitmap_is_prefix(const MY_BITMAP *map, uint prefix_size)
 
256
bool bitmap_is_prefix(const MY_BITMAP *map, uint prefix_size)
257
257
{
258
258
  uint prefix_bits= prefix_size & 0x7, res;
259
259
  uchar *m= (uchar*)map->bitmap;
280
280
}
281
281
 
282
282
 
283
 
my_bool bitmap_is_set_all(const MY_BITMAP *map)
 
283
bool bitmap_is_set_all(const MY_BITMAP *map)
284
284
{
285
285
  my_bitmap_map *data_ptr= map->bitmap;
286
286
  my_bitmap_map *end= map->last_word_ptr;
292
292
}
293
293
 
294
294
 
295
 
my_bool bitmap_is_clear_all(const MY_BITMAP *map)
 
295
bool bitmap_is_clear_all(const MY_BITMAP *map)
296
296
{
297
297
  my_bitmap_map *data_ptr= map->bitmap;
298
298
  my_bitmap_map *end;
307
307
 
308
308
/* Return TRUE if map1 is a subset of map2 */
309
309
 
310
 
my_bool bitmap_is_subset(const MY_BITMAP *map1, const MY_BITMAP *map2)
 
310
bool bitmap_is_subset(const MY_BITMAP *map1, const MY_BITMAP *map2)
311
311
{
312
312
  my_bitmap_map *m1= map1->bitmap, *m2= map2->bitmap, *end;
313
313
 
327
327
 
328
328
/* True if bitmaps has any common bits */
329
329
 
330
 
my_bool bitmap_is_overlapping(const MY_BITMAP *map1, const MY_BITMAP *map2)
 
330
bool bitmap_is_overlapping(const MY_BITMAP *map1, const MY_BITMAP *map2)
331
331
{
332
332
  my_bitmap_map *m1= map1->bitmap, *m2= map2->bitmap, *end;
333
333
 
560
560
 
561
561
 
562
562
#ifdef NOT_USED
563
 
my_bool bitmap_lock_is_prefix(const MY_BITMAP *map, uint prefix_size)
 
563
bool bitmap_lock_is_prefix(const MY_BITMAP *map, uint prefix_size)
564
564
{
565
 
  my_bool res;
 
565
  bool res;
566
566
  bitmap_lock((MY_BITMAP *)map);
567
567
  res= bitmap_is_prefix(map, prefix_size);
568
568
  bitmap_unlock((MY_BITMAP *)map);
594
594
}
595
595
 
596
596
 
597
 
my_bool bitmap_lock_is_clear_all(const MY_BITMAP *map)
 
597
bool bitmap_lock_is_clear_all(const MY_BITMAP *map)
598
598
{
599
599
  uint res;
600
600
  bitmap_lock((MY_BITMAP *)map);
604
604
}
605
605
 
606
606
 
607
 
my_bool bitmap_lock_is_set_all(const MY_BITMAP *map)
 
607
bool bitmap_lock_is_set_all(const MY_BITMAP *map)
608
608
{
609
609
  uint res;
610
610
  bitmap_lock((MY_BITMAP *)map);
614
614
}
615
615
 
616
616
 
617
 
my_bool bitmap_lock_is_set(const MY_BITMAP *map, uint bitmap_bit)
 
617
bool bitmap_lock_is_set(const MY_BITMAP *map, uint bitmap_bit)
618
618
{
619
 
  my_bool res;
 
619
  bool res;
620
620
  DBUG_ASSERT(map->bitmap && bitmap_bit < map->n_bits);
621
621
  bitmap_lock((MY_BITMAP *)map);
622
622
  res= bitmap_is_set(map, bitmap_bit);
625
625
}
626
626
 
627
627
 
628
 
my_bool bitmap_lock_is_subset(const MY_BITMAP *map1, const MY_BITMAP *map2)
 
628
bool bitmap_lock_is_subset(const MY_BITMAP *map1, const MY_BITMAP *map2)
629
629
{
630
630
  uint res;
631
631
  bitmap_lock((MY_BITMAP *)map1);
637
637
}
638
638
 
639
639
 
640
 
my_bool bitmap_lock_cmp(const MY_BITMAP *map1, const MY_BITMAP *map2)
 
640
bool bitmap_lock_cmp(const MY_BITMAP *map1, const MY_BITMAP *map2)
641
641
{
642
642
  uint res;
643
643
 
751
751
  return (rand() % bitsize);
752
752
}
753
753
 
754
 
my_bool test_set_get_clear_bit(MY_BITMAP *map, uint bitsize)
 
754
bool test_set_get_clear_bit(MY_BITMAP *map, uint bitsize)
755
755
{
756
756
  uint i, test_bit;
757
757
  uint no_loops= bitsize > 128 ? 128 : bitsize;
774
774
  return TRUE;
775
775
}
776
776
 
777
 
my_bool test_flip_bit(MY_BITMAP *map, uint bitsize)
 
777
bool test_flip_bit(MY_BITMAP *map, uint bitsize)
778
778
{
779
779
  uint i, test_bit;
780
780
  uint no_loops= bitsize > 128 ? 128 : bitsize;
797
797
  return TRUE;
798
798
}
799
799
 
800
 
my_bool test_operators(MY_BITMAP *map __attribute__((unused)),
 
800
bool test_operators(MY_BITMAP *map __attribute__((unused)),
801
801
                    uint bitsize __attribute__((unused)))
802
802
{
803
803
  return FALSE;
804
804
}
805
805
 
806
 
my_bool test_get_all_bits(MY_BITMAP *map, uint bitsize)
 
806
bool test_get_all_bits(MY_BITMAP *map, uint bitsize)
807
807
{
808
808
  uint i;
809
809
  bitmap_set_all(map);
845
845
  return TRUE;
846
846
}
847
847
 
848
 
my_bool test_compare_operators(MY_BITMAP *map, uint bitsize)
 
848
bool test_compare_operators(MY_BITMAP *map, uint bitsize)
849
849
{
850
850
  uint i, j, test_bit1, test_bit2, test_bit3,test_bit4;
851
851
  uint no_loops= bitsize > 128 ? 128 : bitsize;
951
951
  return TRUE;
952
952
}
953
953
 
954
 
my_bool test_count_bits_set(MY_BITMAP *map, uint bitsize)
 
954
bool test_count_bits_set(MY_BITMAP *map, uint bitsize)
955
955
{
956
956
  uint i, bit_count=0, test_bit;
957
957
  uint no_loops= bitsize > 128 ? 128 : bitsize;
977
977
  return TRUE;
978
978
}
979
979
 
980
 
my_bool test_get_first_bit(MY_BITMAP *map, uint bitsize)
 
980
bool test_get_first_bit(MY_BITMAP *map, uint bitsize)
981
981
{
982
982
  uint i, test_bit;
983
983
  uint no_loops= bitsize > 128 ? 128 : bitsize;
1002
1002
  return TRUE;
1003
1003
}
1004
1004
 
1005
 
my_bool test_get_next_bit(MY_BITMAP *map, uint bitsize)
 
1005
bool test_get_next_bit(MY_BITMAP *map, uint bitsize)
1006
1006
{
1007
1007
  uint i, j, test_bit;
1008
1008
  uint no_loops= bitsize > 128 ? 128 : bitsize;
1021
1021
  return TRUE;
1022
1022
}
1023
1023
 
1024
 
my_bool test_prefix(MY_BITMAP *map, uint bitsize)
 
1024
bool test_prefix(MY_BITMAP *map, uint bitsize)
1025
1025
{
1026
1026
  uint i, j, test_bit;
1027
1027
  uint no_loops= bitsize > 128 ? 128 : bitsize;
1056
1056
}
1057
1057
 
1058
1058
 
1059
 
my_bool do_test(uint bitsize)
 
1059
bool do_test(uint bitsize)
1060
1060
{
1061
1061
  MY_BITMAP map;
1062
1062
  my_bitmap_map buf[1024];