~drizzle-trunk/drizzle/development : contents of drizzled/sql

~drizzle-trunk/drizzle/development : (revision 1567.1.1)

/* Copyright (C) 2000 MySQL AB

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; version 2 of the License.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */

#ifndef DRIZZLED_SQL_BITMAP_H
#define DRIZZLED_SQL_BITMAP_H

/*
  Implementation of a bitmap type.
  The idea with this is to be able to handle any constant number of bits but
  also be able to use 32 or 64 bits bitmaps very efficiently
*/

#include <drizzled/definitions.h>
#include <drizzled/util/test.h>
#include <drizzled/key_map.h>
#include <pthread.h>

#include <cstring>

namespace drizzled
{

typedef uint64_t table_map;          /* Used for table bits in join */
typedef uint32_t nesting_map;  /* Used for flags of nesting constructs */


static const uint32_t MY_BIT_NONE= UINT32_MAX;

typedef uint32_t my_bitmap_map;

/**
 * @class MyBitmap
 * @brief Represents a dynamically sized bitmap.
 *
 * Handling of unsigned char arrays as large bitmaps.
 *
 * API limitations (or, rather asserted safety assumptions,
 * to encourage correct programming)
 *   - the internal size is a set of 32 bit words
 *   - the number of bits specified in creation can be any number
 *     greater than 0
 *
 * Original version created by Sergei Golubchik 2001 - 2004.
 * New version written and test program added and some changes to the
 * interface was made by Mikael Ronström 2005, with assistance of Tomas
 * Ulin and Mats Kindahl.
 */
class MyBitmap
{
public:
  MyBitmap()
    :
      bitmap(NULL),
      n_bits(0),
      last_word_mask(0),
      last_word_ptr(NULL)
  {}

  MyBitmap(const MyBitmap& rhs);

  ~MyBitmap()
  {
      /*
       * We are not de-allocating memory here correctly at the moment!!!!
       * Placing a delete [] statement here causes bad bad things to
       * happen......
       * Placing this comment here in the hope that someone can help me
       * resolve this issue....
       */
      bitmap= 0;
  }

  MyBitmap& operator=(const MyBitmap& rhs);

  bool init(my_bitmap_map *buf, uint32_t num_bits);

  /**
   * Compare the given bitmap with this bitmap.
   *
   * @param[in] map bitmap to perform a comparison against
   * @return true if bitmaps are equal; false otherwise
   */
  bool operator==(const MyBitmap *map)
  {
    *last_word_ptr|= last_word_mask;
    *(map)->last_word_ptr|= (map)->last_word_mask;
    return memcmp(bitmap, map->getBitmap(), 4*numOfWordsInMap())==0;
  }

  /**
   * Test whether the specified bit is set in the bitmap
   * already and set it if it was not already set.
   *
   * @param[in] bitPos position to test and set
   * @return false if the bit was not set; true otherwise
   */
  bool testAndSet(const uint32_t bitPos);

  /**
   * Test whether the specified bit is set in the bitmap
   * and clear it if it was set.
   *
   * @param[in] bitPos position to test and clear
   * @return false if the bit was not set; true otherwise
   */
  bool testAndClear(const uint32_t bitPos);

  /**
   * Set the next bit position that is not yet set starting
   * from the beginning of the bitmap.
   *
   * @return the bit position that was set
   */
  uint32_t setNext();

  uint32_t getFirst();

  /**
   * @return the position of the first bit set.
   */
  uint32_t getFirstSet();

  /**
   * @return the bits set in this bitmap.
   */
  uint32_t getBitsSet();

  /**
   * Set/clear all bits above a bit.
   * Only full bytes can be set/cleared.
   * The function is meant for the situation that you can copy
   * a smaller bitmap to a bigger bitmap. Bitmap lengths are
   * always a multiple of 8 (byte size). Using 'from_byte' saves
   * multiplication and division by 8 during parameter passing.
   *
   * @param[in] from_byte bitmap buffer byte offset to start with
   * @param[in] use_bit bit value (1/0) to use for all upper bits
   */
  void setAbove(const uint32_t from_byte, const uint32_t use_bit);


  /**
   * Test whether all the bits in the bitmap are clear or not.
   *
   * @return true if all bits in bitmap are cleared; false otherwise
   */
  bool isClearAll() const;

  bool isPrefix(const uint32_t prefix_size) const;

  void setPrefix(uint32_t prefix_size);

  /**
   * Test whether all the bits in the bitmap are set or not.
   *
   * @return true if all bits in bitmap are set; false otherwise
   */
  bool isSetAll() const;


  /**
   * Test if the specified bit is set or not.
   *
   * @param[in] bit position of bit to test
   * @return true if the bit is set; false otherwise
   */
  bool isBitSet(const uint32_t bit) const
  {
     return (bool)((reinterpret_cast<unsigned char *>(bitmap))[bit / 8] &  (1 << ((bit) & 7)));
  }

  /**
   * Set the specified bit.
   *
   * @param[in] bit position of bit to set in bitmap
   */
  void setBit(const uint32_t bit)
  {
    reinterpret_cast<unsigned char *>(bitmap)[bit / 8]=
      static_cast<unsigned char>(
      (reinterpret_cast<unsigned char *>(bitmap))[bit / 8] |
      (1 << ((bit) & 7)));
  }

  /**
   * Flip the specified bit.
   *
   * @param[in] bit position of bit to flip in bitmap
   */
  void flipBit(const uint32_t bit)
  {
    reinterpret_cast<unsigned char *>(bitmap)[bit / 8]=
      static_cast<unsigned char>(
      (reinterpret_cast<unsigned char *>(bitmap))[bit / 8] ^
      (1 << ((bit) & 7)));
  }

  /**
   * Clear the specified bit.
   *
   * @param[in] bit position of bit to clear in bitmap
   */
  void clearBit(const uint32_t bit)
  {
    reinterpret_cast<unsigned char *>(bitmap)[bit / 8]=
      static_cast<unsigned char>(
      (reinterpret_cast<unsigned char *>(bitmap))[bit / 8] &
      ~ (1 << ((bit) & 7)));
  }

  /**
   * Clear all the bits in the bitmap i.e. set every
   * bit to 0.
   */
  void clearAll()
  {
     memset(bitmap, 0, 4*numOfWordsInMap());
  }

  /**
   * Set all the bits in the bitmap i.e. set every
   * bit to 1.
   */
  void setAll()
  {
     memset(bitmap, 0xFF, 4*numOfWordsInMap());
  }

  /**
   * @return the number of words in this bitmap.
   */
  uint32_t numOfWordsInMap() const
  {
    return ((n_bits + 31)/32);
  }

  /**
   * @return the number of bytes in this bitmap.
   */
  uint32_t numOfBytesInMap() const
  {
    return ((n_bits + 7)/8);
  }

  /**
   * Get the size of the bitmap in bits.
   *
   * @return the size of the bitmap in bits.
   */
  uint32_t numOfBitsInMap() const
  {
    return n_bits;
  }

  /**
   * @return the current bitmap
   */
  my_bitmap_map *getBitmap() const
  {
    return bitmap;
  }

  /**
   * Set the bitmap to the specified bitmap.
   *
   * @param[in] new_bitmap bitmap to use
   */
  void setBitmap(my_bitmap_map *new_bitmap)
  {
    bitmap= new_bitmap;
  }

  /**
   * Obtains the number of used bits (1..8) in the last
   * byte and creates a mask with the upper 'unused' bits
   * set and the lower 'used' bits clear.
   */
  void createLastWordMask();

  /**
   * @return the last word pointer for this bitmap
   */
  my_bitmap_map *getLastWordPtr() const
  {
    return last_word_ptr;
  }

  void addMaskToLastWord() const
  {
    *last_word_ptr|= last_word_mask;
  }

  /**
   * This resets the last bits in the bitmap to 0.
   */
  void subtractMaskFromLastWord() const
  {
    *last_word_ptr&= ~last_word_mask;
  }

private:

  /**
   * The bitmap is stored in this variable.
   */
  my_bitmap_map *bitmap;

  /**
   * Number of bits occupied by the bitmap.
   */
  uint32_t n_bits;

  /**
   * A mask used for the last word in the bitmap.
   */
  my_bitmap_map last_word_mask;

  /**
   * A pointer to the last word in the bitmap.
   */
  my_bitmap_map *last_word_ptr;

};

bool bitmap_is_subset(const MyBitmap *map1, const MyBitmap *map2);
bool bitmap_is_overlapping(const MyBitmap *map1,
                           const MyBitmap *map2);

void bitmap_intersect(MyBitmap *map, const MyBitmap *map2);
void bitmap_subtract(MyBitmap *map, const MyBitmap *map2);
void bitmap_union(MyBitmap *map, const MyBitmap *map2);
void bitmap_xor(MyBitmap *map, const MyBitmap *map2);
void bitmap_invert(MyBitmap *map);

/* Fast, not thread safe, bitmap functions */
/* This one is a define because it gets used in an array decl */
#define bitmap_buffer_size(bits) ((bits+31)/32)*4

template <class T>
inline T bytes_word_aligned(T bytes)
{
  return (4*((bytes + 3)/4));
}

static inline bool bitmap_cmp(const MyBitmap *map1, const MyBitmap *map2)
{
  map1->addMaskToLastWord();
  map2->addMaskToLastWord();
  return memcmp((map1)->getBitmap(),
                (map2)->getBitmap(),
                4*map1->numOfWordsInMap()) == 0;
}

} /* namespace drizzled */

#endif /* DRIZZLED_SQL_BITMAP_H */

1005.2.1 by Monty Taylor Reverted a crap-ton of padraig's work.	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
1241.9.54 by Monty Taylor Moved bitmap into drizzled.	16	#ifndef DRIZZLED_SQL_BITMAP_H
	17	#define DRIZZLED_SQL_BITMAP_H
	18
	19	/*
	20	Implementation of a bitmap type.
	21	The idea with this is to be able to handle any constant number of bits but
	22	also be able to use 32 or 64 bits bitmaps very efficiently
	23	*/
	24
	25	#include <drizzled/definitions.h>
	26	#include <drizzled/util/test.h>
	27	#include <drizzled/key_map.h>
1005.2.15 by Monty Taylor More my_bitmap header cleanup.	28	#include <pthread.h>
1241.9.54 by Monty Taylor Moved bitmap into drizzled.	29
	30	#include <cstring>
	31
1280.1.10 by Monty Taylor Put everything in drizzled into drizzled namespace.	32	namespace drizzled
	33	{
1241.9.54 by Monty Taylor Moved bitmap into drizzled.	34
	35	typedef uint64_t table_map; /* Used for table bits in join */
	36	typedef uint32_t nesting_map; /* Used for flags of nesting constructs */
	37
1005.2.15 by Monty Taylor More my_bitmap header cleanup.	38
1005.2.15 by Monty Taylor More my_bitmap header cleanup.	39	static const uint32_t MY_BIT_NONE= UINT32_MAX;
1005.2.1 by Monty Taylor Reverted a crap-ton of padraig's work.	40
	41	typedef uint32_t my_bitmap_map;
	42
1103.6.1 by Padraig O'Sullivan Converted MY_BITMAP from a struct to a class named MyBitmap. Added a copy	43	/**
	44	* @class MyBitmap
	45	* @brief Represents a dynamically sized bitmap.
	46	*
	47	* Handling of unsigned char arrays as large bitmaps.
1241.3.3 by Trond Norbye Cleanup: use c++ style casting	48	*
1103.6.1 by Padraig O'Sullivan Converted MY_BITMAP from a struct to a class named MyBitmap. Added a copy	49	* API limitations (or, rather asserted safety assumptions,
	50	* to encourage correct programming)
	51	* - the internal size is a set of 32 bit words
	52	* - the number of bits specified in creation can be any number
	53	* greater than 0
	54	*
	55	* Original version created by Sergei Golubchik 2001 - 2004.
1241.3.3 by Trond Norbye Cleanup: use c++ style casting	56	* New version written and test program added and some changes to the
1241.3.3 by Trond Norbye Cleanup: use c++ style casting	57	* interface was made by Mikael Ronström 2005, with assistance of Tomas
1103.6.1 by Padraig O'Sullivan Converted MY_BITMAP from a struct to a class named MyBitmap. Added a copy	58	* Ulin and Mats Kindahl.
	59	*/
	60	class MyBitmap
1005.2.1 by Monty Taylor Reverted a crap-ton of padraig's work.	61	{
1103.6.1 by Padraig O'Sullivan Converted MY_BITMAP from a struct to a class named MyBitmap. Added a copy	62	public:
	63	MyBitmap()
	64	:
	65	bitmap(NULL),
	66	n_bits(0),
	67	last_word_mask(0),
1103.6.2 by Padraig O'Sullivan Removing references to MY_BITMAP throughout the code base and updating calls	68	last_word_ptr(NULL)
1103.6.1 by Padraig O'Sullivan Converted MY_BITMAP from a struct to a class named MyBitmap. Added a copy	69	{}
	70
	71	MyBitmap(const MyBitmap& rhs);
	72
	73	~MyBitmap()
	74	{
1103.6.6 by Padraig O'Sullivan Updating desctructor in MyBitmap class to work for now (although not	75	/*
	76	* We are not de-allocating memory here correctly at the moment!!!!
	77	* Placing a delete [] statement here causes bad bad things to
	78	* happen......
	79	* Placing this comment here in the hope that someone can help me
	80	* resolve this issue....
	81	*/
	82	bitmap= 0;
1103.6.1 by Padraig O'Sullivan Converted MY_BITMAP from a struct to a class named MyBitmap. Added a copy	83	}
	84
	85	MyBitmap& operator=(const MyBitmap& rhs);
	86
	87	bool init(my_bitmap_map *buf, uint32_t num_bits);
	88
	89	/**
	90	* Compare the given bitmap with this bitmap.
	91	*
	92	* @param[in] map bitmap to perform a comparison against
	93	* @return true if bitmaps are equal; false otherwise
	94	*/
	95	bool operator==(const MyBitmap *map)
	96	{
	97	*last_word_ptr\|= last_word_mask;
	98	*(map)->last_word_ptr\|= (map)->last_word_mask;
	99	return memcmp(bitmap, map->getBitmap(), 4*numOfWordsInMap())==0;
	100	}
	101
	102	/**
	103	* Test whether the specified bit is set in the bitmap
	104	* already and set it if it was not already set.
	105	*
	106	* @param[in] bitPos position to test and set
	107	* @return false if the bit was not set; true otherwise
	108	*/
	109	bool testAndSet(const uint32_t bitPos);
	110
	111	/**
	112	* Test whether the specified bit is set in the bitmap
	113	* and clear it if it was set.
	114	*
	115	* @param[in] bitPos position to test and clear
	116	* @return false if the bit was not set; true otherwise
	117	*/
	118	bool testAndClear(const uint32_t bitPos);
	119
	120	/**
	121	* Set the next bit position that is not yet set starting
	122	* from the beginning of the bitmap.
	123	*
	124	* @return the bit position that was set
	125	*/
	126	uint32_t setNext();
	127
	128	uint32_t getFirst();
	129
	130	/**
	131	* @return the position of the first bit set.
	132	*/
	133	uint32_t getFirstSet();
	134
	135	/**
	136	* @return the bits set in this bitmap.
	137	*/
	138	uint32_t getBitsSet();
	139
	140	/**
	141	* Set/clear all bits above a bit.
	142	* Only full bytes can be set/cleared.
	143	* The function is meant for the situation that you can copy
	144	* a smaller bitmap to a bigger bitmap. Bitmap lengths are
	145	* always a multiple of 8 (byte size). Using 'from_byte' saves
	146	* multiplication and division by 8 during parameter passing.
147	*
148	* @param[in] from_byte bitmap buffer byte offset to start with
149	* @param[in] use_bit bit value (1/0) to use for all upper bits
150	*/
151	void setAbove(const uint32_t from_byte, const uint32_t use_bit);
152
153
154	/**
155	* Test whether all the bits in the bitmap are clear or not.
156	*
157	* @return true if all bits in bitmap are cleared; false otherwise
158	*/
159	bool isClearAll() const;
160
161	bool isPrefix(const uint32_t prefix_size) const;
162
163	void setPrefix(uint32_t prefix_size);
164
165	/**
166	* Test whether all the bits in the bitmap are set or not.
167	*
168	* @return true if all bits in bitmap are set; false otherwise
169	*/
170	bool isSetAll() const;
171
172
173	/**
174	* Test if the specified bit is set or not.
175	*
176	* @param[in] bit position of bit to test
177	* @return true if the bit is set; false otherwise
178	*/
179	bool isBitSet(const uint32_t bit) const
180	{
1241.3.3 by Trond Norbye Cleanup: use c++ style casting	181	return (bool)((reinterpret_cast<unsigned char *>(bitmap))[bit / 8] & (1 << ((bit) & 7)));
1103.6.1 by Padraig O'Sullivan Converted MY_BITMAP from a struct to a class named MyBitmap. Added a copy	182	}
	183
	184	/**
	185	* Set the specified bit.
	186	*
	187	* @param[in] bit position of bit to set in bitmap
	188	*/
	189	void setBit(const uint32_t bit)
	190	{
1241.3.3 by Trond Norbye Cleanup: use c++ style casting	191	reinterpret_cast<unsigned char *>(bitmap)[bit / 8]=
1126.8.1 by Joe Daly changes to allow -Wconversion flag to be turned on	192	static_cast<unsigned char>(
1241.3.3 by Trond Norbye Cleanup: use c++ style casting	193	(reinterpret_cast<unsigned char *>(bitmap))[bit / 8] \|
1126.8.1 by Joe Daly changes to allow -Wconversion flag to be turned on	194	(1 << ((bit) & 7)));
1103.6.1 by Padraig O'Sullivan Converted MY_BITMAP from a struct to a class named MyBitmap. Added a copy	195	}
	196
	197	/**
	198	* Flip the specified bit.
	199	*
	200	* @param[in] bit position of bit to flip in bitmap
	201	*/
	202	void flipBit(const uint32_t bit)
	203	{
1241.3.3 by Trond Norbye Cleanup: use c++ style casting	204	reinterpret_cast<unsigned char *>(bitmap)[bit / 8]=
1126.8.1 by Joe Daly changes to allow -Wconversion flag to be turned on	205	static_cast<unsigned char>(
1241.3.3 by Trond Norbye Cleanup: use c++ style casting	206	(reinterpret_cast<unsigned char *>(bitmap))[bit / 8] ^
1126.8.1 by Joe Daly changes to allow -Wconversion flag to be turned on	207	(1 << ((bit) & 7)));
1103.6.1 by Padraig O'Sullivan Converted MY_BITMAP from a struct to a class named MyBitmap. Added a copy	208	}
	209
	210	/**
	211	* Clear the specified bit.
	212	*
	213	* @param[in] bit position of bit to clear in bitmap
	214	*/
	215	void clearBit(const uint32_t bit)
	216	{
1241.3.3 by Trond Norbye Cleanup: use c++ style casting	217	reinterpret_cast<unsigned char *>(bitmap)[bit / 8]=
1126.8.1 by Joe Daly changes to allow -Wconversion flag to be turned on	218	static_cast<unsigned char>(
1241.3.3 by Trond Norbye Cleanup: use c++ style casting	219	(reinterpret_cast<unsigned char *>(bitmap))[bit / 8] &
1126.8.1 by Joe Daly changes to allow -Wconversion flag to be turned on	220	~ (1 << ((bit) & 7)));
1103.6.1 by Padraig O'Sullivan Converted MY_BITMAP from a struct to a class named MyBitmap. Added a copy	221	}
	222
	223	/**
	224	* Clear all the bits in the bitmap i.e. set every
	225	* bit to 0.
	226	*/
	227	void clearAll()
	228	{
	229	memset(bitmap, 0, 4*numOfWordsInMap());
	230	}
	231
	232	/**
	233	* Set all the bits in the bitmap i.e. set every
	234	* bit to 1.
	235	*/
	236	void setAll()
	237	{
	238	memset(bitmap, 0xFF, 4*numOfWordsInMap());
	239	}
	240
	241	/**
	242	* @return the number of words in this bitmap.
	243	*/
	244	uint32_t numOfWordsInMap() const
	245	{
	246	return ((n_bits + 31)/32);
	247	}
	248
	249	/**
	250	* @return the number of bytes in this bitmap.
	251	*/
	252	uint32_t numOfBytesInMap() const
	253	{
	254	return ((n_bits + 7)/8);
	255	}
	256
	257	/**
	258	* Get the size of the bitmap in bits.
	259	*
	260	* @return the size of the bitmap in bits.
	261	*/
	262	uint32_t numOfBitsInMap() const
	263	{
	264	return n_bits;
	265	}
	266
	267	/**
	268	* @return the current bitmap
	269	*/
	270	my_bitmap_map *getBitmap() const
	271	{
	272	return bitmap;
	273	}
	274
	275	/**
1103.6.2 by Padraig O'Sullivan Removing references to MY_BITMAP throughout the code base and updating calls	276	* Set the bitmap to the specified bitmap.
	277	*
	278	* @param[in] new_bitmap bitmap to use
	279	*/
	280	void setBitmap(my_bitmap_map *new_bitmap)
	281	{
	282	bitmap= new_bitmap;
	283	}
	284
	285	/**
1103.6.1 by Padraig O'Sullivan Converted MY_BITMAP from a struct to a class named MyBitmap. Added a copy	286	* Obtains the number of used bits (1..8) in the last
	287	* byte and creates a mask with the upper 'unused' bits
1241.3.3 by Trond Norbye Cleanup: use c++ style casting	288	* set and the lower 'used' bits clear.
1103.6.1 by Padraig O'Sullivan Converted MY_BITMAP from a struct to a class named MyBitmap. Added a copy	289	*/
	290	void createLastWordMask();
	291
	292	/**
	293	* @return the last word pointer for this bitmap
	294	*/
	295	my_bitmap_map *getLastWordPtr() const
	296	{
	297	return last_word_ptr;
	298	}
	299
	300	void addMaskToLastWord() const
	301	{
	302	*last_word_ptr\|= last_word_mask;
	303	}
	304
	305	/**
	306	* This resets the last bits in the bitmap to 0.
	307	*/
	308	void subtractMaskFromLastWord() const
	309	{
	310	*last_word_ptr&= ~last_word_mask;
	311	}
	312
	313	private:
	314
	315	/**
	316	* The bitmap is stored in this variable.
	317	*/
1005.2.1 by Monty Taylor Reverted a crap-ton of padraig's work.	318	my_bitmap_map *bitmap;
1103.6.1 by Padraig O'Sullivan Converted MY_BITMAP from a struct to a class named MyBitmap. Added a copy	319
	320	/**
	321	* Number of bits occupied by the bitmap.
	322	*/
	323	uint32_t n_bits;
	324
	325	/**
	326	* A mask used for the last word in the bitmap.
	327	*/
1005.2.1 by Monty Taylor Reverted a crap-ton of padraig's work.	328	my_bitmap_map last_word_mask;
1103.6.1 by Padraig O'Sullivan Converted MY_BITMAP from a struct to a class named MyBitmap. Added a copy	329
	330	/**
	331	* A pointer to the last word in the bitmap.
	332	*/
1005.2.1 by Monty Taylor Reverted a crap-ton of padraig's work.	333	my_bitmap_map *last_word_ptr;
1103.6.1 by Padraig O'Sullivan Converted MY_BITMAP from a struct to a class named MyBitmap. Added a copy	334
	335	};
	336
	337	bool bitmap_is_subset(const MyBitmap map1, const MyBitmap map2);
	338	bool bitmap_is_overlapping(const MyBitmap *map1,
	339	const MyBitmap *map2);
	340
	341	void bitmap_intersect(MyBitmap map, const MyBitmap map2);
	342	void bitmap_subtract(MyBitmap map, const MyBitmap map2);
	343	void bitmap_union(MyBitmap map, const MyBitmap map2);
	344	void bitmap_xor(MyBitmap map, const MyBitmap map2);
	345	void bitmap_invert(MyBitmap *map);
1005.2.15 by Monty Taylor More my_bitmap header cleanup.	346
1005.2.1 by Monty Taylor Reverted a crap-ton of padraig's work.	347	/* Fast, not thread safe, bitmap functions */
1005.2.15 by Monty Taylor More my_bitmap header cleanup.	348	/* This one is a define because it gets used in an array decl */
	349	#define bitmap_buffer_size(bits) ((bits+31)/32)*4
	350
	351	template <class T>
	352	inline T bytes_word_aligned(T bytes)
	353	{
	354	return (4*((bytes + 3)/4));
	355	}
1005.2.13 by Monty Taylor Turned macros in my_bitmap into honest inline methods.	356
1103.6.1 by Padraig O'Sullivan Converted MY_BITMAP from a struct to a class named MyBitmap. Added a copy	357	static inline bool bitmap_cmp(const MyBitmap map1, const MyBitmap map2)
	358	{
	359	map1->addMaskToLastWord();
	360	map2->addMaskToLastWord();
1241.3.3 by Trond Norbye Cleanup: use c++ style casting	361	return memcmp((map1)->getBitmap(),
1103.6.1 by Padraig O'Sullivan Converted MY_BITMAP from a struct to a class named MyBitmap. Added a copy	362	(map2)->getBitmap(),
	363	4*map1->numOfWordsInMap()) == 0;
1005.2.13 by Monty Taylor Turned macros in my_bitmap into honest inline methods.	364	}
1005.2.1 by Monty Taylor Reverted a crap-ton of padraig's work.	365
1280.1.10 by Monty Taylor Put everything in drizzled into drizzled namespace.	366	} /* namespace drizzled */
	367
1241.9.54 by Monty Taylor Moved bitmap into drizzled.	368	#endif /* DRIZZLED_SQL_BITMAP_H */