← Back to branch summary

~ubuntu-branches/ubuntu/wily/gs-collections/wily

« back to all changes in this revision

Viewing changes to collections-api/src/main/java/com/gs/collections/api/map/ImmutableMap.java

  • Committer: Package Import Robot
  • Author(s): Emmanuel Bourg
  • Date: 2015-07-23 12:42:30 UTC
  • Revision ID: package-import@ubuntu.com-20150723124230-2rjvfv6elyn2m7d4
Tags: upstream-5.1.0
Import upstream version 5.1.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
collections-api/src/main/java/com/gs/collections/api/map/ImmutableMap.java
 
1
/*
 
2
 * Copyright 2014 Goldman Sachs.
 
3
 *
 
4
 * Licensed under the Apache License, Version 2.0 (the "License");
 
5
 * you may not use this file except in compliance with the License.
 
6
 * You may obtain a copy of the License at
 
7
 *
 
8
 *     http://www.apache.org/licenses/LICENSE-2.0
 
9
 *
 
10
 * Unless required by applicable law or agreed to in writing, software
 
11
 * distributed under the License is distributed on an "AS IS" BASIS,
 
12
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 
13
 * See the License for the specific language governing permissions and
 
14
 * limitations under the License.
 
15
 */
 
16
 
 
17
package com.gs.collections.api.map;
 
18
 
 
19
import java.util.Map;
 
20
 
 
21
import com.gs.collections.api.block.function.Function;
 
22
import com.gs.collections.api.block.function.Function0;
 
23
import com.gs.collections.api.block.function.Function2;
 
24
import com.gs.collections.api.block.function.primitive.BooleanFunction;
 
25
import com.gs.collections.api.block.function.primitive.ByteFunction;
 
26
import com.gs.collections.api.block.function.primitive.CharFunction;
 
27
import com.gs.collections.api.block.function.primitive.DoubleFunction;
 
28
import com.gs.collections.api.block.function.primitive.FloatFunction;
 
29
import com.gs.collections.api.block.function.primitive.IntFunction;
 
30
import com.gs.collections.api.block.function.primitive.LongFunction;
 
31
import com.gs.collections.api.block.function.primitive.ShortFunction;
 
32
import com.gs.collections.api.block.predicate.Predicate;
 
33
import com.gs.collections.api.block.predicate.Predicate2;
 
34
import com.gs.collections.api.block.procedure.Procedure2;
 
35
import com.gs.collections.api.collection.ImmutableCollection;
 
36
import com.gs.collections.api.collection.primitive.ImmutableBooleanCollection;
 
37
import com.gs.collections.api.collection.primitive.ImmutableByteCollection;
 
38
import com.gs.collections.api.collection.primitive.ImmutableCharCollection;
 
39
import com.gs.collections.api.collection.primitive.ImmutableDoubleCollection;
 
40
import com.gs.collections.api.collection.primitive.ImmutableFloatCollection;
 
41
import com.gs.collections.api.collection.primitive.ImmutableIntCollection;
 
42
import com.gs.collections.api.collection.primitive.ImmutableLongCollection;
 
43
import com.gs.collections.api.collection.primitive.ImmutableShortCollection;
 
44
import com.gs.collections.api.multimap.ImmutableMultimap;
 
45
import com.gs.collections.api.multimap.set.ImmutableSetMultimap;
 
46
import com.gs.collections.api.partition.PartitionImmutableCollection;
 
47
import com.gs.collections.api.tuple.Pair;
 
48
import net.jcip.annotations.Immutable;
 
49
 
 
50
/**
 
51
 * An ImmutableMap is different than a JCF Map but in that it has no mutating methods.  It shares the read-only
 
52
 * protocol of a JDK Map.
 
53
 */
 
54
@Immutable
 
55
public interface ImmutableMap<K, V>
 
56
        extends UnsortedMapIterable<K, V>
 
57
{
 
58
    ImmutableMap<K, V> select(Predicate2<? super K, ? super V> predicate);
 
59
 
 
60
    <K2, V2> ImmutableMap<K2, V2> collect(Function2<? super K, ? super V, Pair<K2, V2>> function);
 
61
 
 
62
    <R> ImmutableMap<K, R> collectValues(Function2<? super K, ? super V, ? extends R> function);
 
63
 
 
64
    ImmutableMap<K, V> reject(Predicate2<? super K, ? super V> predicate);
 
65
 
 
66
    Map<K, V> castToMap();
 
67
 
 
68
    ImmutableMap<K, V> newWithKeyValue(K key, V value);
 
69
 
 
70
    ImmutableMap<K, V> newWithAllKeyValues(Iterable<? extends Pair<? extends K, ? extends V>> keyValues);
 
71
 
 
72
    ImmutableMap<K, V> newWithAllKeyValueArguments(Pair<? extends K, ? extends V>... keyValuePairs);
 
73
 
 
74
    ImmutableMap<K, V> newWithoutKey(K key);
 
75
 
 
76
    ImmutableMap<K, V> newWithoutAllKeys(Iterable<? extends K> keys);
 
77
 
 
78
    MutableMap<K, V> toMap();
 
79
 
 
80
    ImmutableSetMultimap<V, K> flip();
 
81
 
 
82
    <R> ImmutableCollection<R> collect(Function<? super V, ? extends R> function);
 
83
 
 
84
    ImmutableBooleanCollection collectBoolean(BooleanFunction<? super V> booleanFunction);
 
85
 
 
86
    ImmutableByteCollection collectByte(ByteFunction<? super V> byteFunction);
 
87
 
 
88
    ImmutableCharCollection collectChar(CharFunction<? super V> charFunction);
 
89
 
 
90
    ImmutableDoubleCollection collectDouble(DoubleFunction<? super V> doubleFunction);
 
91
 
 
92
    ImmutableFloatCollection collectFloat(FloatFunction<? super V> floatFunction);
 
93
 
 
94
    ImmutableIntCollection collectInt(IntFunction<? super V> intFunction);
 
95
 
 
96
    ImmutableLongCollection collectLong(LongFunction<? super V> longFunction);
 
97
 
 
98
    ImmutableShortCollection collectShort(ShortFunction<? super V> shortFunction);
 
99
 
 
100
    <R> ImmutableCollection<R> collectIf(Predicate<? super V> predicate, Function<? super V, ? extends R> function);
 
101
 
 
102
    <R> ImmutableCollection<R> flatCollect(Function<? super V, ? extends Iterable<R>> function);
 
103
 
 
104
    ImmutableCollection<V> select(Predicate<? super V> predicate);
 
105
 
 
106
    ImmutableCollection<V> reject(Predicate<? super V> predicate);
 
107
 
 
108
    PartitionImmutableCollection<V> partition(Predicate<? super V> predicate);
 
109
 
 
110
    <P> PartitionImmutableCollection<V> partitionWith(Predicate2<? super V, ? super P> predicate, P parameter);
 
111
 
 
112
    <S> ImmutableCollection<S> selectInstancesOf(Class<S> clazz);
 
113
 
 
114
    <S> ImmutableCollection<Pair<V, S>> zip(Iterable<S> that);
 
115
 
 
116
    ImmutableCollection<Pair<V, Integer>> zipWithIndex();
 
117
 
 
118
    <VV> ImmutableMultimap<VV, V> groupBy(Function<? super V, ? extends VV> function);
 
119
 
 
120
    <VV> ImmutableMultimap<VV, V> groupByEach(Function<? super V, ? extends Iterable<VV>> function);
 
121
 
 
122
    <V1> ImmutableMap<V1, V> groupByUniqueKey(Function<? super V, ? extends V1> function);
 
123
 
 
124
    <K2, V2> ImmutableMap<K2, V2> aggregateInPlaceBy(
 
125
            Function<? super V, ? extends K2> groupBy,
 
126
            Function0<? extends V2> zeroValueFactory,
 
127
            Procedure2<? super V2, ? super V> mutatingAggregator);
 
128
 
 
129
    <K2, V2> ImmutableMap<K2, V2> aggregateBy(
 
130
            Function<? super V, ? extends K2> groupBy,
 
131
            Function0<? extends V2> zeroValueFactory,
 
132
            Function2<? super V2, ? super V, ? extends V2> nonMutatingAggregator);
 
133
 
 
134
    ImmutableMap<V, K> flipUniqueValues();
 
135
}