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
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
/**
* $RCSfile$
* $Revision$
* $Date$
*
* Copyright (C) 2004 Jive Software. All rights reserved.
*
* This software is published under the terms of the GNU Public License (GPL),
* a copy of which is included in this distribution.
*/
package org.jivesoftware.messenger.muc;
import org.jivesoftware.util.Log;
import org.jivesoftware.messenger.JiveGlobals;
import org.xmpp.packet.Message;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.ListIterator;
/**
* <p>Multi-User Chat rooms may cache history of the conversations in the room in order to
* play them back to newly arriving members.</p>
*
* <p>This class is an internal component of MUCRoomHistory that describes the strategy that can
* be used, and provides a method of administering the history behavior.</p>
*
* @author Gaston Dombiak
* @author Derek DeMoro
*/
public class HistoryStrategy {
/**
* The type of strategy being used.
*/
private Type type = Type.number;
/**
* List containing the history of messages.
*/
private LinkedList history = new LinkedList();
/**
* Default max number.
*/
private static final int DEFAULT_MAX_NUMBER = 25;
/**
* The maximum number of chat history messages stored for the room.
*/
private int maxNumber;
/**
* The parent history used for default settings, or null if no parent
* (chat server defaults).
*/
private HistoryStrategy parent;
/**
* Track the latest room subject change or null if none exists yet.
*/
private Message roomSubject = null;
/**
* The string prefix to be used on the context property names
* (do not include trailing dot).
*/
private String contextPrefix = null;
/**
* Create a history strategy with the given parent strategy (for defaults) or null if no
* parent exists.
*
* @param parentStrategy The parent strategy of this strategy or null if none exists.
*/
public HistoryStrategy(HistoryStrategy parentStrategy) {
this.parent = parentStrategy;
if (parent == null) {
maxNumber = DEFAULT_MAX_NUMBER;
}
else {
type = Type.defaulType;
maxNumber = parent.getMaxNumber();
}
}
/**
* Obtain the maximum number of messages for strategies using message number limitations.
*
* @return The maximum number of messages to store in applicable strategies.
*/
public int getMaxNumber() {
return maxNumber;
}
/**
* Set the maximum number of messages for strategies using message number limitations.
*
* @param max The maximum number of messages to store in applicable strategies.
*/
public void setMaxNumber(int max) {
this.maxNumber = max;
if (contextPrefix != null){
JiveGlobals.setProperty(contextPrefix + ".maxNumber",
Integer.toString(maxNumber));
}
}
/**
* Set the type of history strategy being used.
*
* @param newType The new type of chat history to use.
*/
public void setType(Type newType){
if (newType != null){
type = newType;
}
if (contextPrefix != null){
JiveGlobals.setProperty(contextPrefix + ".type", type.toString());
}
}
/**
* Obtain the type of history strategy being used.
*
* @return The current type of strategy being used.
*/
public Type getType(){
return type;
}
/**
* Add a message to the current chat history. The strategy type will determine what
* actually happens to the message.
*
* @param packet The packet to add to the chatroom's history.
*/
public void addMessage(Message packet){
// get the conditions based on default or not
Type strategyType;
int strategyMaxNumber;
if (type == Type.defaulType && parent != null) {
strategyType = parent.getType();
strategyMaxNumber = parent.getMaxNumber();
}
else {
strategyType = type;
strategyMaxNumber = maxNumber;
}
// Room subject change messages are special
boolean subjectChange = false;
if (packet.getSubject() != null && packet.getSubject().length() > 0){
subjectChange = true;
roomSubject = packet;
}
// store message according to active strategy
if (strategyType == Type.none){
if (subjectChange) {
history.clear();
history.add(packet);
}
}
else if (strategyType == Type.all) {
history.addLast(packet);
}
else if (strategyType == Type.number) {
if (history.size() >= strategyMaxNumber) {
// We have to remove messages so the new message won't exceed
// the max history size
// This is complicated somewhat because we must skip over the
// last room subject
// message because we want to preserve the room subject if
// possible.
ListIterator historyIter = history.listIterator();
while (historyIter.hasNext() && history.size() > strategyMaxNumber) {
if (historyIter.next() != roomSubject) {
historyIter.remove();
}
}
}
history.addLast(packet);
}
}
/**
* Obtain the current history as an iterator of messages to play back to a new room member.
*
* @return An iterator of Message objects to be sent to the new room member.
*/
public Iterator getMessageHistory(){
LinkedList list = new LinkedList(history);
return list.iterator();
}
/**
* Obtain the current history to be iterated in reverse mode. This means that the returned list
* iterator will be positioned at the end of the history so senders of this message must
* traverse the list in reverse mode.
*
* @return A list iterator of Message objects positioned at the end of the list.
*/
public ListIterator getReverseMessageHistory(){
LinkedList list = new LinkedList(history);
return list.listIterator(list.size());
}
/**
* Strategy type.
*/
public enum Type {
defaulType, none, all, number;
}
/**
* Obtain the strategy type from string name. See the Type enumeration name
* strings for the names strings supported. If nothing matches
* and parent != null DEFAULT is used, otherwise, NUMBER is used.
*
* @param typeName The text name of the strategy type
*/
public void setTypeFromString(String typeName) {
try {
setType(Type.valueOf(typeName));
}
catch (Exception e) {
if (parent != null) {
setType(Type.defaulType);
}
else {
setType(Type.number);
}
}
}
/**
* Sets the prefix to use for retrieving and saving settings (and also
* triggers an immediate loading of properties).
*
* @param prefix the prefix to use (without trailing dot) on property names.
*/
public void setContext(String prefix) {
this.contextPrefix = prefix;
setTypeFromString(JiveGlobals.getProperty(prefix + ".type"));
String maxNumberString = JiveGlobals.getProperty(prefix + ".maxNumber");
if (maxNumberString != null && maxNumberString.trim().length() > 0){
try {
setMaxNumber(Integer.parseInt(maxNumberString));
}catch (Exception e){
Log.info("Jive property "
+ prefix + ".maxNumber not a valid number.");
}
}
}
/**
* Returns true if there is a message within the history of the room that has changed the
* room's subject.
*
* @return true if there is a message within the history of the room that has changed the
* room's subject.
*/
public boolean hasChangedSubject() {
return roomSubject != null;
}
}