1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.apache.commons.betwixt.strategy;
18
19
20
21 /***
22 * A name mapper which converts types to a hypenated String. So
23 * a bean type of FooBar will be converted to the element name "foo-bar".
24 * The name mapper can be configured to convert to upper case and to
25 * use a different separator via the <code>separator</code> and
26 * <code>upperCase</code> properties, so that FooBar can be converted
27 * to FOO_BAR if needed, by calling the constructor
28 * <code>new HyphenatedNameMapper(true, "_")</code>.
29 *
30 * @author <a href="mailto:jason@zenplex.com">Jason van Zyl</a>
31 * @author <a href="mailto:jstrachan@apache.org">James Strachan</a>
32 * @version $Revision: 471234 $
33 */
34 public class HyphenatedNameMapper implements NameMapper {
35
36 /*** the separator used to seperate words, which defaults to '-' */
37 private String separator = "-";
38
39 /*** whether upper or lower case conversions should be performed */
40 private boolean upperCase = false;
41
42 /***
43 * Construct a hyphenated name mapper that converts the name to lower case
44 * and uses the default separator.
45 */
46 public HyphenatedNameMapper() {
47 }
48
49 /***
50 * Construct a hyphenated name mapper with default separator.
51 *
52 * @param upperCase should the type name be converted (entirely) to upper case
53 */
54 public HyphenatedNameMapper(boolean upperCase) {
55 this.upperCase = upperCase;
56 }
57
58 /***
59 * Construct a hyphenated name mapper.
60 *
61 * @param upperCase should the type name be converted (entirely) to upper case
62 * @param separator use this string to separate the words in the name returned.
63 * The words in the bean name are deduced by relying on the standard camel's hump
64 * property naming convention.
65 */
66 public HyphenatedNameMapper(boolean upperCase, String separator) {
67 this.upperCase = upperCase;
68 this.separator = separator;
69 }
70
71 /***
72 * <p>The words within the bean name are deduced assuming the
73 * first-letter-capital (for example camel's hump) naming convention. For
74 * example, the words in <code>FooBar</code> are <code>foo</code>
75 * and <code>bar</code>.</p>
76 *
77 * <p>Next convert all letter in the bean name to either upper case or lower case
78 * based on the {@link #isUpperCase} property value.</p>
79 *
80 * <p>Then the {@link #getSeparator} property value is inserted so that it separates
81 * each word.</p>
82 *
83 * @param typeName The name string to convert. If a JavaBean
84 * class name, should included only the last part of the name
85 * rather than the fully qualified name (e.g. FooBar rather than
86 * org.example.FooBar).
87 * @return the bean name converted to either upper or lower case with words separated
88 * by the separator.
89 */
90 public String mapTypeToElementName(String typeName) {
91
92 int length = typeName.length();
93 if (length == 0) {
94 return "";
95 }
96
97 StringBuffer sb = new StringBuffer();
98
99 sb.append(convertChar(typeName.charAt(0)));
100
101 for (int i = 1; i < length; i++) {
102 if (Character.isUpperCase(typeName.charAt(i))) {
103 sb.append(separator);
104 sb.append(convertChar(typeName.charAt(i)));
105 } else {
106 if ( upperCase ) {
107 sb.append(convertChar(typeName.charAt(i)));
108 } else {
109 sb.append(typeName.charAt(i));
110 }
111 }
112 }
113
114 return sb.toString();
115 }
116
117
118
119 /***
120 * This separator will be inserted between the words in the bean name.
121 *
122 * @return the separator used to seperate words, which defaults to '-'
123 */
124 public String getSeparator() {
125 return separator;
126 }
127
128 /***
129 * Sets the separator used to seperate words, which defaults to '-'
130 *
131 * @param separator the string inserted to separate words
132 */
133 public void setSeparator(String separator) {
134 this.separator = separator;
135 }
136
137 /***
138 * <p>Should the bean name be converted to upper case?
139 * </p>
140 * <p>
141 * Otherwise, it will be converted to lower case.
142 * </p>
143 * @return whether upper or lower case conversions should be performed,
144 * which defaults to false for lower case
145 */
146 public boolean isUpperCase() {
147 return upperCase;
148 }
149
150 /***
151 * Sets whether upper or lower case conversions should be performed,
152 * which defaults to false for lower case.
153 *
154 * @param upperCase whether the name is to be converted to upper case
155 */
156 public void setUpperCase(boolean upperCase) {
157 this.upperCase = upperCase;
158 }
159
160
161
162
163 /***
164 * Performs type conversion on the given character based on whether
165 * upper or lower case conversions are being used
166 *
167 * @param ch the character to be converted
168 * @return converted to upper case if {@link #isUpperCase} otherwise to lower case
169 */
170 protected char convertChar(char ch) {
171 if ( upperCase ) {
172 return Character.toUpperCase(ch);
173
174 } else {
175 return Character.toLowerCase(ch);
176 }
177 }
178
179 /***
180 * Outputs brief description.
181 * @since 0.8
182 */
183 public String toString() {
184 return "Hyphenated Name Mapper";
185 }
186 }