1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.apache.hadoop.hbase.util;
20
21 import java.util.ArrayList;
22 import java.util.Collection;
23 import java.util.Collections;
24 import java.util.Comparator;
25 import java.util.Iterator;
26 import java.util.List;
27 import java.util.ListIterator;
28 import java.util.RandomAccess;
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49 @edu.umd.cs.findbugs.annotations.SuppressWarnings(value="UG_SYNC_SET_UNSYNC_GET",
50 justification="TODO: synchronization in here needs review!!!")
51 public class SortedList<E> implements List<E>, RandomAccess {
52 private volatile List<E> list;
53 private final Comparator<? super E> comparator;
54
55
56
57
58
59
60
61 public SortedList(Comparator<? super E> comparator) {
62 this.list = Collections.emptyList();
63 this.comparator = comparator;
64 }
65
66
67
68
69
70
71
72
73
74 public SortedList(Collection<? extends E> c, Comparator<? super E> comparator) {
75 this.list = Collections.unmodifiableList(new ArrayList<E>(c));
76 this.comparator = comparator;
77 }
78
79
80
81
82
83
84
85 public List<E> get() {
86 return list;
87 }
88
89 @Override
90 public int size() {
91 return list.size();
92 }
93
94 @Override
95 public boolean isEmpty() {
96 return list.isEmpty();
97 }
98
99 @Override
100 public boolean contains(Object o) {
101 return list.contains(o);
102 }
103
104 @Override
105 public Iterator<E> iterator() {
106 return list.iterator();
107 }
108
109 @Override
110 public Object[] toArray() {
111 return list.toArray();
112 }
113
114 @Override
115 public <T> T[] toArray(T[] a) {
116 return list.toArray(a);
117 }
118
119 @Override
120 public synchronized boolean add(E e) {
121 ArrayList<E> newList = new ArrayList<E>(list);
122 boolean changed = newList.add(e);
123 if (changed) {
124 Collections.sort(newList, comparator);
125 }
126 list = Collections.unmodifiableList(newList);
127 return changed;
128 }
129
130 @Override
131 public synchronized boolean remove(Object o) {
132 ArrayList<E> newList = new ArrayList<E>(list);
133
134 boolean changed = newList.remove(o);
135 list = Collections.unmodifiableList(newList);
136 return changed;
137 }
138
139 @Override
140 public boolean containsAll(Collection<?> c) {
141 return list.containsAll(c);
142 }
143
144 @Override
145 public synchronized boolean addAll(Collection<? extends E> c) {
146 ArrayList<E> newList = new ArrayList<E>(list);
147 boolean changed = newList.addAll(c);
148 if (changed) {
149 Collections.sort(newList, comparator);
150 }
151 list = Collections.unmodifiableList(newList);
152 return changed;
153 }
154
155 @Override
156 public synchronized boolean addAll(int index, Collection<? extends E> c) {
157 ArrayList<E> newList = new ArrayList<E>(list);
158 boolean changed = newList.addAll(index, c);
159 if (changed) {
160 Collections.sort(newList, comparator);
161 }
162 list = Collections.unmodifiableList(newList);
163 return changed;
164 }
165
166 @Override
167 public synchronized boolean removeAll(Collection<?> c) {
168 ArrayList<E> newList = new ArrayList<E>(list);
169
170 boolean changed = newList.removeAll(c);
171 list = Collections.unmodifiableList(newList);
172 return changed;
173 }
174
175 @Override
176 public synchronized boolean retainAll(Collection<?> c) {
177 ArrayList<E> newList = new ArrayList<E>(list);
178
179 boolean changed = newList.retainAll(c);
180 list = Collections.unmodifiableList(newList);
181 return changed;
182 }
183
184 @Override
185 public synchronized void clear() {
186 list = Collections.emptyList();
187 }
188
189 @Override
190 public synchronized E get(int index) {
191 return list.get(index);
192 }
193
194 @Override
195 public synchronized E set(int index, E element) {
196 ArrayList<E> newList = new ArrayList<E>(list);
197 E result = newList.set(index, element);
198 Collections.sort(list, comparator);
199 list = Collections.unmodifiableList(newList);
200 return result;
201 }
202
203 @Override
204 public synchronized void add(int index, E element) {
205 ArrayList<E> newList = new ArrayList<E>(list);
206 newList.add(index, element);
207 Collections.sort(list, comparator);
208 list = Collections.unmodifiableList(newList);
209 }
210
211 @Override
212 public synchronized E remove(int index) {
213 ArrayList<E> newList = new ArrayList<E>(list);
214
215 E result = newList.remove(index);
216 list = Collections.unmodifiableList(newList);
217 return result;
218 }
219
220 @Override
221 public int indexOf(Object o) {
222 return list.indexOf(o);
223 }
224
225 @Override
226 public int lastIndexOf(Object o) {
227 return list.lastIndexOf(o);
228 }
229
230 @Override
231 public ListIterator<E> listIterator() {
232 return list.listIterator();
233 }
234
235 @Override
236 public ListIterator<E> listIterator(int index) {
237 return list.listIterator(index);
238 }
239
240 @Override
241 public List<E> subList(int fromIndex, int toIndex) {
242 return list.subList(fromIndex, toIndex);
243 }
244 }