1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
|
package bjc.utils.funcdata;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.function.Function;
/**
* Functional wrapper over map providing some useful things
*
* @author ben
*
* @param <KeyType>
* The type of this map's keys
* @param <ValueType>
* The type of this map's values
*
*/
public interface IMap<KeyType, ValueType> {
/**
* Check if this map contains the specified key
*
* @param key
* The key to check
* @return Whether or not the map contains the key
*/
boolean containsKey(KeyType key);
/**
* Extends this map, creating a new map that will delegate queries to
* the map, but store any added values itself
*
* @return An extended map
*/
IMap<KeyType, ValueType> extend();
/**
* Execute an action for each entry in the map
*
* @param action
* the action to execute for each entry in the map
*/
void forEach(BiConsumer<KeyType, ValueType> action);
/**
* Perform an action for each key in the map
*
* @param action
* The action to perform on each key in the map
*/
void forEachKey(Consumer<KeyType> action);
/**
* Perform an action for each value in the map
*
* @param action
* The action to perform on each value in the map
*/
void forEachValue(Consumer<ValueType> action);
/**
* Get the value assigned to the given key
*
* @param key
* The key to look for a value under
* @return The value of the key
*
*
*/
ValueType get(KeyType key);
/**
* Get the number of entries in this map
*
* @return The number of entries in this map
*/
int getSize();
/**
* Get a list of all the keys in this map
*
* @return A list of all the keys in this map
*/
IList<KeyType> keyList();
/**
* Transform the values returned by this map.
*
* NOTE: This transform is applied once for each lookup of a value, so
* the transform passed should be a proper function, or things will
* likely not work as expected.
*
* @param <V2>
* The new type of returned values
* @param transformer
* The function to use to transform values
* @return The map where each value will be transformed after lookup
*/
<V2> IMap<KeyType, V2> mapValues(Function<ValueType, V2> transformer);
/**
* Add an entry to the map
*
* @param key
* The key to put the value under
* @param val
* The value to add
* @return The previous value of the key in the map, or null if the key
* wasn't in the map. However, note that it may also return
* null if the key was set to null.
*
* @throws UnsupportedOperationException
* if the map implementation doesn't support modifying the
* map
*/
ValueType put(KeyType key, ValueType val);
/**
* Remove the value bound to the key
*
* @param key
* The key to remove from the map
* @return The previous value for the key in the map, or null if the
* key wasn't in the class. NOTE: Just because you recieved
* null, doesn't mean the map wasn't changed. It may mean that
* someone put a null value for that key into the map
*/
ValueType remove(KeyType key);
/**
* Get a list of the values in this map
*
* @return A list of values in this map
*/
IList<ValueType> valueList();
/**
* Delete all the values in the map
*/
void clear();
default ValueType getOrDefault(KeyType key, ValueType defaultValue) {
try {
return get(key);
} catch (IllegalArgumentException iaex) {
// We don't care about this, because it indicates a key is
// missing
return defaultValue;
}
}
}
|
