release/src/router/mysql/storage/ndb/include/util/Bitmask.hpp

   1 /* Copyright (c) 2003-2006, 2008 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA */
  15
  16 #ifndef NDB_BITMASK_H
  17 #define NDB_BITMASK_H
  18
  19 #include <ndb_global.h>
  20
  21 /**
  22  * Bitmask implementation.  Size is given explicitly
  23  * (as first argument).  All methods are static.
  24  */
  25 class BitmaskImpl {
  26 public:
  27   STATIC_CONST( NotFound = (unsigned)-1 );
  28
  29   /**
  30    * get - Check if bit n is set.
  31    */
  32   static bool get(unsigned size, const Uint32 data[], unsigned n);
  33
  34   /**
  35    * set - Set bit n to given value (true/false).
  36    */
  37   static void set(unsigned size, Uint32 data[], unsigned n, bool value);
  38
  39   /**
  40    * set - Set bit n.
  41    */
  42   static void set(unsigned size, Uint32 data[], unsigned n);
  43
  44   /**
  45    * set - Set all bits.
  46    */
  47   static void set(unsigned size, Uint32 data[]);
  48
  49   /**
  50    * set bit from <em>start</em> to <em>last</em>
  51    */
  52   static void set_range(unsigned size, Uint32 data[], unsigned start, unsigned last);
  53
  54   /**
  55    * assign - Set all bits in <em>dst</em> to corresponding in <em>src/<em>
  56    */
  57   static void assign(unsigned size, Uint32 dst[], const Uint32 src[]);
  58
  59   /**
  60    * clear - Clear bit n.
  61    */
  62   static void clear(unsigned size, Uint32 data[], unsigned n);
  63
  64   /**
  65    * clear - Clear all bits.
  66    */
  67   static void clear(unsigned size, Uint32 data[]);
  68
  69   /**
  70    * clear bit from <em>start</em> to <em>last</em>
  71    */
  72   static void clear_range(unsigned size, Uint32 data[], unsigned start, unsigned last);
  73
  74   static Uint32 getWord(unsigned size, Uint32 data[], unsigned word_pos);
  75   static void setWord(unsigned size, Uint32 data[],
  76                       unsigned word_pos, Uint32 new_word);
  77   /**
  78    * isclear -  Check if all bits are clear.  This is faster
  79    * than checking count() == 0.
  80    */
  81   static bool isclear(unsigned size, const Uint32 data[]);
  82
  83   /**
  84    * count - Count number of set bits.
  85    */
  86   static unsigned count(unsigned size, const Uint32 data[]);
  87
  88   /**
  89    * find - Find first set bit, starting at given position.
  90    * Returns NotFound when not found.
  91    */
  92   static unsigned find(unsigned size, const Uint32 data[], unsigned n);
  93
  94   /**
  95    * equal - Bitwise equal.
  96    */
  97   static bool equal(unsigned size, const Uint32 data[], const Uint32 data2[]);
  98
  99   /**
 100    * bitOR - Bitwise (x | y) into first operand.
 101    */
 102   static void bitOR(unsigned size, Uint32 data[], const Uint32 data2[]);
 103
 104   /**
 105    * bitAND - Bitwise (x & y) into first operand.
 106    */
 107   static void bitAND(unsigned size, Uint32 data[], const Uint32 data2[]);
 108
 109   /**
 110    * bitANDC - Bitwise (x & ~y) into first operand.
 111    */
 112   static void bitANDC(unsigned size, Uint32 data[], const Uint32 data2[]);
 113
 114   /**
 115    * bitXOR - Bitwise (x ^ y) into first operand.
 116    */
 117   static void bitXOR(unsigned size, Uint32 data[], const Uint32 data2[]);
 118
 119   /**
 120    * bitXORC - Bitwise (x ^ ~y) into first operand.
 121    */
 122   static void bitXORC(unsigned size, Uint32 data[], const Uint32 data2[]);
 123
 124   /**
 125    * contains - Check if all bits set in data2 are set in data
 126    */
 127   static bool contains(unsigned size, Uint32 data[], const Uint32 data2[]);
 128
 129   /**
 130    * overlaps - Check if any bit set in data is set in data2
 131    */
 132   static bool overlaps(unsigned size, Uint32 data[], const Uint32 data2[]);
 133
 134   /**
 135    * getField - Get bitfield at given position and length (max 32 bits)
 136    */
 137   static Uint32 getField(unsigned size, const Uint32 data[],
 138       unsigned pos, unsigned len);
 139
 140   /**
 141    * setField - Set bitfield at given position and length (max 32 bits)
 142    * Note : length == 0 not supported.
 143    */
 144   static void setField(unsigned size, Uint32 data[],
 145       unsigned pos, unsigned len, Uint32 val);
 146
 147
 148   /**
 149    * getField - Get bitfield at given position and length
 150    * Note : length == 0 not supported.
 151    */
 152   static void getField(unsigned size, const Uint32 data[],
 153                        unsigned pos, unsigned len, Uint32 dst[]);
 154
 155   /**
 156    * setField - Set bitfield at given position and length
 157    */
 158   static void setField(unsigned size, Uint32 data[],
 159                        unsigned pos, unsigned len, const Uint32 src[]);
 160
 161   /**
 162    * getText - Return as hex-digits (only for debug routines).
 163    */
 164   static char* getText(unsigned size, const Uint32 data[], char* buf);
 165 private:
 166   static void getFieldImpl(const Uint32 data[], unsigned, unsigned, Uint32 []);
 167   static void setFieldImpl(Uint32 data[], unsigned, unsigned, const Uint32 []);
 168 };
 169
 170 inline bool
 171 BitmaskImpl::get(unsigned size, const Uint32 data[], unsigned n)
 172 {
 173   assert(n < (size << 5));
 174   return (data[n >> 5] & (1 << (n & 31))) != 0;
 175 }
 176
 177 inline void
 178 BitmaskImpl::set(unsigned size, Uint32 data[], unsigned n, bool value)
 179 {
 180   value ? set(size, data, n) : clear(size, data, n);
 181 }
 182
 183 inline void
 184 BitmaskImpl::set(unsigned size, Uint32 data[], unsigned n)
 185 {
 186   assert(n < (size << 5));
 187   data[n >> 5] |= (1 << (n & 31));
 188 }
 189
 190 inline void
 191 BitmaskImpl::set(unsigned size, Uint32 data[])
 192 {
 193   for (unsigned i = 0; i < size; i++) {
 194     data[i] = ~0;
 195   }
 196 }
 197
 198 inline void
 199 BitmaskImpl::set_range(unsigned size, Uint32 data[],
 200                        unsigned start, unsigned last)
 201 {
 202   Uint32 *ptr = data + (start >> 5);
 203   Uint32 *end =  data + (last >> 5);
 204   assert(start <= last);
 205   assert(last < (size << 5));
 206
 207   Uint32 tmp_word = ~(Uint32)0 << (start & 31);
 208
 209   if (ptr < end)
 210   {
 211     * ptr ++ |= tmp_word;
 212
 213     for(; ptr < end; )
 214     {
 215       * ptr ++ = ~(Uint32)0;
 216     }
 217
 218     tmp_word = ~(Uint32)0;
 219   }
 220
 221   tmp_word &= ~(~(Uint32)0 << (last & 31));
 222
 223   * ptr |= tmp_word;
 224 }
 225
 226 inline void
 227 BitmaskImpl::assign(unsigned size, Uint32 dst[], const Uint32 src[])
 228 {
 229   for (unsigned i = 0; i < size; i++) {
 230     dst[i] = src[i];
 231   }
 232 }
 233
 234 inline void
 235 BitmaskImpl::clear(unsigned size, Uint32 data[], unsigned n)
 236 {
 237   assert(n < (size << 5));
 238   data[n >> 5] &= ~(1 << (n & 31));
 239 }
 240
 241 inline void
 242 BitmaskImpl::clear(unsigned size, Uint32 data[])
 243 {
 244   for (unsigned i = 0; i < size; i++) {
 245     data[i] = 0;
 246   }
 247 }
 248
 249 inline void
 250 BitmaskImpl::clear_range(unsigned size, Uint32 data[],
 251                          unsigned start, unsigned last)
 252 {
 253   Uint32 *ptr = data + (start >> 5);
 254   Uint32 *end =  data + (last >> 5);
 255   assert(start <= last);
 256   assert(last < (size << 5));
 257
 258   Uint32 tmp_word = ~(Uint32)0 << (start & 31);
 259
 260   if (ptr < end)
 261   {
 262     * ptr ++ &= ~tmp_word;
 263
 264     for(; ptr < end; )
 265     {
 266       * ptr ++ = 0;
 267     }
 268
 269     tmp_word = ~(Uint32)0;
 270   }
 271
 272   tmp_word &= ~(~(Uint32)0 << (last & 31));
 273
 274   * ptr &= ~tmp_word;
 275 }
 276
 277 inline
 278 Uint32
 279 BitmaskImpl::getWord(unsigned size, Uint32 data[], unsigned word_pos)
 280 {
 281   return data[word_pos];
 282 }
 283
 284 inline void
 285 BitmaskImpl::setWord(unsigned size, Uint32 data[],
 286                      unsigned word_pos, Uint32 new_word)
 287 {
 288   data[word_pos] = new_word;
 289   return;
 290 }
 291
 292 inline bool
 293 BitmaskImpl::isclear(unsigned size, const Uint32 data[])
 294 {
 295   for (unsigned i = 0; i < size; i++) {
 296     if (data[i] != 0)
 297       return false;
 298   }
 299   return true;
 300 }
 301
 302 inline unsigned
 303 BitmaskImpl::count(unsigned size, const Uint32 data[])
 304 {
 305   unsigned cnt = 0;
 306   for (unsigned i = 0; i < size; i++) {
 307     Uint32 x = data[i];
 308     while (x) {
 309       x &= (x - 1);
 310       cnt++;
 311     }
 312   }
 313   return cnt;
 314 }
 315
 316 inline unsigned
 317 BitmaskImpl::find(unsigned size, const Uint32 data[], unsigned n)
 318 {
 319   while (n < (size << 5)) {             // XXX make this smarter
 320     if (get(size, data, n)) {
 321       return n;
 322     }
 323     n++;
 324   }
 325   return NotFound;
 326 }
 327
 328 inline bool
 329 BitmaskImpl::equal(unsigned size, const Uint32 data[], const Uint32 data2[])
 330 {
 331   for (unsigned i = 0; i < size; i++) {
 332     if (data[i] != data2[i])
 333       return false;
 334   }
 335   return true;
 336 }
 337
 338 inline void
 339 BitmaskImpl::bitOR(unsigned size, Uint32 data[], const Uint32 data2[])
 340 {
 341   for (unsigned i = 0; i < size; i++) {
 342     data[i] |= data2[i];
 343   }
 344 }
 345
 346 inline void
 347 BitmaskImpl::bitAND(unsigned size, Uint32 data[], const Uint32 data2[])
 348 {
 349   for (unsigned i = 0; i < size; i++) {
 350     data[i] &= data2[i];
 351   }
 352 }
 353
 354 inline void
 355 BitmaskImpl::bitANDC(unsigned size, Uint32 data[], const Uint32 data2[])
 356 {
 357   for (unsigned i = 0; i < size; i++) {
 358     data[i] &= ~data2[i];
 359   }
 360 }
 361
 362 inline void
 363 BitmaskImpl::bitXOR(unsigned size, Uint32 data[], const Uint32 data2[])
 364 {
 365   for (unsigned i = 0; i < size; i++) {
 366     data[i] ^= data2[i];
 367   }
 368 }
 369
 370 inline void
 371 BitmaskImpl::bitXORC(unsigned size, Uint32 data[], const Uint32 data2[])
 372 {
 373   for (unsigned i = 0; i < size; i++) {
 374     data[i] ^= ~data2[i];
 375   }
 376 }
 377
 378 inline bool
 379 BitmaskImpl::contains(unsigned size, Uint32 data[], const Uint32 data2[])
 380 {
 381   for (unsigned int i = 0; i < size; i++)
 382     if ((data[i] & data2[i]) != data2[i])
 383       return false;
 384   return true;
 385 }
 386
 387 inline bool
 388 BitmaskImpl::overlaps(unsigned size, Uint32 data[], const Uint32 data2[])
 389 {
 390   for (unsigned int i = 0; i < size; i++)
 391     if ((data[i] & data2[i]) != 0)
 392       return true;
 393   return false;
 394 }
 395
 396 inline Uint32
 397 BitmaskImpl::getField(unsigned size, const Uint32 data[],
 398     unsigned pos, unsigned len)
 399 {
 400   Uint32 val = 0;
 401   for (unsigned i = 0; i < len; i++)
 402     val |= get(size, data, pos + i) << i;
 403   return val;
 404 }
 405
 406 inline void
 407 BitmaskImpl::setField(unsigned size, Uint32 data[],
 408     unsigned pos, unsigned len, Uint32 val)
 409 {
 410   for (unsigned i = 0; i < len; i++)
 411     set(size, data, pos + i, val & (1 << i));
 412 }
 413
 414 inline char *
 415 BitmaskImpl::getText(unsigned size, const Uint32 data[], char* buf)
 416 {
 417   char * org = buf;
 418   const char* const hex = "0123456789abcdef";
 419   for (int i = (size-1); i >= 0; i--) {
 420     Uint32 x = data[i];
 421     for (unsigned j = 0; j < 8; j++) {
 422       buf[7-j] = hex[x & 0xf];
 423       x >>= 4;
 424     }
 425     buf += 8;
 426   }
 427   *buf = 0;
 428   return org;
 429 }
 430
 431 /**
 432  * Bitmasks.  The size is number of 32-bit words (Uint32).
 433  * Unused bits in the last word must be zero.
 434  *
 435  * XXX replace size by length in bits
 436  */
 437 template <unsigned size>
 438 struct BitmaskPOD {
 439 public:
 440   /**
 441    * POD data representation
 442    */
 443   struct Data {
 444     Uint32 data[size];
 445 #if 0
 446     Data & operator=(const BitmaskPOD<size> & src) {
 447       src.copyto(size, data);
 448       return *this;
 449     }
 450 #endif
 451   };
 452 private:
 453
 454   Data rep;
 455 public:
 456   STATIC_CONST( Size = size );
 457   STATIC_CONST( NotFound = BitmaskImpl::NotFound );
 458   STATIC_CONST( TextLength = size * 8 );
 459
 460   /**
 461    * assign - Set all bits in <em>dst</em> to corresponding in <em>src/<em>
 462    */
 463   void assign(const typename BitmaskPOD<size>::Data & src);
 464
 465   /**
 466    * assign - Set all bits in <em>dst</em> to corresponding in <em>src/<em>
 467    */
 468   static void assign(Uint32 dst[], const Uint32 src[]);
 469   static void assign(Uint32 dst[], const BitmaskPOD<size> & src);
 470   void assign(const BitmaskPOD<size> & src);
 471
 472   /**
 473    * copy this to <em>dst</em>
 474    */
 475   void copyto(unsigned sz, Uint32 dst[]) const;
 476
 477   /**
 478    * assign <em>this</em> according to <em>src/em>
 479    */
 480   void assign(unsigned sz, const Uint32 src[]);
 481
 482   /**
 483    * get - Check if bit n is set.
 484    */
 485   static bool get(const Uint32 data[], unsigned n);
 486   bool get(unsigned n) const;
 487
 488   /**
 489    * set - Set bit n to given value (true/false).
 490    */
 491   static void set(Uint32 data[], unsigned n, bool value);
 492   void set(unsigned n, bool value);
 493
 494   /**
 495    * set - Set bit n.
 496    */
 497   static void set(Uint32 data[], unsigned n);
 498   void set(unsigned n);
 499
 500   /**
 501    * set - set all bits.
 502    */
 503   static void set(Uint32 data[]);
 504   void set();
 505
 506   /**
 507    * clear - Clear bit n.
 508    */
 509   static void clear(Uint32 data[], unsigned n);
 510   void clear(unsigned n);
 511
 512   /**
 513    * clear - Clear all bits.
 514    */
 515   static void clear(Uint32 data[]);
 516   void clear();
 517
 518   /**
 519    * Get and set words of bits
 520    */
 521   Uint32 getWord(unsigned word_pos);
 522   void setWord(unsigned word_pos, Uint32 new_word);
 523
 524   /**
 525    * isclear -  Check if all bits are clear.  This is faster
 526    * than checking count() == 0.
 527    */
 528   static bool isclear(const Uint32 data[]);
 529   bool isclear() const;
 530
 531   /**
 532    * count - Count number of set bits.
 533    */
 534   static unsigned count(const Uint32 data[]);
 535   unsigned count() const;
 536
 537   /**
 538    * find - Find first set bit, starting at given position.
 539    * Returns NotFound when not found.
 540    */
 541   static unsigned find(const Uint32 data[], unsigned n);
 542   unsigned find(unsigned n) const;
 543
 544   /**
 545    * equal - Bitwise equal.
 546    */
 547   static bool equal(const Uint32 data[], const Uint32 data2[]);
 548   bool equal(const BitmaskPOD<size>& mask2) const;
 549
 550   /**
 551    * bitOR - Bitwise (x | y) into first operand.
 552    */
 553   static void bitOR(Uint32 data[], const Uint32 data2[]);
 554   BitmaskPOD<size>& bitOR(const BitmaskPOD<size>& mask2);
 555
 556   /**
 557    * bitAND - Bitwise (x & y) into first operand.
 558    */
 559   static void bitAND(Uint32 data[], const Uint32 data2[]);
 560   BitmaskPOD<size>& bitAND(const BitmaskPOD<size>& mask2);
 561
 562   /**
 563    * bitANDC - Bitwise (x & ~y) into first operand.
 564    */
 565   static void bitANDC(Uint32 data[], const Uint32 data2[]);
 566   BitmaskPOD<size>& bitANDC(const BitmaskPOD<size>& mask2);
 567
 568   /**
 569    * bitXOR - Bitwise (x ^ y) into first operand.
 570    */
 571   static void bitXOR(Uint32 data[], const Uint32 data2[]);
 572   BitmaskPOD<size>& bitXOR(const BitmaskPOD<size>& mask2);
 573
 574   /**
 575    * bitXORC - Bitwise (x ^ ~y) into first operand.
 576    */
 577   static void bitXORC(Uint32 data[], const Uint32 data2[]);
 578   BitmaskPOD<size>& bitXORC(const BitmaskPOD<size>& mask2);
 579
 580   /**
 581    * contains - Check if all bits set in data2 (that) are also set in data (this)
 582    */
 583   static bool contains(Uint32 data[], const Uint32 data2[]);
 584   bool contains(BitmaskPOD<size> that);
 585
 586   /**
 587    * overlaps - Check if any bit set in this BitmaskPOD (data) is also set in that (data2)
 588    */
 589   static bool overlaps(Uint32 data[], const Uint32 data2[]);
 590   bool overlaps(BitmaskPOD<size> that);
 591
 592   /**
 593    * getText - Return as hex-digits (only for debug routines).
 594    */
 595   static char* getText(const Uint32 data[], char* buf);
 596   char* getText(char* buf) const;
 597 };
 598
 599 template <unsigned size>
 600 inline void
 601 BitmaskPOD<size>::assign(Uint32 dst[], const Uint32 src[])
 602 {
 603   BitmaskImpl::assign(size, dst, src);
 604 }
 605
 606 template <unsigned size>
 607 inline void
 608 BitmaskPOD<size>::assign(Uint32 dst[], const BitmaskPOD<size> & src)
 609 {
 610   BitmaskImpl::assign(size, dst, src.rep.data);
 611 }
 612
 613 template <unsigned size>
 614 inline void
 615 BitmaskPOD<size>::assign(const typename BitmaskPOD<size>::Data & src)
 616 {
 617   BitmaskPOD<size>::assign(rep.data, src.data);
 618 }
 619
 620 template <unsigned size>
 621 inline void
 622 BitmaskPOD<size>::assign(const BitmaskPOD<size> & src)
 623 {
 624   BitmaskPOD<size>::assign(rep.data, src.rep.data);
 625 }
 626
 627 template <unsigned size>
 628 inline void
 629 BitmaskPOD<size>::copyto(unsigned sz, Uint32 dst[]) const
 630 {
 631   BitmaskImpl::assign(sz, dst, rep.data);
 632 }
 633
 634 template <unsigned size>
 635 inline void
 636 BitmaskPOD<size>::assign(unsigned sz, const Uint32 src[])
 637 {
 638   BitmaskImpl::assign(sz, rep.data, src);
 639 }
 640
 641 template <unsigned size>
 642 inline bool
 643 BitmaskPOD<size>::get(const Uint32 data[], unsigned n)
 644 {
 645   return BitmaskImpl::get(size, data, n);
 646 }
 647
 648 template <unsigned size>
 649 inline bool
 650 BitmaskPOD<size>::get(unsigned n) const
 651 {
 652   return BitmaskPOD<size>::get(rep.data, n);
 653 }
 654
 655 template <unsigned size>
 656 inline void
 657 BitmaskPOD<size>::set(Uint32 data[], unsigned n, bool value)
 658 {
 659   BitmaskImpl::set(size, data, n, value);
 660 }
 661
 662 template <unsigned size>
 663 inline void
 664 BitmaskPOD<size>::set(unsigned n, bool value)
 665 {
 666   BitmaskPOD<size>::set(rep.data, n, value);
 667 }
 668
 669 template <unsigned size>
 670 inline void
 671 BitmaskPOD<size>::set(Uint32 data[], unsigned n)
 672 {
 673   BitmaskImpl::set(size, data, n);
 674 }
 675
 676 template <unsigned size>
 677 inline void
 678 BitmaskPOD<size>::set(unsigned n)
 679 {
 680   BitmaskPOD<size>::set(rep.data, n);
 681 }
 682
 683 template <unsigned size>
 684 inline void
 685 BitmaskPOD<size>::set(Uint32 data[])
 686 {
 687   BitmaskImpl::set(size, data);
 688 }
 689
 690 template <unsigned size>
 691 inline void
 692 BitmaskPOD<size>::set()
 693 {
 694   BitmaskPOD<size>::set(rep.data);
 695 }
 696
 697 template <unsigned size>
 698 inline void
 699 BitmaskPOD<size>::clear(Uint32 data[], unsigned n)
 700 {
 701   BitmaskImpl::clear(size, data, n);
 702 }
 703
 704 template <unsigned size>
 705 inline void
 706 BitmaskPOD<size>::clear(unsigned n)
 707 {
 708   BitmaskPOD<size>::clear(rep.data, n);
 709 }
 710
 711 template <unsigned size>
 712 inline void
 713 BitmaskPOD<size>::clear(Uint32 data[])
 714 {
 715   BitmaskImpl::clear(size, data);
 716 }
 717
 718 template <unsigned size>
 719 inline void
 720 BitmaskPOD<size>::clear()
 721 {
 722   BitmaskPOD<size>::clear(rep.data);
 723 }
 724
 725 template <unsigned size>
 726 inline Uint32
 727 BitmaskPOD<size>::getWord(unsigned word_pos)
 728 {
 729   return BitmaskImpl::getWord(size, rep.data, word_pos);
 730 }
 731
 732 template <unsigned size>
 733 inline void
 734 BitmaskPOD<size>::setWord(unsigned word_pos, Uint32 new_word)
 735 {
 736   BitmaskImpl::setWord(size, rep.data, word_pos, new_word);
 737 }
 738
 739 template <unsigned size>
 740 inline bool
 741 BitmaskPOD<size>::isclear(const Uint32 data[])
 742 {
 743   return BitmaskImpl::isclear(size, data);
 744 }
 745
 746 template <unsigned size>
 747 inline bool
 748 BitmaskPOD<size>::isclear() const
 749 {
 750   return BitmaskPOD<size>::isclear(rep.data);
 751 }
 752
 753 template <unsigned size>
 754 unsigned
 755 BitmaskPOD<size>::count(const Uint32 data[])
 756 {
 757   return BitmaskImpl::count(size, data);
 758 }
 759
 760 template <unsigned size>
 761 inline unsigned
 762 BitmaskPOD<size>::count() const
 763 {
 764   return BitmaskPOD<size>::count(rep.data);
 765 }
 766
 767 template <unsigned size>
 768 unsigned
 769 BitmaskPOD<size>::find(const Uint32 data[], unsigned n)
 770 {
 771   return BitmaskImpl::find(size, data, n);
 772 }
 773
 774 template <unsigned size>
 775 inline unsigned
 776 BitmaskPOD<size>::find(unsigned n) const
 777 {
 778   return BitmaskPOD<size>::find(rep.data, n);
 779 }
 780
 781 template <unsigned size>
 782 inline bool
 783 BitmaskPOD<size>::equal(const Uint32 data[], const Uint32 data2[])
 784 {
 785   return BitmaskImpl::equal(size, data, data2);
 786 }
 787
 788 template <unsigned size>
 789 inline bool
 790 BitmaskPOD<size>::equal(const BitmaskPOD<size>& mask2) const
 791 {
 792   return BitmaskPOD<size>::equal(rep.data, mask2.rep.data);
 793 }
 794
 795 template <unsigned size>
 796 inline void
 797 BitmaskPOD<size>::bitOR(Uint32 data[], const Uint32 data2[])
 798 {
 799   BitmaskImpl::bitOR(size,data, data2);
 800 }
 801
 802 template <unsigned size>
 803 inline BitmaskPOD<size>&
 804 BitmaskPOD<size>::bitOR(const BitmaskPOD<size>& mask2)
 805 {
 806   BitmaskPOD<size>::bitOR(rep.data, mask2.rep.data);
 807   return *this;
 808 }
 809
 810 template <unsigned size>
 811 inline void
 812 BitmaskPOD<size>::bitAND(Uint32 data[], const Uint32 data2[])
 813 {
 814   BitmaskImpl::bitAND(size,data, data2);
 815 }
 816
 817 template <unsigned size>
 818 inline BitmaskPOD<size>&
 819 BitmaskPOD<size>::bitAND(const BitmaskPOD<size>& mask2)
 820 {
 821   BitmaskPOD<size>::bitAND(rep.data, mask2.rep.data);
 822   return *this;
 823 }
 824
 825 template <unsigned size>
 826 inline void
 827 BitmaskPOD<size>::bitANDC(Uint32 data[], const Uint32 data2[])
 828 {
 829   BitmaskImpl::bitANDC(size,data, data2);
 830 }
 831
 832 template <unsigned size>
 833 inline BitmaskPOD<size>&
 834 BitmaskPOD<size>::bitANDC(const BitmaskPOD<size>& mask2)
 835 {
 836   BitmaskPOD<size>::bitANDC(rep.data, mask2.rep.data);
 837   return *this;
 838 }
 839
 840 template <unsigned size>
 841 inline void
 842 BitmaskPOD<size>::bitXOR(Uint32 data[], const Uint32 data2[])
 843 {
 844   BitmaskImpl::bitXOR(size,data, data2);
 845 }
 846
 847 template <unsigned size>
 848 inline BitmaskPOD<size>&
 849 BitmaskPOD<size>::bitXOR(const BitmaskPOD<size>& mask2)
 850 {
 851   BitmaskPOD<size>::bitXOR(rep.data, mask2.rep.data);
 852   return *this;
 853 }
 854
 855 template <unsigned size>
 856 inline void
 857 BitmaskPOD<size>::bitXORC(Uint32 data[], const Uint32 data2[])
 858 {
 859   BitmaskImpl::bitXORC(size,data, data2);
 860 }
 861
 862 template <unsigned size>
 863 inline BitmaskPOD<size>&
 864 BitmaskPOD<size>::bitXORC(const BitmaskPOD<size>& mask2)
 865 {
 866   BitmaskPOD<size>::bitXORC(rep.data, mask2.rep.data);
 867   return *this;
 868 }
 869
 870 template <unsigned size>
 871 char *
 872 BitmaskPOD<size>::getText(const Uint32 data[], char* buf)
 873 {
 874   return BitmaskImpl::getText(size, data, buf);
 875 }
 876
 877 template <unsigned size>
 878 inline char *
 879 BitmaskPOD<size>::getText(char* buf) const
 880 {
 881   return BitmaskPOD<size>::getText(rep.data, buf);
 882 }
 883
 884 template <unsigned size>
 885 inline bool
 886 BitmaskPOD<size>::contains(Uint32 data[], const Uint32 data2[])
 887 {
 888   return BitmaskImpl::contains(size, data, data2);
 889 }
 890
 891 template <unsigned size>
 892 inline bool
 893 BitmaskPOD<size>::contains(BitmaskPOD<size> that)
 894 {
 895   return BitmaskPOD<size>::contains(this->rep.data, that.rep.data);
 896 }
 897
 898 template <unsigned size>
 899 inline bool
 900 BitmaskPOD<size>::overlaps(Uint32 data[], const Uint32 data2[])
 901 {
 902   return BitmaskImpl::overlaps(size, data, data2);
 903 }
 904
 905 template <unsigned size>
 906 inline bool
 907 BitmaskPOD<size>::overlaps(BitmaskPOD<size> that)
 908 {
 909   return BitmaskPOD<size>::overlaps(this->rep.data, that.rep.data);
 910 }
 911
 912 template <unsigned size>
 913 class Bitmask : public BitmaskPOD<size> {
 914 public:
 915   Bitmask() { this->clear();}
 916 };
 917
 918 inline void
 919 BitmaskImpl::getField(unsigned size, const Uint32 src[],
 920                       unsigned pos, unsigned len, Uint32 dst[])
 921 {
 922   assert(pos + len <= (size << 5));
 923   assert (len != 0);
 924   if (len == 0)
 925     return;
 926
 927   src += (pos >> 5);
 928   Uint32 offset = pos & 31;
 929   * dst = (* src >> offset) & (len >= 32 ? ~0 : (1 << len) - 1);
 930
 931   if(offset + len <= 32)
 932   {
 933     return;
 934   }
 935   Uint32 used = (32 - offset);
 936   assert(len > used);
 937   getFieldImpl(src+1, used & 31, len-used, dst+(used >> 5));
 938 }
 939
 940 inline void
 941 BitmaskImpl::setField(unsigned size, Uint32 dst[],
 942                       unsigned pos, unsigned len, const Uint32 src[])
 943 {
 944   assert(pos + len <= (size << 5));
 945   assert(len != 0);
 946   if (len == 0)
 947     return;
 948
 949   dst += (pos >> 5);
 950   Uint32 offset = pos & 31;
 951   Uint32 mask = (len >= 32 ? ~0 : (1 << len) - 1) << offset;
 952
 953   * dst = (* dst & ~mask) | ((*src << offset) & mask);
 954
 955   if(offset + len <= 32)
 956   {
 957     return;
 958   }
 959   Uint32 used = (32 - offset);
 960   assert(len > used);
 961   setFieldImpl(dst+1, used & 31, len-used, src+(used >> 5));
 962 }
 963
 964
 965 #endif