    001/*
    002 * Licensed to the Apache Software Foundation (ASF) under one or more
    003 * contributor license agreements.  See the NOTICE file distributed with
    004 * this work for additional information regarding copyright ownership.
    005 * The ASF licenses this file to You under the Apache License, Version 2.0
    006 * (the "License"); you may not use this file except in compliance with
    007 * the License.  You may obtain a copy of the License at
    008 *
    009 *      http://www.apache.org/licenses/LICENSE-2.0
    010 *
    011 * Unless required by applicable law or agreed to in writing, software
    012 * distributed under the License is distributed on an "AS IS" BASIS,
    013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    014 * See the License for the specific language governing permissions and
    015 * limitations under the License.
    016 */
    017package org.apache.commons.collections4;
    018
    019import java.util.Collection;
    020import java.util.Map;
    021import java.util.Objects;
    022import java.util.Set;
    023
    024import org.apache.commons.collections4.collection.UnmodifiableCollection;
    025import org.apache.commons.collections4.iterators.UnmodifiableMapIterator;
    026import org.apache.commons.collections4.map.EntrySetToMapIteratorAdapter;
    027import org.apache.commons.collections4.map.UnmodifiableEntrySet;
    028import org.apache.commons.collections4.set.UnmodifiableSet;
    029
    030/**
    031 * Utilities for working with "split maps:" objects that implement {@link Put}
    032 * and/or {@link Get} but not {@link Map}.
    033 *
    034 * @since 4.0
    035 *
    036 * @see Get
    037 * @see Put
    038 */
    039public class SplitMapUtils {
    040
    041    private static final class WrappedGet<K, V> implements IterableMap<K, V>, Unmodifiable {
    042        private final Get<K, V> get;
    043
    044        private WrappedGet(final Get<K, V> get) {
    045            this.get = get;
    046        }
    047
    048        @Override
    049        public void clear() {
    050            throw new UnsupportedOperationException();
    051        }
    052
    053        @Override
    054        public boolean containsKey(final Object key) {
    055            return get.containsKey(key);
    056        }
    057
    058        @Override
    059        public boolean containsValue(final Object value) {
    060            return get.containsValue(value);
    061        }
    062
    063        @Override
    064        public Set<Map.Entry<K, V>> entrySet() {
    065            return UnmodifiableEntrySet.unmodifiableEntrySet(get.entrySet());
    066        }
    067
    068        @Override
    069        public boolean equals(final Object arg0) {
    070            if (arg0 == this) {
    071                return true;
    072            }
    073            return arg0 instanceof WrappedGet && ((WrappedGet<?, ?>) arg0).get.equals(this.get);
    074        }
    075
    076        @Override
    077        public V get(final Object key) {
    078            return get.get(key);
    079        }
    080
    081        @Override
    082        public int hashCode() {
    083            return "WrappedGet".hashCode() << 4 | get.hashCode();
    084        }
    085
    086        @Override
    087        public boolean isEmpty() {
    088            return get.isEmpty();
    089        }
    090
    091        @Override
    092        public Set<K> keySet() {
    093            return UnmodifiableSet.unmodifiableSet(get.keySet());
    094        }
    095
    096        @Override
    097        public MapIterator<K, V> mapIterator() {
    098            final MapIterator<K, V> it;
    099            if (get instanceof IterableGet) {
    100                it = ((IterableGet<K, V>) get).mapIterator();
    101            } else {
    102                it = new EntrySetToMapIteratorAdapter<>(get.entrySet());
    103            }
    104            return UnmodifiableMapIterator.unmodifiableMapIterator(it);
    105        }
    106
    107        @Override
    108        public V put(final K key, final V value) {
    109            throw new UnsupportedOperationException();
    110        }
    111
    112        @Override
    113        public void putAll(final Map<? extends K, ? extends V> t) {
    114            throw new UnsupportedOperationException();
    115        }
    116
    117        @Override
    118        public V remove(final Object key) {
    119            return get.remove(key);
    120        }
    121
    122        @Override
    123        public int size() {
    124            return get.size();
    125        }
    126
    127        @Override
    128        public Collection<V> values() {
    129            return UnmodifiableCollection.unmodifiableCollection(get.values());
    130        }
    131    }
    132
    133    private static final class WrappedPut<K, V> implements Map<K, V>, Put<K, V> {
    134        private final Put<K, V> put;
    135
    136        private WrappedPut(final Put<K, V> put) {
    137            this.put = put;
    138        }
    139
    140        @Override
    141        public void clear() {
    142            put.clear();
    143        }
    144
    145        @Override
    146        public boolean containsKey(final Object key) {
    147            throw new UnsupportedOperationException();
    148        }
    149
    150        @Override
    151        public boolean containsValue(final Object value) {
    152            throw new UnsupportedOperationException();
    153        }
    154
    155        @Override
    156        public Set<Map.Entry<K, V>> entrySet() {
    157            throw new UnsupportedOperationException();
    158        }
    159
    160        @Override
    161        public boolean equals(final Object obj) {
    162            if (obj == this) {
    163                return true;
    164            }
    165            return obj instanceof WrappedPut && ((WrappedPut<?, ?>) obj).put.equals(this.put);
    166        }
    167
    168        @Override
    169        public V get(final Object key) {
    170            throw new UnsupportedOperationException();
    171        }
    172
    173        @Override
    174        public int hashCode() {
    175            return "WrappedPut".hashCode() << 4 | put.hashCode();
    176        }
    177
    178        @Override
    179        public boolean isEmpty() {
    180            throw new UnsupportedOperationException();
    181        }
    182
    183        @Override
    184        public Set<K> keySet() {
    185            throw new UnsupportedOperationException();
    186        }
    187
    188        @Override
    189        @SuppressWarnings("unchecked")
    190        public V put(final K key, final V value) {
    191            return (V) put.put(key, value);
    192        }
    193
    194        @Override
    195        public void putAll(final Map<? extends K, ? extends V> t) {
    196            put.putAll(t);
    197        }
    198
    199        @Override
    200        public V remove(final Object key) {
    201            throw new UnsupportedOperationException();
    202        }
    203
    204        @Override
    205        public int size() {
    206            throw new UnsupportedOperationException();
    207        }
    208
    209        @Override
    210        public Collection<V> values() {
    211            throw new UnsupportedOperationException();
    212        }
    213    }
    214
    215    /**
    216     * Gets the specified {@link Get} as an instance of {@link IterableMap}.
    217     * If {@code get} implements {@link IterableMap} directly, no conversion will take place.
    218     * If {@code get} implements {@link Map} but not {@link IterableMap} it will be decorated.
    219     * Otherwise, an {@link Unmodifiable} {@link IterableMap} will be returned.
    220     * @param <K> the key type
    221     * @param <V> the value type
    222     * @param get to wrap, must not be null
    223     * @return {@link IterableMap}
    224     * @throws NullPointerException if the argument is null
    225     */
    226    @SuppressWarnings("unchecked")
    227    public static <K, V> IterableMap<K, V> readableMap(final Get<K, V> get) {
    228        Objects.requireNonNull(get, "get");
    229        if (get instanceof Map) {
    230            return get instanceof IterableMap ?
    231                    (IterableMap<K, V>) get :
    232                    MapUtils.iterableMap((Map<K, V>) get);
    233        }
    234        return new WrappedGet<>(get);
    235    }
    236
    237    /**
    238     * Gets the specified {@link Put} as an instanceof {@link Map}.
    239     * If {@code put} implements {@link Map} directly, no conversion will take place.
    240     * Otherwise, a <em>write-only</em> {@link Map} will be returned.  On such a {@link Map}
    241     * it is recommended that the result of #put(K, V) be discarded as it likely will not
    242     * match {@code V} at runtime.
    243     *
    244     * @param <K> the key type
    245     * @param <V> the element type
    246     * @param put to wrap, must not be null
    247     * @return {@link Map}
    248     * @throws NullPointerException if the argument is null
    249     */
    250    @SuppressWarnings("unchecked")
    251    public static <K, V> Map<K, V> writableMap(final Put<K, V> put) {
    252        Objects.requireNonNull(put, "put");
    253        if (put instanceof Map) {
    254            return (Map<K, V>) put;
    255        }
    256        return new WrappedPut<>(put);
    257    }
    258
    259    /**
    260     * Don't allow instances.
    261     */
    262    private SplitMapUtils() {}
    263
    264}