org.eclipse.collections.impl.map.mutable.AbstractMutableMap Maven / Gradle / Ivy
/*
* Copyright (c) 2016 Goldman Sachs.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* and Eclipse Distribution License v. 1.0 which accompany this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*/
package org.eclipse.collections.impl.map.mutable;
import java.util.Collection;
import org.eclipse.collections.api.bag.MutableBag;
import org.eclipse.collections.api.bag.primitive.MutableBooleanBag;
import org.eclipse.collections.api.bag.primitive.MutableByteBag;
import org.eclipse.collections.api.bag.primitive.MutableCharBag;
import org.eclipse.collections.api.bag.primitive.MutableDoubleBag;
import org.eclipse.collections.api.bag.primitive.MutableFloatBag;
import org.eclipse.collections.api.bag.primitive.MutableIntBag;
import org.eclipse.collections.api.bag.primitive.MutableLongBag;
import org.eclipse.collections.api.bag.primitive.MutableShortBag;
import org.eclipse.collections.api.block.function.Function;
import org.eclipse.collections.api.block.function.Function2;
import org.eclipse.collections.api.block.function.primitive.BooleanFunction;
import org.eclipse.collections.api.block.function.primitive.ByteFunction;
import org.eclipse.collections.api.block.function.primitive.CharFunction;
import org.eclipse.collections.api.block.function.primitive.DoubleFunction;
import org.eclipse.collections.api.block.function.primitive.FloatFunction;
import org.eclipse.collections.api.block.function.primitive.IntFunction;
import org.eclipse.collections.api.block.function.primitive.LongFunction;
import org.eclipse.collections.api.block.function.primitive.ShortFunction;
import org.eclipse.collections.api.block.predicate.Predicate;
import org.eclipse.collections.api.block.predicate.Predicate2;
import org.eclipse.collections.api.block.procedure.Procedure;
import org.eclipse.collections.api.factory.Maps;
import org.eclipse.collections.api.map.ImmutableMap;
import org.eclipse.collections.api.map.MutableMap;
import org.eclipse.collections.api.multimap.bag.MutableBagMultimap;
import org.eclipse.collections.api.multimap.set.MutableSetMultimap;
import org.eclipse.collections.api.ordered.OrderedIterable;
import org.eclipse.collections.api.partition.bag.PartitionMutableBag;
import org.eclipse.collections.api.set.MutableSet;
import org.eclipse.collections.api.tuple.Pair;
import org.eclipse.collections.impl.bag.mutable.HashBag;
import org.eclipse.collections.impl.bag.mutable.primitive.BooleanHashBag;
import org.eclipse.collections.impl.bag.mutable.primitive.ByteHashBag;
import org.eclipse.collections.impl.bag.mutable.primitive.CharHashBag;
import org.eclipse.collections.impl.bag.mutable.primitive.DoubleHashBag;
import org.eclipse.collections.impl.bag.mutable.primitive.FloatHashBag;
import org.eclipse.collections.impl.bag.mutable.primitive.IntHashBag;
import org.eclipse.collections.impl.bag.mutable.primitive.LongHashBag;
import org.eclipse.collections.impl.bag.mutable.primitive.ShortHashBag;
import org.eclipse.collections.impl.block.factory.Functions;
import org.eclipse.collections.impl.block.factory.Predicates;
import org.eclipse.collections.impl.block.procedure.PartitionPredicate2Procedure;
import org.eclipse.collections.impl.block.procedure.PartitionProcedure;
import org.eclipse.collections.impl.block.procedure.SelectInstancesOfProcedure;
import org.eclipse.collections.impl.block.procedure.primitive.CollectBooleanProcedure;
import org.eclipse.collections.impl.block.procedure.primitive.CollectByteProcedure;
import org.eclipse.collections.impl.block.procedure.primitive.CollectCharProcedure;
import org.eclipse.collections.impl.block.procedure.primitive.CollectDoubleProcedure;
import org.eclipse.collections.impl.block.procedure.primitive.CollectFloatProcedure;
import org.eclipse.collections.impl.block.procedure.primitive.CollectIntProcedure;
import org.eclipse.collections.impl.block.procedure.primitive.CollectLongProcedure;
import org.eclipse.collections.impl.block.procedure.primitive.CollectShortProcedure;
import org.eclipse.collections.impl.list.fixed.ArrayAdapter;
import org.eclipse.collections.impl.multimap.bag.HashBagMultimap;
import org.eclipse.collections.impl.partition.bag.PartitionHashBag;
import org.eclipse.collections.impl.set.mutable.UnifiedSet;
import org.eclipse.collections.impl.utility.MapIterate;
public abstract class AbstractMutableMap extends AbstractMutableMapIterable
implements MutableMap
{
@Override
@SuppressWarnings("AbstractMethodOverridesAbstractMethod")
public abstract MutableMap clone();
/**
* Creates a new instance of the same type, using the given capacity and the default growth parameters.
*/
public abstract MutableMap newEmpty(int capacity);
@Override
public MutableMap asUnmodifiable()
{
return UnmodifiableMutableMap.of(this);
}
@Override
public ImmutableMap toImmutable()
{
return Maps.immutable.withAll(this);
}
@Override
public MutableMap asSynchronized()
{
return SynchronizedMutableMap.of(this);
}
@Override
public MutableSetMultimap flip()
{
return MapIterate.flip(this);
}
@Override
public MutableMap collectValues(Function2 function)
{
return MapIterate.collectValues(this, function, this.newEmpty(this.size()));
}
@Override
public MutableMap select(Predicate2 predicate)
{
return MapIterate.selectMapOnEntry(this, predicate, this.newEmpty());
}
@Override
public MutableMap reject(Predicate2 predicate)
{
return MapIterate.rejectMapOnEntry(this, predicate, this.newEmpty());
}
@Override
public MutableBag collect(Function function)
{
return this.collect(function, HashBag.newBag());
}
@Override
public MutableBooleanBag collectBoolean(BooleanFunction booleanFunction)
{
MutableBooleanBag result = new BooleanHashBag();
this.forEach(new CollectBooleanProcedure<>(booleanFunction, result));
return result;
}
@Override
public MutableByteBag collectByte(ByteFunction byteFunction)
{
MutableByteBag result = new ByteHashBag();
this.forEach(new CollectByteProcedure<>(byteFunction, result));
return result;
}
@Override
public MutableCharBag collectChar(CharFunction charFunction)
{
MutableCharBag result = new CharHashBag();
this.forEach(new CollectCharProcedure<>(charFunction, result));
return result;
}
@Override
public MutableDoubleBag collectDouble(DoubleFunction doubleFunction)
{
MutableDoubleBag result = new DoubleHashBag();
this.forEach(new CollectDoubleProcedure<>(doubleFunction, result));
return result;
}
@Override
public MutableFloatBag collectFloat(FloatFunction floatFunction)
{
MutableFloatBag result = new FloatHashBag();
this.forEach(new CollectFloatProcedure<>(floatFunction, result));
return result;
}
@Override
public MutableIntBag collectInt(IntFunction intFunction)
{
MutableIntBag result = new IntHashBag();
this.forEach(new CollectIntProcedure<>(intFunction, result));
return result;
}
@Override
public MutableLongBag collectLong(LongFunction longFunction)
{
MutableLongBag result = new LongHashBag();
this.forEach(new CollectLongProcedure<>(longFunction, result));
return result;
}
@Override
public MutableShortBag collectShort(ShortFunction shortFunction)
{
MutableShortBag result = new ShortHashBag();
this.forEach(new CollectShortProcedure<>(shortFunction, result));
return result;
}
@Override
public MutableBag collectWith(Function2 function, P parameter)
{
return this.collect(Functions.bind(function, parameter));
}
@Override
public MutableBag collectIf(Predicate predicate, Function function)
{
return this.collectIf(predicate, function, new HashBag<>());
}
@Override
public MutableBag flatCollect(Function> function)
{
return this.flatCollect(function, new HashBag<>());
}
@Override
public MutableBag select(Predicate predicate)
{
return this.select(predicate, new HashBag<>());
}
@Override
public MutableMap tap(Procedure procedure)
{
this.forEach(procedure);
return this;
}
@Override
public MutableBag selectWith(Predicate2 predicate, P parameter)
{
return this.select(Predicates.bind(predicate, parameter));
}
@Override
public MutableBag reject(Predicate predicate)
{
return this.reject(predicate, new HashBag<>());
}
@Override
public MutableBag rejectWith(Predicate2 predicate, P parameter)
{
return this.reject(Predicates.bind(predicate, parameter));
}
@Override
public PartitionMutableBag partition(Predicate predicate)
{
PartitionMutableBag partitionMutableBag = new PartitionHashBag<>();
this.forEach(new PartitionProcedure<>(predicate, partitionMutableBag));
return partitionMutableBag;
}
@Override
public PartitionMutableBag partitionWith(Predicate2 predicate, P parameter)
{
PartitionMutableBag partitionMutableBag = new PartitionHashBag<>();
this.forEach(new PartitionPredicate2Procedure<>(predicate, parameter, partitionMutableBag));
return partitionMutableBag;
}
@Override
public MutableBag selectInstancesOf(Class clazz)
{
MutableBag result = HashBag.newBag();
this.forEach(new SelectInstancesOfProcedure<>(clazz, result));
return result;
}
/**
* @deprecated in 6.0. Use {@link OrderedIterable#zip(Iterable)} instead.
*/
@Override
@Deprecated
public MutableBag> zip(Iterable that)
{
return this.zip(that, new HashBag<>(this.size()));
}
/**
* @deprecated in 6.0. Use {@link OrderedIterable#zipWithIndex()} instead.
*/
@Override
@Deprecated
public MutableSet> zipWithIndex()
{
return this.zipWithIndex(new UnifiedSet<>(this.size()));
}
@Override
public MutableMap withKeyValue(K key, V value)
{
this.put(key, value);
return this;
}
@Override
public MutableMap withAllKeyValues(Iterable> keyValues)
{
for (Pair keyVal : keyValues)
{
this.put(keyVal.getOne(), keyVal.getTwo());
}
return this;
}
@Override
public MutableMap withAllKeyValueArguments(Pair... keyValues)
{
return this.withAllKeyValues(ArrayAdapter.adapt(keyValues));
}
@Override
public MutableMap withoutKey(K key)
{
this.removeKey(key);
return this;
}
@Override
public MutableMap withoutAllKeys(Iterable keys)
{
for (K key : keys)
{
this.removeKey(key);
}
return this;
}
/**
* Trait-style class that is used to capture commonalities between ValuesCollection class implementations in order to
* avoid code duplication.
*/
protected abstract static class ValuesCollectionCommon implements Collection
{
@Override
public boolean add(V v)
{
throw new UnsupportedOperationException("Cannot call add() on " + this.getClass().getSimpleName());
}
@Override
public boolean addAll(Collection collection)
{
throw new UnsupportedOperationException("Cannot call addAll() on " + this.getClass().getSimpleName());
}
}
@Override
public MutableBagMultimap groupBy(Function function)
{
return this.groupBy(function, HashBagMultimap.newMultimap());
}
@Override
public MutableBagMultimap groupByEach(Function> function)
{
return this.groupByEach(function, HashBagMultimap.newMultimap());
}
@Override
public MutableMap groupByUniqueKey(Function function)
{
return this.groupByUniqueKey(function, UnifiedMap.newMap(this.size()));
}
}