bitvector.h:

  new file

sql/bitvector.h

+/* -*- Mode: C++ -*-
+
+   Copyright (C) 2005 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; either version 2 of the License, or
+   (at your option) any later version.
+
+   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 BITVECTOR_H
+#define BITVECTOR_H
+
+#include <my_global.h>
+#include <my_sys.h>
+#include <cstring>
+#include <climits>
+
+/* Some compile-time checks to ensure the integrity of the implementation. */
+#if CHAR_BIT != 8
+#  error "This implementation is designed for 8-bit bytes!"
+#endif
+
+#ifndef __cplusplus
+#  error "This is not a C header file, it's a C++ header file"
+#endif
+
+namespace
+{
+  /* Defining my own swap, since we cannot use std::swap() */
+  template <class T>
+  inline void my_swap(T& x, T& y)
+  { 
+    T t(x); x= y; y= t; 
+  }
+}
+
+/*
+  A run-time sized bitvector for storing bits.
+
+  
+  CAVEAT
+
+    This class is not designed to be inherited from, please don't do that.
+
+    Right now, the vector cannot change size. It's only used as a replacement
+    for using an array of bytes and a counter. If you want to change the size
+    of the vector, construct a new bitvector and assign it to the vector,
+    e.g.:
+
+      bitvector new_bv(new_size);
+      old_bv= new_bv;
+
+    An alternative is to use the swap member function to replace the instance:
+
+      bitvector new_bv(new_size);
+      old_bv.swap(new_bv);
+
+    The latter may be more efficient on compilers that are not so good at
+    inlining code.
+*/
+
+class bitvector
+{
+private:
+  /* Helper classes */
+  struct flip_bit_op
+  { 
+    void operator()(byte* p, byte m) { *p^= m; }
+  };
+
+  struct set_bit_op
+  { 
+    void operator()(byte* p, byte m) { *p|= m; }
+  };
+
+  struct clear_bit_op
+  { 
+    void operator()(byte* p, byte m) { *p&= ~m; }
+  };
+
+  struct test_bit_op
+  { 
+    bool operator()(byte* p, byte m) { return *p & m; }
+  };
+
+  /* Compute the number of bytes required to store 'bits' bits in an array. */
+  static inline size_t byte_size(size_t bits)
+  { 
+    int const byte_bits = sizeof(byte) * CHAR_BIT;
+    return (bits + (byte_bits-1)) / byte_bits; 
+  }
+
+  /* Tidy the last byte (by clearing the unused bits) of the bitvector to make
+   * comparison easy.  This code is assuming that we're working with 8-bit
+   * bytes.
+   */
+  void tidy_last_byte()
+  {
+    byte* const last_byte= m_data + bytes() - 1;
+
+    /* Get the number of used bits (1..8) in the last byte */
+    unsigned int const used= 1U + ((size()-1U) & 0x7U);
+
+    /* Create a mask with the upper 'unused' bits clear and the lower 'used'
+     * bits set. The bits within each byte is stored in big-endian order.
+     */
+    unsigned int const mask= ((1 << used) - 1);
+
+    /* Mask the last byte */
+    *last_byte&= mask;
+  }
+
+  template <class ReturnType, class Func>
+  inline ReturnType apply_to_byte(size_t const pos, Func op) const
+  {
+    /* Here I'm assuming that we're working with 8-bit bytes. */
+    ptrdiff_t const byte_pos= pos >> 3;
+    byte const mask= (1 << (pos & 0x7U));
+    return op(&m_data[byte_pos], mask);
+  }
+
+public:
+  bitvector() 
+    : m_size(0), m_data(0)
+  {
+  }
+
+  explicit bitvector(size_t size, bool value= false) 
+    : m_size(size), m_data(my_malloc(byte_size(size), MYF(0)))
+  {
+    if (value)
+      set_all();
+    else
+      clear_all();
+  }
+
+  /* Constructor to create a bitvector from data. Observe that 'size' is the
+   * number of *bits* in the bitvector. 
+   */
+  explicit bitvector(byte const* data, size_t size)
+    : m_size(size), m_data(my_malloc(byte_size(size), MYF(0)))
+  {
+    /* std::copy(data, data + byte_size(size), m_data); */
+    memcpy(m_data, data, byte_size(size));
+    tidy_last_byte();
+  }
+
+  bitvector(bitvector const& other) 
+    : m_size(other.size()), m_data(my_malloc(other.bytes(), MYF(0)))
+  {
+    /* std::copy(other.m_data, other.m_data + other.bytes(), m_data); */
+    memcpy(m_data, other.data(), other.bytes());
+    tidy_last_byte();           /* Just a precaution */
+  }
+
+  /* Assignment operator */
+  bitvector& operator=(bitvector other)
+  {
+    swap(other);
+    return *this;
+  }
+
+  ~bitvector() 
+  {
+    if (m_data)
+      my_free(m_data, MYF(0));
+  }
+
+  /* Swap the guts of this instance with another instance. */
+  void swap(bitvector& other)
+  {
+    my_swap(m_size, other.m_size);
+    my_swap(m_data, other.m_data);
+  }
+
+  /* A pointer to the bytes representing the bits */
+  byte const *data() const { return m_data; }
+
+  /* The size of the data in *bytes* */
+  size_t bytes() const { return byte_size(m_size); }
+
+  /* The number of bits in the bit vector */
+  size_t size() const { return m_size; }
+
+  /* Set all bits in the vector */
+  void set_all()
+  { 
+    /* std::fill_n(m_data, bytes(), 255); */
+    memset(m_data, 255, bytes()); 
+    tidy_last_byte();
+  }
+
+  /* Set a bit to a value */
+  void set_bit(size_t pos)
+  {
+    apply_to_byte<void>(pos, set_bit_op());
+  }
+
+  /* Reset (clear) all bits in the vector */
+  void clear_all()
+  { 
+    /* std::fill_n(m_data, bytes(), 0); */
+    memset(m_data, 0, bytes()); 
+    tidy_last_byte();
+  }
+
+  /* Reset one bit in the vector */
+  void clear_bit(size_t pos)
+  {
+    apply_to_byte<void>(pos, clear_bit_op());
+  }
+
+  void flip_bit(size_t pos)
+  {
+    apply_to_byte<void>(pos, flip_bit_op());
+  }
+
+  bool get_bit(size_t pos) const
+  {
+    return apply_to_byte<bool>(pos, test_bit_op());
+  };
+
+  bool operator==(bitvector const& rhs) const
+  {
+    if (size() != rhs.size())
+      return false;
+    /* This works since I have ensured that the last byte of the array contain
+     * sensible data.
+     */
+    if (memcmp(data(), rhs.data(), bytes()) != 0)
+      return false;
+    return true;
+  }
+
+  bool operator!=(bitvector const& rhs) const
+  {
+    return !(*this == rhs);
+  }
+
+private:
+  size_t m_size;
+  byte *m_data;
+};
+
+#endif /* BITVECTOR_H */