~tokenstream();
/** Fetch the next token from the stream
- * @returns The next token is returned, or an empty string if none remain
+ * @return The next token is returned, or an empty string if none remain
*/
const std::string GetToken();
};
virtual ~sepstream();
/** Fetch the next token from the stream
- * @returns The next token is returned, or an empty string if none remain
+ * @return The next token is returned, or an empty string if none remain
*/
virtual const std::string GetToken();
};
/** Ending port in a range of ports
*/
long range_end;
+ /** Allow overlapped port ranges
+ */
+ bool overlapped;
+ /** Used to determine overlapping of ports
+ * without O(n) algorithm being used
+ */
+ std::map<long, bool> overlap_set;
+ /** Returns true if val overlaps an existing range
+ */
+ bool Overlaps(long val);
public:
/** Create a portparser and fill it with the provided data
+ * @param source The source text to parse from
+ * @param allow_overlapped Allow overlapped ranges
*/
- portparser(const std::string &source);
+ portparser(const std::string &source, bool allow_overlapped = true);
/** Frees the internal commasepstream object
*/
~portparser();
/** Fetch the next token from the stream
- * @returns The next port number is returned, or 0 if none remain
+ * @return The next port number is returned, or 0 if none remain
*/
long GetToken();
};
+ /** Used to hold a bitfield definition in dynamicbitmask.
+ * You must be allocated one of these by dynamicbitmask::Allocate(),
+ * you should not fill the values yourself!
+ */
+ typedef std::pair<size_t, unsigned char> bitfield;
+
+ /** The irc::dynamicbitmask class is used to maintain a bitmap of
+ * boolean values, which can grow to any reasonable size no matter
+ * how many bitfields are in it.
+ *
+ * It starts off at 32 bits in size, large enough to hold 32 boolean
+ * values, with a memory allocation of 8 bytes. If you allocate more
+ * than 32 bits, the class will grow the bitmap by 8 bytes at a time
+ * for each set of 8 bitfields you allocate with the Allocate()
+ * method.
+ *
+ * This method is designed so that multiple modules can be allocated
+ * bit values in a bitmap dynamically, rather than having to define
+ * costs in a fixed size unsigned integer and having the possibility
+ * of collisions of values in different third party modules.
+ *
+ * IMPORTANT NOTE:
+ *
+ * To use this class, you must derive from it.
+ * This is because each derived instance has its own freebits array
+ * which can determine what bitfields are allocated on a TYPE BY TYPE
+ * basis, e.g. an irc::dynamicbitmask type for userrecs, and one for
+ * chanrecs, etc. You should inheret it in a very simple way as follows.
+ * The base class will resize and maintain freebits as required, you are
+ * just required to make the pointer static and specific to this class
+ * type.
+ *
+ * \code
+ * class mydbitmask : public irc::dynamicbitmask
+ * {
+ * private:
+ *
+ * static unsigned char* freebits;
+ *
+ * public:
+ *
+ * mydbitmask() : irc::dynamicbitmask()
+ * {
+ * freebits = new unsigned char[this->bits_size];
+ * memset(freebits, 0, this->bits_size);
+ * }
+ *
+ * ~mydbitmask()
+ * {
+ * delete[] freebits;
+ * }
+ *
+ * unsigned char* GetFreeBits()
+ * {
+ * return freebits;
+ * }
+ *
+ * void SetFreeBits(unsigned char* freebt)
+ * {
+ * freebits = freebt;
+ * }
+ * };
+ * \endcode
+ */
+ class dynamicbitmask : public classbase
+ {
+ private:
+ /** Data bits. We start with four of these,
+ * and we grow the bitfield as we allocate
+ * more than 32 entries with Allocate().
+ */
+ unsigned char* bits;
+ protected:
+ /** Current set size (size of freebits and bits).
+ * Both freebits and bits will ALWAYS be the
+ * same length.
+ */
+ unsigned char bits_size;
+ public:
+ /** Allocate the initial memory for bits and
+ * freebits and zero the memory.
+ */
+ dynamicbitmask();
+
+ /** Free the memory used by bits and freebits
+ */
+ virtual ~dynamicbitmask();
+
+ /** Allocate an irc::bitfield.
+ * @return An irc::bitfield which can be used
+ * with Get, Deallocate and Toggle methods.
+ * @throw Can throw std::bad_alloc if there is
+ * no ram left to grow the bitmask.
+ */
+ bitfield Allocate();
+
+ /** Deallocate an irc::bitfield.
+ * @param An irc::bitfield to deallocate.
+ * @return True if the bitfield could be
+ * deallocated, false if it could not.
+ */
+ bool Deallocate(bitfield &pos);
+
+ /** Toggle the value of a bitfield.
+ * @param pos A bitfield to allocate, previously
+ * allocated by dyamicbitmask::Allocate().
+ * @param state The state to set the field to.
+ */
+ void Toggle(bitfield &pos, bool state);
+
+ /** Get the value of a bitfield.
+ * @param pos A bitfield to retrieve, previously
+ * allocated by dyamicbitmask::Allocate().
+ * @return The value of the bitfield.
+ * @throw Will throw ModuleException if the bitfield
+ * you provide is outside of the range
+ * 0 >= bitfield.first < size_bits.
+ */
+ bool Get(bitfield &pos);
+
+ /** Return the size in bytes allocated to the bits
+ * array.
+ * Note that the actual allocation is twice this,
+ * as there are an equal number of bytes allocated
+ * for the freebits array.
+ */
+ unsigned char GetSize();
+
+ virtual unsigned char* GetFreeBits() { return NULL; }
+
+ virtual void SetFreeBits(unsigned char* freebits) { }
+ };
+
/** 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.
projects / user / henk / code / inspircd.git / blobdiff