include/base.h

   1 /*       +------------------------------------+
   2  *       | Inspire Internet Relay Chat Daemon |
   3  *       +------------------------------------+
   4  *
   5  *  InspIRCd is copyright (C) 2002-2006 ChatSpike-Dev.
   6  *                       E-mail:
   7  *                <brain@chatspike.net>
   8  *                <Craig@chatspike.net>
   9  *
  10  * Written by Craig Edwards, Craig McLure, and others.
  11  * This program is free but copyrighted software; see
  12  *            the file COPYING for details.
  13  *
  14  * ---------------------------------------------------
  15  */
  16
  17 #ifndef __BASE_H__
  18 #define __BASE_H__
  19
  20 #include "inspircd_config.h"
  21 #include <time.h>
  22 #include <map>
  23 #include <deque>
  24 #include <string>
  25
  26 typedef void* VoidPointer;
  27 typedef std::map<std::string,char*> ExtensibleStore;
  28
  29 /** The base class for all inspircd classes
  30 */
  31 class classbase
  32 {
  33  public:
  34         /** Time that the object was instantiated (used for TS calculation etc)
  35         */
  36         time_t age;
  37
  38         /** Constructor,
  39          * Sets the object's time
  40          */
  41         classbase() { age = time(NULL); }
  42         ~classbase() { }
  43 };
  44
  45 /** class Extensible is the parent class of many classes such as userrec and chanrec.
  46  * class Extensible implements a system which allows modules to 'extend' the class by attaching data within
  47  * a map associated with the object. In this way modules can store their own custom information within user
  48  * objects, channel objects and server objects, without breaking other modules (this is more sensible than using
  49  * a flags variable, and each module defining bits within the flag as 'theirs' as it is less prone to conflict and
  50  * supports arbitary data storage).
  51  */
  52 class Extensible : public classbase
  53 {
  54         /** Private data store
  55          */
  56         ExtensibleStore Extension_Items;
  57
  58 public:
  59
  60         /** Extend an Extensible class.
  61          *
  62          * @param key The key parameter is an arbitary string which identifies the extension data
  63          * @param p This parameter is a pointer to any data you wish to associate with the object
  64          *
  65          * You must provide a key to store the data as, and a void* to the data (typedef VoidPointer)
  66          * The data will be inserted into the map. If the data already exists, you may not insert it
  67          * twice, Extensible::Extend will return false in this case.
  68          *
  69          * @return Returns true on success, false if otherwise
  70          */
  71         template<typename T> bool Extend(const std::string &key, T* p)
  72         {
  73                 /* This will only add an item if it doesnt already exist,
  74                  * the return value is a std::pair of an iterator to the
  75                  * element, and a bool saying if it was actually inserted.
  76                  */
  77                 return this->Extension_Items.insert(std::make_pair(key, (char*)p)).second;
  78         }
  79
  80         /** Shrink an Extensible class.
  81          *
  82          * @param key The key parameter is an arbitary string which identifies the extension data
  83          *
  84          * You must provide a key name. The given key name will be removed from the classes data. If
  85          * you provide a nonexistent key (case is important) then the function will return false.
  86          *
  87          * @return Returns true on success.
  88          */
  89         bool Shrink(const std::string &key);
  90
  91         /** Get an extension item.
  92          *
  93          * @param key The key parameter is an arbitary string which identifies the extension data
  94          *
  95          * @return If you provide a non-existent key name, the function returns NULL, otherwise a pointer to the item referenced by the key is returned.
  96          */
  97         char* GetExt(const std::string &key);
  98
  99         /** Get a list of all extension items names.
 100          *
 101          * @param list A deque of strings to receive the list
 102          *
 103          * @return This function writes a list of all extension items stored in this object by name into the given deque and returns void.
 104          */
 105         void GetExtList(std::deque<std::string> &list);
 106 };
 107
 108 /** BoolSet is a utility class designed to hold eight bools in a bitmask.
 109  * Use BoolSet::Set and BoolSet::Get to set and get bools in the bitmask,
 110  * and Unset and Invert for special operations upon them.
 111  */
 112 class BoolSet
 113 {
 114         char bits;
 115
 116  public:
 117
 118         /** The default constructor initializes the BoolSet to all values unset.
 119          */
 120         BoolSet();
 121
 122         /** This constructor copies the default bitmask from a char
 123          */
 124         BoolSet(char bitmask);
 125
 126         /** The Set method sets one bool in the set.
 127          *
 128          * @param number The number of the item to set. This must be between 0 and 7.
 129          */
 130         void Set(int number);
 131
 132         /** The Get method returns the value of one bool in the set
 133          *
 134          * @param number The number of the item to retrieve. This must be between 0 and 7.
 135          *
 136          * @return True if the item is set, false if it is unset.
 137          */
 138         bool Get(int number);
 139
 140         /** The Unset method unsets one value in the set
 141          *
 142          * @param number The number of the item to set. This must be between 0 and 7.
 143          */
 144         void Unset(int number);
 145
 146         /** The Unset method inverts (flips) one value in the set
 147          *
 148          * @param number The number of the item to invert. This must be between 0 and 7.
 149          */
 150         void Invert(int number);
 151
 152         /** Compare two BoolSets
 153          */
 154         bool operator==(BoolSet other);
 155
 156         /** OR two BoolSets together
 157          */
 158         BoolSet operator|(BoolSet other);
 159
 160         /** AND two BoolSets together
 161          */
 162         BoolSet operator&(BoolSet other);
 163
 164         /** Assign one BoolSet to another
 165          */
 166         bool operator=(BoolSet other);
 167 };
 168
 169
 170 #endif