~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();
};
*/
~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;
- unsigned char* freebits;
- size_t bits_size;
+ 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();
- ~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);
- size_t GetSize();
+ /** 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.