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