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
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
|
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.math3.util;
import org.apache.commons.math3.exception.MathIllegalArgumentException;
import java.io.Serializable;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/**
* This TansformerMap automates the transformation of mixed object types. It provides a means to set
* NumberTransformers that will be selected based on the Class of the object handed to the Maps
* <code>double transform(Object o)</code> method.
*/
public class TransformerMap implements NumberTransformer, Serializable {
/** Serializable version identifier */
private static final long serialVersionUID = 4605318041528645258L;
/** A default Number Transformer for Numbers and numeric Strings. */
private NumberTransformer defaultTransformer = null;
/** The internal Map. */
private Map<Class<?>, NumberTransformer> map = null;
/** Build a map containing only the default transformer. */
public TransformerMap() {
map = new HashMap<Class<?>, NumberTransformer>();
defaultTransformer = new DefaultTransformer();
}
/**
* Tests if a Class is present in the TransformerMap.
*
* @param key Class to check
* @return true|false
*/
public boolean containsClass(Class<?> key) {
return map.containsKey(key);
}
/**
* Tests if a NumberTransformer is present in the TransformerMap.
*
* @param value NumberTransformer to check
* @return true|false
*/
public boolean containsTransformer(NumberTransformer value) {
return map.containsValue(value);
}
/**
* Returns the Transformer that is mapped to a class if mapping is not present, this returns
* null.
*
* @param key The Class of the object
* @return the mapped NumberTransformer or null.
*/
public NumberTransformer getTransformer(Class<?> key) {
return map.get(key);
}
/**
* Sets a Class to Transformer Mapping in the Map. If the Class is already present, this
* overwrites that mapping.
*
* @param key The Class
* @param transformer The NumberTransformer
* @return the replaced transformer if one is present
*/
public NumberTransformer putTransformer(Class<?> key, NumberTransformer transformer) {
return map.put(key, transformer);
}
/**
* Removes a Class to Transformer Mapping in the Map.
*
* @param key The Class
* @return the removed transformer if one is present or null if none was present.
*/
public NumberTransformer removeTransformer(Class<?> key) {
return map.remove(key);
}
/** Clears all the Class to Transformer mappings. */
public void clear() {
map.clear();
}
/**
* Returns the Set of Classes used as keys in the map.
*
* @return Set of Classes
*/
public Set<Class<?>> classes() {
return map.keySet();
}
/**
* Returns the Set of NumberTransformers used as values in the map.
*
* @return Set of NumberTransformers
*/
public Collection<NumberTransformer> transformers() {
return map.values();
}
/**
* Attempts to transform the Object against the map of NumberTransformers. Otherwise it returns
* Double.NaN.
*
* @param o the Object to be transformed.
* @return the double value of the Object.
* @throws MathIllegalArgumentException if the Object can not be transformed into a Double.
* @see org.apache.commons.math3.util.NumberTransformer#transform(java.lang.Object)
*/
public double transform(Object o) throws MathIllegalArgumentException {
double value = Double.NaN;
if (o instanceof Number || o instanceof String) {
value = defaultTransformer.transform(o);
} else {
NumberTransformer trans = getTransformer(o.getClass());
if (trans != null) {
value = trans.transform(o);
}
}
return value;
}
/** {@inheritDoc} */
@Override
public boolean equals(Object other) {
if (this == other) {
return true;
}
if (other instanceof TransformerMap) {
TransformerMap rhs = (TransformerMap) other;
if (!defaultTransformer.equals(rhs.defaultTransformer)) {
return false;
}
if (map.size() != rhs.map.size()) {
return false;
}
for (Map.Entry<Class<?>, NumberTransformer> entry : map.entrySet()) {
if (!entry.getValue().equals(rhs.map.get(entry.getKey()))) {
return false;
}
}
return true;
}
return false;
}
/** {@inheritDoc} */
@Override
public int hashCode() {
int hash = defaultTransformer.hashCode();
for (NumberTransformer t : map.values()) {
hash = hash * 31 + t.hashCode();
}
return hash;
}
}
|
