• Home
• com.goldmansachs
• gs-collections
• 5.0.0
• source code
• AbstractMutableBiMap.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.gs.collections.impl.bimap.mutable.AbstractMutableBiMap Maven / Gradle / Ivy

/*
 * Copyright 2014 Goldman Sachs.
 *
 * Licensed 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 com.gs.collections.impl.bimap.mutable;

import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.lang.reflect.Array;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

import com.gs.collections.api.LazyIterable;
import com.gs.collections.api.RichIterable;
import com.gs.collections.api.bag.MutableBag;
import com.gs.collections.api.bimap.ImmutableBiMap;
import com.gs.collections.api.bimap.MutableBiMap;
import com.gs.collections.api.block.function.Function;
import com.gs.collections.api.block.function.Function0;
import com.gs.collections.api.block.function.Function2;
import com.gs.collections.api.block.function.primitive.BooleanFunction;
import com.gs.collections.api.block.function.primitive.ByteFunction;
import com.gs.collections.api.block.function.primitive.CharFunction;
import com.gs.collections.api.block.function.primitive.DoubleFunction;
import com.gs.collections.api.block.function.primitive.DoubleObjectToDoubleFunction;
import com.gs.collections.api.block.function.primitive.FloatFunction;
import com.gs.collections.api.block.function.primitive.FloatObjectToFloatFunction;
import com.gs.collections.api.block.function.primitive.IntFunction;
import com.gs.collections.api.block.function.primitive.IntObjectToIntFunction;
import com.gs.collections.api.block.function.primitive.LongFunction;
import com.gs.collections.api.block.function.primitive.LongObjectToLongFunction;
import com.gs.collections.api.block.function.primitive.ShortFunction;
import com.gs.collections.api.block.predicate.Predicate;
import com.gs.collections.api.block.predicate.Predicate2;
import com.gs.collections.api.block.procedure.Procedure;
import com.gs.collections.api.block.procedure.Procedure2;
import com.gs.collections.api.block.procedure.primitive.ObjectIntProcedure;
import com.gs.collections.api.collection.MutableCollection;
import com.gs.collections.api.collection.primitive.MutableBooleanCollection;
import com.gs.collections.api.collection.primitive.MutableByteCollection;
import com.gs.collections.api.collection.primitive.MutableCharCollection;
import com.gs.collections.api.collection.primitive.MutableDoubleCollection;
import com.gs.collections.api.collection.primitive.MutableFloatCollection;
import com.gs.collections.api.collection.primitive.MutableIntCollection;
import com.gs.collections.api.collection.primitive.MutableLongCollection;
import com.gs.collections.api.collection.primitive.MutableShortCollection;
import com.gs.collections.api.list.MutableList;
import com.gs.collections.api.map.MutableMap;
import com.gs.collections.api.map.sorted.MutableSortedMap;
import com.gs.collections.api.multimap.MutableMultimap;
import com.gs.collections.api.multimap.set.MutableSetMultimap;
import com.gs.collections.api.partition.PartitionMutableCollection;
import com.gs.collections.api.set.MutableSet;
import com.gs.collections.api.set.sorted.MutableSortedSet;
import com.gs.collections.api.tuple.Pair;
import com.gs.collections.impl.block.procedure.MapCollectProcedure;
import com.gs.collections.impl.list.fixed.ArrayAdapter;
import com.gs.collections.impl.map.mutable.UnifiedMap;
import com.gs.collections.impl.utility.Iterate;
import com.gs.collections.impl.utility.MapIterate;

abstract class AbstractMutableBiMap implements MutableBiMap
{
    private UnifiedMap delegate;
    private AbstractMutableBiMap inverse;

    private AbstractMutableBiMap(Map delegate, AbstractMutableBiMap valuesToKeys)
    {
        this.delegate = UnifiedMap.newMap(delegate);
        this.inverse = valuesToKeys;
    }

    AbstractMutableBiMap(Map map)
    {
        this.delegate = UnifiedMap.newMap();
        this.inverse = new Inverse(UnifiedMap.newMap(), this);
        this.putAll(map);
    }

    AbstractMutableBiMap(Map delegate, Map inverse)
    {
        this.checkNull(delegate, inverse);
        this.checkSame(delegate, inverse);
        this.delegate = UnifiedMap.newMap(delegate);
        this.inverse = new Inverse(inverse, this);
    }

    private void checkNull(Map delegate, Map inverse)
    {
        if (delegate == null || inverse == null)
        {
            throw new IllegalArgumentException("The delegate maps cannot be null.");
        }
    }

    private void checkSame(Map keysToValues, Map valuesToKeys)
    {
        if (keysToValues == valuesToKeys)
        {
            throw new IllegalArgumentException("The delegate maps cannot be same.");
        }
    }

    private static boolean nullSafeEquals(Object value, Object other)
    {
        if (value == null)
        {
            if (other == null)
            {
                return true;
            }
        }
        else if (other == value || value.equals(other))
        {
            return true;
        }
        return false;
    }

    public MutableSetMultimap flip()
    {
        // TODO: We could optimize this since we know the values are unique
        return MapIterate.flip(this);
    }

    @Override
    public MutableBiMap clone()
    {
        return new HashBiMap(this);
    }

    @Override
    public boolean equals(Object obj)
    {
        if (this == obj)
        {
            return true;
        }
        if (!(obj instanceof Map))
        {
            return false;
        }

        Map map = (Map) obj;

        return this.delegate.equals(map);
    }

    @Override
    public int hashCode()
    {
        return this.delegate.hashCode();
    }

    @Override
    public String toString()
    {
        return this.delegate.toString();
    }

    public V put(K key, V value)
    {
        if (this.inverse.delegate.containsKey(value))
        {
            if (AbstractMutableBiMap.nullSafeEquals(key, this.inverse.delegate.get(value)))
            {
                return value;
            }
            throw new IllegalArgumentException("Value " + value + " already exists in map!");
        }

        boolean containsKey = this.delegate.containsKey(key);
        V put = this.delegate.put(key, value);
        if (containsKey)
        {
            this.inverse.delegate.removeKey(put);
        }
        this.inverse.delegate.put(value, key);
        return put;
    }

    public V forcePut(K key, V value)
    {
        boolean containsValue = this.inverse.delegate.containsKey(value);
        if (containsValue)
        {
            if (AbstractMutableBiMap.nullSafeEquals(key, this.inverse.delegate.get(value)))
            {
                return value;
            }
        }

        boolean containsKey = this.delegate.containsKey(key);
        V put = this.delegate.put(key, value);
        if (containsKey)
        {
            this.inverse.delegate.removeKey(put);
        }
        K oldKey = this.inverse.delegate.put(value, key);
        if (containsValue)
        {
            this.delegate.removeKey(oldKey);
        }
        return put;
    }

    public V remove(Object key)
    {
        if (!this.delegate.containsKey(key))
        {
            return null;
        }
        V oldValue = this.delegate.remove(key);
        this.inverse.delegate.remove(oldValue);
        return oldValue;
    }

    public void putAll(Map map)
    {
        Set> entries = map.entrySet();
        for (Map.Entry entry : entries)
        {
            this.put(entry.getKey(), entry.getValue());
        }
    }

    public void clear()
    {
        this.delegate.clear();
        this.inverse.delegate.clear();
    }

    public Set keySet()
    {
        return new KeySet();
    }

    public Collection values()
    {
        return new ValuesCollection();
    }

    public Set> entrySet()
    {
        return new EntrySet();
    }

    public boolean containsKey(Object key)
    {
        return this.delegate.containsKey(key);
    }

    public int size()
    {
        return this.delegate.size();
    }

    public boolean isEmpty()
    {
        return this.delegate.isEmpty();
    }

    public boolean notEmpty()
    {
        return this.delegate.notEmpty();
    }

    public V getFirst()
    {
        return this.delegate.getFirst();
    }

    public V getLast()
    {
        return this.delegate.getLast();
    }

    public boolean contains(Object object)
    {
        return this.inverse.delegate.containsKey(object);
    }

    public boolean containsAllIterable(Iterable source)
    {
        return this.inverse.delegate.keysView().containsAllIterable(source);
    }

    public boolean containsAll(Collection source)
    {
        return this.inverse.delegate.keysView().containsAll(source);
    }

    public boolean containsAllArguments(Object... elements)
    {
        return this.inverse.delegate.keysView().containsAllArguments(elements);
    }

    public > R select(Predicate predicate, R target)
    {
        return this.delegate.select(predicate, target);
    }

    public 
 RichIterable selectWith(Predicate2 predicate, P parameter)
    {
        return this.delegate.selectWith(predicate, parameter);
    }

    public 
 RichIterable rejectWith(Predicate2 predicate, P parameter)
    {
        return this.delegate.rejectWith(predicate, parameter);
    }

    public  MutableCollection collect(Function function)
    {
        return this.delegate.collect(function);
    }

    public MutableBooleanCollection collectBoolean(BooleanFunction booleanFunction)
    {
        return this.delegate.collectBoolean(booleanFunction);
    }

    public  R collectBoolean(BooleanFunction booleanFunction, R target)
    {
        return this.delegate.collectBoolean(booleanFunction, target);
    }

    public MutableByteCollection collectByte(ByteFunction byteFunction)
    {
        return this.delegate.collectByte(byteFunction);
    }

    public  R collectByte(ByteFunction byteFunction, R target)
    {
        return this.delegate.collectByte(byteFunction, target);
    }

    public MutableCharCollection collectChar(CharFunction charFunction)
    {
        return this.delegate.collectChar(charFunction);
    }

    public  R collectChar(CharFunction charFunction, R target)
    {
        return this.delegate.collectChar(charFunction, target);
    }

    public > R selectWith(Predicate2 predicate, P parameter, R targetCollection)
    {
        return this.delegate.selectWith(predicate, parameter, targetCollection);
    }

    public MutableDoubleCollection collectDouble(DoubleFunction doubleFunction)
    {
        return this.delegate.collectDouble(doubleFunction);
    }

    public  R collectDouble(DoubleFunction doubleFunction, R target)
    {
        return this.delegate.collectDouble(doubleFunction, target);
    }

    public MutableFloatCollection collectFloat(FloatFunction floatFunction)
    {
        return this.delegate.collectFloat(floatFunction);
    }

    public  R collectFloat(FloatFunction floatFunction, R target)
    {
        return this.delegate.collectFloat(floatFunction, target);
    }

    public MutableIntCollection collectInt(IntFunction intFunction)
    {
        return this.delegate.collectInt(intFunction);
    }

    public  R collectInt(IntFunction intFunction, R target)
    {
        return this.delegate.collectInt(intFunction, target);
    }

    public MutableLongCollection collectLong(LongFunction longFunction)
    {
        return this.delegate.collectLong(longFunction);
    }

    public  R collectLong(LongFunction longFunction, R target)
    {
        return this.delegate.collectLong(longFunction, target);
    }

    public MutableShortCollection collectShort(ShortFunction shortFunction)
    {
        return this.delegate.collectShort(shortFunction);
    }

    public  R collectShort(ShortFunction shortFunction, R target)
    {
        return this.delegate.collectShort(shortFunction, target);
    }

    public  MutableCollection collectIf(Predicate predicate, Function function)
    {
        return this.delegate.collectIf(predicate, function);
    }

    public MutableCollection reject(Predicate predicate)
    {
        return this.delegate.reject(predicate);
    }

    public MutableCollection select(Predicate predicate)
    {
        return this.delegate.select(predicate);
    }

    public PartitionMutableCollection partition(Predicate predicate)
    {
        return this.delegate.partition(predicate);
    }

    public 
 PartitionMutableCollection partitionWith(Predicate2 predicate, P parameter)
    {
        return this.delegate.partitionWith(predicate, parameter);
    }

    public  MutableCollection selectInstancesOf(Class clazz)
    {
        return this.delegate.selectInstancesOf(clazz);
    }

    public MutableCollection> zipWithIndex()
    {
        return this.delegate.zipWithIndex();
    }

    public > R reject(Predicate predicate, R target)
    {
        return this.delegate.reject(predicate, target);
    }

    public > R rejectWith(Predicate2 predicate, P parameter, R targetCollection)
    {
        return this.delegate.rejectWith(predicate, parameter, targetCollection);
    }

    public  MutableMap aggregateBy(Function groupBy, Function0 zeroValueFactory, Function2 nonMutatingAggregator)
    {
        return this.delegate.aggregateBy(groupBy, zeroValueFactory, nonMutatingAggregator);
    }

    public > R collect(Function function, R target)
    {
        return this.delegate.collect(function, target);
    }

    public  MutableList collectWith(Function2 function, P parameter)
    {
        return this.delegate.collectWith(function, parameter);
    }

    public > R collectWith(Function2 function, P parameter, R targetCollection)
    {
        return this.delegate.collectWith(function, parameter, targetCollection);
    }

    public > R collectIf(Predicate predicate, Function function, R target)
    {
        return this.delegate.collectIf(predicate, function, target);
    }

    public  MutableCollection flatCollect(Function> function)
    {
        return this.delegate.flatCollect(function);
    }

    public > R flatCollect(Function> function, R target)
    {
        return this.delegate.flatCollect(function, target);
    }

    public V detect(Predicate predicate)
    {
        return this.delegate.detect(predicate);
    }

    public 
 V detectWith(Predicate2 predicate, P parameter)
    {
        return this.delegate.detectWith(predicate, parameter);
    }

    public V detectIfNone(Predicate predicate, Function0 function)
    {
        return this.delegate.detectIfNone(predicate, function);
    }

    public 
 V detectWithIfNone(Predicate2 predicate, P parameter, Function0 function)
    {
        return this.delegate.detectWithIfNone(predicate, parameter, function);
    }

    public int count(Predicate predicate)
    {
        return this.delegate.count(predicate);
    }

    public 
 int countWith(Predicate2 predicate, P parameter)
    {
        return this.delegate.countWith(predicate, parameter);
    }

    public boolean anySatisfy(Predicate predicate)
    {
        return this.delegate.anySatisfy(predicate);
    }

    public 
 boolean anySatisfyWith(Predicate2 predicate, P parameter)
    {
        return this.delegate.anySatisfyWith(predicate, parameter);
    }

    public boolean allSatisfy(Predicate predicate)
    {
        return this.delegate.allSatisfy(predicate);
    }

    public 
 boolean allSatisfyWith(Predicate2 predicate, P parameter)
    {
        return this.delegate.allSatisfyWith(predicate, parameter);
    }

    public boolean noneSatisfy(Predicate predicate)
    {
        return this.delegate.noneSatisfy(predicate);
    }

    public 
 boolean noneSatisfyWith(Predicate2 predicate, P parameter)
    {
        return this.delegate.noneSatisfyWith(predicate, parameter);
    }

    public  IV injectInto(IV injectedValue, Function2 function)
    {
        return this.delegate.injectInto(injectedValue, function);
    }

    public int injectInto(int injectedValue, IntObjectToIntFunction function)
    {
        return this.delegate.injectInto(injectedValue, function);
    }

    public long injectInto(long injectedValue, LongObjectToLongFunction function)
    {
        return this.delegate.injectInto(injectedValue, function);
    }

    public float injectInto(float injectedValue, FloatObjectToFloatFunction function)
    {
        return this.delegate.injectInto(injectedValue, function);
    }

    public double injectInto(double injectedValue, DoubleObjectToDoubleFunction function)
    {
        return this.delegate.injectInto(injectedValue, function);
    }

    public MutableList toList()
    {
        return this.delegate.toList();
    }

    public MutableList toSortedList()
    {
        return this.delegate.toSortedList();
    }

    public MutableList toSortedList(Comparator comparator)
    {
        return this.delegate.toSortedList(comparator);
    }

    public > MutableList toSortedListBy(Function function)
    {
        return this.delegate.toSortedListBy(function);
    }

    public MutableSet toSet()
    {
        return this.delegate.toSet();
    }

    public MutableSortedSet toSortedSet()
    {
        return this.delegate.toSortedSet();
    }

    public MutableSortedSet toSortedSet(Comparator comparator)
    {
        return this.delegate.toSortedSet(comparator);
    }

    public > MutableSortedSet toSortedSetBy(Function function)
    {
        return this.delegate.toSortedSetBy(function);
    }

    public MutableBag toBag()
    {
        return this.delegate.toBag();
    }

    public  MutableMap toMap(Function keyFunction, Function valueFunction)
    {
        return this.delegate.toMap(keyFunction, valueFunction);
    }

    public  MutableSortedMap toSortedMap(Function keyFunction, Function valueFunction)
    {
        return this.delegate.toSortedMap(keyFunction, valueFunction);
    }

    public  MutableSortedMap toSortedMap(Comparator comparator, Function keyFunction, Function valueFunction)
    {
        return this.delegate.toSortedMap(comparator, keyFunction, valueFunction);
    }

    public LazyIterable asLazy()
    {
        return this.delegate.asLazy();
    }

    public Object[] toArray()
    {
        return this.delegate.toArray();
    }

    public  T[] toArray(T[] a)
    {
        return this.delegate.toArray(a);
    }

    public V min(Comparator comparator)
    {
        return this.delegate.min(comparator);
    }

    public V max(Comparator comparator)
    {
        return this.delegate.max(comparator);
    }

    public V min()
    {
        return this.delegate.min();
    }

    public V max()
    {
        return this.delegate.max();
    }

    public > V minBy(Function function)
    {
        return this.delegate.minBy(function);
    }

    public > V maxBy(Function function)
    {
        return this.delegate.maxBy(function);
    }

    public long sumOfInt(IntFunction function)
    {
        return this.delegate.sumOfInt(function);
    }

    public double sumOfFloat(FloatFunction function)
    {
        return this.delegate.sumOfFloat(function);
    }

    public long sumOfLong(LongFunction function)
    {
        return this.delegate.sumOfLong(function);
    }

    public double sumOfDouble(DoubleFunction function)
    {
        return this.delegate.sumOfDouble(function);
    }

    public String makeString()
    {
        return this.delegate.makeString();
    }

    public String makeString(String separator)
    {
        return this.delegate.makeString(separator);
    }

    public String makeString(String start, String separator, String end)
    {
        return this.delegate.makeString(start, separator, end);
    }

    public void appendString(Appendable appendable)
    {
        this.delegate.appendString(appendable);
    }

    public void appendString(Appendable appendable, String separator)
    {
        this.delegate.appendString(appendable, separator);
    }

    public void appendString(Appendable appendable, String start, String separator, String end)
    {
        this.delegate.appendString(appendable, start, separator, end);
    }

    public  MutableMultimap groupBy(Function function)
    {
        return this.delegate.groupBy(function);
    }

    public > R groupBy(Function function, R target)
    {
        return this.delegate.groupBy(function, target);
    }

    public  MutableMultimap groupByEach(Function> function)
    {
        return this.delegate.groupByEach(function);
    }

    public > R groupByEach(Function> function, R target)
    {
        return this.delegate.groupByEach(function, target);
    }

    public  MutableMap groupByUniqueKey(Function function)
    {
        return this.delegate.groupByUniqueKey(function);
    }

    public  MutableCollection> zip(Iterable that)
    {
        return this.delegate.zip(that);
    }

    public >> R zip(Iterable that, R target)
    {
        return this.delegate.zip(that, target);
    }

    public >> R zipWithIndex(R target)
    {
        return this.delegate.zipWithIndex(target);
    }

    public RichIterable> chunk(int size)
    {
        return this.delegate.chunk(size);
    }

    public  MutableMap aggregateInPlaceBy(Function groupBy, Function0 zeroValueFactory, Procedure2 mutatingAggregator)
    {
        return this.delegate.aggregateInPlaceBy(groupBy, zeroValueFactory, mutatingAggregator);
    }

    public boolean containsValue(Object value)
    {
        return this.inverse.delegate.containsKey(value);
    }

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

    public HashBiMap select(final Predicate2 predicate)
    {
        final HashBiMap result = HashBiMap.newMap();
        this.delegate.forEachKeyValue(new Procedure2()
        {
            public void value(K key, V value)
            {
                if (predicate.accept(key, value))
                {
                    result.put(key, value);
                }
            }
        });
        return result;
    }

    public  HashBiMap collectValues(final Function2 function)
    {
        final HashBiMap result = HashBiMap.newMap();
        this.delegate.forEachKeyValue(new Procedure2()
        {
            public void value(K key, V value)
            {
                result.put(key, function.value(key, value));
            }
        });
        return result;
    }

    public  HashBiMap collect(final Function2> function)
    {
        final HashBiMap result = HashBiMap.newMap();
        this.delegate.forEachKeyValue(new Procedure2()
        {
            public void value(K key, V value)
            {
                Pair pair = function.value(key, value);
                result.put(pair.getOne(), pair.getTwo());
            }
        });
        return result;
    }

    public HashBiMap reject(final Predicate2 predicate)
    {
        final HashBiMap result = HashBiMap.newMap();
        this.delegate.forEachKeyValue(new Procedure2()
        {
            public void value(K key, V value)
            {
                if (!predicate.accept(key, value))
                {
                    result.put(key, value);
                }
            }
        });
        return result;
    }

    public void forEachValue(Procedure procedure)
    {
        this.inverse.delegate.forEachKey(procedure);
    }

    public void forEachKey(Procedure procedure)
    {
        this.delegate.forEachKey(procedure);
    }

    public void forEachKeyValue(Procedure2 procedure)
    {
        this.delegate.forEachKeyValue(procedure);
    }

    public MutableBiMap flipUniqueValues()
    {
        return new HashBiMap(this.inverse());
    }

    public V getIfAbsent(K key, Function0 function)
    {
        return this.delegate.getIfAbsent(key, function);
    }

    public V getIfAbsentValue(K key, V value)
    {
        return this.delegate.getIfAbsentValue(key, value);
    }

    public 
 V getIfAbsentWith(K key, Function function, P parameter)
    {
        return this.delegate.getIfAbsentWith(key, function, parameter);
    }

    public  A ifPresentApply(K key, Function function)
    {
        return this.delegate.ifPresentApply(key, function);
    }

    public RichIterable keysView()
    {
        return this.delegate.keysView();
    }

    public RichIterable valuesView()
    {
        return this.delegate.valuesView();
    }

    public RichIterable> keyValuesView()
    {
        return this.delegate.keyValuesView();
    }

    public Pair detect(Predicate2 predicate)
    {
        return this.delegate.detect(predicate);
    }

    public ImmutableBiMap toImmutable()
    {
        throw new UnsupportedOperationException(this.getClass().getSimpleName() + ".toImmutable() not implemented yet");
    }

    public MutableBiMap asSynchronized()
    {
        throw new UnsupportedOperationException(this.getClass().getSimpleName() + ".asSynchronized() not implemented yet");
    }

    public MutableBiMap asUnmodifiable()
    {
        throw new UnsupportedOperationException(this.getClass().getSimpleName() + ".asUnmodifiable() not implemented yet");
    }

    public  MutableMap collectKeysAndValues(Iterable iterable, Function keyFunction, Function valueFunction)
    {
        Iterate.forEach(iterable, new MapCollectProcedure(this, keyFunction, valueFunction));
        return this;
    }

    public V removeKey(K key)
    {
        return this.remove(key);
    }

    public V getIfAbsentPut(K key, Function0 function)
    {
        V value = this.delegate.get(key);

        if (value != null || this.delegate.containsKey(key))
        {
            return value;
        }

        V newValue = function.value();
        this.put(key, newValue);
        return newValue;
    }

    public V getIfAbsentPut(K key, V value)
    {
        V oldValue = this.delegate.get(key);

        if (oldValue != null || this.delegate.containsKey(key))
        {
            return oldValue;
        }

        this.put(key, value);
        return value;
    }

    public V getIfAbsentPutWithKey(K key, Function function)
    {
        V value = this.delegate.get(key);

        if (value != null || this.delegate.containsKey(key))
        {
            return value;
        }

        V newValue = function.valueOf(key);
        this.put(key, newValue);
        return newValue;
    }

    public 
 V getIfAbsentPutWith(K key, Function function, P parameter)
    {
        V value = this.delegate.get(key);

        if (value != null || this.delegate.containsKey(key))
        {
            return value;
        }

        V newValue = function.valueOf(parameter);
        this.put(key, newValue);
        return newValue;
    }

    public V add(Pair keyValuePair)
    {
        return this.put(keyValuePair.getOne(), keyValuePair.getTwo());
    }

    public MutableBiMap withKeyValue(K key, V value)
    {
        this.put(key, value);
        return this;
    }

    public MutableBiMap withAllKeyValues(Iterable> keyValues)
    {
        for (Pair keyVal : keyValues)
        {
            this.put(keyVal.getOne(), keyVal.getTwo());
        }
        return this;
    }

    public MutableBiMap withAllKeyValueArguments(Pair... keyValuePairs)
    {
        return this.withAllKeyValues(ArrayAdapter.adapt(keyValuePairs));
    }

    public MutableBiMap withoutKey(K key)
    {
        this.removeKey(key);
        return this;
    }

    public MutableMap withoutAllKeys(Iterable keys)
    {
        for (K key : keys)
        {
            this.removeKey(key);
        }
        return this;
    }

    public HashBiMap newEmpty()
    {
        return new HashBiMap();
    }

    public V updateValue(K key, Function0 factory, Function function)
    {
        if (this.delegate.containsKey(key))
        {
            V newValue = function.valueOf(this.delegate.get(key));
            this.put(key, newValue);
            return newValue;
        }

        V newValue = function.valueOf(factory.value());
        this.put(key, newValue);
        return newValue;
    }

    public 
 V updateValueWith(K key, Function0 factory, Function2 function, P parameter)
    {
        if (this.delegate.containsKey(key))
        {
            V newValue = function.value(this.delegate.get(key), parameter);
            this.put(key, newValue);
            return newValue;
        }

        V newValue = function.value(factory.value(), parameter);
        this.put(key, newValue);
        return newValue;
    }

    public MutableBiMap inverse()
    {
        return this.inverse;
    }

    public void forEach(Procedure procedure)
    {
        this.inverse.delegate.forEachKey(procedure);
    }

    public void forEachWithIndex(ObjectIntProcedure objectIntProcedure)
    {
        this.delegate.forEachWithIndex(objectIntProcedure);
    }

    public 
 void forEachWith(Procedure2 procedure, P parameter)
    {
        this.delegate.forEachWith(procedure, parameter);
    }

    public Iterator iterator()
    {
        return new InternalIterator();
    }

    public void writeExternal(ObjectOutput out) throws IOException
    {
        this.delegate.writeExternal(out);
    }

    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
    {
        this.delegate = UnifiedMap.newMap();
        this.delegate.readExternal(in);
        final UnifiedMap inverseDelegate = UnifiedMap.newMap();
        this.delegate.forEachKeyValue(new Procedure2()
        {
            public void value(K key, V value)
            {
                inverseDelegate.put(value, key);
            }
        });
        this.inverse = new Inverse(inverseDelegate, this);
    }

    private class InternalIterator implements Iterator
    {
        private final Iterator iterator = AbstractMutableBiMap.this.delegate.iterator();
        private V currentValue;

        public boolean hasNext()
        {
            return this.iterator.hasNext();
        }

        public V next()
        {
            V next = this.iterator.next();
            this.currentValue = next;
            return next;
        }

        public void remove()
        {
            this.iterator.remove();
            AbstractMutableBiMap.this.inverse.delegate.remove(this.currentValue);
        }
    }

    private class KeySet implements Set
    {
        @Override
        public boolean equals(Object obj)
        {
            return AbstractMutableBiMap.this.delegate.keySet().equals(obj);
        }

        @Override
        public int hashCode()
        {
            return AbstractMutableBiMap.this.delegate.keySet().hashCode();
        }

        public int size()
        {
            return AbstractMutableBiMap.this.size();
        }

        public boolean isEmpty()
        {
            return AbstractMutableBiMap.this.isEmpty();
        }

        public boolean contains(Object key)
        {
            return AbstractMutableBiMap.this.delegate.containsKey(key);
        }

        public Object[] toArray()
        {
            return AbstractMutableBiMap.this.delegate.keySet().toArray();
        }

        public  T[] toArray(T[] a)
        {
            return AbstractMutableBiMap.this.delegate.keySet().toArray(a);
        }

        public boolean add(K key)
        {
            throw new UnsupportedOperationException("Cannot call add() on " + this.getClass().getSimpleName());
        }

        public boolean remove(Object key)
        {
            int oldSize = AbstractMutableBiMap.this.size();
            AbstractMutableBiMap.this.remove(key);
            return AbstractMutableBiMap.this.size() != oldSize;
        }

        public boolean containsAll(Collection source)
        {
            for (Object key : source)
            {
                if (!AbstractMutableBiMap.this.delegate.containsKey(key))
                {
                    return false;
                }
            }
            return true;
        }

        public boolean addAll(Collection source)
        {
            throw new UnsupportedOperationException("Cannot call addAll() on " + this.getClass().getSimpleName());
        }

        public boolean retainAll(Collection collection)
        {
            int oldSize = AbstractMutableBiMap.this.size();
            Iterator iterator = this.iterator();
            while (iterator.hasNext())
            {
                K next = iterator.next();
                if (!collection.contains(next))
                {
                    this.remove(next);
                }
            }
            return oldSize != AbstractMutableBiMap.this.size();
        }

        public boolean removeAll(Collection collection)
        {
            int oldSize = AbstractMutableBiMap.this.size();
            for (Object object : collection)
            {
                AbstractMutableBiMap.this.remove(object);
            }
            return oldSize != AbstractMutableBiMap.this.size();
        }

        public void clear()
        {
            AbstractMutableBiMap.this.clear();
        }

        public Iterator iterator()
        {
            return AbstractMutableBiMap.this.inverse().iterator();
        }

        @Override
        public String toString()
        {
            return Iterate.makeString(this, "[", ", ", "]");
        }
    }

    private class ValuesCollection implements Collection
    {
        public int size()
        {
            return AbstractMutableBiMap.this.size();
        }

        public boolean isEmpty()
        {
            return AbstractMutableBiMap.this.isEmpty();
        }

        public boolean contains(Object key)
        {
            return AbstractMutableBiMap.this.inverse.delegate.containsKey(key);
        }

        public Object[] toArray()
        {
            return AbstractMutableBiMap.this.delegate.values().toArray();
        }

        public  T[] toArray(T[] a)
        {
            return AbstractMutableBiMap.this.delegate.values().toArray(a);
        }

        public boolean add(V v)
        {
            throw new UnsupportedOperationException("Cannot call add() on " + this.getClass().getSimpleName());
        }

        public boolean remove(Object value)
        {
            int oldSize = AbstractMutableBiMap.this.size();
            AbstractMutableBiMap.this.inverse().remove(value);
            return oldSize != AbstractMutableBiMap.this.size();
        }

        public boolean containsAll(Collection collection)
        {
            for (Object key : collection)
            {
                if (!AbstractMutableBiMap.this.inverse.delegate.containsKey(key))
                {
                    return false;
                }
            }
            return true;
        }

        public boolean addAll(Collection collection)
        {
            throw new UnsupportedOperationException("Cannot call addAll() on " + this.getClass().getSimpleName());
        }

        public boolean removeAll(Collection collection)
        {
            int oldSize = AbstractMutableBiMap.this.size();
            for (Object object : collection)
            {
                this.remove(object);
            }
            return oldSize != AbstractMutableBiMap.this.size();
        }

        public boolean retainAll(Collection collection)
        {
            int oldSize = AbstractMutableBiMap.this.size();
            Iterator iterator = this.iterator();
            while (iterator.hasNext())
            {
                V next = iterator.next();
                if (!collection.contains(next))
                {
                    this.remove(next);
                }
            }
            return oldSize != AbstractMutableBiMap.this.size();
        }

        public void clear()
        {
            AbstractMutableBiMap.this.clear();
        }

        public Iterator iterator()
        {
            return AbstractMutableBiMap.this.iterator();
        }

        @Override
        public String toString()
        {
            return Iterate.makeString(this, "[", ", ", "]");
        }
    }

    private class EntrySet implements Set>
    {
        @Override
        public boolean equals(Object obj)
        {
            if (obj instanceof Set)
            {
                Set other = (Set) obj;
                if (other.size() == this.size())
                {
                    return this.containsAll(other);
                }
            }
            return false;
        }

        @Override
        public int hashCode()
        {
            return AbstractMutableBiMap.this.hashCode();
        }

        public int size()
        {
            return AbstractMutableBiMap.this.size();
        }

        public boolean isEmpty()
        {
            return AbstractMutableBiMap.this.isEmpty();
        }

        public boolean contains(Object o)
        {
            if (!(o instanceof Map.Entry))
            {
                return false;
            }
            Map.Entry entry = (Map.Entry) o;
            K key = entry.getKey();
            V actualValue = AbstractMutableBiMap.this.get(key);
            if (actualValue != null)
            {
                return actualValue.equals(entry.getValue());
            }
            return entry.getValue() == null && AbstractMutableBiMap.this.containsKey(key);
        }

        public Object[] toArray()
        {
            Object[] result = new Object[AbstractMutableBiMap.this.size()];
            return this.copyEntries(result);
        }

        public  T[] toArray(T[] result)
        {
            int size = AbstractMutableBiMap.this.size();
            if (result.length < size)
            {
                result = (T[]) Array.newInstance(result.getClass().getComponentType(), size);
            }
            this.copyEntries(result);
            if (size < result.length)
            {
                result[size] = null;
            }
            return result;
        }

        public boolean add(Map.Entry entry)
        {
            throw new UnsupportedOperationException();
        }

        public boolean remove(Object e)
        {
            if (!(e instanceof Map.Entry))
            {
                return false;
            }
            Map.Entry entry = (Map.Entry) e;
            K key = (K) entry.getKey();
            V value = (V) entry.getValue();

            V actualValue = AbstractMutableBiMap.this.delegate.get(key);
            if (actualValue != null)
            {
                if (actualValue.equals(value))
                {
                    AbstractMutableBiMap.this.remove(key);
                    return true;
                }
                return false;
            }
            if (value == null && AbstractMutableBiMap.this.delegate.containsKey(key))
            {
                AbstractMutableBiMap.this.remove(key);
                return true;
            }
            return false;
        }

        public boolean containsAll(Collection collection)
        {
            for (Object obj : collection)
            {
                if (!this.contains(obj))
                {
                    return false;
                }
            }
            return true;
        }

        public boolean addAll(Collection> collection)
        {
            throw new UnsupportedOperationException("Cannot call addAll() on " + this.getClass().getSimpleName());
        }

        public boolean retainAll(Collection collection)
        {
            int oldSize = AbstractMutableBiMap.this.size();
            Iterator> iterator = this.iterator();
            while (iterator.hasNext())
            {
                Map.Entry next = iterator.next();
                if (!collection.contains(next))
                {
                    iterator.remove();
                }
            }
            return oldSize != AbstractMutableBiMap.this.size();
        }

        public boolean removeAll(Collection collection)
        {
            boolean changed = false;
            for (Object obj : collection)
            {
                if (this.remove(obj))
                {
                    changed = true;
                }
            }
            return changed;
        }

        public void clear()
        {
            AbstractMutableBiMap.this.clear();
        }

        public Iterator> iterator()
        {
            return new InternalEntrySetIterator();
        }

        private Object[] copyEntries(Object[] result)
        {
            int count = 0;
            for (Pair pair : AbstractMutableBiMap.this.keyValuesView())
            {
                result[count] = new InternalEntry(pair.getOne(), pair.getTwo());
                count++;
            }
            return result;
        }

        private class InternalEntrySetIterator implements Iterator>
        {
            private final Iterator> iterator = AbstractMutableBiMap.this.delegate.entrySet().iterator();
            private V currentValue;

            public boolean hasNext()
            {
                return this.iterator.hasNext();
            }

            public Entry next()
            {
                Entry next = this.iterator.next();
                Entry result = new InternalEntry(next.getKey(), next.getValue());
                this.currentValue = result.getValue();
                return result;
            }

            public void remove()
            {
                this.iterator.remove();
                AbstractMutableBiMap.this.inverse.delegate.removeKey(this.currentValue);
            }
        }

        private final class InternalEntry implements Entry
        {
            private final K key;
            private V value;

            private InternalEntry(K key, V value)
            {
                this.key = key;
                this.value = value;
            }

            public K getKey()
            {
                return this.key;
            }

            public V getValue()
            {
                return this.value;
            }

            @Override
            public boolean equals(Object obj)
            {
                if (obj instanceof Entry)
                {
                    Entry other = (Entry) obj;
                    Object otherKey = other.getKey();
                    Object otherValue = other.getValue();
                    return AbstractMutableBiMap.nullSafeEquals(this.key, otherKey)
                            && AbstractMutableBiMap.nullSafeEquals(this.value, otherValue);
                }
                return false;
            }

            @Override
            public int hashCode()
            {
                return (this.key == null ? 0 : this.key.hashCode())
                        ^ (this.value == null ? 0 : this.value.hashCode());
            }

            @Override
            public String toString()
            {
                return this.key + "=" + this.value;
            }

            public V setValue(V value)
            {
                V result = AbstractMutableBiMap.this.put(this.key, value);
                this.value = value;
                return result;
            }
        }
    }

    private static class Inverse extends AbstractMutableBiMap implements Externalizable
    {
        private static final long serialVersionUID = 1L;

        public Inverse()
        {
            // Empty constructor for Externalizable class
            super(UnifiedMap.newMap(), UnifiedMap.newMap());
        }

        Inverse(Map delegate, AbstractMutableBiMap inverse)
        {
            super(delegate, inverse);
        }
    }
}