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
|
/*******************************************************************************
* Copyright (c) 2007 Oracle. All rights reserved.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0, which accompanies this distribution
* and is available at http://www.eclipse.org/legal/epl-v10.html.
*
* Contributors:
* Oracle - initial API and implementation
******************************************************************************/
package org.eclipse.jpt.utility.internal.model.value.prefs;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.prefs.BackingStoreException;
import java.util.prefs.PreferenceChangeEvent;
import java.util.prefs.PreferenceChangeListener;
import java.util.prefs.Preferences;
import org.eclipse.jpt.utility.internal.iterators.ArrayIterator;
import org.eclipse.jpt.utility.internal.iterators.TransformationIterator;
import org.eclipse.jpt.utility.internal.model.value.AspectAdapter;
import org.eclipse.jpt.utility.internal.model.value.CollectionValueModel;
import org.eclipse.jpt.utility.internal.model.value.ValueModel;
/**
* This adapter wraps a Preferences node and converts its preferences into a
* CollectionValueModel of PreferencePropertyValueModels. It listens for
* "preference" changes and converts them into VALUE collection changes.
*/
public class PreferencesCollectionValueModel
extends AspectAdapter
implements CollectionValueModel
{
/** Cache the current preferences, stored in models and keyed by name. */
protected Map preferences;
/** A listener that listens to the preferences node for added or removed preferences. */
protected PreferenceChangeListener preferenceChangeListener;
// ********** constructors **********
/**
* Construct an adapter for the specified preferences node.
*/
public PreferencesCollectionValueModel(Preferences preferences) {
super(preferences);
}
/**
* Construct an adapter for the specified preferences node.
*/
public PreferencesCollectionValueModel(ValueModel preferencesHolder) {
super(preferencesHolder);
}
// ********** initialization **********
@Override
protected void initialize() {
super.initialize();
this.preferences = new HashMap();
this.preferenceChangeListener = this.buildPreferenceChangeListener();
}
/**
* A preferences have changed, notify the listeners.
*/
protected PreferenceChangeListener buildPreferenceChangeListener() {
// transform the preference change events into VALUE collection change events
return new PreferenceChangeListener() {
public void preferenceChange(PreferenceChangeEvent e) {
PreferencesCollectionValueModel.this.preferenceChanged(e.getKey(), e.getNewValue());
}
@Override
public String toString() {
return "preference change listener";
}
};
}
// ********** ValueModel implementation **********
/**
* Return an iterator on the preference models.
*/
public synchronized Object value() {
return this.preferences.values().iterator();
}
// ********** CollectionValueModel implementation **********
public void addItem(Object item) {
throw new UnsupportedOperationException();
}
public void addItems(Collection items) {
for (Iterator stream = items.iterator(); stream.hasNext(); ) {
this.addItem(stream.next());
}
}
public void removeItem(Object item) {
throw new UnsupportedOperationException();
}
public void removeItems(Collection items) {
for (Iterator stream = items.iterator(); stream.hasNext(); ) {
this.removeItem(stream.next());
}
}
public synchronized int size() {
return this.preferences.size();
}
// ********** AspectAdapter implementation **********
@Override
protected boolean hasListeners() {
return this.hasAnyCollectionChangeListeners(VALUE);
}
@Override
protected void fireAspectChange(Object oldValue, Object newValue) {
this.fireCollectionChanged(VALUE);
}
@Override
protected void engageNonNullSubject() {
((Preferences) this.subject).addPreferenceChangeListener(this.preferenceChangeListener);
for (Iterator stream = this.preferenceModels(); stream.hasNext(); ) {
PreferencePropertyValueModel preferenceModel = (PreferencePropertyValueModel) stream.next();
this.preferences.put(preferenceModel.getKey(), preferenceModel);
}
}
@Override
protected void disengageNonNullSubject() {
try {
((Preferences) this.subject).removePreferenceChangeListener(this.preferenceChangeListener);
} catch (IllegalStateException ex) {
// for some odd reason, we are not allowed to remove a listener from a "dead"
// preferences node; so handle the exception that gets thrown here
if ( ! ex.getMessage().equals("Node has been removed.")) {
// if it is not the expected exception, re-throw it
throw ex;
}
}
this.preferences.clear();
}
// ********** AbstractModel implementation **********
@Override
public void toString(StringBuilder sb) {
sb.append(this.subject);
}
// ********** internal methods **********
/**
* Return an iterator on the preference models.
* At this point we can be sure that the subject is not null.
*/
protected Iterator preferenceModels() {
String[] keys;
try {
keys = ((Preferences) this.subject).keys();
} catch (BackingStoreException ex) {
throw new RuntimeException(ex);
}
return new TransformationIterator(new ArrayIterator(keys)) {
protected Object transform(Object next) {
return PreferencesCollectionValueModel.this.buildPreferenceModel((String) next);
}
};
}
/**
* Override this method to tweak the model used to wrap the
* specified preference (e.g. to customize the model's converter).
*/
protected PreferencePropertyValueModel buildPreferenceModel(String key) {
return new PreferencePropertyValueModel(this.subjectHolder, key);
}
protected synchronized void preferenceChanged(String key, String newValue) {
if (newValue == null) {
// a preference was removed
PreferencePropertyValueModel preferenceModel = (PreferencePropertyValueModel) this.preferences.remove(key);
this.fireItemRemoved(VALUE, preferenceModel);
} else if ( ! this.preferences.containsKey(key)) {
// a preference was added
PreferencePropertyValueModel preferenceModel = this.buildPreferenceModel(key);
this.preferences.put(key, preferenceModel);
this.fireItemAdded(VALUE, preferenceModel);
} else {
// a preference's value changed - do nothing
}
}
}
|
