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
|
/* +------------------------------------+
* | Inspire Internet Relay Chat Daemon |
* +------------------------------------+
*
* InspIRCd: (C) 2002-2011 InspIRCd Development Team
* See: http://wiki.inspircd.org/Credits
*
* This program is free but copyrighted software; see
* the file COPYING for details.
*
* ---------------------------------------------------
*/
#ifndef INSPIRCD_LISTMODE_PROVIDER
#define INSPIRCD_LISTMODE_PROVIDER
/** The number of items a listmode's list may contain
*/
class ListLimit
{
public:
std::string mask;
unsigned int limit;
};
/** Max items per channel by name
*/
typedef std::list<ListLimit> limitlist;
class CoreExport ListExtItem : public LocalExtItem
{
public:
ListExtItem(const std::string& Key, Module* parent) : LocalExtItem(EXTENSIBLE_CHANNEL, Key, parent)
{
}
virtual ~ListExtItem()
{
}
inline modelist* get(const Extensible* container) const
{
return static_cast<modelist*>(get_raw(container));
}
inline modelist* make(Extensible* container)
{
modelist* ml = new modelist;
modelist* old = static_cast<modelist*>(set_raw(container, static_cast<void*>(ml)));
this->free(old);
return ml;
}
inline void unset(Extensible* container)
{
modelist* old = static_cast<modelist*>(unset_raw(container));
this->free(old);
}
virtual void free(void* item);
};
/** The base class for list modes, should be inherited.
*/
class CoreExport ListModeBase : public ModeHandler
{
protected:
/** Numeric to use when outputting the list
*/
unsigned int listnumeric;
/** Numeric to indicate end of list
*/
unsigned int endoflistnumeric;
/** String to send for end of list
*/
std::string endofliststring;
/** Automatically tidy up entries
*/
bool tidy;
/** Config tag to check for max items per channel
*/
std::string configtag;
/** Limits on a per-channel basis read from the tag
* specified in ListModeBase::configtag
*/
limitlist chanlimits;
public:
/** Storage key
*/
ListExtItem extItem;
/** Constructor.
* @param Instance The creator of this class
* @param modechar Mode character
* @param eolstr End of list string
* @pram lnum List numeric
* @param eolnum End of list numeric
* @param autotidy Automatically tidy list entries on add
* @param ctag Configuration tag to get limits from
*/
ListModeBase(Module* Creator, const std::string& Name, char modechar, const std::string &eolstr, unsigned int lnum, unsigned int eolnum, bool autotidy, const std::string &ctag = "banlist")
: ModeHandler(Creator, Name, modechar, PARAM_ALWAYS, MODETYPE_CHANNEL),
listnumeric(lnum), endoflistnumeric(eolnum), endofliststring(eolstr), tidy(autotidy),
configtag(ctag), extItem(name + "_mode_list", Creator)
{
list = true;
}
inline void init()
{
DoRehash();
ServerInstance->Extensions.Register(&extItem);
}
virtual void DisplayList(User* user, Channel* channel);
virtual void PopulateChanModes(Channel* channel, irc::modestacker& stack);
virtual const modelist* GetList(Channel* channel);
virtual void DisplayEmptyList(User* user, Channel* channel)
{
user->WriteNumeric(endoflistnumeric, "%s %s :%s", user->nick.c_str(), channel->name.c_str(), endofliststring.c_str());
}
virtual void RemoveMode(Channel* channel, irc::modestacker* stack);
virtual void RemoveMode(User*, irc::modestacker* stack);
/** Perform a rehash of this mode's configuration data
*/
virtual void DoRehash();
/** Handle the list mode.
* See mode.h
*/
virtual ModeAction OnModeChange(User* source, User*, Channel* channel, std::string ¶meter, bool adding);
/** Validate parameters.
* Overridden by implementing module.
* @param source Source user adding the parameter
* @param channel Channel the parameter is being added to
* @param parameter The actual parameter being added
* @return true if the parameter is valid
*/
virtual bool ValidateParam(User*, Channel*, std::string&)
{
return true;
}
/** Tell the user the list is too long.
* Overridden by implementing module.
* @param source Source user adding the parameter
* @param channel Channel the parameter is being added to
* @param parameter The actual parameter being added
* @return Ignored
*/
virtual bool TellListTooLong(User*, Channel*, std::string&)
{
return false;
}
/** Tell the user an item is already on the list.
* Overridden by implementing module.
* @param source Source user adding the parameter
* @param channel Channel the parameter is being added to
* @param parameter The actual parameter being added
*/
virtual void TellAlreadyOnList(User*, Channel*, std::string&)
{
}
/** Tell the user that the parameter is not in the list.
* Overridden by implementing module.
* @param source Source user removing the parameter
* @param channel Channel the parameter is being removed from
* @param parameter The actual parameter being removed
*/
virtual void TellNotSet(User*, Channel*, std::string&)
{
}
};
#endif
|
