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
151
152
153
154
|
/*
* Conditions Of Use
*
* This software was developed by employees of the National Institute of
* Standards and Technology (NIST), an agency of the Federal Government.
* Pursuant to title 15 Untied States Code Section 105, works of NIST
* employees are not subject to copyright protection in the United States
* and are considered to be in the public domain. As a result, a formal
* license is not needed to use the software.
*
* This software is provided by NIST as a service and is expressly
* provided "AS IS." NIST MAKES NO WARRANTY OF ANY KIND, EXPRESS, IMPLIED
* OR STATUTORY, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTY OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT
* AND DATA ACCURACY. NIST does not warrant or make any representations
* regarding the use of the software or the results thereof, including but
* not limited to the correctness, accuracy, reliability or usefulness of
* the software.
*
* Permission to use this software is contingent upon your acceptance
* of the terms of this agreement.
*
*/
package gov.nist.core;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class MultiValueMapImpl<V> implements MultiValueMap<String, V>, Cloneable {
private HashMap<String, ArrayList<V>> map = new HashMap<String, ArrayList<V>>();
private static final long serialVersionUID = 4275505380960964605L;
public MultiValueMapImpl() {
super();
}
public List<V> put(String key, V value) {
ArrayList<V> keyList = map.get(key);
if (keyList == null) {
keyList = new ArrayList<V>(10);
map.put(key, keyList);
}
keyList.add(value);
return keyList;
}
public boolean containsValue(Object value) {
Set pairs = map.entrySet();
if (pairs == null)
return false;
Iterator pairsIterator = pairs.iterator();
while (pairsIterator.hasNext()) {
Map.Entry keyValuePair = (Map.Entry) (pairsIterator.next());
ArrayList list = (ArrayList) (keyValuePair.getValue());
if (list.contains(value))
return true;
}
return false;
}
public void clear() {
Set pairs = map.entrySet();
Iterator pairsIterator = pairs.iterator();
while (pairsIterator.hasNext()) {
Map.Entry keyValuePair = (Map.Entry) (pairsIterator.next());
ArrayList list = (ArrayList) (keyValuePair.getValue());
list.clear();
}
map.clear();
}
public Collection values() {
ArrayList returnList = new ArrayList(map.size());
Set pairs = map.entrySet();
Iterator pairsIterator = pairs.iterator();
while (pairsIterator.hasNext()) {
Map.Entry keyValuePair = (Map.Entry) (pairsIterator.next());
ArrayList list = (ArrayList) (keyValuePair.getValue());
Object[] values = list.toArray();
for (int ii = 0; ii < values.length; ii++) {
returnList.add(values[ii]);
}
}
return returnList;
}
public Object clone() {
MultiValueMapImpl obj = new MultiValueMapImpl<V>();
obj.map = (HashMap<Object, ArrayList<V>>) this.map.clone();
return obj;
}
public int size() {
return this.map.size();
}
public boolean containsKey(Object key) {
return map.containsKey(key);
}
public Set entrySet() {
return map.entrySet();
}
public boolean isEmpty() {
return map.isEmpty();
}
public Set<String> keySet() {
return this.map.keySet();
}
public Object remove(String key, V item) {
ArrayList<V> list = this.map.get(key);
if (list == null) {
return null;
} else {
return list.remove(item);
}
}
public List<V> get(Object key) {
return map.get(key);
}
public List<V> put(String key, List<V> value) {
return this.map.put(key,(ArrayList<V>) value);
}
public List<V> remove(Object key) {
return map.remove(key);
}
public void putAll(Map< ? extends String, ? extends List<V>> mapToPut) {
for (String k : mapToPut.keySet()) {
ArrayList<V> al = new ArrayList<V>();
al.addAll(mapToPut.get(k));
this.map.put(k, al);
}
}
}
|
