ListPropertyDecorator.java
001 /*
002  * SPDX-License-Identifier: Apache-2.0
003  *
004  * Copyright 2008-2017 the original author or authors.
005  *
006  * Licensed under the Apache License, Version 2.0 (the "License");
007  * you may not use this file except in compliance with the License.
008  * You may obtain a copy of the License at
009  *
010  *     http://www.apache.org/licenses/LICENSE-2.0
011  *
012  * Unless required by applicable law or agreed to in writing, software
013  * distributed under the License is distributed on an "AS IS" BASIS,
014  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
015  * See the License for the specific language governing permissions and
016  * limitations under the License.
017  */
018 package griffon.javafx.beans.binding;
019 
020 import javafx.beans.InvalidationListener;
021 import javafx.beans.binding.BooleanBinding;
022 import javafx.beans.binding.ObjectBinding;
023 import javafx.beans.binding.StringBinding;
024 import javafx.beans.property.ListProperty;
025 import javafx.beans.property.Property;
026 import javafx.beans.property.ReadOnlyBooleanProperty;
027 import javafx.beans.property.ReadOnlyIntegerProperty;
028 import javafx.beans.value.ChangeListener;
029 import javafx.beans.value.ObservableIntegerValue;
030 import javafx.beans.value.ObservableValue;
031 import javafx.collections.ListChangeListener;
032 import javafx.collections.ObservableList;
033 
034 import javax.annotation.Nonnull;
035 import java.util.Collection;
036 import java.util.Iterator;
037 import java.util.List;
038 import java.util.ListIterator;
039 
040 import static java.util.Objects.requireNonNull;
041 
042 /**
043  @author Andres Almiray
044  @since 2.11.0
045  */
046 public class ListPropertyDecorator<E> extends ListProperty<E> {
047     private final ListProperty<E> delegate;
048 
049     public ListPropertyDecorator(@Nonnull ListProperty<E> delegate) {
050         this.delegate = requireNonNull(delegate, "Argument 'delegate' must not be null");
051     }
052 
053     @Nonnull
054     protected final ListProperty<E> getDelegate() {
055         return delegate;
056     }
057 
058     @Override
059     public void setValue(ObservableList<E> v) {
060         delegate.setValue(v);
061     }
062 
063     @Override
064     public void bindBidirectional(Property<ObservableList<E>> other) {
065         delegate.bindBidirectional(other);
066     }
067 
068     @Override
069     public void unbindBidirectional(Property<ObservableList<E>> other) {
070         delegate.unbindBidirectional(other);
071     }
072 
073     @Override
074     public boolean equals(Object o) {
075         return this == o || delegate.equals(o);
076     }
077 
078     @Override
079     public int hashCode() {
080         return delegate.hashCode();
081     }
082 
083     @Override
084     public String toString() {
085         return getClass().getName() ":" + delegate.toString();
086     }
087 
088     @Override
089     public void bindContentBidirectional(ObservableList<E> list) {
090         delegate.bindContentBidirectional(list);
091     }
092 
093     @Override
094     public void unbindContentBidirectional(Object object) {
095         delegate.unbindContentBidirectional(object);
096     }
097 
098     @Override
099     public void bindContent(ObservableList<E> list) {
100         delegate.bindContent(list);
101     }
102 
103     @Override
104     public void unbindContent(Object object) {
105         delegate.unbindContent(object);
106     }
107 
108     @Override
109     public ObservableList<E> getValue() {
110         return delegate.getValue();
111     }
112 
113     @Override
114     public int getSize() {
115         return delegate.getSize();
116     }
117 
118     @Override
119     public ReadOnlyIntegerProperty sizeProperty() {
120         return delegate.sizeProperty();
121     }
122 
123     @Override
124     public ReadOnlyBooleanProperty emptyProperty() {
125         return delegate.emptyProperty();
126     }
127 
128     @Override
129     public ObjectBinding<E> valueAt(int index) {
130         return delegate.valueAt(index);
131     }
132 
133     @Override
134     public ObjectBinding<E> valueAt(ObservableIntegerValue index) {
135         return delegate.valueAt(index);
136     }
137 
138     @Override
139     public BooleanBinding isEqualTo(ObservableList<?> other) {
140         return delegate.isEqualTo(other);
141     }
142 
143     @Override
144     public BooleanBinding isNotEqualTo(ObservableList<?> other) {
145         return delegate.isNotEqualTo(other);
146     }
147 
148     @Override
149     public BooleanBinding isNull() {
150         return delegate.isNull();
151     }
152 
153     @Override
154     public BooleanBinding isNotNull() {
155         return delegate.isNotNull();
156     }
157 
158     @Override
159     public StringBinding asString() {
160         return delegate.asString();
161     }
162 
163     @Override
164     public int size() {
165         return delegate.size();
166     }
167 
168     @Override
169     public boolean isEmpty() {
170         return delegate.isEmpty();
171     }
172 
173     @Override
174     public boolean contains(Object obj) {
175         return delegate.contains(obj);
176     }
177 
178     @Override
179     public Iterator<E> iterator() {
180         return delegate.iterator();
181     }
182 
183     @Override
184     public Object[] toArray() {
185         return delegate.toArray();
186     }
187 
188     @Override
189     public <T> T[] toArray(T[] array) {
190         return delegate.toArray(array);
191     }
192 
193     @Override
194     public boolean add(E element) {
195         return delegate.add(element);
196     }
197 
198     @Override
199     public boolean remove(Object obj) {
200         return delegate.remove(obj);
201     }
202 
203     @Override
204     public boolean containsAll(Collection<?> objects) {
205         return delegate.containsAll(objects);
206     }
207 
208     @Override
209     public boolean addAll(Collection<? extends E> elements) {
210         return delegate.addAll(elements);
211     }
212 
213     @Override
214     public boolean addAll(int i, Collection<? extends E> elements) {
215         return delegate.addAll(i, elements);
216     }
217 
218     @Override
219     public boolean removeAll(Collection<?> objects) {
220         return delegate.removeAll(objects);
221     }
222 
223     @Override
224     public boolean retainAll(Collection<?> objects) {
225         return delegate.retainAll(objects);
226     }
227 
228     @Override
229     public void clear() {
230         delegate.clear();
231     }
232 
233     @Override
234     public E get(int i) {
235         return delegate.get(i);
236     }
237 
238     @Override
239     public E set(int i, E element) {
240         return delegate.set(i, element);
241     }
242 
243     @Override
244     public void add(int i, E element) {
245         delegate.add(i, element);
246     }
247 
248     @Override
249     public E remove(int i) {
250         return delegate.remove(i);
251     }
252 
253     @Override
254     public int indexOf(Object obj) {
255         return delegate.indexOf(obj);
256     }
257 
258     @Override
259     public int lastIndexOf(Object obj) {
260         return delegate.lastIndexOf(obj);
261     }
262 
263     @Override
264     public ListIterator<E> listIterator() {
265         return delegate.listIterator();
266     }
267 
268     @Override
269     public ListIterator<E> listIterator(int i) {
270         return delegate.listIterator(i);
271     }
272 
273     @Override
274     public List<E> subList(int from, int to) {
275         return delegate.subList(from, to);
276     }
277 
278     @Override
279     public boolean addAll(E[] elements) {
280         return delegate.addAll(elements);
281     }
282 
283     @Override
284     public boolean setAll(E[] elements) {
285         return delegate.setAll(elements);
286     }
287 
288     @Override
289     public boolean setAll(Collection<? extends E> elements) {
290         return delegate.setAll(elements);
291     }
292 
293     @Override
294     public boolean removeAll(E[] elements) {
295         return delegate.removeAll(elements);
296     }
297 
298     @Override
299     public boolean retainAll(E[] elements) {
300         return delegate.retainAll(elements);
301     }
302 
303     @Override
304     public void remove(int from, int to) {
305         delegate.remove(from, to);
306     }
307 
308     @Override
309     public ObservableList<E> get() {
310         return delegate.get();
311     }
312 
313     @Override
314     public void addListener(ChangeListener<? super ObservableList<E>> listener) {
315         delegate.addListener(listener);
316     }
317 
318     @Override
319     public void removeListener(ChangeListener<? super ObservableList<E>> listener) {
320         delegate.removeListener(listener);
321     }
322 
323     @Override
324     public void addListener(InvalidationListener listener) {
325         delegate.addListener(listener);
326     }
327 
328     @Override
329     public void removeListener(InvalidationListener listener) {
330         delegate.removeListener(listener);
331     }
332 
333     @Override
334     public void addListener(ListChangeListener<? super E> listener) {
335         delegate.addListener(listener);
336     }
337 
338     @Override
339     public void removeListener(ListChangeListener<? super E> listener) {
340         delegate.removeListener(listener);
341     }
342 
343     @Override
344     public Object getBean() {
345         return delegate.getBean();
346     }
347 
348     @Override
349     public String getName() {
350         return delegate.getName();
351     }
352 
353     @Override
354     public void bind(ObservableValue<? extends ObservableList<E>> observable) {
355         delegate.bind(observable);
356     }
357 
358     @Override
359     public void unbind() {
360         delegate.unbind();
361     }
362 
363     @Override
364     public boolean isBound() {
365         return delegate.isBound();
366     }
367 
368     @Override
369     public void set(ObservableList<E> value) {
370         delegate.set(value);
371     }
372 }