Merge v2.0.23 and v2.0.24 into master.

[user/henk/code/inspircd.git] / include / hashcomp.h

diff --git a/include/hashcomp.h b/include/hashcomp.h
index 464fb16deddb36513fcd74fc4b0dd9c5b5be6d11..f3b1ba6e99275614b74546cee9dc60c2ab49c420 100644 (file)
--- a/include/hashcomp.h
+++ b/include/hashcomp.h
@@ -40,11 +40,9 @@
  * treat [ identical to {, ] identical to }, and \
  * as identical to |.
  *
- * Our hashing functions are designed  to accept
- * std::string and compare/hash them as type irc::string
- * by converting them internally. This makes them
- * backwards compatible with other code which is not
- * aware of irc::string.
+ * There are functors that accept std::string and
+ * compare/hash them as type irc::string by using
+ * mapping arrays internally.
  *******************************************************/
 
 /** Seperate from the other casemap tables so that code *can* still exclusively rely on RFC casemapping
@@ -70,34 +68,10 @@ CoreExport extern unsigned const char ascii_case_insensitive_map[256];
  */
 CoreExport extern unsigned const char rfc_case_sensitive_map[256];
 
-template<typename T> const T& SearchAndReplace(T& text, const T& pattern, const T& replace)
-{
-       T replacement;
-       if ((!pattern.empty()) && (!text.empty()))
-       {
-               for (std::string::size_type n = 0; n != text.length(); ++n)
-               {
-                       if (text.length() >= pattern.length() && text.substr(n, pattern.length()) == pattern)
-                       {
-                               // Found the pattern in the text, replace it, and advance
-                               replacement.append(replace);
-                               n = n + pattern.length() - 1;
-                       }
-                       else
-                       {
-                               replacement += text[n];
-                       }
-               }
-       }
-       text = replacement;
-       return text;
-}
-
 /** The irc namespace contains a number of helper classes.
  */
 namespace irc
 {
-
        /** Check if two IRC object (e.g. nick or channel) names are equal.
         * This function uses national_case_insensitive_map to determine equality, which, by default does comparison
         * according to RFC 1459, treating certain otherwise non-identical characters as identical.
@@ -182,14 +156,15 @@ namespace irc
 
        /** Joins the contents of a vector to a string.
         * @param sequence Zero or more items to join.
-        * @separator The character to place between the items.
+        * @param separator The character to place between the items, defaults to ' ' (space).
+        * @return Joined string.
         */
        std::string CoreExport stringjoiner(const std::vector<std::string>& sequence, char separator = ' ');
 
        /** irc::sepstream allows for splitting token seperated lists.
         * Each successive call to sepstream::GetToken() returns
         * the next token, until none remain, at which point the method returns
-        * an empty string.
+        * false.
         */
        class CoreExport sepstream
        {
@@ -344,75 +319,3 @@ namespace irc
                long GetToken();
        };
 }
-
-/* Define operators for using >> and << with irc::string to an ostream on an istream. */
-/* This was endless fun. No. Really. */
-/* It was also the first core change Ommeh made, if anyone cares */
-
-/** Operator << for irc::string
- */
-inline std::ostream& operator<<(std::ostream &os, const irc::string &str) { return os << str.c_str(); }
-
-/** Operator >> for irc::string
- */
-inline std::istream& operator>>(std::istream &is, irc::string &str)
-{
-       std::string tmp;
-       is >> tmp;
-       str = tmp.c_str();
-       return is;
-}
-
-/* Define operators for + and == with irc::string to std::string for easy assignment
- * and comparison
- *
- * Operator +
- */
-inline std::string operator+ (std::string& leftval, irc::string& rightval)
-{
-       return leftval + std::string(rightval.c_str());
-}
-
-/* Define operators for + and == with irc::string to std::string for easy assignment
- * and comparison
- *
- * Operator +
- */
-inline irc::string operator+ (irc::string& leftval, std::string& rightval)
-{
-       return leftval + irc::string(rightval.c_str());
-}
-
-/* Define operators for + and == with irc::string to std::string for easy assignment
- * and comparison
- *
- * Operator ==
- */
-inline bool operator== (const std::string& leftval, const irc::string& rightval)
-{
-       return (leftval.c_str() == rightval);
-}
-
-/* Define operators for + and == with irc::string to std::string for easy assignment
- * and comparison
- *
- * Operator ==
- */
-inline bool operator== (const irc::string& leftval, const std::string& rightval)
-{
-       return (leftval == rightval.c_str());
-}
-
-/* Define operators != for irc::string to std::string for easy comparison
- */
-inline bool operator!= (const irc::string& leftval, const std::string& rightval)
-{
-       return !(leftval == rightval.c_str());
-}
-
-/* Define operators != for std::string to irc::string for easy comparison
- */
-inline bool operator!= (const std::string& leftval, const irc::string& rightval)
-{
-       return !(leftval.c_str() == rightval);
-}