X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=include%2Fhashcomp.h;h=1dd1b3b9835d699df41ac5f72d106aaa2c278caf;hb=60d92db9a1b71bbfd4230c5eb9f04cd6a87a41d8;hp=168ecb2898cf244bc752a2d272f45a9b967c3ace;hpb=e1e9341a84b89111c61c6c4bcceab1759b90f818;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/include/hashcomp.h b/include/hashcomp.h index 168ecb289..1dd1b3b98 100644 --- 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 @@ -66,47 +64,31 @@ CoreExport extern unsigned const char rfc_case_insensitive_map[256]; */ CoreExport extern unsigned const char ascii_case_insensitive_map[256]; -/** Case sensitive (identity) map. - */ -CoreExport extern unsigned const char rfc_case_sensitive_map[256]; - -template 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. + * @param s1 First string to compare + * @param s2 Second string to compare + * @return True if the two names are equal, false otherwise + */ + CoreExport bool equals(const std::string& s1, const std::string& s2); /** This class returns true if two strings match. * Case sensitivity is ignored, and the RFC 'character set' * is adhered to */ - struct CoreExport StrHashComp + struct StrHashComp { /** The operator () does the actual comparison in hash_map */ - bool operator()(const std::string& s1, const std::string& s2) const; + bool operator()(const std::string& s1, const std::string& s2) const + { + return equals(s1, s2); + } }; struct insensitive @@ -170,14 +152,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& 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 { @@ -332,83 +315,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); -} - -/** Assign an irc::string to a std::string. - */ -inline std::string assign(const irc::string &other) { return other.c_str(); } - -/** Assign a std::string to an irc::string. - */ -inline irc::string assign(const std::string &other) { return other.c_str(); }