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: 1.15 $ $Date: 2004/06/23 16:26:15 $
    32   */
    33  public class TransformerMap implements NumberTransformer, Serializable {
    34
    35      /*** Serializable version identifier */
    36      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 }