*/
-#ifndef HASHCOMP_H
-#define HASHCOMP_H
+#pragma once
#include <cstring>
#include <string>
#include <deque>
#include <map>
#include <set>
-#include "hash_map.h"
+#include "inspircd.h"
/*******************************************************
* This file contains classes and templates that deal
bool operator()(const std::string& s1, const std::string& s2) const;
};
+ struct insensitive
+ {
+ size_t CoreExport operator()(const std::string &s) const;
+ };
+
/** The irc_char_traits class is used for RFC-style comparison of strings.
* This class is used to implement irc::string, a case-insensitive, RFC-
* comparing string class.
*/
- struct irc_char_traits : std::char_traits<char> {
-
+ struct CoreExport irc_char_traits : public std::char_traits<char>
+ {
/** Check if two chars match.
* @param c1st First character
* @param c2nd Second character
static CoreExport const char* find(const char* s1, int n, char c);
};
- /** Compose a hex string from raw data.
- * @param raw The raw data to compose hex from
- * @param rawsz The size of the raw data buffer
- * @return The hex string.
- */
- CoreExport std::string hex(const unsigned char *raw, size_t rawsz);
-
/** This typedef declares irc::string based upon irc_char_traits.
*/
typedef std::basic_string<char, irc_char_traits, std::allocator<char> > string;
/** irc::stringjoiner joins string lists into a string, using
- * the given seperator string.
- * This class can join a vector of std::string, a deque of
- * std::string, or a const char* const* array, using overloaded
- * constructors.
+ * space as the separator.
+ * This class can join a vector of std::string.
*/
class CoreExport stringjoiner
{
public:
- /** Join elements of a vector, between (and including) begin and end
- * @param seperator The string to seperate values with
- * @param sequence One or more items to seperate
- * @param begin The starting element in the sequence to be joined
- * @param end The ending element in the sequence to be joined
+ /** Join all elements of a vector, in the resulting string
+ * each element will be seperated by a single space character.
+ * @param sequence Zero or more items to seperate
*/
- stringjoiner(const std::string &seperator, const std::vector<std::string> &sequence, int begin, int end);
-
- /** Join elements of a deque, between (and including) begin and end
- * @param seperator The string to seperate values with
- * @param sequence One or more items to seperate
- * @param begin The starting element in the sequence to be joined
- * @param end The ending element in the sequence to be joined
- */
- stringjoiner(const std::string &seperator, const std::deque<std::string> &sequence, int begin, int end);
-
- /** Join elements of an array of char arrays, between (and including) begin and end
- * @param seperator The string to seperate values with
- * @param sequence One or more items to seperate
- * @param begin The starting element in the sequence to be joined
- * @param end The ending element in the sequence to be joined
- */
- stringjoiner(const std::string &seperator, const char* const* sequence, int begin, int end);
+ stringjoiner(const std::vector<std::string>& sequence);
/** Get the joined sequence
- * @return A reference to the joined string
+ * @return A constant reference to the joined string
*/
- std::string& GetJoined();
+ const std::string& GetJoined() const { return joined; }
};
/** irc::modestacker stacks mode sequences into a list.
*/
int GetStackedLine(std::vector<std::string> &result, int max_line_size = 360);
- /** deprecated compatability interface - TODO remove */
- int GetStackedLine(std::deque<std::string> &result, int max_line_size = 360) {
- std::vector<std::string> r;
- int n = GetStackedLine(r, max_line_size);
- result.clear();
- result.insert(result.end(), r.begin(), r.end());
- return n;
- }
- };
-
- /** irc::tokenstream reads a string formatted as per RFC1459 and RFC2812.
- * It will split the string into 'tokens' each containing one parameter
- * from the string.
- * For instance, if it is instantiated with the string:
- * "PRIVMSG #test :foo bar baz qux"
- * then each successive call to tokenstream::GetToken() will return
- * "PRIVMSG", "#test", "foo bar baz qux", "".
- * Note that if the whole string starts with a colon this is not taken
- * to mean the string is all one parameter, and the first item in the
- * list will be ":item". This is to allow for parsing 'source' fields
- * from data.
- */
- class CoreExport tokenstream
- {
- private:
-
- /** Original string
- */
- std::string tokens;
-
- /** Last position of a seperator token
- */
- std::string::iterator last_starting_position;
-
- /** Current string position
- */
- std::string::iterator n;
-
- /** True if the last value was an ending value
- */
- bool last_pushed;
- public:
-
- /** Create a tokenstream and fill it with the provided data
- */
- tokenstream(const std::string &source);
-
- /** Destructor
- */
- ~tokenstream();
-
- /** Fetch the next token from the stream as a std::string
- * @param token The next token available, or an empty string if none remain
- * @return True if tokens are left to be read, false if the last token was just retrieved.
- */
- bool GetToken(std::string &token);
-
- /** Fetch the next token from the stream as an irc::string
- * @param token The next token available, or an empty string if none remain
- * @return True if tokens are left to be read, false if the last token was just retrieved.
- */
- bool GetToken(irc::string &token);
-
- /** Fetch the next token from the stream as an integer
- * @param token The next token available, or undefined if none remain
- * @return True if tokens are left to be read, false if the last token was just retrieved.
- */
- bool GetToken(int &token);
-
- /** Fetch the next token from the stream as a long integer
- * @param token The next token available, or undefined if none remain
- * @return True if tokens are left to be read, false if the last token was just retrieved.
- */
- bool GetToken(long &token);
};
/** irc::sepstream allows for splitting token seperated lists.
*/
class CoreExport sepstream
{
- private:
+ protected:
/** Original string.
*/
std::string tokens;
- /** Last position of a seperator token
+ /** Separator value
*/
- std::string::iterator last_starting_position;
+ char sep;
/** Current string position
*/
- std::string::iterator n;
- /** Seperator value
+ size_t pos;
+ /** If set then GetToken() can return an empty string
*/
- char sep;
+ bool allow_empty;
public:
/** Create a sepstream and fill it with the provided data
*/
- sepstream(const std::string &source, char seperator);
-
- /** Destructor
- */
- virtual ~sepstream();
+ sepstream(const std::string &source, char separator, bool allowempty = false);
/** Fetch the next token from the stream
* @param token The next token from the stream is placed here
* @return True if tokens still remain, false if there are none left
*/
- virtual bool GetToken(std::string &token);
+ bool GetToken(std::string& token);
/** Fetch the entire remaining stream, without tokenizing
* @return The remaining part of the stream
*/
- virtual const std::string GetRemaining();
+ const std::string GetRemaining();
/** Returns true if the end of the stream has been reached
* @return True if the end of the stream has been reached, otherwise false
*/
- virtual bool StreamEnd();
+ bool StreamEnd();
};
/** A derived form of sepstream, which seperates on commas
class CoreExport commasepstream : public sepstream
{
public:
- /** Initialize with comma seperator
+ /** Initialize with comma separator
*/
- commasepstream(const std::string &source) : sepstream(source, ',')
+ commasepstream(const std::string &source, bool allowempty = false) : sepstream(source, ',', allowempty)
{
}
};
class CoreExport spacesepstream : public sepstream
{
public:
- /** Initialize with space seperator
+ /** Initialize with space separator
*/
- spacesepstream(const std::string &source) : sepstream(source, ' ')
+ spacesepstream(const std::string &source, bool allowempty = false) : sepstream(source, ' ', allowempty)
{
}
};
+ /** irc::tokenstream reads a string formatted as per RFC1459 and RFC2812.
+ * It will split the string into 'tokens' each containing one parameter
+ * from the string.
+ * For instance, if it is instantiated with the string:
+ * "PRIVMSG #test :foo bar baz qux"
+ * then each successive call to tokenstream::GetToken() will return
+ * "PRIVMSG", "#test", "foo bar baz qux", "".
+ * Note that if the whole string starts with a colon this is not taken
+ * to mean the string is all one parameter, and the first item in the
+ * list will be ":item". This is to allow for parsing 'source' fields
+ * from data.
+ */
+ class CoreExport tokenstream : private spacesepstream
+ {
+ public:
+ /** Create a tokenstream and fill it with the provided data
+ */
+ tokenstream(const std::string &source);
+
+ /** Fetch the next token from the stream as a std::string
+ * @param token The next token available, or an empty string if none remain
+ * @return True if tokens are left to be read, false if the last token was just retrieved.
+ */
+ bool GetToken(std::string &token);
+
+ /** Fetch the next token from the stream as an irc::string
+ * @param token The next token available, or an empty string if none remain
+ * @return True if tokens are left to be read, false if the last token was just retrieved.
+ */
+ bool GetToken(irc::string &token);
+
+ /** Fetch the next token from the stream as an integer
+ * @param token The next token available, or undefined if none remain
+ * @return True if tokens are left to be read, false if the last token was just retrieved.
+ */
+ bool GetToken(int &token);
+
+ /** Fetch the next token from the stream as a long integer
+ * @param token The next token available, or undefined if none remain
+ * @return True if tokens are left to be read, false if the last token was just retrieved.
+ */
+ bool GetToken(long &token);
+ };
+
/** The portparser class seperates out a port range into integers.
* A port range may be specified in the input string in the form
* "6660,6661,6662-6669,7020". The end of the stream is indicated by
long GetToken();
};
- /** Turn _ characters in a string into spaces
- * @param n String to translate
- * @return The new value with _ translated to space.
- */
- CoreExport const char* Spacify(const char* n);
-
struct hash
{
/** Hash an irc::string using RFC1459 case sensitivity rules
return str;
}
-
-/** Hashing stuff is totally different on vc++'s hash_map implementation, so to save a buttload of
- * \#ifdefs we'll just do it all at once. Except, of course, with TR1, when it's the same as GCC.
- */
-BEGIN_HASHMAP_NAMESPACE
-
- /** Hashing function to hash irc::string
- */
-#if defined(_WIN32) && !defined(HAS_TR1_UNORDERED)
- template<> class CoreExport hash_compare<irc::string, std::less<irc::string> >
- {
- public:
- enum { bucket_size = 4, min_buckets = 8 }; /* Got these numbers from the CRT source, if anyone wants to change them feel free. */
-
- /** Compare two irc::string values for hashing in hash_map
- */
- bool operator()(const irc::string & s1, const irc::string & s2) const
- {
- if(s1.length() != s2.length()) return true;
- return (irc::irc_char_traits::compare(s1.c_str(), s2.c_str(), (size_t)s1.length()) < 0);
- }
-
- /** Hash an irc::string value for hash_map
- */
- size_t operator()(const irc::string & s) const;
- };
-
- template<> class CoreExport hash_compare<std::string, std::less<std::string> >
- {
- public:
- enum { bucket_size = 4, min_buckets = 8 }; /* Again, from the CRT source */
-
- /** Compare two std::string values for hashing in hash_map
- */
- bool operator()(const std::string & s1, const std::string & s2) const
- {
- if(s1.length() != s2.length()) return true;
- return (irc::irc_char_traits::compare(s1.c_str(), s2.c_str(), (size_t)s1.length()) < 0);
- }
-
- /** Hash a std::string using RFC1459 case sensitivity rules
- * @param s A string to hash
- * @return The hash value
- */
- size_t operator()(const std::string & s) const;
- };
-#else
-
- /* XXX FIXME: Implement a hash function overriding std::string's that works with TR1! */
-
-#ifdef HASHMAP_DEPRECATED
- struct insensitive
-#else
- CoreExport template<> struct hash<std::string>
-#endif
- {
- size_t CoreExport operator()(const std::string &s) const;
- };
-
-#endif
-
- /** Convert a string to lower case respecting RFC1459
- * @param n A string to lowercase
- */
- void strlower(char *n);
-
-END_HASHMAP_NAMESPACE
-
-#endif
projects / user / henk / code / inspircd.git / blobdiff