com.groupbyinc.common.apache.commons.collections4.SplitMapUtils Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of common-api Show documentation
${project.name}
There is a newer version: 198
/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.commons.collections4;

import java.util.Collection;
import java.util.Map;
import java.util.Set;

import org.apache.commons.collections4.collection.UnmodifiableCollection;
import org.apache.commons.collections4.iterators.UnmodifiableMapIterator;
import org.apache.commons.collections4.map.EntrySetToMapIteratorAdapter;
import org.apache.commons.collections4.map.UnmodifiableEntrySet;
import org.apache.commons.collections4.set.UnmodifiableSet;

/**
 * Utilities for working with "split maps:" objects that implement {@link Put}
 * and/or {@link Get} but not {@link Map}.
 *
 * @since 4.0
 * @version $Id: SplitMapUtils.java 1686855 2015-06-22 13:00:27Z tn $
 *
 * @see Get
 * @see Put
 */
public class SplitMapUtils {

    /**
     * SplitMapUtils should not normally be instantiated.
     */
    private SplitMapUtils() {}

    //-----------------------------------------------------------------------

    private static class WrappedGet implements IterableMap, Unmodifiable {
        private final Get get;

        private WrappedGet(final Get get) {
            this.get = get;
        }

        public void clear() {
            throw new UnsupportedOperationException();
        }

        public boolean containsKey(final Object key) {
            return get.containsKey(key);
        }

        public boolean containsValue(final Object value) {
            return get.containsValue(value);
        }

        public Set> entrySet() {
            return UnmodifiableEntrySet.unmodifiableEntrySet(get.entrySet());
        }

        @Override
        public boolean equals(final Object arg0) {
            if (arg0 == this) {
                return true;
            }
            return arg0 instanceof WrappedGet && ((WrappedGet) arg0).get.equals(this.get);
        }

        public V get(final Object key) {
            return get.get(key);
        }

        @Override
        public int hashCode() {
            return ("WrappedGet".hashCode() << 4) | get.hashCode();
        }

        public boolean isEmpty() {
            return get.isEmpty();
        }

        public Set keySet() {
            return UnmodifiableSet.unmodifiableSet(get.keySet());
        }

        public V put(final K key, final V value) {
            throw new UnsupportedOperationException();
        }

        public void putAll(final Map t) {
            throw new UnsupportedOperationException();
        }

        public V remove(final Object key) {
            return get.remove(key);
        }

        public int size() {
            return get.size();
        }

        public Collection values() {
            return UnmodifiableCollection.unmodifiableCollection(get.values());
        }

        public MapIterator mapIterator() {
            MapIterator it;
            if (get instanceof IterableGet) {
                it = ((IterableGet) get).mapIterator();
            } else {
                it = new EntrySetToMapIteratorAdapter(get.entrySet());
            }
            return UnmodifiableMapIterator.unmodifiableMapIterator(it);
        }
    }

    private static class WrappedPut implements Map, Put {
        private final Put put;

        private WrappedPut(final Put put) {
            this.put = put;
        }

        public void clear() {
            put.clear();
        }

        public boolean containsKey(final Object key) {
            throw new UnsupportedOperationException();
        }

        public boolean containsValue(final Object value) {
            throw new UnsupportedOperationException();
        }

        public Set> entrySet() {
            throw new UnsupportedOperationException();
        }

        @Override
        public boolean equals(final Object obj) {
            if (obj == this) {
                return true;
            }
            return obj instanceof WrappedPut && ((WrappedPut) obj).put.equals(this.put);
        }

        public V get(final Object key) {
            throw new UnsupportedOperationException();
        }

        @Override
        public int hashCode() {
            return ("WrappedPut".hashCode() << 4) | put.hashCode();
        }

        public boolean isEmpty() {
            throw new UnsupportedOperationException();
        }

        public Set keySet() {
            throw new UnsupportedOperationException();
        }

        @SuppressWarnings("unchecked")
        public V put(final K key, final V value) {
            return (V) put.put(key, value);
        }

        public void putAll(final Map t) {
            put.putAll(t);
        }

        public V remove(final Object key) {
            throw new UnsupportedOperationException();
        }

        public int size() {
            throw new UnsupportedOperationException();
        }

        public Collection values() {
            throw new UnsupportedOperationException();
        }
    }

    //-----------------------------------------------------------------------

    /**
     * Get the specified {@link Get} as an instance of {@link IterableMap}.
     * If get implements {@link IterableMap} directly, no conversion will take place.
     * If get implements {@link Map} but not {@link IterableMap} it will be decorated.
     * Otherwise an {@link Unmodifiable} {@link IterableMap} will be returned.
     * @param  the key type
     * @param  the value type
     * @param get to wrap, must not be null
     * @return {@link IterableMap}
     * @throws NullPointerException if the argument is null
     */
    @SuppressWarnings("unchecked")
    public static  IterableMap readableMap(final Get get) {
        if (get == null) {
            throw new NullPointerException("Get must not be null");
        }
        if (get instanceof Map) {
            return get instanceof IterableMap ?
                    ((IterableMap) get) :
                    MapUtils.iterableMap((Map) get);
        }
        return new WrappedGet(get);
    }

    /**
     * Get the specified {@link Put} as an instanceof {@link Map}.
     * If put implements {@link Map} directly, no conversion will take place.
     * Otherwise a write-only {@link Map} will be returned.  On such a {@link Map}
     * it is recommended that the result of #put(K, V) be discarded as it likely will not
     * match V at runtime.
     *
     * @param  the key type
     * @param  the element type
     * @param put to wrap, must not be null
     * @return {@link Map}
     * @throws NullPointerException if the argument is null
     */
    @SuppressWarnings("unchecked")
    public static  Map writableMap(final Put put) {
        if (put == null) {
            throw new NullPointerException("Put must not be null");
        }
        if (put instanceof Map) {
            return (Map) put;
        }
        return new WrappedPut(put);
    }

}