1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
|
/* +------------------------------------+
* | Inspire Internet Relay Chat Daemon |
* +------------------------------------+
*
* InspIRCd: (C) 2002-2009 InspIRCd Development Team
* See: http://wiki.inspircd.org/Credits
*
* This program is free but copyrighted software; see
* the file COPYING for details.
*
* ---------------------------------------------------
*/
#ifndef __BASE_H__
#define __BASE_H__
#include <map>
#include <deque>
#include <string>
/** Dummy class to help enforce culls being parent-called up to classbase */
class CullResult
{
CullResult();
friend class classbase;
};
/** The base class for all inspircd classes with a well-defined lifetime.
* Classes that inherit from this may be destroyed through GlobalCulls,
* and may rely on cull() being called prior to their deletion.
*/
class CoreExport classbase
{
public:
classbase();
/**
* Called just prior to destruction via cull list.
*
* @return true to allow the delete, or false to halt the delete
*/
virtual CullResult cull();
virtual ~classbase();
private:
// uncopyable
classbase(const classbase&);
void operator=(const classbase&);
};
/** The base class for inspircd classes that provide a wrapping interface, and
* should only exist while being used. Prevents heap allocation.
*/
class CoreExport interfacebase
{
public:
interfacebase() {}
private:
interfacebase(const interfacebase&);
void operator=(const interfacebase&);
void* operator new(size_t);
void operator delete(void*);
};
/** The base class for inspircd classes that support reference counting.
* Any objects that do not have a well-defined lifetime should inherit from
* this, and should be assigned to a reference<type> object to establish their
* lifetime.
*
* Reference objects should not hold circular references back to themselves,
* even indirectly; this will cause a memory leak because the count will never
* drop to zero.
*
* Using a normal pointer for the object is recommended if you can assure that
* at least one reference<> will remain as long as that pointer is used; this
* will avoid the slight overhead of changing the reference count.
*/
class CoreExport refcountbase
{
mutable unsigned int refcount;
public:
refcountbase();
virtual ~refcountbase();
inline unsigned int GetReferenceCount() const { return refcount; }
friend class reference_base;
void* operator new(size_t);
void operator delete(void*);
private:
// uncopyable
refcountbase(const refcountbase&);
void operator=(const refcountbase&);
};
class CoreExport reference_base
{
protected:
template<typename T> static inline unsigned int inc(T* v) { return ++(v->refcount); }
template<typename T> static inline unsigned int dec(T* v) { return --(v->refcount); }
};
template <typename T>
class reference : public reference_base
{
T* value;
public:
reference() : value(0) { }
reference(T* v) : value(v) { if (value) inc(value); }
reference(const reference<T>& v) : value(v.value) { if (value) inc(value); }
reference<T>& operator=(const reference<T>& other)
{
if (other.value)
inc(other.value);
this->reference::~reference();
value = other.value;
return *this;
}
~reference()
{
if (value)
{
int rc = dec(value);
if (rc == 0)
delete value;
}
}
inline operator bool() const { return value; }
inline operator T*() const { return value; }
inline T* operator->() const { return value; }
inline T& operator*() const { return *value; }
inline bool operator<(const reference<T>& other) const { return value < other.value; }
inline bool operator>(const reference<T>& other) const { return value > other.value; }
inline bool operator==(const reference<T>& other) const { return value == other.value; }
inline bool operator!=(const reference<T>& other) const { return value != other.value; }
private:
void* operator new(size_t);
void operator delete(void*);
};
/** This class can be used on its own to represent an exception, or derived to represent a module-specific exception.
* When a module whishes to abort, e.g. within a constructor, it should throw an exception using ModuleException or
* a class derived from ModuleException. If a module throws an exception during its constructor, the module will not
* be loaded. If this happens, the error message returned by ModuleException::GetReason will be displayed to the user
* attempting to load the module, or dumped to the console if the ircd is currently loading for the first time.
*/
class CoreExport CoreException : public std::exception
{
protected:
/** Holds the error message to be displayed
*/
const std::string err;
/** Source of the exception
*/
const std::string source;
public:
/** Default constructor, just uses the error mesage 'Core threw an exception'.
*/
CoreException() : err("Core threw an exception"), source("The core") {}
/** This constructor can be used to specify an error message before throwing.
*/
CoreException(const std::string &message) : err(message), source("The core") {}
/** This constructor can be used to specify an error message before throwing,
* and to specify the source of the exception.
*/
CoreException(const std::string &message, const std::string &src) : err(message), source(src) {}
/** This destructor solves world hunger, cancels the world debt, and causes the world to end.
* Actually no, it does nothing. Never mind.
* @throws Nothing!
*/
virtual ~CoreException() throw() {};
/** Returns the reason for the exception.
* The module should probably put something informative here as the user will see this upon failure.
*/
virtual const char* GetReason()
{
return err.c_str();
}
virtual const char* GetSource()
{
return source.c_str();
}
};
class Module;
class CoreExport ModuleException : public CoreException
{
public:
/** This constructor can be used to specify an error message before throwing.
*/
ModuleException(const std::string &message, Module* me = NULL);
};
/** Module reference, similar to reference<Module>
*/
class CoreExport ModuleRef : public reference_base
{
Module* const value;
public:
ModuleRef(Module* v);
~ModuleRef();
inline operator Module*() const { return value; }
inline Module* operator->() const { return value; }
inline Module& operator*() const { return *value; }
private:
ModuleRef(const ModuleRef&);
void operator=(const ModuleRef&);
void* operator new(size_t);
void operator delete(void*);
};
#endif
|
