Rewrote the hashing systems to properly handle the new Anope::strings which we have everywhere.

2 files changed, 102 insertions, 118 deletions

diff --git a/src/hashcomp.cpp b/src/hashcomp.cpp
index 72bcf0936..839d65da8 100644
--- a/src/hashcomp.cpp
+++ b/src/hashcomp.cpp
@@ -10,16 +10,35 @@
 
 #include "anope.h"
 
-/******************************************************
+/*
+ *
+ * This is an implementation of two special string classes:
  *
- * This is the implementation of our special irc::string
- * class which is a case-insensitive equivalent to
+ * irc::string which is a case-insensitive equivalent to
  * std::string which is not only case-insensitive but
  * can also do scandanavian comparisons, e.g. { = [, etc.
  *
- * This class depends on the const array 'national_case_insensitive_map'.
+ * ci::string which is a case-insensitive equivalent to
+ * std::string.
  *
- ******************************************************/
+ * These classes depend on rfc_case_insensitive_map and
+ * ascii_case_insensitive_map
+ *
+ */
+
+/** Hash an Anope::string for unordered_map
+ * @param s The string
+ * @return A hash value for the string
+ */
+bool Anope::hash::operator()(const Anope::string &s) const
+{
+	register size_t t = 0;
+
+	for (Anope::string::const_iterator it = s.begin(), it_end = s.end(); it != it_end; ++it)
+		t = 5 * t + *it;
+
+	return t;
+}
 
 bool irc::irc_char_traits::eq(char c1st, char c2nd)
 {
@@ -62,6 +81,25 @@ const char *irc::irc_char_traits::find(const char *s1, int n, char c)
 	return n >= 0 ? s1 : NULL;
 }
 
+/** Hash an irc::string for unordered_map
+ * @param s The string
+ * @return A hash value for the string
+ */
+size_t irc::hash::operator()(const irc::string &s) const
+{
+        register size_t t = 0;
+
+        for (irc::string::const_iterator it = s.begin(), it_end = s.end(); it != it_end; ++it)
+                t = 5 * t + rfc_case_insensitive_map[static_cast<const unsigned char>(*it)];
+
+        return t;
+}
+
+size_t irc::hash::operator()(const Anope::string &s) const
+{
+        return operator()(s.irc_str());
+}
+
 bool ci::ci_char_traits::eq(char c1st, char c2nd)
 {
 	return ascii_case_insensitive_map[static_cast<unsigned char>(c1st)] == ascii_case_insensitive_map[static_cast<unsigned char>(c2nd)];
@@ -103,157 +141,103 @@ const char *ci::ci_char_traits::find(const char *s1, int n, char c)
 	return n >= 0 ? s1 : NULL;
 }
 
-sepstream::sepstream(const Anope::string &source, char seperator) : tokens(source), sep(seperator)
-{
-	last_starting_position = n = tokens.begin();
-}
-
-bool sepstream::GetToken(Anope::string &token)
+/** Hash a ci::string for unordered_map
+ * @param s The string
+ * @return A hash value for the string
+ */
+size_t ci::hash::operator()(const ci::string &s) const
 {
-	Anope::string::iterator lsp = last_starting_position;
-
-	while (n != tokens.end())
-	{
-		if (*n == sep || n + 1 == tokens.end())
-		{
-			last_starting_position = n + 1;
-			token = Anope::string(lsp, n + 1 == tokens.end() ? n + 1 : n);
-
-			while (token.length() && token.rfind(sep) == token.length() - 1)
-				token.erase(token.end() - 1);
-
-			++n;
-
-			return true;
-		}
-
-		++n;
-	}
+	register size_t t = 0;
 
-	token.clear();
-	return false;
-}
+	for (ci::string::const_iterator it = s.begin(), it_end = s.end(); it != it_end; ++it)
+		t = 5 * t + ascii_case_insensitive_map[static_cast<const unsigned char>(*it)];
 
-const Anope::string sepstream::GetRemaining()
-{
-	return Anope::string(n, tokens.end());
+	return t;
 }
 
-bool sepstream::StreamEnd()
+size_t ci::hash::operator()(const Anope::string &s) const
 {
-	return n == tokens.end();
+	return operator()(s.ci_str());
 }
 
-/** Compare two std::string's values for hashing in hash_map
+/** Compare two Anope::strings as ci::strings
  * @param s1 The first string
  * @param s2 The second string
- * @return similar to strcmp, zero for equal, less than zero for str1
- * being less and greater than zero for str1 being greater than str2.
+ * @return true if they are equal
  */
-bool hash_compare_std_string::operator()(const std::string &s1, const std::string &s2) const
-{
-	register int i = std::char_traits<char>::compare(s1.c_str(), s2.c_str(), s1.length() < s2.length() ? s1.length() : s2.length());
-	if (!i)
-		return s1.length() < s2.length();
-	return i < 0;
-}
-
-bool hash_compare_std_string::operator()(const Anope::string &s1, const Anope::string &s2) const
+bool std::equal_to<ci::string>::operator()(const Anope::string &s1, const Anope::string &s2) const
 {
-	return operator()(s1.str(), s2.str());
+	return s1.ci_str() == s2.ci_str();
 }
 
-/** Return a hash value for a string
- * @param s The string
- * @return The hash value
+/** Compare two Anope::strings as irc::strings
+ * @param s1 The first string
+ * @param s2 The second string
+ * @return true if they are equal
  */
-size_t hash_compare_std_string::operator()(const std::string &s) const
+bool std::equal_to<irc::string>::operator()(const Anope::string &s1, const Anope::string &s2) const
 {
-	register size_t t = 0;
-
-	for (std::string::const_iterator it = s.begin(), it_end = s.end(); it != it_end; ++it)
-		t = 5 * t + static_cast<const unsigned char>(*it);
-
-	return t;
+	return s1.irc_str() == s2.irc_str();
 }
 
-size_t hash_compare_std_string::operator()(const Anope::string &s) const
+/** Compare two Anope::strings as ci::strings and find which one is less
+ * @param s1 The first string
+ * @param s2 The second string
+ * @return true if s1 < s2, else false
+ */
+bool std::less<ci::string>::operator()(const Anope::string &s1, const Anope::string &s2) const
 {
-	return operator()(s.str());
+	return s1.ci_str().compare(s2.ci_str()) < 0;
 }
 
-/** Compare two ci::string's values for hashing in hash_map
+/** Compare two Anope::strings as irc::strings and find which one is les
  * @param s1 The first string
  * @param s2 The second string
- * @return similar to strcmp, zero for equal, less than zero for str1
- * being less and greater than zero for str1 being greater than str2.
+ * @return true if s1 < s2, else false
  */
-bool hash_compare_ci_string::operator()(const ci::string &s1, const ci::string &s2) const
+bool std::less<irc::string>::operator()(const Anope::string &s1, const Anope::string &s2) const
 {
-	register int i = ci::ci_char_traits::compare(s1.c_str(), s2.c_str(), s1.length() < s2.length() ? s1.length() : s2.length());
-	if (!i)
-		return s1.length() < s2.length();
-	return i < 0;
+	return s2.irc_str().compare(s2.irc_str()) < 0;
 }
 
-bool hash_compare_ci_string::operator()(const Anope::string &s1, const Anope::string &s2) const
+sepstream::sepstream(const Anope::string &source, char seperator) : tokens(source), sep(seperator)
 {
-	return operator()(s1.ci_str(), s2.ci_str());
+	last_starting_position = n = tokens.begin();
 }
 
-/** Return a hash value for a string using case insensitivity
- * @param s The string
- * @return The hash value
- */
-size_t hash_compare_ci_string::operator()(const ci::string &s) const
+bool sepstream::GetToken(Anope::string &token)
 {
-	register size_t t = 0;
+	Anope::string::iterator lsp = last_starting_position;
 
-	for (ci::string::const_iterator it = s.begin(), it_end = s.end(); it != it_end; ++it)
-		t = 5 * t + ascii_case_insensitive_map[static_cast<const unsigned char>(*it)];
+	while (n != tokens.end())
+	{
+		if (*n == sep || n + 1 == tokens.end())
+		{
+			last_starting_position = n + 1;
+			token = Anope::string(lsp, n + 1 == tokens.end() ? n + 1 : n);
 
-	return t;
-}
+			while (token.length() && token.rfind(sep) == token.length() - 1)
+				token.erase(token.end() - 1);
 
-size_t hash_compare_ci_string::operator()(const Anope::string &s) const
-{
-	return operator()(s.ci_str());
-}
+			++n;
 
-/** Compare two irc::string's values for hashing in hash_map
- * @param s1 The first string
- * @param s2 The second string
- * @return similar to strcmp, zero for equal, less than zero for str1
- * being less and greater than zero for str1 being greater than str2.
- */
-bool hash_compare_irc_string::operator()(const irc::string &s1, const irc::string &s2) const
-{
-	register int i = irc::irc_char_traits::compare(s1.c_str(), s2.c_str(), s1.length() < s2.length() ? s1.length() : s2.length());
-	if (!i)
-		return s1.length() < s2.length();
-	return i < 0;
-}
+			return true;
+		}
 
-bool hash_compare_irc_string::operator()(const Anope::string &s1, const Anope::string &s2) const
-{
-	return operator()(s1.irc_str(), s2.irc_str());
+		++n;
+	}
+
+	token.clear();
+	return false;
 }
 
-/** Return a hash value for a string using RFC1459 case sensitivity rules
- * @param s The string
- * @return The hash value
- */
-size_t hash_compare_irc_string::operator()(const irc::string &s) const
+const Anope::string sepstream::GetRemaining()
 {
-	register size_t t = 0;
-
-	for (irc::string::const_iterator it = s.begin(), it_end = s.end(); it != it_end; ++it)
-		t = 5 * t + rfc_case_insensitive_map[static_cast<const unsigned char>(*it)];
-
-	return t;
+	return Anope::string(n, tokens.end());
 }
 
-size_t hash_compare_irc_string::operator()(const Anope::string &s) const
+bool sepstream::StreamEnd()
 {
-	return operator()(s.irc_str());
+	return n == tokens.end();
 }
+
diff --git a/src/nickserv.cpp b/src/nickserv.cpp
index 0397c8b32..960ae7a97 100644
--- a/src/nickserv.cpp
+++ b/src/nickserv.cpp
@@ -17,8 +17,8 @@ nickalias_map NickAliasList;
 nickcore_map NickCoreList;
 nickrequest_map NickRequestList;
 
-typedef std::map<Anope::string, NickServCollide *, hash_compare_std_string> nickservcollides_map;
-typedef std::map<Anope::string, NickServRelease *, hash_compare_std_string> nickservreleases_map;
+typedef std::map<Anope::string, NickServCollide *> nickservcollides_map;
+typedef std::map<Anope::string, NickServRelease *> nickservreleases_map;
 
 static nickservcollides_map NickServCollides;
 static nickservreleases_map NickServReleases;