cwchessboard: BitBoard.h Source File

Go to the documentation of this file.
00001 // cwchessboard -- A C++ chessboard tool set
00002 //
00003 //! @file BitBoard.h This file contains the declaration of class BitBoard.
00004 //
00005 // Copyright (C) 2008, by
00006 // 
00007 // Carlo Wood, Run on IRC <carlo@alinoe.com>
00008 // RSA-1024 0x624ACAD5 1997-01-26                    Sign & Encrypt
00009 // Fingerprint16 = 32 EC A7 B6 AC DB 65 A6  F6 F6 55 DD 1C DC FF 61
00010 // 
00011 // This program is free software: you can redistribute it and/or modify
00012 // it under the terms of the GNU General Public License as published by
00013 // the Free Software Foundation, either version 2 of the License, or
00014 // (at your option) any later version.
00015 // 
00016 // This program is distributed in the hope that it will be useful,
00017 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00018 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00019 // GNU General Public License for more details.
00020 // 
00021 // You should have received a copy of the GNU General Public License
00022 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
00023 
00024 #ifndef BITBOARD_H
00025 #define BITBOARD_H
00026 
00027 #ifndef USE_PCH
00028 #include <stdint.h>
00029 #endif
00030 
00031 #include "Index.h"
00032 
00033 #define DEBUG_BITBOARD_INITIALIZATION 0
00034 
00035 #if DEBUG_BITBOARD_INITIALIZATION
00036 #include <cassert>
00037 #endif
00038 
00039 /** @namespace cwchess
00040  *  @brief A namespace for all chess related objects that are not related to the GUI.
00041 * /
00042 namespace cwchess {
00043 
00044 /** @brief The type of an internal BitBoard mask.
00045 * 
00046  * Don't use this, use \link cwchess::BitBoard BitBoard \endlink.
00047 * /
00048 typedef uint64_t mask_t;
00049 
00050 /** @brief Convert Index to a mask_t.* /
00051 inline mask_t index2mask(Index index)
00052 {
00053   return CW_MASK_T_CONST(1) << index();
00054 }
00055 
00056 /** @brief Convert a \a col, \a row pair to a mask_t.* /
00057 inline mask_t colrow2mask(int col, int row)
00058 {
00059   return CW_MASK_T_CONST(1) << (col + (row << 3));
00060 }
00061 
00062 /** @brief Convert a single bit mask into it's Index.
00063 * 
00064  * The provided \a mask should have a single bit set.
00065  * However, if that is not the case, then this function
00066  * returns either 64 if no bit is set, or the index
00067  * of the first (least significant) bit that is set.
00068 * /
00069 inline Index mask2index(mask_t mask)
00070 {
00071   Index result(index_pre_begin);
00072   result.next_bit_in(mask);
00073   return result;
00074 }
00075 
00076 /** @brief The POD base type of class BitBoard.
00077 * 
00078  * This class contains a 64-bit unsigned integer
00079  * where each bit represents one square on the chessboard.
00080 * 
00081  * It may not have constructors or destructors, because
00082  * it is needed that this struct is POD in order for
00083  * optimisation to work.
00084 * 
00085  * @sa BitBoard
00086 * /
00087 struct BitBoardData {
00088     /** @brief A one-bit-per-square chessboard mask.
00089     * 
00090      * The least significant bit represents square a1.
00091      * The next bit b1, c1, ... h1, a2, b2, ... etcetera till h8.
00092     * /
00093     mask_t M_bitmask;
00094 };
00095 
00096 BitBoardData const a1 = { CW_MASK_T_CONST(0x1) };                       //!< The square a1.
00097 BitBoardData const b1 = { CW_MASK_T_CONST(0x2) };                       //!< The square b1.
00098 BitBoardData const c1 = { CW_MASK_T_CONST(0x4) };                       //!< The square c1.
00099 BitBoardData const d1 = { CW_MASK_T_CONST(0x8) };                       //!< The square d1.
00100 BitBoardData const e1 = { CW_MASK_T_CONST(0x10) };                      //!< The square e1.
00101 BitBoardData const f1 = { CW_MASK_T_CONST(0x20) };                      //!< The square f1.
00102 BitBoardData const g1 = { CW_MASK_T_CONST(0x40) };                      //!< The square g1.
00103 BitBoardData const h1 = { CW_MASK_T_CONST(0x80) };                      //!< The square h1.
00104 BitBoardData const a2 = { CW_MASK_T_CONST(0x100) };                     //!< The square a2.
00105 BitBoardData const b2 = { CW_MASK_T_CONST(0x200) };                     //!< The square b2.
00106 BitBoardData const c2 = { CW_MASK_T_CONST(0x400) };                     //!< The square c2.
00107 BitBoardData const d2 = { CW_MASK_T_CONST(0x800) };                     //!< The square d2.
00108 BitBoardData const e2 = { CW_MASK_T_CONST(0x1000) };                    //!< The square e2.
00109 BitBoardData const f2 = { CW_MASK_T_CONST(0x2000) };                    //!< The square f2.
00110 BitBoardData const g2 = { CW_MASK_T_CONST(0x4000) };                    //!< The square g2.
00111 BitBoardData const h2 = { CW_MASK_T_CONST(0x8000) };                    //!< The square h2.
00112 BitBoardData const a3 = { CW_MASK_T_CONST(0x10000) };                   //!< The square a3.
00113 BitBoardData const b3 = { CW_MASK_T_CONST(0x20000) };                   //!< The square b3.
00114 BitBoardData const c3 = { CW_MASK_T_CONST(0x40000) };                   //!< The square c3.
00115 BitBoardData const d3 = { CW_MASK_T_CONST(0x80000) };                   //!< The square d3.
00116 BitBoardData const e3 = { CW_MASK_T_CONST(0x100000) };                  //!< The square e3.
00117 BitBoardData const f3 = { CW_MASK_T_CONST(0x200000) };                  //!< The square f3.
00118 BitBoardData const g3 = { CW_MASK_T_CONST(0x400000) };                  //!< The square g3.
00119 BitBoardData const h3 = { CW_MASK_T_CONST(0x800000) };                  //!< The square h3.
00120 BitBoardData const a4 = { CW_MASK_T_CONST(0x1000000) };         //!< The square a4.
00121 BitBoardData const b4 = { CW_MASK_T_CONST(0x2000000) };         //!< The square b4.
00122 BitBoardData const c4 = { CW_MASK_T_CONST(0x4000000) };         //!< The square c4.
00123 BitBoardData const d4 = { CW_MASK_T_CONST(0x8000000) };         //!< The square d4.
00124 BitBoardData const e4 = { CW_MASK_T_CONST(0x10000000) };                //!< The square e4.
00125 BitBoardData const f4 = { CW_MASK_T_CONST(0x20000000) };                //!< The square f4.
00126 BitBoardData const g4 = { CW_MASK_T_CONST(0x40000000) };                //!< The square g4.
00127 BitBoardData const h4 = { CW_MASK_T_CONST(0x80000000) };                //!< The square h4.
00128 BitBoardData const a5 = { CW_MASK_T_CONST(0x100000000) };               //!< The square a5.
00129 BitBoardData const b5 = { CW_MASK_T_CONST(0x200000000) };               //!< The square b5.
00130 BitBoardData const c5 = { CW_MASK_T_CONST(0x400000000) };               //!< The square c5.
00131 BitBoardData const d5 = { CW_MASK_T_CONST(0x800000000) };               //!< The square d5.
00132 BitBoardData const e5 = { CW_MASK_T_CONST(0x1000000000) };              //!< The square e5.
00133 BitBoardData const f5 = { CW_MASK_T_CONST(0x2000000000) };              //!< The square f5.
00134 BitBoardData const g5 = { CW_MASK_T_CONST(0x4000000000) };              //!< The square g5.
00135 BitBoardData const h5 = { CW_MASK_T_CONST(0x8000000000) };              //!< The square h5.
00136 BitBoardData const a6 = { CW_MASK_T_CONST(0x10000000000) };             //!< The square a6.
00137 BitBoardData const b6 = { CW_MASK_T_CONST(0x20000000000) };             //!< The square b6.
00138 BitBoardData const c6 = { CW_MASK_T_CONST(0x40000000000) };             //!< The square c6.
00139 BitBoardData const d6 = { CW_MASK_T_CONST(0x80000000000) };             //!< The square d6.
00140 BitBoardData const e6 = { CW_MASK_T_CONST(0x100000000000) };            //!< The square e6.
00141 BitBoardData const f6 = { CW_MASK_T_CONST(0x200000000000) };            //!< The square f6.
00142 BitBoardData const g6 = { CW_MASK_T_CONST(0x400000000000) };            //!< The square g6.
00143 BitBoardData const h6 = { CW_MASK_T_CONST(0x800000000000) };            //!< The square h6.
00144 BitBoardData const a7 = { CW_MASK_T_CONST(0x1000000000000) };           //!< The square a7.
00145 BitBoardData const b7 = { CW_MASK_T_CONST(0x2000000000000) };           //!< The square b7.
00146 BitBoardData const c7 = { CW_MASK_T_CONST(0x4000000000000) };           //!< The square c7.
00147 BitBoardData const d7 = { CW_MASK_T_CONST(0x8000000000000) };           //!< The square d7.
00148 BitBoardData const e7 = { CW_MASK_T_CONST(0x10000000000000) };          //!< The square e7.
00149 BitBoardData const f7 = { CW_MASK_T_CONST(0x20000000000000) };          //!< The square f7.
00150 BitBoardData const g7 = { CW_MASK_T_CONST(0x40000000000000) };          //!< The square g7.
00151 BitBoardData const h7 = { CW_MASK_T_CONST(0x80000000000000) };          //!< The square h7.
00152 BitBoardData const a8 = { CW_MASK_T_CONST(0x100000000000000) }; //!< The square a8.
00153 BitBoardData const b8 = { CW_MASK_T_CONST(0x200000000000000) }; //!< The square b8.
00154 BitBoardData const c8 = { CW_MASK_T_CONST(0x400000000000000) }; //!< The square c8
00155 BitBoardData const d8 = { CW_MASK_T_CONST(0x800000000000000) }; //!< The square d8
00156 BitBoardData const e8 = { CW_MASK_T_CONST(0x1000000000000000) };        //!< The square e8.
00157 BitBoardData const f8 = { CW_MASK_T_CONST(0x2000000000000000) };        //!< The square f8.
00158 BitBoardData const g8 = { CW_MASK_T_CONST(0x4000000000000000) };        //!< The square g8.
00159 BitBoardData const h8 = { CW_MASK_T_CONST(0x8000000000000000) };        //!< The square h8.
00160 
00161 // Compare constants (this should never be needed, but why not add it).
00162 inline bool operator==(BitBoardData b1, BitBoardData b2) { return b1.M_bitmask == b2.M_bitmask; }
00163 inline bool operator!=(BitBoardData b1, BitBoardData b2) { return b1.M_bitmask != b2.M_bitmask; }
00164 
00165 /** @brief Calculate the union of two bit board constants.* /
00166 inline BitBoardData operator|(BitBoardData x, BitBoardData y)
00167 {
00168   BitBoardData result;
00169   result.M_bitmask = x.M_bitmask | y.M_bitmask;
00170   return result;
00171 }
00172 
00173 /** @brief Calculate the intersection of two bit board constants.* /
00174 inline BitBoardData operator&(BitBoardData x, BitBoardData y)
00175 {
00176   BitBoardData result;
00177   result.M_bitmask = x.M_bitmask & y.M_bitmask;
00178   return result;
00179 }
00180 
00181 /** @brief Calculate the union minus the intersection of two bit board constants.* /
00182 inline BitBoardData operator^(BitBoardData x, BitBoardData y)
00183 {
00184   BitBoardData result;
00185   result.M_bitmask = x.M_bitmask ^ y.M_bitmask;
00186   return result;
00187 }
00188 
00189 /** @brief Calculate the inverse of the bitboard constant.* /
00190 inline BitBoardData operator~(BitBoardData x)
00191 {
00192   BitBoardData result;
00193   result.M_bitmask = ~x.M_bitmask;
00194   return result;
00195 }
00196 
00197 BitBoardData const file_a = a1|a2|a3|a4|a5|a6|a7|a8;    //!< The a-file.
00198 BitBoardData const file_b = b1|b2|b3|b4|b5|b6|b7|b8;    //!< The b-file.
00199 BitBoardData const file_c = c1|c2|c3|c4|c5|c6|c7|c8;    //!< The c-file.
00200 BitBoardData const file_d = d1|d2|d3|d4|d5|d6|d7|d8;    //!< The d-file.
00201 BitBoardData const file_e = e1|e2|e3|e4|e5|e6|e7|e8;    //!< The e-file.
00202 BitBoardData const file_f = f1|f2|f3|f4|f5|f6|f7|f8;    //!< The f-file.
00203 BitBoardData const file_g = g1|g2|g3|g4|g5|g6|g7|g8;    //!< The g-file.
00204 BitBoardData const file_h = h1|h2|h3|h4|h5|h6|h7|h8;    //!< The h-file.
00205 
00206 BitBoardData const rank_1 = a1|b1|c1|d1|e1|f1|g1|h1;    //!< The first rank.
00207 BitBoardData const rank_2 = a2|b2|c2|d2|e2|f2|g2|h2;    //!< The second rank.
00208 BitBoardData const rank_3 = a3|b3|c3|d3|e3|f3|g3|h3;    //!< The third rank.
00209 BitBoardData const rank_4 = a4|b4|c4|d4|e4|f4|g4|h4;    //!< The fourth rank.
00210 BitBoardData const rank_5 = a5|b5|c5|d5|e5|f5|g5|h5;    //!< The fifth rank.
00211 BitBoardData const rank_6 = a6|b6|c6|d6|e6|f6|g6|h6;    //!< The sixth rank.
00212 BitBoardData const rank_7 = a7|b7|c7|d7|e7|f7|g7|h7;    //!< The seventh rank.
00213 BitBoardData const rank_8 = a8|b8|c8|d8|e8|f8|g8|h8;    //!< The eighth rank.
00214 
00215 BitBoardData const bdl_1 =                      h8;     //!< The black diagonal from h8 to h8.
00216 BitBoardData const bdl_2 =                f8|g7|h6;     //!< The black diagonal from f8 to h6.
00217 BitBoardData const bdl_3 =          d8|e7|f6|g5|h4;     //!< The black diagonal from d8 to h4.
00218 BitBoardData const bdl_4 =    b8|c7|d6|e5|f4|g3|h2;     //!< The black diagonal from b8 to h2.
00219 BitBoardData const bdl_5 = a7|b6|c5|d4|e3|f2|g1;        //!< The black diagonal from a7 to g1.
00220 BitBoardData const bdl_6 = a5|b4|c3|d2|e1;              //!< The black diagonal from a5 to e1.
00221 BitBoardData const bdl_7 = a3|b2|c1;                    //!< The black diagonal from a3 to c1.
00222 BitBoardData const bdl_8 = a1;                          //!< The black diagonal from a1 to a1.
00223 
00224 BitBoardData const bdr_1 = a7|b8;                       //!< The black diagonal from a7 to b8.
00225 BitBoardData const bdr_2 = a5|b6|c7|d8;                 //!< The black diagonal from a5 to d8.
00226 BitBoardData const bdr_3 = a3|b4|c5|d6|e7|f8;           //!< The black diagonal from a3 to f8.
00227 BitBoardData const bdr_4 = a1|b2|c3|d4|e5|f6|g7|h8;     //!< The black diagonal from a1 to h8.
00228 BitBoardData const bdr_5 =       c1|d2|e3|f4|g5|h6;     //!< The black diagonal from c1 to h6.
00229 BitBoardData const bdr_6 =             e1|f2|g3|h4;     //!< The black diagonal from e1 to h4.
00230 BitBoardData const bdr_7 =                   g1|h2;     //!< The black diagonal from g1 ti h2.
00231 
00232 BitBoardData const wdr_1 = a8;                          //!< The white diagonal from a8 to a8.
00233 BitBoardData const wdr_2 = a6|b7|c8;                    //!< The white diagonal from a6 to c8.
00234 BitBoardData const wdr_3 = a4|b5|c6|d7|e8;              //!< The white diagonal from a4 to e8.
00235 BitBoardData const wdr_4 = a2|b3|c4|d5|e6|f7|g8;        //!< The white diagonal from a2 to g8.
00236 BitBoardData const wdr_5 =    b1|c2|d3|e4|f5|g6|h7;     //!< The white diagonal from b1 to h7.
00237 BitBoardData const wdr_6 =          d1|e2|f3|g4|h5;     //!< The white diagonal from d1 to h5.
00238 BitBoardData const wdr_7 =                f1|g2|h3;     //!< The white diagonal from f1 to h3.
00239 BitBoardData const wdr_8 =                      h1;     //!< The white diagonal from h1 to h1.
00240 
00241 BitBoardData const wdl_1 =                   g8|h7;     //!< The white diagonal from g8 to h7.
00242 BitBoardData const wdl_2 =             e8|f7|g6|h5;     //!< The white diagonal from e8 to h5.
00243 BitBoardData const wdl_3 =       c8|d7|e6|f5|g4|h3;     //!< The white diagonal from c8 to h3.
00244 BitBoardData const wdl_4 = a8|b7|c6|d5|e4|f3|g2|h1;     //!< The white diagonal from a8 to h1.
00245 BitBoardData const wdl_5 = a6|b5|c4|d3|e2|f1;           //!< The white diagonal from a6 to f1.
00246 BitBoardData const wdl_6 = a4|b3|c2|d1;                 //!< The white diagonal from a4 to d1.
00247 BitBoardData const wdl_7 = a2|b1;                       //!< The white diagonal from a2 to b1.
00248 
00249 #if DEBUG_BITBOARD_INITIALIZATION
00250 uint64_t const bitboard_initialization_magic = 1212121212121212121;
00251 uint64_t const bitboard_destructed_magic = 555555555555555555;
00252 #endif
00253 
00254 /** @brief A one-boolean-per-square chessboard.
00255 * 
00256  * This class defines the interface for access to the bit-board.
00257 * 
00258  * Normally one should be hidden from the bit-level implemention (mask_t thus).
00259  * Instead use BitBoardData constant:
00260 * 
00261  * \link cwchess::a1 a1 \endlink, ..., \link cwchess::h8 h8 \endlink<br>
00262  * \link cwchess::file_a file_a \endlink, ..., \link cwchess::file_h file_h \endlink<br>
00263  * \link cwchess::rank_1 rank_1 \endlink, ..., \link cwchess::rank_8 rank_8 \endlink<br>
00264  * and others.
00265 * /
00266 class BitBoard : private BitBoardData {
00267 #if DEBUG_BITBOARD_INITIALIZATION
00268   private:
00269     uint64_t M_initialized;
00270 #endif
00271 
00272   public:
00273 #if DEBUG_BITBOARD_INITIALIZATION
00274     BitBoard(void) : M_initialized(0) { }    
00275     ~BitBoard(void) { M_initialized = bitboard_destructed_magic; }
00276 
00277     bool is_initialized(void) const { return M_initialized == bitboard_initialization_magic; }
00278 #else
00279   //! @name Constructors
00280   //@{
00281 
00282     //! Construct an uninitialized BitBoard.
00283     BitBoard(void) { }    
00284 
00285 #endif
00286 
00287     //! Construct a BitBoard from another BitBoard.
00288     BitBoard(BitBoard const& other)
00289     {
00290 #if DEBUG_BITBOARD_INITIALIZATION
00291       assert(other.is_initialized());
00292       M_initialized = bitboard_initialization_magic;
00293 #endif
00294       M_bitmask = other.M_bitmask;
00295     }
00296 
00297     //! Construct a BitBoard with a single bit set at \a index.
00298     BitBoard(Index const& index)
00299     {
00300 #if DEBUG_BITBOARD_INITIALIZATION
00301       M_initialized = bitboard_initialization_magic;
00302 #endif
00303       M_bitmask = index2mask(index);
00304     }
00305 
00306     //! Construct a BitBoard from a constant.
00307     BitBoard(BitBoardData data)
00308     {
00309 #if DEBUG_BITBOARD_INITIALIZATION
00310       M_initialized = bitboard_initialization_magic;
00311 #endif
00312       M_bitmask = data.M_bitmask;
00313     }
00314 
00315     //! Construct a BitBoard with a single bit set at \a col, \a row.
00316     BitBoard(int col, int row)
00317     {
00318 #if DEBUG_BITBOARD_INITIALIZATION
00319       M_initialized = bitboard_initialization_magic;
00320 #endif
00321       M_bitmask = colrow2mask(col, row);
00322     }
00323 
00324     //! Construct a BitBoard from a constant or mask (for internal use only).
00325     explicit BitBoard(mask_t bitmask)
00326     {
00327 #if DEBUG_BITBOARD_INITIALIZATION
00328       M_initialized = bitboard_initialization_magic;
00329 #endif
00330       M_bitmask = bitmask;
00331     }
00332 
00333   //@}
00334 
00335   //! @name Assignment operators
00336   //@{
00337 
00338     //! Assignment from other BitBoard.
00339     BitBoard& operator=(BitBoard const& bitboard)
00340     {
00341 #if DEBUG_BITBOARD_INITIALIZATION
00342       assert(bitboard.is_initialized());
00343       M_initialized = bitboard_initialization_magic;
00344 #endif
00345       M_bitmask = bitboard.M_bitmask;
00346       return* this;
00347     }
00348 
00349     //! Assignment from a constant.
00350     BitBoard& operator=(BitBoardData bitboard)
00351     {
00352 #if DEBUG_BITBOARD_INITIALIZATION
00353       M_initialized = bitboard_initialization_magic;
00354 #endif
00355       M_bitmask = bitboard.M_bitmask;
00356       return* this;
00357     }
00358 
00359   //@}
00360 
00361   //! @name Comparison operators
00362   //@{
00363 
00364     friend bool operator==(BitBoard const& b1, BitBoard const& b2) { return b1.M_bitmask == b2.M_bitmask; }
00365     friend bool operator==(BitBoard const& b1, BitBoardData b2) { return b1.M_bitmask == b2.M_bitmask; }
00366     friend bool operator==(BitBoardData b1, BitBoard const& b2) { return b1.M_bitmask == b2.M_bitmask; }
00367     friend bool operator!=(BitBoard const& b1, BitBoard const& b2) { return b1.M_bitmask != b2.M_bitmask; }
00368     friend bool operator!=(BitBoard const& b1, BitBoardData b2) { return b1.M_bitmask != b2.M_bitmask; }
00369     friend bool operator!=(BitBoardData b1, BitBoard const& b2) { return b1.M_bitmask != b2.M_bitmask; }
00370 
00371   //@}
00372 
00373   //! @name Initialization
00374   //@{
00375 
00376     //! Set all values to FALSE.
00377     void reset(void)
00378     {
00379 #if DEBUG_BITBOARD_INITIALIZATION
00380       M_initialized = bitboard_initialization_magic;
00381 #endif
00382       M_bitmask = 0; 
00383     }
00384 
00385     //! Set all values to TRUE.
00386     void set(void)
00387     {
00388 #if DEBUG_BITBOARD_INITIALIZATION
00389       M_initialized = bitboard_initialization_magic;
00390 #endif
00391       M_bitmask = CW_MASK_T_CONST(0xffffffffffffffff);
00392     }
00393 
00394   //@}
00395 
00396   //! @name Bit fiddling
00397   //@{
00398 
00399     //! @brief Reset the bit at \a col, \a row.
00400     void reset(int col, int row) { M_bitmask& = ~colrow2mask(col, row); }
00401 
00402     //! @brief Reset the bit at \a index.
00403     void reset(Index const& index) { M_bitmask& = ~index2mask(index); }
00404 
00405     //! @brief Reset the bits from \a mask.
00406     void reset(mask_t mask) { M_bitmask& = ~mask; }
00407 
00408     //! @brief Reset the bits from \a bitboard.
00409     void reset(BitBoardData bitboard) { M_bitmask& = ~bitboard.M_bitmask; }
00410 
00411     //! @brief Reset the bits from \a bitboard.
00412     void reset(BitBoard bitboard) { M_bitmask& = ~bitboard.M_bitmask; }
00413 
00414     //! @brief Set the bit at \a col, \a row.
00415     void set(int col, int row) { M_bitmask |= colrow2mask(col, row); }
00416 
00417     //! @brief Set the bit at \a index.
00418     void set(Index const& index) { M_bitmask |= index2mask(index); }
00419 
00420     //! @brief Set the bits from \a mask.
00421     void set(mask_t mask) { M_bitmask |= mask; }
00422 
00423     //! @brief Set the bits from \a bitboard.
00424     void set(BitBoardData bitboard) { M_bitmask |= bitboard.M_bitmask; }
00425 
00426     //! @brief Set the bits from \a bitboard.
00427     void set(BitBoard const& bitboard) { M_bitmask |= bitboard.M_bitmask; }
00428 
00429     //! @brief Toggle the bit at \a col, \a row.
00430     void toggle(int col, int row) { M_bitmask ^= colrow2mask(col, row); }
00431 
00432     //! @brief Toggle the bit at \a index.
00433     void toggle(Index const& index) { M_bitmask ^= index2mask(index); }
00434 
00435     //! @brief Toggle the bits from \a mask.
00436     void toggle(mask_t mask) { M_bitmask ^= mask; }
00437 
00438     //! @brief Toggle the bits from \a bitboard.
00439     void toggle(BitBoardData bitboard) { M_bitmask ^= bitboard.M_bitmask; }
00440 
00441     //! @brief Toggle the bits from \a bitboard.
00442     void toggle(BitBoard const& bitboard) { M_bitmask ^= bitboard.M_bitmask; }
00443 
00444   //@}
00445 
00446   //! @name Accessors
00447   //@{
00448 
00449     //! @brief Test if any bit is set at all.
00450     bool test(void) const { return M_bitmask; }
00451 
00452     //! @brief Test if the bit at \a col, \a row is set.
00453     bool test(int col, int row) const { return M_bitmask & colrow2mask(col, row); }
00454 
00455     //! @brief Test if the bit at \a index is set.
00456     bool test(Index const& index) const { return M_bitmask & index2mask(index); }
00457 
00458     //! @brief Test if any bit in \a mask is set.
00459     bool test(mask_t mask) const { return M_bitmask & mask; }
00460 
00461     //! @brief Test if any bit in \a bitboard is set.
00462     bool test(BitBoardData bitboard) const { return M_bitmask & bitboard.M_bitmask; }
00463 
00464     //! @brief Test if any bit in \a bitboard is set.
00465     bool test(BitBoard const& bitboard) const { return M_bitmask & bitboard.M_bitmask; }
00466 
00467     //! @brief Return the inverse of the bitboard.
00468     BitBoard operator~(void) const { return BitBoard(~M_bitmask); }
00469 
00470     //! @brief Return TRUE if the bitboard is not empty.
00471 #ifdef __x86_64
00472     operator void*(void) const { return reinterpret_cast<void*>(M_bitmask); }
00473 #else
00474     // Casting to void* would only give us the lower 32 bits.
00475     operator void*(void) const { return M_bitmask ? (void*)1 : 0; }
00476 #endif
00477 
00478     //! @brief Return the underlaying bitmask.
00479     mask_t operator()(void) const { return M_bitmask; }
00480 
00481   //@}
00482 
00483   //! @name Bit-wise OR operators with another BitBoard
00484   //@{
00485     BitBoard& operator|=(BitBoard const& bitboard) { M_bitmask |= bitboard.M_bitmask; return* this; }
00486     BitBoard& operator|=(BitBoardData bitboard) { M_bitmask |= bitboard.M_bitmask; return* this; }
00487     BitBoard& operator|=(mask_t bitmask) { M_bitmask |= bitmask; return* this; }
00488     friend BitBoard operator|(BitBoard const& bitboard1, BitBoard const& bitboard2) { return BitBoard(bitboard1.M_bitmask | bitboard2.M_bitmask); }
00489     friend BitBoard operator|(BitBoard const& bitboard1, BitBoardData bitboard2) { return BitBoard(bitboard1.M_bitmask | bitboard2.M_bitmask); }
00490     friend BitBoard operator|(BitBoardData bitboard1, BitBoard const& bitboard2) { return BitBoard(bitboard1.M_bitmask | bitboard2.M_bitmask); }
00491   //@}
00492 
00493   //! @name Bit-wise AND operators with another BitBoard
00494   //@{
00495     BitBoard& operator&=(BitBoard const& bitboard) { M_bitmask& = bitboard.M_bitmask; return* this; }
00496     BitBoard& operator&=(BitBoardData bitboard) { M_bitmask& = bitboard.M_bitmask; return* this; }
00497     BitBoard& operator&=(mask_t bitmask) { M_bitmask& = bitmask; return* this; }
00498     friend BitBoard operator&(BitBoard bitboard1, BitBoard bitboard2) { return BitBoard(bitboard1.M_bitmask & bitboard2.M_bitmask); }
00499     friend BitBoard operator&(BitBoard bitboard1, BitBoardData bitboard2) { return BitBoard(bitboard1.M_bitmask & bitboard2.M_bitmask); }
00500     friend BitBoard operator&(BitBoardData bitboard1, BitBoard bitboard2) { return BitBoard(bitboard1.M_bitmask & bitboard2.M_bitmask); }
00501   //@}
00502 
00503   //! @name Bit-wise XOR operators with another BitBoard
00504   //@{
00505     BitBoard& operator^=(BitBoard const& bitboard) { M_bitmask ^= bitboard.M_bitmask; return* this; }
00506     BitBoard& operator^=(BitBoardData bitboard) { M_bitmask ^= bitboard.M_bitmask; return* this; }
00507     BitBoard& operator^=(mask_t bitmask) { M_bitmask ^= bitmask; return* this; }
00508     friend BitBoard operator^(BitBoard bitboard1, BitBoard bitboard2) { return BitBoard(bitboard1.M_bitmask ^ bitboard2.M_bitmask); }
00509     friend BitBoard operator^(BitBoard bitboard1, BitBoardData bitboard2) { return BitBoard(bitboard1.M_bitmask ^ bitboard2.M_bitmask); }
00510     friend BitBoard operator^(BitBoardData bitboard1, BitBoard bitboard2) { return BitBoard(bitboard1.M_bitmask ^ bitboard2.M_bitmask); }
00511   //@}
00512 
00513 };
00514 
00515 } // namespace cwchess
00516 
00517 #endif  // BITBOARD_H