MapPropertyDecorator.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.MapProperty;
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.ObservableValue;
030 import javafx.collections.MapChangeListener;
031 import javafx.collections.ObservableMap;
032 
033 import javax.annotation.Nonnull;
034 import java.util.Collection;
035 import java.util.Map;
036 import java.util.Set;
037 
038 import static java.util.Objects.requireNonNull;
039 
040 /**
041  @author Andres Almiray
042  @since 2.11.0
043  */
044 public class MapPropertyDecorator<K, V> extends MapProperty<K, V> {
045     private final MapProperty<K, V> delegate;
046 
047     public MapPropertyDecorator(@Nonnull MapProperty<K, V> delegate) {
048         this.delegate = requireNonNull(delegate, "Argument 'delegate' must not be null");
049     }
050 
051     @Nonnull
052     protected final MapProperty<K, V> getDelegate() {
053         return delegate;
054     }
055 
056     @Override
057     public void setValue(ObservableMap<K, V> v) {
058         delegate.setValue(v);
059     }
060 
061     @Override
062     public void bindBidirectional(Property<ObservableMap<K, V>> other) {
063         delegate.bindBidirectional(other);
064     }
065 
066     @Override
067     public void unbindBidirectional(Property<ObservableMap<K, V>> other) {
068         delegate.unbindBidirectional(other);
069     }
070 
071     @Override
072     public boolean equals(Object o) {
073         return this == o || delegate.equals(o);
074     }
075 
076     @Override
077     public int hashCode() {
078         return delegate.hashCode();
079     }
080 
081     @Override
082     public String toString() {
083         return getClass().getName() ":" + delegate.toString();
084     }
085 
086     @Override
087     public void bindContentBidirectional(ObservableMap<K, V> map) {
088         delegate.bindContentBidirectional(map);
089     }
090 
091     @Override
092     public void unbindContentBidirectional(Object object) {
093         delegate.unbindContentBidirectional(object);
094     }
095 
096     @Override
097     public void bindContent(ObservableMap<K, V> map) {
098         delegate.bindContent(map);
099     }
100 
101     @Override
102     public void unbindContent(Object object) {
103         delegate.unbindContent(object);
104     }
105 
106     @Override
107     public ObservableMap<K, V> getValue() {
108         return delegate.getValue();
109     }
110 
111     @Override
112     public int getSize() {
113         return delegate.getSize();
114     }
115 
116     @Override
117     public ReadOnlyIntegerProperty sizeProperty() {
118         return delegate.sizeProperty();
119     }
120 
121     @Override
122     public ReadOnlyBooleanProperty emptyProperty() {
123         return delegate.emptyProperty();
124     }
125 
126     @Override
127     public ObjectBinding<V> valueAt(K key) {
128         return delegate.valueAt(key);
129     }
130 
131     @Override
132     public ObjectBinding<V> valueAt(ObservableValue<K> key) {
133         return delegate.valueAt(key);
134     }
135 
136     @Override
137     public BooleanBinding isEqualTo(ObservableMap<?, ?> other) {
138         return delegate.isEqualTo(other);
139     }
140 
141     @Override
142     public BooleanBinding isNotEqualTo(ObservableMap<?, ?> other) {
143         return delegate.isNotEqualTo(other);
144     }
145 
146     @Override
147     public BooleanBinding isNull() {
148         return delegate.isNull();
149     }
150 
151     @Override
152     public BooleanBinding isNotNull() {
153         return delegate.isNotNull();
154     }
155 
156     @Override
157     public StringBinding asString() {
158         return delegate.asString();
159     }
160 
161     @Override
162     public int size() {
163         return delegate.size();
164     }
165 
166     @Override
167     public boolean isEmpty() {
168         return delegate.isEmpty();
169     }
170 
171     @Override
172     public boolean containsKey(Object obj) {
173         return delegate.containsKey(obj);
174     }
175 
176     @Override
177     public boolean containsValue(Object obj) {
178         return delegate.containsValue(obj);
179     }
180 
181     @Override
182     public V put(K key, V value) {
183         return delegate.put(key, value);
184     }
185 
186     @Override
187     public V remove(Object obj) {
188         return delegate.remove(obj);
189     }
190 
191     @Override
192     public void putAll(Map<? extends K, ? extends V> elements) {
193         delegate.putAll(elements);
194     }
195 
196     @Override
197     public void clear() {
198         delegate.clear();
199     }
200 
201     @Override
202     public Set<K> keySet() {
203         return delegate.keySet();
204     }
205 
206     @Override
207     public Collection<V> values() {
208         return delegate.values();
209     }
210 
211     @Override
212     public Set<Entry<K, V>> entrySet() {
213         return delegate.entrySet();
214     }
215 
216     @Override
217     public V get(Object key) {
218         return delegate.get(key);
219     }
220 
221     @Override
222     public ObservableMap<K, V> get() {
223         return delegate.get();
224     }
225 
226     @Override
227     public void addListener(ChangeListener<? super ObservableMap<K, V>> listener) {
228         delegate.addListener(listener);
229     }
230 
231     @Override
232     public void removeListener(ChangeListener<? super ObservableMap<K, V>> listener) {
233         delegate.removeListener(listener);
234     }
235 
236     @Override
237     public void addListener(InvalidationListener listener) {
238         delegate.addListener(listener);
239     }
240 
241     @Override
242     public void removeListener(InvalidationListener listener) {
243         delegate.removeListener(listener);
244     }
245 
246     @Override
247     public void addListener(MapChangeListener<? super K, ? super V> listener) {
248         delegate.addListener(listener);
249     }
250 
251     @Override
252     public void removeListener(MapChangeListener<? super K, ? super V> listener) {
253         delegate.removeListener(listener);
254     }
255 
256     @Override
257     public Object getBean() {
258         return delegate.getBean();
259     }
260 
261     @Override
262     public String getName() {
263         return delegate.getName();
264     }
265 
266     @Override
267     public void bind(ObservableValue<? extends ObservableMap<K, V>> observable) {
268         delegate.bind(observable);
269     }
270 
271     @Override
272     public void unbind() {
273         delegate.unbind();
274     }
275 
276     @Override
277     public boolean isBound() {
278         return delegate.isBound();
279     }
280 
281     @Override
282     public void set(ObservableMap<K, V> value) {
283         delegate.set(value);
284     }
285 }