include/base.h

   1 /*
   2  * InspIRCd -- Internet Relay Chat Daemon
   3  *
   4  *   Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org>
   5  *   Copyright (C) 2006-2007 Oliver Lupton <oliverlupton@gmail.com>
   6  *   Copyright (C) 2007 Dennis Friis <peavey@inspircd.org>
   7  *   Copyright (C) 2003-2005, 2007 Craig Edwards <craigedwards@brainbox.cc>
   8  *
   9  * This file is part of InspIRCd.  InspIRCd is free software: you can
  10  * redistribute it and/or modify it under the terms of the GNU General Public
  11  * License as published by the Free Software Foundation, version 2.
  12  *
  13  * This program is distributed in the hope that it will be useful, but WITHOUT
  14  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  15  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
  16  * details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20  */
  21
  22
  23 #pragma once
  24
  25 #include <map>
  26 #include <deque>
  27 #include <string>
  28 #include <list>
  29
  30 /** Dummy class to help enforce culls being parent-called up to classbase */
  31 class CullResult
  32 {
  33         CullResult();
  34         friend class classbase;
  35 };
  36
  37 /** The base class for all inspircd classes with a well-defined lifetime.
  38  * Classes that inherit from this may be destroyed through GlobalCulls,
  39  * and may rely on cull() being called prior to their deletion.
  40  */
  41 class CoreExport classbase
  42 {
  43  public:
  44         classbase();
  45
  46         /**
  47          * Called just prior to destruction via cull list.
  48          */
  49         virtual CullResult cull();
  50         virtual ~classbase();
  51  private:
  52         // uncopyable
  53         classbase(const classbase&);
  54         void operator=(const classbase&);
  55 };
  56
  57 /** The base class for inspircd classes that provide a wrapping interface, and
  58  * should only exist while being used. Prevents heap allocation.
  59  */
  60 class CoreExport interfacebase
  61 {
  62  public:
  63         interfacebase() {}
  64         static inline void* operator new(size_t, void* m) { return m; }
  65  private:
  66         interfacebase(const interfacebase&);
  67         void operator=(const interfacebase&);
  68         static void* operator new(size_t);
  69         static void operator delete(void*);
  70 };
  71
  72 /** The base class for inspircd classes that support reference counting.
  73  * Any objects that do not have a well-defined lifetime should inherit from
  74  * this, and should be assigned to a reference<type> object to establish their
  75  * lifetime.
  76  *
  77  * Reference objects should not hold circular references back to themselves,
  78  * even indirectly; this will cause a memory leak because the count will never
  79  * drop to zero.
  80  *
  81  * Using a normal pointer for the object is recommended if you can assure that
  82  * at least one reference<> will remain as long as that pointer is used; this
  83  * will avoid the slight overhead of changing the reference count.
  84  */
  85 class CoreExport refcountbase
  86 {
  87         mutable unsigned int refcount;
  88  public:
  89         refcountbase();
  90         virtual ~refcountbase();
  91         inline unsigned int GetReferenceCount() const { return refcount; }
  92         static inline void* operator new(size_t, void* m) { return m; }
  93         static void* operator new(size_t);
  94         static void operator delete(void*);
  95         inline void refcount_inc() const { refcount++; }
  96         inline bool refcount_dec() const { refcount--; return !refcount; }
  97  private:
  98         // uncopyable
  99         refcountbase(const refcountbase&);
 100         void operator=(const refcountbase&);
 101 };
 102
 103 /** Base class for use count tracking. Uses reference<>, but does not
 104  * cause object deletion when the last user is removed.
 105  *
 106  * Safe for use as a second parent class; will not add a second vtable.
 107  */
 108 class CoreExport usecountbase
 109 {
 110         mutable unsigned int usecount;
 111  public:
 112         usecountbase() : usecount(0) { }
 113         ~usecountbase();
 114         inline unsigned int GetUseCount() const { return usecount; }
 115         inline void refcount_inc() const { usecount++; }
 116         inline bool refcount_dec() const { usecount--; return false; }
 117  private:
 118         // uncopyable
 119         usecountbase(const usecountbase&);
 120         void operator=(const usecountbase&);
 121 };
 122
 123 template <typename T>
 124 class reference
 125 {
 126         T* value;
 127  public:
 128         reference() : value(0) { }
 129         reference(T* v) : value(v) { if (value) value->refcount_inc(); }
 130         reference(const reference<T>& v) : value(v.value) { if (value) value->refcount_inc(); }
 131         reference<T>& operator=(const reference<T>& other)
 132         {
 133                 if (other.value)
 134                         other.value->refcount_inc();
 135                 this->reference::~reference();
 136                 value = other.value;
 137                 return *this;
 138         }
 139
 140         ~reference()
 141         {
 142                 if (value && value->refcount_dec())
 143                         delete value;
 144         }
 145
 146         inline reference<T>& operator=(T* other)
 147         {
 148                 if (value != other)
 149                 {
 150                         if (value && value->refcount_dec())
 151                                 delete value;
 152                         value = other;
 153                         if (value)
 154                                 value->refcount_inc();
 155                 }
 156
 157                 return *this;
 158         }
 159
 160         inline operator bool() const { return (value != NULL); }
 161         inline operator T*() const { return value; }
 162         inline T* operator->() const { return value; }
 163         inline T& operator*() const { return *value; }
 164         inline bool operator<(const reference<T>& other) const { return value < other.value; }
 165         inline bool operator>(const reference<T>& other) const { return value > other.value; }
 166         static inline void* operator new(size_t, void* m) { return m; }
 167  private:
 168 #ifndef _WIN32
 169         static void* operator new(size_t);
 170         static void operator delete(void*);
 171 #endif
 172 };
 173
 174 /** This class can be used on its own to represent an exception, or derived to represent a module-specific exception.
 175  * When a module whishes to abort, e.g. within a constructor, it should throw an exception using ModuleException or
 176  * a class derived from ModuleException. If a module throws an exception during its constructor, the module will not
 177  * be loaded. If this happens, the error message returned by ModuleException::GetReason will be displayed to the user
 178  * attempting to load the module, or dumped to the console if the ircd is currently loading for the first time.
 179  */
 180 class CoreExport CoreException : public std::exception
 181 {
 182  protected:
 183         /** Holds the error message to be displayed
 184          */
 185         const std::string err;
 186         /** Source of the exception
 187          */
 188         const std::string source;
 189
 190  public:
 191         /** This constructor can be used to specify an error message before throwing.
 192          * @param message Human readable error message
 193          */
 194         CoreException(const std::string &message) : err(message), source("The core") {}
 195         /** This constructor can be used to specify an error message before throwing,
 196          * and to specify the source of the exception.
 197          * @param message Human readable error message
 198          * @param src Source of the exception
 199          */
 200         CoreException(const std::string &message, const std::string &src) : err(message), source(src) {}
 201         /** This destructor solves world hunger, cancels the world debt, and causes the world to end.
 202          * Actually no, it does nothing. Never mind.
 203          * @throws Nothing!
 204          */
 205         virtual ~CoreException() throw() {}
 206         /** Returns the reason for the exception.
 207          * @return Human readable description of the error
 208          */
 209         const std::string& GetReason() const { return err; }
 210
 211         /** Returns the source of the exception
 212          * @return Source of the exception
 213          */
 214         const std::string& GetSource() const { return source; }
 215 };
 216
 217 class Module;
 218 class CoreExport ModuleException : public CoreException
 219 {
 220  public:
 221         /** This constructor can be used to specify an error message before throwing.
 222          */
 223         ModuleException(const std::string &message, Module* me = NULL);
 224 };
 225
 226 typedef const reference<Module> ModuleRef;
 227
 228 enum ServiceType {
 229         /** is a Command */
 230         SERVICE_COMMAND,
 231         /** is a ModeHandler */
 232         SERVICE_MODE,
 233         /** is a metadata descriptor */
 234         SERVICE_METADATA,
 235         /** is a data processing provider (MD5, SQL) */
 236         SERVICE_DATA,
 237         /** is an I/O hook provider (SSL) */
 238         SERVICE_IOHOOK,
 239         /** Service managed by a module */
 240         SERVICE_CUSTOM
 241 };
 242
 243 /** A structure defining something that a module can provide */
 244 class CoreExport ServiceProvider : public classbase
 245 {
 246  public:
 247         /** Module that is providing this service */
 248         ModuleRef creator;
 249         /** Name of the service being provided */
 250         const std::string name;
 251         /** Type of service (must match object type) */
 252         const ServiceType service;
 253         ServiceProvider(Module* Creator, const std::string& Name, ServiceType Type);
 254         virtual ~ServiceProvider();
 255
 256         /** Register this service in the appropriate registrar
 257          */
 258         virtual void RegisterService();
 259
 260         /** If called, this ServiceProvider won't be registered automatically
 261          */
 262         void DisableAutoRegister();
 263 };