View Javadoc

1   /*
2    * Copyright 2003-2004 The Apache Software Foundation.
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  package org.apache.commons.math.util;
17  
18  import java.io.Serializable;
19  import java.util.Collection;
20  import java.util.HashMap;
21  import java.util.Map;
22  import java.util.Set;
23  
24  import org.apache.commons.math.MathException;
25  
26  /**
27   * This TansformerMap automates the transformation of of mixed object types.
28   * It provides a means to set NumberTransformers that will be selected 
29   * based on the Class of the object handed to the Maps
30   * <code>double transform(Object o)</code> method.
31   * @version $Revision: 348519 $ $Date: 2005-11-23 12:12:18 -0700 (Wed, 23 Nov 2005) $
32   */
33  public class TransformerMap implements NumberTransformer, Serializable {
34  
35      /** Serializable version identifier */
36      private static final long serialVersionUID = -942772950698439883L;
37      
38      /**
39       * A default Number Transformer for Numbers and numeric Strings.
40       */
41      private NumberTransformer defaultTransformer = null;
42  
43      /**
44       * The internal Map.
45       */
46      private Map map = null;
47  
48      /**
49       * 
50       */
51      public TransformerMap() {
52          map = new HashMap();
53          defaultTransformer = new DefaultTransformer();
54      }
55  
56      /**
57       * Tests if a Class is present in the TransformerMap.
58       * @param key Class to check
59       * @return true|false
60       */
61      public boolean containsClass(Class key) {
62          return map.containsKey(key);
63      }
64  
65      /**
66       * Tests if a NumberTransformer is present in the TransformerMap.
67       * @param value NumberTransformer to check
68       * @return true|false
69       */
70      public boolean containsTransformer(NumberTransformer value) {
71          return map.containsValue(value);
72      }
73  
74      /**
75       * Returns the Transformer that is mapped to a class
76       * if mapping is not present, this returns null.
77       * @param key The Class of the object
78       * @return the mapped NumberTransformer or null.
79       */
80      public NumberTransformer getTransformer(Class key) {
81          return (NumberTransformer) map.get(key);
82      }
83  
84      /**
85       * Sets a Class to Transformer Mapping in the Map. If
86       * the Class is already present, this overwrites that
87       * mapping.
88       * @param key The Class
89       * @param transformer The NumberTransformer
90       * @return the replaced transformer if one is present
91       */
92      public Object putTransformer(Class key, NumberTransformer transformer) {
93          return map.put(key, transformer);
94      }
95  
96      /**
97       * Removes a Class to Transformer Mapping in the Map.
98       * @param key The Class
99       * @return the removed transformer if one is present or
100      * null if none was present.
101      */
102     public Object removeTransformer(Class key) {
103         return map.remove(key);
104     }
105 
106     /**
107      * Clears all the Class to Transformer mappings.
108      */
109     public void clear() {
110         map.clear();
111     }
112 
113     /**
114      * Returns the Set of Classes used as keys in the map.
115      * @return Set of Classes
116      */
117     public Set classes() {
118         return map.keySet();
119     }
120 
121     /**
122      * Returns the Set of NumberTransformers used as values 
123      * in the map.
124      * @return Set of NumberTransformers
125      */
126     public Collection transformers() {
127         return map.values();
128     }
129 
130     /**
131      * Attempts to transform the Object against the map of
132      * NumberTransformers. Otherwise it returns Double.NaN.
133      * 
134      * @see org.apache.commons.math.util.NumberTransformer#transform(java.lang.Object)
135      */
136     public double transform(Object o) throws MathException {
137         double value = Double.NaN;
138 
139         if (o instanceof Number || o instanceof String) {
140             value = defaultTransformer.transform(o);
141         } else {
142             NumberTransformer trans = getTransformer(o.getClass());
143             if (trans != null) {
144                 value = trans.transform(o);
145             }
146         }
147 
148         return value;
149     }
150 
151 }