-/* +------------------------------------+
- * | Inspire Internet Relay Chat Daemon |
- * +------------------------------------+
+/*
+ * InspIRCd -- Internet Relay Chat Daemon
*
- * InspIRCd: (C) 2002-2010 InspIRCd Development Team
- * See: http://wiki.inspircd.org/Credits
+ * Copyright (C) 2011 Adam <Adam@anope.org>
+ * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org>
+ * Copyright (C) 2007, 2009 Dennis Friis <peavey@inspircd.org>
+ * Copyright (C) 2005-2009 Craig Edwards <craigedwards@brainbox.cc>
+ * Copyright (C) 2007-2008 Robin Burchell <robin+git@viroteck.net>
+ * Copyright (C) 2008 Pippijn van Steenhoven <pip88nl@gmail.com>
*
- * This program is free but copyrighted software; see
- * the file COPYING for details.
+ * This file is part of InspIRCd. InspIRCd is free software: you can
+ * redistribute it and/or modify it under the terms of the GNU General Public
+ * License as published by the Free Software Foundation, version 2.
*
- * ---------------------------------------------------
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
-#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
* Case sensitivity is ignored, and the RFC 'character set'
* is adhered to
*/
- struct StrHashComp
+ struct CoreExport StrHashComp
{
/** The operator () does the actual comparison in hash_map
*/
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.
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
- * @pram 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;
* @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::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::string& seperator, const std::vector<std::string>& sequence, unsigned int begin, unsigned int end);
/** 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;
};
/** 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.
*/
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.
*/
sepstream(const std::string &source, char seperator);
- /** Destructor
- */
- virtual ~sepstream();
-
/** 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
/** Used to split on commas
*/
- commasepstream* sep;
+ commasepstream sep;
/** Current position in a range of ports
*/
/** Used to determine overlapping of ports
* without O(n) algorithm being used
*/
- std::map<long, bool> overlap_set;
+ std::set<long> overlap_set;
/** Returns true if val overlaps an existing range
*/
*/
portparser(const std::string &source, bool allow_overlapped = true);
- /** Frees the internal commasepstream object
- */
- ~portparser();
-
/** Fetch the next token from the stream
* @return The next port number is returned, or 0 if none remain
*/
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
+ * @param s A string to hash
+ * @return The hash value
+ */
+ size_t CoreExport operator()(const irc::string &s) const;
+ };
}
/* Define operators for using >> and << with irc::string to an ostream on an istream. */
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(WINDOWS) && !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
-
- template<> struct hash<irc::string>
- {
- /** Hash an irc::string using RFC1459 case sensitivity rules
- * @param s A string to hash
- * @return The hash value
- */
- size_t CoreExport operator()(const irc::string &s) const;
- };
-
- /* 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