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 }
|