DelegatingObservableMap.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.collections;
019 
020 import javafx.collections.MapChangeListener;
021 import javafx.collections.ObservableMap;
022 import javafx.collections.WeakMapChangeListener;
023 
024 import javax.annotation.Nonnull;
025 import java.util.Collection;
026 import java.util.Map;
027 import java.util.Set;
028 
029 import static java.util.Objects.requireNonNull;
030 
031 /**
032  @author Andres Almiray
033  @since 2.9.0
034  */
035 public abstract class DelegatingObservableMap<K, V> extends ObservableMapBase<K, V> implements ObservableMap<K, V> {
036     private final ObservableMap<K, V> delegate;
037     private MapChangeListener<K, V> sourceListener;
038 
039     public DelegatingObservableMap(@Nonnull ObservableMap<K, V> delegate) {
040         this.delegate = requireNonNull(delegate, "Argument 'delegate' must not be null");
041         this.delegate.addListener(new WeakMapChangeListener<>(getListener()));
042     }
043 
044     @Nonnull
045     protected ObservableMap<K, V> getDelegate() {
046         return delegate;
047     }
048 
049     private MapChangeListener<K, V> getListener() {
050         if (sourceListener == null) {
051             sourceListener = DelegatingObservableMap.this::sourceChanged;
052         }
053         return sourceListener;
054     }
055 
056     protected abstract void sourceChanged(@Nonnull MapChangeListener.Change<? extends K, ? extends V> c);
057 
058     // --== Delegate methods ==--
059 
060     @Override
061     public int size() {
062         return getDelegate().size();
063     }
064 
065     @Override
066     public boolean isEmpty() {
067         return getDelegate().isEmpty();
068     }
069 
070     @Override
071     public boolean containsValue(Object value) {
072         return getDelegate().containsValue(value);
073     }
074 
075     @Override
076     public boolean containsKey(Object key) {
077         return getDelegate().containsKey(key);
078     }
079 
080     @Override
081     public V get(Object key) {
082         return getDelegate().get(key);
083     }
084 
085     @Override
086     public V put(K key, V value) {
087         return getDelegate().put(key, value);
088     }
089 
090     @Override
091     public V remove(Object key) {
092         return getDelegate().remove(key);
093     }
094 
095     @Override
096     public void putAll(Map<? extends K, ? extends V> m) {
097         getDelegate().putAll(m);
098     }
099 
100     @Override
101     public void clear() {
102         getDelegate().clear();
103     }
104 
105     @Override
106     public Set<K> keySet() {
107         return getDelegate().keySet();
108     }
109 
110     @Override
111     public Collection<V> values() {
112         return getDelegate().values();
113     }
114 
115     @Override
116     public Set<Entry<K, V>> entrySet() {
117         return getDelegate().entrySet();
118     }
119 
120     @Override
121     public boolean equals(Object o) {
122         return getDelegate().equals(o);
123     }
124 
125     @Override
126     public int hashCode() {
127         return getDelegate().hashCode();
128     }
129 
130     @Override
131     public String toString() {
132         return getDelegate().toString();
133     }
134 }