* | 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>
*
******************************************************/
-using namespace std;
using namespace irc::sockets;
/* convert a string to lowercase. Note following special circumstances
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();
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)
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);
}
}
-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()
* 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,
*/
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
*/
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
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();
+}
+