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 | |
package com.sun.javafx.runtime.sequence; |
27 | |
|
28 | |
import com.sun.javafx.runtime.location.IntLocation; |
29 | |
import com.sun.javafx.runtime.location.SequenceLocation; |
30 | |
import com.sun.javafx.runtime.location.SequenceChangeListener; |
31 | |
import com.sun.javafx.runtime.location.IntChangeListener; |
32 | |
|
33 | |
|
34 | |
|
35 | |
|
36 | |
|
37 | |
|
38 | |
|
39 | 271 | class BoundSequenceSlice<T> extends AbstractBoundSequence<T> implements SequenceLocation<T> { |
40 | |
private final SequenceLocation<T> sequenceLoc; |
41 | |
private final IntLocation lowerLoc; |
42 | |
private final IntLocation upperLoc; |
43 | |
private final boolean isExclusive; |
44 | |
private int lower, upper; |
45 | |
private int size; |
46 | |
|
47 | |
BoundSequenceSlice(Class<T> clazz, SequenceLocation<T> sequenceLoc, IntLocation lowerLoc, IntLocation upperLoc, boolean isExclusive) { |
48 | 8 | super(clazz); |
49 | 8 | this.sequenceLoc = sequenceLoc; |
50 | 8 | this.lowerLoc = lowerLoc; |
51 | 8 | this.upperLoc = upperLoc; |
52 | 8 | this.isExclusive = isExclusive; |
53 | 8 | setInitialValue(computeValue()); |
54 | 8 | addTriggers(); |
55 | 8 | } |
56 | |
|
57 | |
private Sequence<T> computeValue() { |
58 | 8 | computeBounds(true, true); |
59 | 8 | return sequenceLoc.get().getSlice(lower, upper); |
60 | |
} |
61 | |
|
62 | |
|
63 | |
|
64 | |
|
65 | |
private int adjusted(int upperValue) { |
66 | 48 | return (isExclusive ? -1 : 0) + upperValue; |
67 | |
} |
68 | |
|
69 | |
private void computeBounds(boolean updateLower, boolean updateUpper) { |
70 | 54 | int seqSize = sequenceLoc.getAsSequence().size(); |
71 | |
|
72 | 54 | if (updateLower) { |
73 | 42 | lower = lowerLoc.get(); |
74 | |
} |
75 | 54 | if (updateUpper) { |
76 | 44 | upper = adjusted(upperLoc == null ? seqSize-1 : upperLoc.get()); |
77 | |
} |
78 | |
|
79 | 54 | if (seqSize == 0) { |
80 | 1 | size = 0; |
81 | |
} else { |
82 | 53 | int range = ((upper >= seqSize)? seqSize-1:upper) - ((lower<0)? 0: lower); |
83 | 53 | size = (range >= 0) ? range + 1 : 0; |
84 | |
} |
85 | 54 | } |
86 | |
|
87 | |
protected Sequence<T> computeFull(int lower, int upper) { |
88 | 0 | return sequenceLoc.getSlice(lower, upper); |
89 | |
} |
90 | |
|
91 | |
private void addTriggers() { |
92 | 8 | sequenceLoc.addChangeListener(new SequenceChangeListener<T>() { |
93 | |
|
94 | |
public void onChange(int startPos, int endPos, Sequence newElements, Sequence oldValue, Sequence newValue) { |
95 | 24 | computeBounds(true, true); |
96 | |
|
97 | 24 | Sequence<T> newSeq = newValue.getSlice(lower, upper); |
98 | 24 | updateSlice(0, size == 0 ? 0 : size - 1, newSeq, newSeq); |
99 | 24 | } |
100 | |
}); |
101 | 11 | lowerLoc.addChangeListener(new IntChangeListener() { |
102 | |
|
103 | |
public void onChange(int oldValue, int newValue) { |
104 | 10 | assert oldValue != newValue; |
105 | 10 | int oldSize = size; |
106 | 10 | computeBounds(true, false); |
107 | |
|
108 | 10 | if (sequenceLoc.getAsSequence().size() > 0 && size != oldSize) { |
109 | 9 | if (size > oldSize) { |
110 | 3 | updateSlice( |
111 | |
0, |
112 | |
-1, |
113 | |
sequenceLoc.getSlice(newValue, (oldSize == 0) ? upper : (oldValue - 1))); |
114 | |
} else { |
115 | 6 | updateSlice( |
116 | |
0, |
117 | |
oldSize - size - 1, |
118 | |
Sequences.emptySequence(sequenceLoc.getAsSequence().getElementType())); |
119 | |
} |
120 | |
} |
121 | 10 | } |
122 | |
}); |
123 | 8 | if (upperLoc != null) { |
124 | 6 | upperLoc.addChangeListener(new IntChangeListener() { |
125 | |
|
126 | |
public void onChange(int oldValue, int newValue) { |
127 | 12 | assert oldValue != newValue; |
128 | 12 | int oldSize = size; |
129 | 12 | computeBounds(false, true); |
130 | |
|
131 | 12 | if (sequenceLoc.getAsSequence().size() > 0 && size != oldSize) { |
132 | 10 | if (size > oldSize) { |
133 | 4 | int oldUpper = adjusted(oldValue); |
134 | 4 | updateSlice( |
135 | |
oldSize, |
136 | |
oldSize - 1, |
137 | |
sequenceLoc.getSlice((oldUpper >= lower) ? oldUpper + 1 : lower, upper)); |
138 | 4 | } else { |
139 | 6 | updateSlice( |
140 | |
size, |
141 | |
oldSize - 1, |
142 | |
Sequences.emptySequence(sequenceLoc.getAsSequence().getElementType())); |
143 | |
} |
144 | |
} |
145 | 12 | } |
146 | |
}); |
147 | |
} |
148 | 8 | } |
149 | |
} |