View Javadoc

1   //$Id: TypeAbbreviator.java 256 2006-10-23 21:56:10Z jg_hamburg $
2   /********************************************************************************
3    * DDTUnit, a Datadriven Approach to Unit- and Moduletesting
4    * Copyright (c) 2004, Joerg and Kai Gellien
5    * All rights reserved.
6    *
7    * The Software is provided under the terms of the Common Public License 1.0
8    * as provided with the distribution of DDTUnit in the file cpl-v10.html.
9    * Redistribution and use in source and binary forms, with or without
10   * modification, are permitted provided that the following conditions
11   * are met:
12   *
13   *     + Redistributions of source code must retain the above copyright
14   *       notice, this list of conditions and the following disclaimer.
15   *
16   *     + Redistributions in binary form must reproduce the above
17   *       copyright notice, this list of conditions and the following
18   *       disclaimer in the documentation and/or other materials provided
19   *       with the distribution.
20   *
21   *     + Neither the name of the authors or DDTUnit, nor the
22   *       names of its contributors may be used to endorse or promote
23   *       products derived from this software without specific prior
24   *       written permission.
25   *
26   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
27   * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
28   * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
29   * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR
30   * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
31   * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
32   * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
33   * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
34   * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
35   * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
36   * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
37   ********************************************************************************/
38  package junitx.ddtunit.data.processing;
39  
40  import java.io.IOException;
41  import java.util.Iterator;
42  import java.util.Map;
43  import java.util.Properties;
44  import java.util.Map.Entry;
45  
46  /**
47   * @author jg
48   */
49  public class TypeAbbreviator {
50      /**
51       * Properties file containing shortcut to java type mappings
52       */
53      public static final String TYPEABBREVIATOR_PROPERTIES = "TypeAbbreviator.properties";
54  
55      private static final String LF = "\n";
56  
57      private static final String DELIM = " - ";
58  
59      private static TypeAbbreviator singleton;
60  
61      private static Properties dictionary = new Properties();
62  
63      /**
64       * @throws IOException
65       * 
66       */
67      private TypeAbbreviator() throws IOException {
68          dictionary.load(TypeAbbreviator.class
69              .getResourceAsStream(TYPEABBREVIATOR_PROPERTIES));
70      }
71  
72      /**
73       * Provide singleton reference on a <code>TypeAbbreviator</code> class.
74       * 
75       * @return instance of TypeAbbreviator
76       * @throws IOException
77       */
78      public final static TypeAbbreviator getInstance() throws IOException {
79          if (singleton == null) {
80              singleton = new TypeAbbreviator();
81          }
82          return singleton;
83      }
84  
85      /**
86       * Check for java type shortcut in internal type dictionary. If nothing
87       * found, the original type is returned else the expanded type.
88       * 
89       * @param shortcut to resolve
90       * @return resolved form if exists or shortcut input if no dictionary entry
91       */
92      public String resolve(String shortcut) {
93          String resolved;
94          String extended = (String) dictionary.get(shortcut);
95          if (extended != null) {
96              resolved = extended;
97          } else {
98              resolved = shortcut;
99          }
100         return resolved;
101     }
102 
103     /**
104      * Print out Mapping definitions.
105      */
106     public String toString() {
107         StringBuffer sb = new StringBuffer("Dictionary of Type Abbreviations:")
108             .append(LF).append(" Key ").append(DELIM).append(" Values ")
109             .append(LF);
110         for (Iterator iter = dictionary.entrySet().iterator(); iter.hasNext();) {
111             Map.Entry dictEntry = (Entry) iter.next();
112             String key = (String) dictEntry.getKey();
113             sb.append(key).append(DELIM).append(dictEntry.getValue());
114             if (iter.hasNext()) {
115                 sb.append(LF);
116             }
117         }
118         return sb.toString();
119     }
120 
121     /**
122      * @return Number of abbreviation entries in dictionary
123      */
124     public int size() {
125         return dictionary.size();
126     }
127 
128     public static void main(String[] argv) throws IOException {
129         TypeAbbreviator abbrev = new TypeAbbreviator();
130         System.out.println(abbrev.toString());
131     }
132 }