Removed a pointless check in ./configure --clean that made it only work with one...

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

diff --git a/src/hashcomp.cpp b/src/hashcomp.cpp
index 4c62390dd4221e65a483e7f767370f0c48db86e7..5c9cac7bbe5a9fbb26fd5ecc5bd6b5d149722e88 100644 (file)
--- a/src/hashcomp.cpp
+++ b/src/hashcomp.cpp
@@ -2,20 +2,15 @@
  *       | Inspire Internet Relay Chat Daemon |
  *       +------------------------------------+
  *
- *  InspIRCd is copyright (C) 2002-2006 ChatSpike-Dev.
- *                    E-mail:
- *             <brain@chatspike.net>
- *             <Craig@chatspike.net>
+ *  InspIRCd: (C) 2002-2007 InspIRCd Development Team
+ * See: http://www.inspircd.org/wiki/index.php/Credits
  *
- * Written by Craig Edwards, Craig McLure, and others.
  * This program is free but copyrighted software; see
- *         the file COPYING for details.
+ *            the file COPYING for details.
  *
  * ---------------------------------------------------
  */
 
-using namespace std;
-
 #include "inspircd.h"
 #include "hashcomp.h"
 #include <ext/hash_map>
@@ -50,7 +45,6 @@ using namespace std;
  *
  ******************************************************/
 
-using namespace std;
 using namespace irc::sockets;
 
 /* convert a string to lowercase. Note following special circumstances
@@ -92,6 +86,14 @@ size_t nspace::hash<string>::operator()(const string &s) const
        return t;
 }
 
+size_t nspace::hash<irc::string>::operator()(const irc::string &s) const
+{
+       register size_t t = 0;
+       for (irc::string::const_iterator x = s.begin(); x != s.end(); ++x) /* ++x not x++, as its faster */
+               t = 5 * t + lowermap[(unsigned char)*x];
+       return t;
+}
+
 bool irc::StrHashComp::operator()(const std::string& s1, const std::string& s2) const
 {
        unsigned char* n1 = (unsigned char*)s1.c_str();
@@ -171,12 +173,12 @@ irc::string operator+ (irc::string& leftval, std::string& rightval)
 
 bool operator== (std::string& leftval, irc::string& rightval)
 {
-       return (leftval == std::string(rightval.c_str()));
+       return (leftval.c_str() == rightval);
 }
 
 bool operator== (irc::string& leftval, std::string& rightval)
 {
-       return (rightval == std::string(leftval.c_str()));
+       return (leftval == rightval.c_str());
 }
 
 const char* irc::irc_char_traits::find(const char* s1, int  n, char c)
@@ -291,19 +293,24 @@ std::string irc::hex(const unsigned char *raw, size_t rawsz)
        if (!rawsz)
                return "";
 
+       /* EWW! This used to be using sprintf, which is WAY inefficient. -Special */
+       
+       const char *hex = "0123456789abcdef";
+       
        char buf[rawsz*2+1];
-       size_t i;
 
-       for (i = 0; i < rawsz; i++)
+       size_t i, j;
+       for (i = 0, j = 0; j < rawsz; ++j)
        {
-               sprintf (&(buf[i*2]), "%02x", raw[i]);
+               buf[i++] = hex[raw[j] / 16];
+               buf[i++] = hex[raw[j] % 16];
        }
-       buf[i*2] = 0;
+       buf[i] = '\0';
 
        return buf;
 }
 
-const char* irc::Spacify(char* n)
+const char* irc::Spacify(const char* n)
 {
        static char x[MAXBUF];
        strlcpy(x,n,MAXBUF);
@@ -473,24 +480,20 @@ long irc::portparser::GetToken()
        }
 }
 
-irc::dynamicbitmask::dynamicbitmask()
+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_size = 4;
        bits = new unsigned char[bits_size];
-       freebits = new unsigned char[bits_size];
        memset(bits, 0, bits_size);
-       memset(freebits, 0, bits_size);
 }
 
 irc::dynamicbitmask::~dynamicbitmask()
 {
        /* Tidy up the entire used memory on delete */
        delete[] bits;
-       delete[] freebits;
 }
                          
 irc::bitfield irc::dynamicbitmask::Allocate()
@@ -499,7 +502,8 @@ irc::bitfield irc::dynamicbitmask::Allocate()
         * should only be allocating bitfields on load, the Toggle and
         * Get methods are O(1) as these are called much more often.
         */
-       for (size_t i = 0; i < bits_size; i++)
+       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
@@ -515,7 +519,12 @@ irc::bitfield irc::dynamicbitmask::Allocate()
                }
        }
        /* We dont have any free space left, increase by one */
-       int old_bits_size = bits_size;
+
+       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];
@@ -531,6 +540,7 @@ irc::bitfield irc::dynamicbitmask::Allocate()
         */
        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
@@ -555,7 +565,7 @@ bool irc::dynamicbitmask::Deallocate(irc::bitfield &pos)
         */
        if (pos.first < bits_size)
        {
-               freebits[pos.first] &= ~pos.second;
+               this->GetFreeBits()[pos.first] &= ~pos.second;
                return true;
        }
        /* They gave a bitfield outside of the
@@ -591,8 +601,18 @@ bool irc::dynamicbitmask::Get(irc::bitfield &pos)
                throw ModuleException("irc::dynamicbitmask::Get(): Invalid bitfield, out of range");
 }
 
-size_t irc::dynamicbitmask::GetSize()
+unsigned char irc::dynamicbitmask::GetSize()
 {
        return bits_size;
 }
 
+std::string assign(const irc::string &other)
+{
+       return other.c_str();
+}
+
+irc::string assign(const std::string &other)
+{
+       return other.c_str();
+}
+