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
|
/*******************************************************************************
* Copyright (c) 2007, 2009 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.common.utility.internal.model.value.prefs;
import java.util.EventListener;
import java.util.HashMap;
import java.util.Iterator;
import java.util.prefs.BackingStoreException;
import java.util.prefs.PreferenceChangeEvent;
import java.util.prefs.PreferenceChangeListener;
import java.util.prefs.Preferences;
import org.eclipse.jpt.common.utility.internal.CollectionTools;
import org.eclipse.jpt.common.utility.internal.iterators.ArrayIterator;
import org.eclipse.jpt.common.utility.internal.iterators.TransformationIterator;
import org.eclipse.jpt.common.utility.internal.model.value.AspectAdapter;
import org.eclipse.jpt.common.utility.internal.model.value.StaticPropertyValueModel;
import org.eclipse.jpt.common.utility.model.listener.CollectionChangeListener;
import org.eclipse.jpt.common.utility.model.value.CollectionValueModel;
import org.eclipse.jpt.common.utility.model.value.PropertyValueModel;
/**
* 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<P>
extends AspectAdapter<Preferences>
implements CollectionValueModel<PreferencePropertyValueModel<P>>
{
/** Cache the current preferences, stored in models and keyed by name. */
protected final HashMap<String, PreferencePropertyValueModel<P>> preferences;
/** A listener that listens to the preferences node for added or removed preferences. */
protected final PreferenceChangeListener preferenceChangeListener;
// ********** constructors **********
/**
* Construct an adapter for the specified preferences node.
*/
public PreferencesCollectionValueModel(Preferences preferences) {
this(new StaticPropertyValueModel<Preferences>(preferences));
}
/**
* Construct an adapter for the specified preferences node.
*/
public PreferencesCollectionValueModel(PropertyValueModel<? extends Preferences> preferencesHolder) {
super(preferencesHolder);
this.preferences = new HashMap<String, PreferencePropertyValueModel<P>>();
this.preferenceChangeListener = this.buildPreferenceChangeListener();
}
// ********** initialization **********
/**
* 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 event) {
PreferencesCollectionValueModel.this.preferenceChanged(event.getKey(), event.getNewValue());
}
@Override
public String toString() {
return "preference change listener"; //$NON-NLS-1$
}
};
}
// ********** CollectionValueModel implementation **********
/**
* Return an iterator on the preference models.
*/
public synchronized Iterator<PreferencePropertyValueModel<P>> iterator() {
return this.preferences.values().iterator();
}
public synchronized int size() {
return this.preferences.size();
}
// ********** AspectAdapter implementation **********
@Override
protected Object getValue() {
return this.iterator();
}
@Override
protected Class<? extends EventListener> getListenerClass() {
return CollectionChangeListener.class;
}
@Override
protected String getListenerAspectName() {
return VALUES;
}
@Override
protected boolean hasListeners() {
return this.hasAnyCollectionChangeListeners(VALUES);
}
@Override
protected void fireAspectChanged(Object oldValue, Object newValue) {
@SuppressWarnings("unchecked") Iterator<PreferencePropertyValueModel<P>> iterator = (Iterator<PreferencePropertyValueModel<P>>) newValue;
this.fireCollectionChanged(VALUES, CollectionTools.collection(iterator));
}
@Override
protected void engageSubject_() {
this.subject.addPreferenceChangeListener(this.preferenceChangeListener);
for (Iterator<PreferencePropertyValueModel<P>> stream = this.preferenceModels(); stream.hasNext(); ) {
PreferencePropertyValueModel<P> preferenceModel = stream.next();
this.preferences.put(preferenceModel.getKey(), preferenceModel);
}
}
@Override
protected void disengageSubject_() {
try {
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.")) { //$NON-NLS-1$
// 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<PreferencePropertyValueModel<P>> preferenceModels() {
String[] keys;
try {
keys = this.subject.keys();
} catch (BackingStoreException ex) {
throw new RuntimeException(ex);
}
return new TransformationIterator<String, PreferencePropertyValueModel<P>>(new ArrayIterator<String>(keys)) {
@Override
protected PreferencePropertyValueModel<P> transform(String key) {
return PreferencesCollectionValueModel.this.buildPreferenceModel(key);
}
};
}
/**
* Override this method to tweak the model used to wrap the
* specified preference (e.g. to customize the model's converter).
*/
protected PreferencePropertyValueModel<P> buildPreferenceModel(String key) {
return new PreferencePropertyValueModel<P>(this.subjectHolder, key);
}
protected synchronized void preferenceChanged(String key, String newValue) {
if (newValue == null) {
// a preference was removed
PreferencePropertyValueModel<P> preferenceModel = this.preferences.remove(key);
this.fireItemRemoved(VALUES, preferenceModel);
} else if ( ! this.preferences.containsKey(key)) {
// a preference was added
PreferencePropertyValueModel<P> preferenceModel = this.buildPreferenceModel(key);
this.preferences.put(key, preferenceModel);
this.fireItemAdded(VALUES, preferenceModel);
} else {
// a preference's value changed - do nothing
}
}
}
|
