Fix silly oversight discovered by tra26 (thanks!) where the core tries to handle...

[user/henk/code/inspircd.git] / src / hashcomp.cpp

diff --git a/src/hashcomp.cpp b/src/hashcomp.cpp
index a9a3441b9e80b5180b5ae07ed5c9fcdd41582de6..ed68cd9418c03c278824eabb8eb67711e2214209 100644 (file)
--- a/src/hashcomp.cpp
+++ b/src/hashcomp.cpp
@@ -501,129 +501,3 @@ long irc::portparser::GetToken()
        }
 }
 
-irc::dynamicbitmask::dynamicbitmask() : bits_size(4)
-{
-       /* We start with 4 bytes allocated which is room
-        * for 4 items. Something makes me doubt its worth
-        * allocating less than 4 bytes.
-        */
-       bits = new unsigned char[bits_size];
-       memset(bits, 0, bits_size);
-}
-
-irc::dynamicbitmask::~dynamicbitmask()
-{
-       /* Tidy up the entire used memory on delete */
-       delete[] bits;
-}
-
-irc::bitfield irc::dynamicbitmask::Allocate()
-{
-       /* Yeah, this isnt too efficient, however a module or the core
-        * should only be allocating bitfields on load, the Toggle and
-        * Get methods are O(1) as these are called much more often.
-        */
-       unsigned char* freebits = this->GetFreeBits();
-       for (unsigned char i = 0; i < bits_size; i++)
-       {
-               /* Yes, this is right. You'll notice we terminate the  loop when !current_pos,
-                * this is because we logic shift our bit off the end of unsigned char, and its
-                * lost, making the loop counter 0 when we're done.
-                */
-               for (unsigned char current_pos = 1; current_pos; current_pos = current_pos << 1)
-               {
-                       if (!(freebits[i] & current_pos))
-                       {
-                               freebits[i] |= current_pos;
-                               return std::make_pair(i, current_pos);
-                       }
-               }
-       }
-       /* We dont have any free space left, increase by one */
-
-       if (bits_size == 255)
-               /* Oh dear, cant grow it any further */
-               throw std::bad_alloc();
-
-       unsigned char old_bits_size = bits_size;
-       bits_size++;
-       /* Allocate new bitfield space */
-       unsigned char* temp_bits = new unsigned char[bits_size];
-       unsigned char* temp_freebits = new unsigned char[bits_size];
-       /* Copy the old data in */
-       memcpy(temp_bits, bits, old_bits_size);
-       memcpy(temp_freebits, freebits, old_bits_size);
-       /* Delete the old data pointers */
-       delete[] bits;
-       delete[] freebits;
-       /* Swap the pointers over so now the new 
-        * pointers point to our member values
-        */
-       bits = temp_bits;
-       freebits = temp_freebits;
-       this->SetFreeBits(freebits);
-       /* Initialize the new byte on the end of
-        * the bitfields, pre-allocate the one bit
-        * for this allocation
-        */
-       bits[old_bits_size] = 0;
-       freebits[old_bits_size] = 1;
-       /* We already know where we just allocated
-        * the bitfield, so no loop needed
-        */
-       return std::make_pair(old_bits_size, 1);
-}
-
-bool irc::dynamicbitmask::Deallocate(irc::bitfield &pos)
-{
-       /* We dont bother to shrink the bitfield
-        * on deallocation, the most we could do
-        * is save one byte (!) and this would cost
-        * us a loop (ugly O(n) stuff) so we just
-        * clear the bit and leave the memory
-        * claimed -- nobody will care about one
-        * byte.
-        */
-       if (pos.first < bits_size)
-       {
-               this->GetFreeBits()[pos.first] &= ~pos.second;
-               return true;
-       }
-       /* They gave a bitfield outside of the
-        * length of our array. BAD programmer.
-        */
-       return false;
-}
-
-void irc::dynamicbitmask::Toggle(irc::bitfield &pos, bool state)
-{
-       /* Range check the value */
-       if (pos.first < bits_size)
-       {
-               if (state)
-                       /* Set state, OR the state in */
-                       bits[pos.first] |= pos.second;
-               else
-                       /* Clear state, AND the !state out */
-                       bits[pos.first] &= ~pos.second;
-       }
-}
-
-bool irc::dynamicbitmask::Get(irc::bitfield &pos)
-{
-       /* Range check the value */
-       if (pos.first < bits_size)
-               return (bits[pos.first] & pos.second);
-       else
-               /* We can't return false, otherwise we can't
-                * distinguish between failure and a cleared bit!
-                * Our only sensible choice is to throw (ew).
-                */
-               throw ModuleException("irc::dynamicbitmask::Get(): Invalid bitfield, out of range");
-}
-
-unsigned char irc::dynamicbitmask::GetSize()
-{
-       return bits_size;
-}
-