001 /*
002 * Copyright 2008-2017 the original author or authors.
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 * http://www.apache.org/licenses/LICENSE-2.0
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016 package griffon.javafx.beans.binding;
017
018 import javafx.beans.InvalidationListener;
019 import javafx.beans.binding.BooleanBinding;
020 import javafx.beans.binding.ObjectBinding;
021 import javafx.beans.binding.StringBinding;
022 import javafx.beans.property.MapProperty;
023 import javafx.beans.property.Property;
024 import javafx.beans.property.ReadOnlyBooleanProperty;
025 import javafx.beans.property.ReadOnlyIntegerProperty;
026 import javafx.beans.value.ChangeListener;
027 import javafx.beans.value.ObservableValue;
028 import javafx.collections.MapChangeListener;
029 import javafx.collections.ObservableMap;
030
031 import javax.annotation.Nonnull;
032 import java.util.Collection;
033 import java.util.Map;
034 import java.util.Set;
035
036 import static java.util.Objects.requireNonNull;
037
038 /**
039 * @author Andres Almiray
040 * @since 2.11.0
041 */
042 public class MapPropertyDecorator<K, V> extends MapProperty<K, V> {
043 private final MapProperty<K, V> delegate;
044
045 public MapPropertyDecorator(@Nonnull MapProperty<K, V> delegate) {
046 this.delegate = requireNonNull(delegate, "Argument 'delegate' must not be null");
047 }
048
049 @Nonnull
050 protected final MapProperty<K, V> getDelegate() {
051 return delegate;
052 }
053
054 @Override
055 public void setValue(ObservableMap<K, V> v) {
056 delegate.setValue(v);
057 }
058
059 @Override
060 public void bindBidirectional(Property<ObservableMap<K, V>> other) {
061 delegate.bindBidirectional(other);
062 }
063
064 @Override
065 public void unbindBidirectional(Property<ObservableMap<K, V>> other) {
066 delegate.unbindBidirectional(other);
067 }
068
069 @Override
070 public boolean equals(Object o) {
071 return this == o || delegate.equals(o);
072 }
073
074 @Override
075 public int hashCode() {
076 return delegate.hashCode();
077 }
078
079 @Override
080 public String toString() {
081 return getClass().getName() + ":" + delegate.toString();
082 }
083
084 @Override
085 public void bindContentBidirectional(ObservableMap<K, V> map) {
086 delegate.bindContentBidirectional(map);
087 }
088
089 @Override
090 public void unbindContentBidirectional(Object object) {
091 delegate.unbindContentBidirectional(object);
092 }
093
094 @Override
095 public void bindContent(ObservableMap<K, V> map) {
096 delegate.bindContent(map);
097 }
098
099 @Override
100 public void unbindContent(Object object) {
101 delegate.unbindContent(object);
102 }
103
104 @Override
105 public ObservableMap<K, V> getValue() {
106 return delegate.getValue();
107 }
108
109 @Override
110 public int getSize() {
111 return delegate.getSize();
112 }
113
114 @Override
115 public ReadOnlyIntegerProperty sizeProperty() {
116 return delegate.sizeProperty();
117 }
118
119 @Override
120 public ReadOnlyBooleanProperty emptyProperty() {
121 return delegate.emptyProperty();
122 }
123
124 @Override
125 public ObjectBinding<V> valueAt(K key) {
126 return delegate.valueAt(key);
127 }
128
129 @Override
130 public ObjectBinding<V> valueAt(ObservableValue<K> key) {
131 return delegate.valueAt(key);
132 }
133
134 @Override
135 public BooleanBinding isEqualTo(ObservableMap<?, ?> other) {
136 return delegate.isEqualTo(other);
137 }
138
139 @Override
140 public BooleanBinding isNotEqualTo(ObservableMap<?, ?> other) {
141 return delegate.isNotEqualTo(other);
142 }
143
144 @Override
145 public BooleanBinding isNull() {
146 return delegate.isNull();
147 }
148
149 @Override
150 public BooleanBinding isNotNull() {
151 return delegate.isNotNull();
152 }
153
154 @Override
155 public StringBinding asString() {
156 return delegate.asString();
157 }
158
159 @Override
160 public int size() {
161 return delegate.size();
162 }
163
164 @Override
165 public boolean isEmpty() {
166 return delegate.isEmpty();
167 }
168
169 @Override
170 public boolean containsKey(Object obj) {
171 return delegate.containsKey(obj);
172 }
173
174 @Override
175 public boolean containsValue(Object obj) {
176 return delegate.containsValue(obj);
177 }
178
179 @Override
180 public V put(K key, V value) {
181 return delegate.put(key, value);
182 }
183
184 @Override
185 public V remove(Object obj) {
186 return delegate.remove(obj);
187 }
188
189 @Override
190 public void putAll(Map<? extends K, ? extends V> elements) {
191 delegate.putAll(elements);
192 }
193
194 @Override
195 public void clear() {
196 delegate.clear();
197 }
198
199 @Override
200 public Set<K> keySet() {
201 return delegate.keySet();
202 }
203
204 @Override
205 public Collection<V> values() {
206 return delegate.values();
207 }
208
209 @Override
210 public Set<Entry<K, V>> entrySet() {
211 return delegate.entrySet();
212 }
213
214 @Override
215 public V get(Object key) {
216 return delegate.get(key);
217 }
218
219 @Override
220 public ObservableMap<K, V> get() {
221 return delegate.get();
222 }
223
224 @Override
225 public void addListener(ChangeListener<? super ObservableMap<K, V>> listener) {
226 delegate.addListener(listener);
227 }
228
229 @Override
230 public void removeListener(ChangeListener<? super ObservableMap<K, V>> listener) {
231 delegate.removeListener(listener);
232 }
233
234 @Override
235 public void addListener(InvalidationListener listener) {
236 delegate.addListener(listener);
237 }
238
239 @Override
240 public void removeListener(InvalidationListener listener) {
241 delegate.removeListener(listener);
242 }
243
244 @Override
245 public void addListener(MapChangeListener<? super K, ? super V> listener) {
246 delegate.addListener(listener);
247 }
248
249 @Override
250 public void removeListener(MapChangeListener<? super K, ? super V> listener) {
251 delegate.removeListener(listener);
252 }
253
254 @Override
255 public Object getBean() {
256 return delegate.getBean();
257 }
258
259 @Override
260 public String getName() {
261 return delegate.getName();
262 }
263
264 @Override
265 public void bind(ObservableValue<? extends ObservableMap<K, V>> observable) {
266 delegate.bind(observable);
267 }
268
269 @Override
270 public void unbind() {
271 delegate.unbind();
272 }
273
274 @Override
275 public boolean isBound() {
276 return delegate.isBound();
277 }
278
279 @Override
280 public void set(ObservableMap<K, V> value) {
281 delegate.set(value);
282 }
283 }
|