Debian Codegraph @

src/main/java/io/reactivex/rxjava3/internal/disposables/ListCompositeDisposable.java

raw
1 /*
2 * Copyright (c) 2016-present, RxJava Contributors.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in
5 * compliance with the License. You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software distributed under the License is
10 * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See
11 * the License for the specific language governing permissions and limitations under the License.
12 */
13
14 package io.reactivex.rxjava3.internal.disposables;
15
16 import java.util.*;
17
18 import io.reactivex.rxjava3.disposables.*;
19 import io.reactivex.rxjava3.exceptions.*;
20 import io.reactivex.rxjava3.internal.util.ExceptionHelper;
21
22 /**
23 * A disposable container that can hold onto multiple other disposables.
24 */
25 public final class ListCompositeDisposable implements Disposable, DisposableContainer {
26
27 List<Disposable> resources;
28
29 volatile boolean disposed;
30
31 public ListCompositeDisposable() {
32 }
33
34 public ListCompositeDisposable(Disposable... resources) {
35 Objects.requireNonNull(resources, "resources is null");
36 this.resources = new LinkedList<>();
37 for (Disposable d : resources) {
38 Objects.requireNonNull(d, "Disposable item is null");
39 this.resources.add(d);
40 }
41 }
42
43 public ListCompositeDisposable(Iterable<? extends Disposable> resources) {
44 Objects.requireNonNull(resources, "resources is null");
45 this.resources = new LinkedList<>();
46 for (Disposable d : resources) {
47 Objects.requireNonNull(d, "Disposable item is null");
48 this.resources.add(d);
49 }
50 }
51
52 @Override
53 public void dispose() {
54 if (disposed) {
55 return;
56 }
57 List<Disposable> set;
58 synchronized (this) {
59 if (disposed) {
60 return;
61 }
62 disposed = true;
63 set = resources;
64 resources = null;
65 }
66
67 dispose(set);
68 }
69
70 @Override
71 public boolean isDisposed() {
72 return disposed;
73 }
74
75 @Override
76 public boolean add(Disposable d) {
77 Objects.requireNonNull(d, "d is null");
78 if (!disposed) {
79 synchronized (this) {
80 if (!disposed) {
81 List<Disposable> set = resources;
82 if (set == null) {
83 set = new LinkedList<>();
84 resources = set;
85 }
86 set.add(d);
87 return true;
88 }
89 }
90 }
91 d.dispose();
92 return false;
93 }
94
95 public boolean addAll(Disposable... ds) {
96 Objects.requireNonNull(ds, "ds is null");
97 if (!disposed) {
98 synchronized (this) {
99 if (!disposed) {
100 List<Disposable> set = resources;
101 if (set == null) {
102 set = new LinkedList<>();
103 resources = set;
104 }
105 for (Disposable d : ds) {
106 Objects.requireNonNull(d, "d is null");
107 set.add(d);
108 }
109 return true;
110 }
111 }
112 }
113 for (Disposable d : ds) {
114 d.dispose();
115 }
116 return false;
117 }
118
119 @Override
120 public boolean remove(Disposable d) {
121 if (delete(d)) {
122 d.dispose();
123 return true;
124 }
125 return false;
126 }
127
128 @Override
129 public boolean delete(Disposable d) {
130 Objects.requireNonNull(d, "Disposable item is null");
131 if (disposed) {
132 return false;
133 }
134 synchronized (this) {
135 if (disposed) {
136 return false;
137 }
138
139 List<Disposable> set = resources;
140 if (set == null || !set.remove(d)) {
141 return false;
142 }
143 }
144 return true;
145 }
146
147 public void clear() {
148 if (disposed) {
149 return;
150 }
151 List<Disposable> set;
152 synchronized (this) {
153 if (disposed) {
154 return;
155 }
156
157 set = resources;
158 resources = null;
159 }
160
161 dispose(set);
162 }
163
164 void dispose(List<Disposable> set) {
165 if (set == null) {
166 return;
167 }
168 List<Throwable> errors = null;
169 for (Disposable o : set) {
170 try {
171 o.dispose();
172 } catch (Throwable ex) {
173 Exceptions.throwIfFatal(ex);
174 if (errors == null) {
175 errors = new ArrayList<>();
176 }
177 errors.add(ex);
178 }
179 }
180 if (errors != null) {
181 if (errors.size() == 1) {
182 throw ExceptionHelper.wrapOrThrow(errors.get(0));
183 }
184 throw new CompositeException(errors);
185 }
186 }
187 }