1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 package org.apache.hadoop.hbase.util;
21
22 import java.util.Collection;
23 import java.util.Comparator;
24 import java.util.Iterator;
25 import java.util.SortedSet;
26 import java.util.TreeSet;
27
28 import org.apache.hadoop.classification.InterfaceAudience;
29 import org.apache.hadoop.classification.InterfaceStability;
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48 @InterfaceAudience.Public
49 @InterfaceStability.Stable
50 public class SortedCopyOnWriteSet<E> implements SortedSet<E> {
51 private volatile SortedSet<E> internalSet;
52
53 public SortedCopyOnWriteSet() {
54 this.internalSet = new TreeSet<E>();
55 }
56
57 public SortedCopyOnWriteSet(Collection<? extends E> c) {
58 this.internalSet = new TreeSet<E>(c);
59 }
60
61 public SortedCopyOnWriteSet(Comparator<? super E> comparator) {
62 this.internalSet = new TreeSet<E>(comparator);
63 }
64
65 @Override
66 public int size() {
67 return internalSet.size();
68 }
69
70 @Override
71 public boolean isEmpty() {
72 return internalSet.isEmpty();
73 }
74
75 @Override
76 public boolean contains(Object o) {
77 return internalSet.contains(o);
78 }
79
80 @Override
81 public Iterator<E> iterator() {
82 return internalSet.iterator();
83 }
84
85 @Override
86 public Object[] toArray() {
87 return internalSet.toArray();
88 }
89
90 @Override
91 public <T> T[] toArray(T[] a) {
92 return internalSet.toArray(a);
93 }
94
95 @Override
96 public synchronized boolean add(E e) {
97 SortedSet<E> newSet = new TreeSet<E>(internalSet);
98 boolean added = newSet.add(e);
99 internalSet = newSet;
100 return added;
101 }
102
103 @Override
104 public synchronized boolean remove(Object o) {
105 SortedSet<E> newSet = new TreeSet<E>(internalSet);
106 boolean removed = newSet.remove(o);
107 internalSet = newSet;
108 return removed;
109 }
110
111 @Override
112 public boolean containsAll(Collection<?> c) {
113 return internalSet.containsAll(c);
114 }
115
116 @Override
117 public synchronized boolean addAll(Collection<? extends E> c) {
118 SortedSet<E> newSet = new TreeSet<E>(internalSet);
119 boolean changed = newSet.addAll(c);
120 internalSet = newSet;
121 return changed;
122 }
123
124 @Override
125 public synchronized boolean retainAll(Collection<?> c) {
126 SortedSet<E> newSet = new TreeSet<E>(internalSet);
127 boolean changed = newSet.retainAll(c);
128 internalSet = newSet;
129 return changed;
130 }
131
132 @Override
133 public synchronized boolean removeAll(Collection<?> c) {
134 SortedSet<E> newSet = new TreeSet<E>(internalSet);
135 boolean changed = newSet.removeAll(c);
136 internalSet = newSet;
137 return changed;
138 }
139
140 @Override
141 public synchronized void clear() {
142 Comparator<? super E> comparator = internalSet.comparator();
143 if (comparator != null) {
144 internalSet = new TreeSet<E>(comparator);
145 } else {
146 internalSet = new TreeSet<E>();
147 }
148 }
149
150 @Override
151 public Comparator<? super E> comparator() {
152 return internalSet.comparator();
153 }
154
155 @Override
156 public SortedSet<E> subSet(E fromElement, E toElement) {
157 return internalSet.subSet(fromElement, toElement);
158 }
159
160 @Override
161 public SortedSet<E> headSet(E toElement) {
162 return internalSet.headSet(toElement);
163 }
164
165 @Override
166 public SortedSet<E> tailSet(E fromElement) {
167 return internalSet.tailSet(fromElement);
168 }
169
170 @Override
171 public E first() {
172 return internalSet.first();
173 }
174
175 @Override
176 public E last() {
177 return internalSet.last();
178 }
179 }