More efficient modestacker

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

diff --git a/src/hashcomp.cpp b/src/hashcomp.cpp
index 953997e5b83c9dd2b8549fd2500fd4026c4e88e5..8a4febb60ece7cf3e67e93279370bde6b971f8ca 100644 (file)
--- a/src/hashcomp.cpp
+++ b/src/hashcomp.cpp
@@ -16,17 +16,11 @@
 
 using namespace std;
 
-#include "inspircd_config.h"
 #include "inspircd.h"
-#include <string>
 #include "hashcomp.h"
-#include "helperfuncs.h"
 #include <ext/hash_map>
-
 #define nspace __gnu_cxx
 
-char lowermap[255];
-
 /******************************************************
  *
  * The hash functions of InspIRCd are the centrepoint
@@ -86,16 +80,16 @@ size_t nspace::hash<insp_inaddr>::operator()(const insp_inaddr &a) const
 
 size_t nspace::hash<string>::operator()(const string &s) const
 {
-       char a[s.length()];
-       size_t t = 0;
-       static struct hash<const char *> strhash;
-
-       for (const char* x = s.c_str(); *x; x++)        /* Faster to do it this way than */
-               a[t++] = lowermap[(unsigned char)*x];   /* Seperate strlcpy and strlower */
-
-       a[t] = 0;
-
-       return strhash(a);
+       /* XXX: NO DATA COPIES! :)
+        * The hash function here is practically
+        * a copy of the one in STL's hash_fun.h,
+        * only with *x replaced with lowermap[*x].
+        * This avoids a copy to use hash<const char*>
+        */
+       register size_t t = 0;
+       for (std::string::const_iterator x = s.begin(); x != s.end(); x++) /* ++x not x++, so we don't hash the \0 */
+               t = 5 * t + lowermap[(unsigned char)*x];
+       return size_t(t);
 }
 
 bool irc::StrHashComp::operator()(const std::string& s1, const std::string& s2) const
@@ -127,9 +121,7 @@ bool irc::InAddr_HashComp::operator()(const insp_inaddr &s1, const insp_inaddr &
  * std::string which is not only case-insensitive but
  * can also do scandanavian comparisons, e.g. { = [, etc.
  *
- * This class depends on the global 'lowermap' which is
- * initialized at startup by inspircd.cpp, and contains
- * the 'scandanavian' casemappings for fast irc compare.
+ * This class depends on the const array 'lowermap'.
  *
  ******************************************************/
 
@@ -210,10 +202,6 @@ std::istream& operator>>(std::istream &is, irc::string &str)
 
 irc::tokenstream::tokenstream(const std::string &source) : tokens(source), last_pushed(false)
 {
-       /* Remove trailing spaces, these muck up token parsing */
-       while (tokens.find_last_of(' ') == tokens.length() - 1)
-               tokens.erase(tokens.end() - 1);
-
        /* Record starting position and current position */
        last_starting_position = tokens.begin();
        n = tokens.begin();
@@ -247,7 +235,12 @@ const std::string irc::tokenstream::GetToken()
                         */
                        last_starting_position = n+1;
                        last_pushed = true;
-                       return std::string(lsp, n+1 == tokens.end() ? n+1  : n++);
+
+                       std::string strip(lsp, n+1 == tokens.end() ? n+1  : n++);
+                       while ((strip.length()) && (strip.find_last_of(' ') == strip.length() - 1))
+                               strip.erase(strip.end() - 1);
+
+                       return strip;
                }
 
                n++;
@@ -255,22 +248,27 @@ const std::string irc::tokenstream::GetToken()
        return "";
 }
 
-irc::commasepstream::commasepstream(const std::string &source) : tokens(source)
+irc::sepstream::sepstream(const std::string &source, char seperator) : tokens(source), sep(seperator)
 {
        last_starting_position = tokens.begin();
        n = tokens.begin();
 }
 
-const std::string irc::commasepstream::GetToken()
+const std::string irc::sepstream::GetToken()
 {
        std::string::iterator lsp = last_starting_position;
 
        while (n != tokens.end())
        {
-               if ((*n == ',') || (n+1 == tokens.end()))
+               if ((*n == sep) || (n+1 == tokens.end()))
                {
                        last_starting_position = n+1;
-                       return std::string(lsp, n+1 == tokens.end() ? n+1  : n++);
+                       std::string strip = std::string(lsp, n+1 == tokens.end() ? n+1  : n++);
+
+                       while ((strip.length()) && (strip.find_last_of(sep) == strip.length() - 1))
+                               strip.erase(strip.end() - 1);
+
+                       return strip;
                }
 
                n++;
@@ -279,21 +277,63 @@ const std::string irc::commasepstream::GetToken()
        return "";
 }
 
-irc::commasepstream::~commasepstream()
+irc::sepstream::~sepstream()
 {
 }
 
-void InspIRCd::MakeLowerMap()
-{       
-       // initialize the lowercase mapping table
-       for (unsigned char cn = 0; cn < 255; cn++)
-               lowermap[cn] = cn;
-       // lowercase the uppercase chars
-       for (unsigned char cn = 65; cn < 91; cn++)
-               lowermap[cn] = tolower(cn);
-       // now replace the specific chars for scandanavian comparison
-       lowermap[(unsigned char)'['] = '{';
-       lowermap[(unsigned char)']'] = '}';
-       lowermap[(unsigned char)'\\'] = '|';
+std::string irc::hex(const unsigned char *raw, size_t rawsz)
+{
+       if (!rawsz)
+               return "";
+
+       char buf[rawsz*2+1];
+       size_t i;
+
+       for (i = 0; i < rawsz; i++)
+       {
+               sprintf (&(buf[i*2]), "%02x", raw[i]);
+       }
+       buf[i*2] = 0;
+
+       return buf;
+}
+
+const char* irc::Spacify(char* n)
+{
+       static char x[MAXBUF];
+       strlcpy(x,n,MAXBUF);
+       for (char* y = x; *y; y++)
+               if (*y == '_')
+                       *y = ' ';
+       return x;
+}
+
+
+irc::modestacker::modestacker(bool add) : adding(add)
+{
+       sequence.clear();
+       sequence.push_back("");
+}
+
+void irc::modestacker::Push(char modeletter, const std::string &parameter)
+{
+       *(sequence.begin()) += modeletter;
+       sequence.push_back(parameter);
+}
+
+int irc::modestacker::GetStackedLine(std::deque<std::string> &result)
+{
+       result.clear();
+       result.push_back(adding ? "+" : "-");
+
+       while (!sequence[0].empty() && (sequence.size() > 1) && (result.size() < MAXMODES+1))
+       {
+               result[0] += *(sequence[0].begin());
+               result.push_back(sequence[1]);
+               sequence[0].erase(sequence[0].begin());
+               sequence.erase(sequence.begin() + 1);
+       }
+
+       return result.size();
 }