blob: fae4291ed1ecfbf8b2249f125648d68644b5cf40 (
plain)
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
|
package org.holoeverywhere.addon;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import org.holoeverywhere.addon.IAddon.Addon;
public final class IAddonBasicAttacher<V extends IAddonBase<Z>, Z> implements IAddonAttacher<V> {
private final class AddonComparator implements Comparator<V> {
@Override
public int compare(V lhs, V rhs) {
final int i1 = getWeight(lhs.getParent());
final int i2 = getWeight(rhs.getParent());
return i1 > i2 ? 1 : i1 < i2 ? -1 : 0;
}
private int getWeight(IAddon addon) {
if (addon.getClass().isAnnotationPresent(Addon.class)) {
return addon.getClass().getAnnotation(Addon.class).weight();
}
return -1;
}
}
private final Map<Class<? extends IAddon>, V> mAddons = new HashMap<Class<? extends IAddon>, V>();
private final Set<V> mAddonsList = new TreeSet<V>(new AddonComparator());
private boolean mLockAttaching = false;
private Z mObject;
public IAddonBasicAttacher(Z object) {
mObject = object;
}
@Override
@SuppressWarnings("unchecked")
public <T extends V> T addon(Class<? extends IAddon> clazz) {
T addon = (T) mAddons.get(clazz);
if (addon == null) {
if (mLockAttaching) {
throw new AttachException(mObject, clazz);
}
addon = IAddon.obtain(clazz, mObject);
if (addon == null) {
return null;
}
mAddons.put(clazz, addon);
mAddonsList.add(addon);
}
return addon;
}
@Override
public void addon(Collection<Class<? extends IAddon>> classes) {
if (classes == null) {
return;
}
for (Class<? extends IAddon> clazz : classes) {
addon(clazz);
}
}
@Override
public <T extends V> T addon(String classname) {
return addon(IAddon.makeAddonClass(classname));
}
public void inhert(Collection<Class<? extends IAddon>> sourceClasses) {
if (sourceClasses == null || sourceClasses.size() == 0) {
return;
}
List<Class<? extends IAddon>> classes = new ArrayList<Class<? extends IAddon>>();
for (Class<? extends IAddon> clazz : sourceClasses) {
if (!clazz.isAnnotationPresent(Addon.class)) {
continue;
}
Addon addon = clazz.getAnnotation(Addon.class);
if (addon.inhert()) {
classes.add(clazz);
}
}
addon(classes);
}
public void inhert(IAddonAttacher<?> attacher) {
inhert(attacher == null ? null : attacher.obtainAddonsList());
}
@Override
public boolean isAddonAttached(Class<? extends IAddon> clazz) {
return mAddons.containsKey(clazz);
}
@Override
public void lockAttaching() {
mLockAttaching = true;
}
@Override
public Collection<Class<? extends IAddon>> obtainAddonsList() {
return new ArrayList<Class<? extends IAddon>>(mAddons.keySet());
}
@Override
public boolean performAddonAction(AddonCallback<V> callback) {
if (mAddons.size() == 0) {
return false;
}
callback.pre();
boolean result = false;
for (V addon : mAddonsList) {
result = callback.performAction(addon);
if (callback.mStopped) {
return result;
}
}
return callback.post();
}
public void reset() {
mAddons.clear();
mAddonsList.clear();
mLockAttaching = false;
}
}
|
