001 /*
002 Copyright (c) 2009 Olivier Chafik, All Rights Reserved
003
004 This file is part of JNAerator (http://jnaerator.googlecode.com/).
005
006 JNAerator is free software: you can redistribute it and/or modify
007 it under the terms of the GNU General Public License as published by
008 the Free Software Foundation, either version 3 of the License, or
009 (at your option) any later version.
010
011 JNAerator is distributed in the hope that it will be useful,
012 but WITHOUT ANY WARRANTY; without even the implied warranty of
013 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
014 GNU General Public License for more details.
015
016 You should have received a copy of the GNU General Public License
017 along with JNAerator. If not, see <http://www.gnu.org/licenses/>.
018 */
019 package com.ochafik.util.string;
020 import java.util.ArrayList;
021 import java.util.Arrays;
022 import java.util.LinkedList;
023 import java.util.List;
024 import java.util.StringTokenizer;
025 import java.util.regex.Matcher;
026 import java.util.regex.Pattern;
027 public class StringUtils {
028 public static String htmlize(String text) {
029 return text.startsWith("<?") || text.startsWith("<html>") ?
030 text : "<html><body>"+
031 text.replace("&", "&").replace("<", "<").replace(">", ">").replace("\n","<br>")+
032 "</body></html>";
033 }
034
035 static Pattern spacePattern;
036 public static List<String> explode(String s) {
037 if (spacePattern == null) {
038 spacePattern = Pattern.compile("\\s+");
039 }
040 return explode(s, spacePattern);
041 }
042 public static List<String> explode(String s, String sep) {
043 StringTokenizer st=new StringTokenizer(s,sep);
044 List<String> v = new ArrayList<String>();
045 for (;st.hasMoreTokens();) {
046 v.add(st.nextToken());
047 }
048 return v;
049 }
050
051 /*
052 public static final String implode(Object[] strings, String separator) {
053 return implode(Arrays.asList(strings), separator);
054 }
055 */
056 public static String implode(double[] array, String separator) {
057 StringBuffer out = new StringBuffer();
058 boolean first = true;
059 for (double v : array) {
060 if (first) first = false;
061 else out.append(separator);
062 out.append(v);
063 }
064 return out.toString();
065 }
066
067 public static String implode(Object[] values) {
068 return implode(values, ", ");
069 }
070 public static String implode(Object[] values, Object separator) {
071 return implode(Arrays.asList(values), separator);
072 }
073 public static final <T> String implode(Iterable<T> elements, Object separator) {
074 String sepStr = separator.toString();
075 StringBuilder out = new StringBuilder();
076 boolean first = true;
077 for (Object s : elements) {
078 if (s == null)
079 continue;
080
081 if (first)
082 first = false;
083 else
084 out.append(sepStr);
085 out.append(s);
086 }
087 return out.toString();
088 }
089 public static final String implode(Iterable<?> strings) {
090 return implode(strings, ", ");
091 }
092 /*
093 public static final String implode(Collection<?> strings, String separator) {
094 int size = 0, n = strings.size();
095 for (Object s : strings)
096 if (s != null)
097 size += s.toString().length();
098
099 StringBuffer out = new StringBuffer(size + separator.length() * (n == 0 ? 0 : n - 1));
100 boolean first = true;
101 for (Object s : strings) {
102 if (s == null)
103 continue;
104
105 if (first) first = false;
106 else out.append(separator);
107 out.append(s);
108 }
109 return out.toString();
110 }
111 */
112 public static final List<String> explode(String string, Pattern separator) {
113 int lastIndex = 0, len = string.length();
114
115 Matcher matcher = separator.matcher(string);
116 List<String> ret = new LinkedList<String>();
117
118 while (matcher.find()) {
119 String s = string.substring(lastIndex, matcher.start());
120 if (s.length() > 0) ret.add(s);
121 lastIndex = matcher.end();
122 }
123 String s = string.substring(lastIndex, len);
124 if (s.length() > 0) ret.add(s);
125
126 return ret;
127 }
128
129 public static String replace(String pattern, String replace, String s) {
130 return concatWithSeparator(explode(s,pattern).toArray(new String[0]),replace);
131 }
132 public static final String concat(String[] a) {
133 StringBuffer b=new StringBuffer();
134 for (int i=0;i<a.length;i++) b.append(a[i]);
135 return b.toString();
136 }
137 public static final String concatln(String[] a) {
138 StringBuffer b=new StringBuffer();
139 int lenm=a.length-1;
140 for (int i=0;i<lenm;i++) {
141 b.append(a[i]);
142 b.append("\n");
143 }
144 if (lenm!=-1) b.append(a[lenm]);
145 return b.toString();
146 }
147 public static final String concatSpace(String[] a) {
148 StringBuffer b=new StringBuffer();
149 int lenm=a.length-1;
150 for (int i=0;i<lenm;i++) {
151 b.append(a[i]);
152 b.append(" ");
153 }
154 if (lenm!=-1) b.append(a[lenm]);
155 return b.toString();
156 }
157 public static final String concatWithSeparator(String[] a,String sep) {
158 StringBuffer b=new StringBuffer();
159 int lenm=a.length-1;
160 for (int i=0;i<lenm;i++) {
161 b.append(a[i]);
162 b.append(sep);
163 }
164 if (lenm!=-1) b.append(a[lenm]);
165 return b.toString();
166 }
167 public static final String javaEscape(String s) {
168 if (s == null)
169 return null;
170 char c;
171 int len=s.length();
172 StringBuffer b=new StringBuffer(len);
173 for (int i=0;i<len;i++) {
174 c=s.charAt(i);
175 switch (c) {
176 case '\n':
177 b.append("\\n");
178 break;
179 case '\t':
180 b.append("\\t");
181 break;
182 case '\r':
183 b.append("\\r");
184 break;
185 case '"':
186 b.append("\"");
187 break;
188 case '\\':
189 b.append("\\\\");
190 break;
191 default:
192 if (c>127||Character.isISOControl(c)) {
193 b.append("\\u");
194 String nb=Integer.toString((int)c,16);
195 int nblen=nb.length();
196 switch (nblen) {
197 case 1:
198 b.append(0);
199 case 2:
200 b.append(0);
201 case 3:
202 b.append(0);
203 case 4:
204 b.append(nb);
205 break;
206 default:
207 throw new IllegalArgumentException("Should not happen !");
208 }
209 } else b.append(c);
210 }
211 }
212 return b.toString();
213 }
214 public static final String javaUnEscape(String s) {
215 char c;
216 int len=s.length();
217 StringBuffer b=new StringBuffer(len);
218 for (int i=0;i<len;i++) {
219 c=s.charAt(i);
220 if (c=='\\') {
221 c=s.charAt(++i);
222 switch (c) {
223 case 'n':
224 b.append('\n');
225 break;
226 case 'r':
227 b.append('\r');
228 break;
229 case 't':
230 b.append('\t');
231 break;
232 case '\\':
233 b.append('\\');
234 break;
235 case '"':
236 b.append('"');
237 break;
238 case '\'':
239 b.append('\'');
240 break;
241 case 'u':
242 try {
243 String nb=s.substring(i+1,i+5);
244 int n=Integer.parseInt(nb,16);
245 b.append((char)n);
246 i+=4;
247 } catch (Exception ex) {
248 throw new IllegalArgumentException("Illegal unicode escaping in string \"" + s + "\" at index " + i, ex);
249 }
250 break;
251 default:
252 throw new IllegalArgumentException("Unknown character: \"\\"+String.valueOf(c)+"...\"");
253 }
254 } else b.append(c);
255 }
256 return b.toString();
257 }
258
259 public static String capitalize(String string) {
260 return string == null ? null : string.length() == 0 ? "" : Character.toUpperCase(string.charAt(0)) + string.substring(1);
261 }
262 public static String capitalize(List<String> strings, String separator) {
263 List<String> cap = new ArrayList<String>(strings.size());
264 for (String s : strings)
265 cap.add(capitalize(s));
266 return implode(cap, separator);
267 }
268
269 public static String uncapitalize(String string) {
270 return string.length() == 0 ? "" : Character.toLowerCase(string.charAt(0)) + string.substring(1);
271 }
272 public static final String LINE_SEPARATOR;
273 static {
274 LINE_SEPARATOR = System.getProperty("line.separator");
275 }
276
277 }