Find Usages Diff Raw Download HTML Widget
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions 
1
   /*
2
    * Licensed to the Apache Software Foundation (ASF) under one or more
3
    * contributor license agreements.  See the NOTICE file distributed with
4
    * this work for additional information regarding copyright ownership.
5
    * The ASF licenses this file to You under the Apache License, Version 2.0
6
    * (the "License"); you may not use this file except in compliance with
7
    * the License.  You may obtain a copy of the License at
8
    *
9
    *      http://www.apache.org/licenses/LICENSE-2.0
10
   *
11
   * Unless required by applicable law or agreed to in writing, software
12
   * distributed under the License is distributed on an "AS IS" BASIS,
13
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14
   * See the License for the specific language governing permissions and
15
   * limitations under the License.
16
   */
17
  package org.apache.wicket.util.string;
18
  
24
  import java.util.List;
27
  
A variety of static String utility methods.

The escapeMarkup() and toMultilineMarkup() methods are useful for turning normal Java Strings into HTML strings.

The lastPathComponent(), firstPathComponent(), afterFirstPathComponent() and beforeLastPathComponent() methods can chop up a String into path components using a separator character. If the separator cannot be found the original String is returned.

Similarly, the beforeLast(), beforeFirst(), afterFirst() and afterLast() methods return sections before and after a separator character. But if the separator cannot be found, an empty string is returned.

Some other miscellaneous methods will strip a given ending off a String if it can be found (stripEnding()), replace all occurrences of one String with another (replaceAll), do type conversions (toBoolean(), toChar(), toString()), check a String for emptiness (isEmpty()), convert a Throwable to a String (toString(Throwable)) or capitalize a String (capitalize()).

Author(s):
Jonathan Locke
52
  
53
  public final class Strings
54
  {
The line separator for the current platform. 
57
  
58
  	public static final String LINE_SEPARATOR;
A table of hex digits
60
  
61
  	private static final char[] hexDigit = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A',
62
  			'B', 'C', 'D', 'E', 'F' };
63
  
64
  	private static final Pattern htmlNumber = Pattern.compile("\\&\\#\\d+\\;");
65
  
66
  	static
67
  	{
68
  		 = (String)AccessController.doPrivileged(new PrivilegedAction()
69
  		{
70
  			public Object run()
71
  			{
72
  				return System.getProperty("line.separator");
73
  			}
74
  		});
75
  	}
Returns everything after the first occurrence of the given character in s.

Parameters:
s The string
c The character
Returns:
Everything after the first occurrence of the given character in s. If the character cannot be found, an empty string is returned.
86
  
87
  	public static String afterFirst(final String s, final char c)
88
  	{
89
  		if (s == null)
90
  		{
91
  			return null;
92
  		}
93
  		final int index = s.indexOf(c);
94
  
95
  		if (index == -1)
96
  		{
97
  			return "";
98
  		}
99
  
100
 		return s.substring(index + 1);
101
 	}
Gets everything after the first path component of a path using a given separator. If the separator cannot be found, an empty String is returned.

For example, afterFirstPathComponent("foo.bar.baz", '.') would return "bar.baz" and afterFirstPathComponent("foo", '.') would return "".

Parameters:
path The path to parse
separator The path separator character
Returns:
Everything after the first component in the path
115
 
116
 	public static String afterFirstPathComponent(final String path, final char separator)
117
 	{
118
 		return afterFirst(path, separator);
119
 	}
Returns everything after the last occurrence of the given character in s.

Parameters:
s The string
c The character
Returns:
Everything after the last occurrence of the given character in s. If the character cannot be found, an empty string is returned.
130
 
131
 	public static String afterLast(final String s, final char c)
132
 	{
133
 		if (s == null)
134
 		{
135
 			return null;
136
 		}
137
 		final int index = s.lastIndexOf(c);
138
 
139
 		if (index == -1)
140
 		{
141
 			return "";
142
 		}
143
 
144
 		return s.substring(index + 1);
145
 	}
Returns everything before the first occurrence of the given character in s.

Parameters:
s The string
c The character
Returns:
Everything before the first occurrence of the given character in s. If the character cannot be found, an empty string is returned.
156
 
157
 	public static String beforeFirst(final String s, final char c)
158
 	{
159
 		if (s == null)
160
 		{
161
 			return null;
162
 		}
163
 		final int index = s.indexOf(c);
164
 
165
 		if (index == -1)
166
 		{
167
 			return "";
168
 		}
169
 
170
 		return s.substring(0, index);
171
 	}
Returns everything before the last occurrence of the given character in s.

Parameters:
s The string
c The character
Returns:
Everything before the last occurrence of the given character in s. If the character cannot be found, an empty string is returned.
182
 
183
 	public static String beforeLast(final String s, final char c)
184
 	{
185
 		if (s == null)
186
 		{
187
 			return null;
188
 		}
189
 		final int index = s.lastIndexOf(c);
190
 
191
 		if (index == -1)
192
 		{
193
 			return "";
194
 		}
195
 
196
 		return s.substring(0, index);
197
 	}
Gets everything before the last path component of a path using a given separator. If the separator cannot be found, the path itself is returned.

For example, beforeLastPathComponent("foo.bar.baz", '.') would return "foo.bar" and beforeLastPathComponent("foo", '.') would return "".

Parameters:
path The path to parse
separator The path separator character
Returns:
Everything before the last component in the path
211
 
212
 	public static String beforeLastPathComponent(final String path, final char separator)
213
 	{
214
 		return beforeLast(path, separator);
215
 	}
Capitalizes a string.

Parameters:
s The string
Returns:
The capitalized string
223
 
224
 	public static String capitalize(final String s)
225
 	{
226
 		if (s == null)
227
 		{
228
 			return null;
229
 		}
230
 		final char[] chars = s.toCharArray();
231
 
232
 		if (chars.length > 0)
233
 		{
234
 			chars[0] = Character.toUpperCase(chars[0]);
235
 		}
236
 
237
 		return new String(chars);
238
 	}
Converts a Java String to an HTML markup string, but does not convert normal spaces to non-breaking space entities (<nbsp>).

Parameters:
s The string to escape
Returns:
The escaped string
See also:
escapeMarkup(java.lang.String,boolean)
248
 
249
 	public static CharSequence escapeMarkup(final String s)
250
 	{
251
 		return escapeMarkup(s, false);
252
 	}
Converts a Java String to an HTML markup String by replacing illegal characters with HTML entities where appropriate. Spaces are converted to non-breaking spaces (<nbsp>) if escapeSpaces is true, tabs are converted to four non-breaking spaces, less than signs are converted to &lt; entities and greater than signs to &gt; entities.

Parameters:
s The string to escape
escapeSpaces True to replace ' ' with nonbreaking space
Returns:
The escaped string
265
 
266
 	public static CharSequence escapeMarkup(final String s, final boolean escapeSpaces)
267
 	{
268
 		return escapeMarkup(s, escapeSpaces, false);
269
 	}
Converts a Java String to an HTML markup String by replacing illegal characters with HTML entities where appropriate. Spaces are converted to non-breaking spaces (<nbsp>) if escapeSpaces is true, tabs are converted to four non-breaking spaces, less than signs are converted to &lt; entities and greater than signs to &gt; entities.

Parameters:
s The string to escape
escapeSpaces True to replace ' ' with nonbreaking space
convertToHtmlUnicodeEscapes True to convert non-7 bit characters to unicode HTML (&#...)
Returns:
The escaped string
284
 
285
 	public static CharSequence escapeMarkup(final String s, final boolean escapeSpaces,
286
 		final boolean convertToHtmlUnicodeEscapes)
287
 	{
288
 		if (s == null)
289
 		{
290
 			return null;
291
 		}
292
 		else
293
 		{
294
 			int len = s.length();
295
 			final AppendingStringBuffer buffer = new AppendingStringBuffer((int)(len * 1.1));
296
 
297
 			for (int i = 0; i < len; i++)
298
 			{
299
 				final char c = s.charAt(i);
300
 
301
 				switch (c)
302
 				{
303
 					case '\t' :
304
 						if (escapeSpaces)
305
 						{
306
 							// Assumption is four space tabs (sorry, but that's
307
 							// just how it is!)
308
 							buffer.append("&nbsp;&nbsp;&nbsp;&nbsp;");
309
 						}
310
 						else
311
 						{
312
 							buffer.append(c);
313
 						}
314
 						break;
315
 
316
 					case ' ' :
317
 						if (escapeSpaces)
318
 						{
319
 							buffer.append("&nbsp;");
320
 						}
321
 						else
322
 						{
323
 							buffer.append(c);
324
 						}
325
 						break;
326
 
327
 					case '<' :
328
 						buffer.append("&lt;");
329
 						break;
330
 
331
 					case '>' :
332
 						buffer.append("&gt;");
333
 						break;
334
 
335
 					case '&' :
336
 
337
 						// if this is an entity (&#), then do not convert
338
 						if ((i < len - 1) && (s.charAt(i + 1) == '#'))
339
 						{
340
 							buffer.append(c);
341
 
342
 						}
343
 						else
344
 						{
345
 							// it is not an entity, so convert it to &amp;
346
 							buffer.append("&amp;");
347
 						}
348
 						break;
349
 
350
 					case '"' :
351
 						buffer.append("&quot;");
352
 						break;
353
 
354
 					case '\'' :
355
 						buffer.append("&#039;");
356
 						break;
357
 
358
 					default :
359
 
360
 						if (convertToHtmlUnicodeEscapes)
361
 						{
362
 							int ci = 0xffff & c;
363
 							if (ci < 160)
364
 							{
365
 								// nothing special only 7 Bit
366
 								buffer.append(c);
367
 							}
368
 							else
369
 							{
370
 								// Not 7 Bit use the unicode system
371
 								buffer.append("&#");
372
 								buffer.append(new Integer(ci).toString());
373
 								buffer.append(';');
374
 							}
375
 						}
376
 						else
377
 						{
378
 							buffer.append(c);
379
 						}
380
 
381
 						break;
382
 				}
383
 			}
384
 
385
 			return buffer;
386
 		}
387
 	}
Gets the first path component of a path using a given separator. If the separator cannot be found, the path itself is returned.

For example, firstPathComponent("foo.bar", '.') would return "foo" and firstPathComponent("foo", '.') would return "foo".

Parameters:
path The path to parse
separator The path separator character
Returns:
The first component in the path or path itself if no separator characters exist.
401
 
402
 	public static String firstPathComponent(final String path, final char separator)
403
 	{
404
 		if (path == null)
405
 		{
406
 			return null;
407
 		}
408
 		final int index = path.indexOf(separator);
409
 
410
 		if (index == -1)
411
 		{
412
 			return path;
413
 		}
414
 
415
 		return path.substring(0, index);
416
 	}
Converts encoded \uxxxx to unicode chars and changes special saved chars to their original forms.

Parameters:
escapedUnicodeString escaped unicode string, like '\u4F60\u597D'.
Returns:
The actual unicode. Can be used for instance with message bundles
426
 
427
 	public static String fromEscapedUnicode(String escapedUnicodeString)
428
 	{
429
 		int off = 0;
430
 		char[] in = escapedUnicodeString.toCharArray();
431
 		int len = in.length;
432
 		char[] convtBuf = new char[len];
433
 
434
 		if (convtBuf.length < len)
435
 		{
436
 			int newLen = len * 2;
437
 			if (newLen < 0)
438
 			{
439
 				newLen = .;
440
 			}
441
 			convtBuf = new char[newLen];
442
 		}
443
 		char aChar;
444
 		char[] out = convtBuf;
445
 		int outLen = 0;
446
 		int end = off + len;
447
 
448
 		while (off < end)
449
 		{
450
 			aChar = in[off++];
451
 			if (aChar == '\\')
452
 			{
453
 				aChar = in[off++];
454
 				if (aChar == 'u')
455
 				{
456
 					// Read the xxxx
457
 					int value = 0;
458
 					for (int i = 0; i < 4; i++)
459
 					{
460
 						aChar = in[off++];
461
 						switch (aChar)
462
 						{
463
 							case '0' :
464
 							case '1' :
465
 							case '2' :
466
 							case '3' :
467
 							case '4' :
468
 							case '5' :
469
 							case '6' :
470
 							case '7' :
471
 							case '8' :
472
 							case '9' :
473
 								value = (value << 4) + aChar - '0';
474
 								break;
475
 							case 'a' :
476
 							case 'b' :
477
 							case 'c' :
478
 							case 'd' :
479
 							case 'e' :
480
 							case 'f' :
481
 								value = (value << 4) + 10 + aChar - 'a';
482
 								break;
483
 							case 'A' :
484
 							case 'B' :
485
 							case 'C' :
486
 							case 'D' :
487
 							case 'E' :
488
 							case 'F' :
489
 								value = (value << 4) + 10 + aChar - 'A';
490
 								break;
491
 							default :
492
 								throw new IllegalArgumentException("Malformed \\uxxxx encoding.");
493
 						}
494
 					}
495
 					out[outLen++] = (char)value;
496
 				}
497
 				else
498
 				{
499
 					if (aChar == 't')
500
 					{
501
 						aChar = '\t';
502
 					}
503
 					else if (aChar == 'r')
504
 					{
505
 						aChar = '\r';
506
 					}
507
 					else if (aChar == 'n')
508
 					{
509
 						aChar = '\n';
510
 					}
511
 					else if (aChar == 'f')
512
 					{
513
 						aChar = '\f';
514
 					}
515
 					out[outLen++] = aChar;
516
 				}
517
 			}
518
 			else
519
 			{
520
 				out[outLen++] = aChar;
521
 			}
522
 		}
523
 		return new String(out, 0, outLen);
524
 	}
Checks whether the string is considered empty. Empty means that the string may contain whitespace, but no visible characters. "\n\t " is considered empty, while " a" is not.

Parameters:
string The string
Returns:
True if the string is null or ""
535
 
536
 	public static boolean isEmpty(final CharSequence string)
537
 	{
538
 		return string == null || string.length() == 0 || string.toString().trim().length() == 0;
539
 	}
Checks whether two strings are equals taken care of 'null' values and treating 'null' same as trim(string).equals("")

Parameters:
string1
string2
Returns:
true, if both strings are equal
548
 
549
 	public static boolean isEqual(final String string1, final String string2)
550
 	{
551
 		if ((string1 == null) && (string2 == null))
552
 		{
553
 			return true;
554
 		}
555
 
556
 		if (isEmpty(string1) && isEmpty(string2))
557
 		{
558
 			return true;
559
 		}
560
 		if (string1 == null || string2 == null)
561
 		{
562
 			return false;
563
 		}
564
 
565
 		return string1.equals(string2);
566
 	}
Converts the text in s to a corresponding boolean. On, yes, y, true and 1 are converted to true. Off, no, n, false and 0 (zero) are converted to false. An empty string is converted to false. Conversion is case-insensitive, and does not take internationalization into account. 'Ja', 'Oui', 'Igen', 'Nein', 'Nee', 'Non', 'Nem' are all illegal values.

Parameters:
s the value to convert into a boolean
Returns:
Boolean the converted value of s
Throws:
StringValueConversionException when the value of s is not recognized.
581
 
582
 	public static boolean isTrue(final String s) throws StringValueConversionException
583
 	{
584
 		if (s != null)
585
 		{
586
 			if (s.equalsIgnoreCase("true"))
587
 			{
588
 				return true;
589
 			}
590
 
591
 			if (s.equalsIgnoreCase("false"))
592
 			{
593
 				return false;
594
 			}
595
 
596
 			if (s.equalsIgnoreCase("on") || s.equalsIgnoreCase("yes") || s.equalsIgnoreCase("y") ||
598
 			{
599
 				return true;
600
 			}
601
 
602
 			if (s.equalsIgnoreCase("off") || s.equalsIgnoreCase("no") || s.equalsIgnoreCase("n") ||
604
 			{
605
 				return false;
606
 			}
607
 
608
 			if (isEmpty(s))
609
 			{
610
 				return false;
611
 			}
612
 
613
 			throw new StringValueConversionException("Boolean value \"" + s + "\" not recognized");
614
 		}
615
 
616
 		return false;
617
 	}
Joins string fragments using the specified separator

Parameters:
separator
fragments
Returns:
combined fragments
625
 
626
 	public static String join(String separator, String[] fragments)
627
 	{
628
 		if (fragments.length < 1)
629
 		{
630
 			// no elements
631
 			return "";
632
 		}
633
 		else if (fragments.length < 2)
634
 		{
635
 			// single element
636
 			return fragments[0];
637
 		}
638
 		else
639
 		{
640
 			// two or more elements
641
 			StringBuffer buff = new StringBuffer(128);
642
 			if (fragments[0] != null)
643
 			{
644
 				buff.append(fragments[0]);
645
 			}
646
 			for (int i = 1; i < fragments.length; i++)
647
 			{
648
 				if ((fragments[i - 1] != null) || (fragments[i] != null))
649
 				{
650
 					boolean lhsClosed = fragments[i - 1].endsWith(separator);
651
 					boolean rhsClosed = fragments[i].startsWith(separator);
652
 					if (lhsClosed && rhsClosed)
653
 					{
654
 						buff.append(fragments[i].substring(1));
655
 					}
656
 					else if (!lhsClosed && !rhsClosed)
657
 					{
658
 						buff.append(separator).append(fragments[i]);
659
 					}
660
 					else
661
 					{
662
 						buff.append(fragments[i]);
663
 					}
664
 				}
665
 			}
666
 			return buff.toString();
667
 		}
668
 	}
Gets the last path component of a path using a given separator. If the separator cannot be found, the path itself is returned.

For example, lastPathComponent("foo.bar", '.') would return "bar" and lastPathComponent("foo", '.') would return "foo".

Parameters:
path The path to parse
separator The path separator character
Returns:
The last component in the path or path itself if no separator characters exist.
682
 
683
 	public static String lastPathComponent(final String path, final char separator)
684
 	{
685
 		if (path == null)
686
 		{
687
 			return null;
688
 		}
689
 
690
 		final int index = path.lastIndexOf(separator);
691
 
692
 		if (index == -1)
693
 		{
694
 			return path;
695
 		}
696
 
697
 		return path.substring(index + 1);
698
 	}
Replace all occurrences of one string replaceWith another string.

Parameters:
s The string to process
searchFor The value to search for
replaceWith The value to searchFor replaceWith
Returns:
The resulting string with searchFor replaced with replaceWith
710
 
711
 	public static CharSequence replaceAll(final CharSequence s, final CharSequence searchFor,
712
 		CharSequence replaceWith)
713
 	{
714
 		if (s == null)
715
 		{
716
 			return null;
717
 		}
718
 
719
 		// If searchFor is null or the empty string, then there is nothing to
720
 		// replace, so returning s is the only option here.
721
 		if (searchFor == null || "".equals(searchFor))
722
 		{
723
 			return s;
724
 		}
725
 
726
 		// If replaceWith is null, then the searchFor should be replaced with
727
 		// nothing, which can be seen as the empty string.
728
 		if (replaceWith == null)
729
 		{
730
 			replaceWith = "";
731
 		}
732
 
733
 		String searchString = searchFor.toString();
734
 		// Look for first occurrence of searchFor
735
 		int matchIndex = search(s, searchString, 0);
736
 		if (matchIndex == -1)
737
 		{
738
 			// No replace operation needs to happen
739
 			return s;
740
 		}
741
 		else
742
 		{
743
 			// Allocate a AppendingStringBuffer that will hold one replacement
744
 			// with a
745
 			// little extra room.
746
 			int size = s.length();
747
 			final int replaceWithLength = replaceWith.length();
748
 			final int searchForLength = searchFor.length();
749
 			if (replaceWithLength > searchForLength)
750
 			{
751
 				size += (replaceWithLength - searchForLength);
752
 			}
753
 			final AppendingStringBuffer buffer = new AppendingStringBuffer(size + 16);
754
 
755
 			int pos = 0;
756
 			do
757
 			{
758
 				// Append text up to the match`
759
 				append(buffer, s, pos, matchIndex);
760
 
761
 				// Add replaceWith text
762
 				buffer.append(replaceWith);
763
 
764
 				// Find next occurrence, if any
765
 				pos = matchIndex + searchForLength;
766
 				matchIndex = search(s, searchString, pos);
767
 			}
768
 			while (matchIndex != -1);
769
 
770
 			// Add tail of s
771
 			buffer.append(s.subSequence(pos, s.length()));
772
 
773
 			// Return processed buffer
774
 			return buffer;
775
 		}
776
 	}
Replace HTML numbers like 值 by the appropriate character.

Parameters:
str The text to be evaluated
Returns:
The text with "numbers" replaced
784
 
785
 	public static String replaceHtmlEscapeNumber(String str)
786
 	{
787
 		if (str == null)
788
 		{
789
 			return null;
790
 		}
791
 		Matcher matcher = .matcher(str);
792
 		while (matcher.find())
793
 		{
794
 			int pos = matcher.start();
795
 			int end = matcher.end();
796
 			int number = Integer.parseInt(str.substring(pos + 2, end - 1));
797
 			char ch = (char)number;
798
 			str = str.substring(0, pos) + ch + str.substring(end);
799
 			matcher = .matcher(str);
800
 		}
801
 
802
 		return str;
803
 	}
Simpler, faster version of String.split() for splitting on a simple character.

Parameters:
s The string to split
c The character to split on
Returns:
The array of strings
813
 
814
 	public static String[] split(final String s, final char c)
815
 	{
816
 		if (s == null)
817
 		{
818
 			return new String[0];
819
 		}
820
 		final List strings = new ArrayList();
821
 		int pos = 0;
822
 		while (true)
823
 		{
824
 			int next = s.indexOf(c, pos);
825
 			if (next == -1)
826
 			{
827
 				strings.add(s.substring(pos));
828
 				break;
829
 			}
830
 			else
831
 			{
832
 				strings.add(s.substring(pos, next));
833
 			}
834
 			pos = next + 1;
835
 		}
836
 		final String[] result = new String[strings.size()];
837
 		strings.toArray(result);
838
 		return result;
839
 	}
Strips the ending from the string s.

Parameters:
s The string to strip
ending The ending to strip off
Returns:
The stripped string or the original string if the ending did not exist
849
 
850
 	public static String stripEnding(final String s, final String ending)
851
 	{
852
 		if (s == null)
853
 		{
854
 			return null;
855
 		}
856
 
857
 		// Stripping a null or empty string from the end returns the
858
 		// original string.
859
 		if (ending == null || "".equals(ending))
860
 		{
861
 			return s;
862
 		}
863
 		final int endingLength = ending.length();
864
 		final int sLength = s.length();
865
 
866
 		// When the length of the ending string is larger
867
 		// than the original string, the original string is returned.
868
 		if (endingLength > sLength)
869
 		{
870
 			return s;
871
 		}
872
 		final int index = s.lastIndexOf(ending);
873
 		final int endpos = sLength - endingLength;
874
 
875
 		if (index == endpos)
876
 		{
877
 			return s.substring(0, endpos);
878
 		}
879
 
880
 		return s;
881
 	}
Strip any jsessionid and possibly other redundant info that might be in our way.

Parameters:
url The url to strip
Returns:
The stripped url
889
 
890
 	public static String stripJSessionId(CharSequence url)
891
 	{
892
 		if (url == null)
893
 		{
894
 			return null;
895
 		}
896
 		StringBuffer path = new StringBuffer(url.toString());
897
 		int ixSemiColon = path.indexOf(";");
898
 		// strip off any jsession id
899
 		if (ixSemiColon != -1)
900
 		{
901
 			int ixEnd = path.indexOf("?");
902
 			// there is no ? in the path so set it to the length (no arguments)
903
 			if (ixEnd == -1)
904
 				ixEnd = path.length();
905
 
906
 
907
 			if (ixEnd <= ixSemiColon)
908
 			{
909
 				// ? is before ; - no jsessionid in the url
910
 				return url.toString();
911
 			}
912
 
913
 			if (ixEnd == -1)
914
 			{
915
 				ixEnd = path.length();
916
 			}
917
 
918
 			path.delete(ixSemiColon, ixEnd);
919
 		}
920
 		return path.toString();
921
 	}
Converts the string s to a Boolean. See isTrue for valid values of s.

Parameters:
s The string to convert.
Returns:
Boolean TRUE when isTrue(s).
Throws:
StringValueConversionException when s is not a valid value
See also:
isTrue(java.lang.String)
933
 
934
 	public static Boolean toBoolean(final String s) throws StringValueConversionException
935
 	{
936
 		return Boolean.valueOf(isTrue(s));
937
 	}
Converts the 1 character string s to a character.

Parameters:
s The 1 character string to convert to a char.
Returns:
Character value to convert
Throws:
StringValueConversionException when the string is longer or shorter than 1 character, or null.
947
 
948
 	public static char toChar(final String s) throws StringValueConversionException
949
 	{
950
 		if (s != null)
951
 		{
952
 			if (s.length() == 1)
953
 			{
954
 				return s.charAt(0);
955
 			}
956
 			else
957
 			{
958
 				throw new StringValueConversionException("Expected single character, not \"" + s +
959
 					"\"");
960
 			}
961
 		}
962
 
963
 		throw new StringValueConversionException("Character value was null");
964
 	}
Converts unicodes to encoded \uxxxx.

Parameters:
unicodeString The unicode string
Returns:
The escaped unicode string, like '\u4F60\u597D'.
972
 
973
 	public static String toEscapedUnicode(String unicodeString)
974
 	{
975
 		if ((unicodeString == null) || (unicodeString.length() == 0))
976
 		{
977
 			return unicodeString;
978
 		}
979
 		int len = unicodeString.length();
980
 		int bufLen = len * 2;
981
 		StringBuffer outBuffer = new StringBuffer(bufLen);
982
 		for (int x = 0; x < len; x++)
983
 		{
984
 			char aChar = unicodeString.charAt(x);
985
 			// Handle common case first, selecting largest block that
986
 			// avoids the specials below
987
 			if ((aChar > 61) && (aChar < 127))
988
 			{
989
 				if (aChar == '\\')
990
 				{
991
 					outBuffer.append('\\');
992
 					outBuffer.append('\\');
993
 					continue;
994
 				}
995
 				outBuffer.append(aChar);
996
 				continue;
997
 			}
998
 			switch (aChar)
999
 			{
1000
				case ' ' :
1001
					if (x == 0)
1003
						outBuffer.append('\\');
1005
					outBuffer.append(' ');
1006
					break;
1007
				case '\t' :
1008
					outBuffer.append('\\');
1009
					outBuffer.append('t');
1010
					break;
1011
				case '\n' :
1012
					outBuffer.append('\\');
1013
					outBuffer.append('n');
1014
					break;
1015
				case '\r' :
1016
					outBuffer.append('\\');
1017
					outBuffer.append('r');
1018
					break;
1019
				case '\f' :
1020
					outBuffer.append('\\');
1021
					outBuffer.append('f');
1022
					break;
1023
				case '=' : // Fall through
1024
				case ':' : // Fall through
1025
				case '#' : // Fall through
1026
				case '!' :
1027
					outBuffer.append('\\');
1028
					outBuffer.append(aChar);
1029
					break;
1030
				default :
1031
					if ((aChar < 0x0020) || (aChar > 0x007e))
1033
						outBuffer.append('\\');
1034
						outBuffer.append('u');
1035
						outBuffer.append(toHex((aChar >> 12) & 0xF));
1036
						outBuffer.append(toHex((aChar >> 8) & 0xF));
1037
						outBuffer.append(toHex((aChar >> 4) & 0xF));
1038
						outBuffer.append(toHex(aChar & 0xF));
1040
					else
1042
						outBuffer.append(aChar);
1046
		return outBuffer.toString();
1047
	}
Converts a String to multiline HTML markup by replacing newlines with line break entities (<br/>) and multiple occurrences of newline with paragraph break entities (<p>).

Parameters:
s String to transform
Returns:
String with all single occurrences of newline replaced with <br/> and all multiple occurrences of newline replaced with <p>.
1058
	public static CharSequence toMultilineMarkup(final CharSequence s)
1060
		if (s == null)
1062
			return null;
1066
		int newlineCount = 0;
1068
		buffer.append("<p>");
1069
		for (int i = 0; i < s.length(); i++)
1071
			final char c = s.charAt(i);
1073
			switch (c)
1075
				case '\n' :
1076
					newlineCount++;
1077
					break;
1079
				case '\r' :
1080
					break;
1082
				default :
1083
					if (newlineCount == 1)
1085
						buffer.append("<br/>");
1087
					else if (newlineCount > 1)
1089
						buffer.append("</p><p>");
1092
					buffer.append(c);
1093
					newlineCount = 0;
1094
					break;
1097
		if (newlineCount == 1)
1099
			buffer.append("<br/>");
1101
		else if (newlineCount > 1)
1103
			buffer.append("</p><p>");
1105
		buffer.append("</p>");
1106
		return buffer;
1107
	}
Converts the given object to a string. Does special conversion for throwables and String arrays of length 1 (in which case it just returns to string in that array, as this is a common thing to have in the Servlet API).

Parameters:
object The object
Returns:
The string
1118
	public static String toString(final Object object)
1120
		if (object == null)
1122
			return null;
1125
		if (object instanceof Throwable)
1127
			return toString((Throwable)object);
1130
		if (object instanceof String)
1132
			return (String)object;
1135
		if (object instanceof String[] && ((String[])object).length == 1)
1137
			return ((String[])object)[0];
1140
		return object.toString();
1141
	}
Creates a location stacktrace string representation for the component for reference when the render check fails. This method filters out most of the unnecessary parts of the stack trace. The message of the location is used as a verb in the rendered string. Use "added", "constructed" or similar verbs as values.

Parameters:
component the component that was constructed or added and failed to render
location the location where the component was created or added in the java code.
Returns:
a string giving the line precise location where the component was added or created.
1155
	public static String toString(final Component component, final Throwable location)
1157
		Class componentClass = component.getClass();
1159
		// try to find the component type, if it is an inner element, then get
1160
		// the parent component.
1161
		String componentType = componentClass.getName();
1162
		if (componentType.indexOf('$') >= 0)
1164
			componentType = componentClass.getSuperclass().getName();
1167
		componentType = componentType.substring(componentType.lastIndexOf('.') + 1);
1169
		// create a user friendly message, using the location's message as a
1170
		// differentiator for the message (e.g. "component foo was ***added***"
1171
		// or "component foo was ***created***")
1172
		AppendingStringBuffer sb = new AppendingStringBuffer("The " + componentType.toLowerCase() +
1173
			" with id '" + component.getId() + "' that failed to render was " +
1174
			location.getMessage() + "\n");
1176
		// a list of stacktrace elements that need to be skipped in the location
1177
		// stack trace
1178
		String[] skippedElements = new String[] { "org.apache.wicket.MarkupContainer",
1179
				"org.apache.wicket.Component", "org.apache.wicket.markup" };
1181
		// a list of stack trace elements that stop the traversal of the stack
1182
		// trace
1183
		String[] breakingElements = new String[] { "org.apache.wicket.protocol.http.WicketServlet",
1184
				"org.apache.wicket.protocol.http.WicketFilter", "java.lang.reflect" };
1186
		StackTraceElement[] trace = location.getStackTrace();
1187
		for (int i = 0; i < trace.length; i++)
1189
			String traceString = trace[i].toString();
1190
			if (shouldSkip(traceString, skippedElements))
1192
				// don't print this line, is wicket internal
1193
				continue;
1196
			if (!(traceString.startsWith("sun.reflect.") && i > 1))
1198
				// filter out reflection API calls from the stack trace
1199
				if (traceString.indexOf("java.lang.reflect") < 0)
1201
					sb.append("     at ");
1202
					sb.append(traceString);
1203
					sb.append("\n");
1205
				if (shouldSkip(traceString, breakingElements))
1207
					break;
1211
		sb.append("\n");
1212
		return sb.toString();
1215
	private static boolean shouldSkip(String text, String[] filters)
1217
		for (int i = 0; i < filters.length; i++)
1219
			if (text.indexOf(filters[i]) >= 0)
1221
				return true;
1224
		return false;
1225
	}
Converts a Throwable to a string.

Parameters:
throwable The throwable
Returns:
The string
1234
	public static String toString(final Throwable throwable)
1236
		if (throwable != null)
1238
			ArrayList al = new ArrayList();
1239
			Throwable cause = throwable;
1240
			al.add(cause);
1241
			while (cause.getCause() != null && cause != cause.getCause())
1243
				cause = cause.getCause();
1244
				al.add(cause);
1248
			// first print the last cause
1249
			int length = al.size() - 1;
1250
			cause = (Throwable)al.get(length);
1251
			if (throwable instanceof WicketRuntimeException)
1253
				sb.append("WicketMessage: ");
1254
				sb.append(throwable.getMessage());
1255
				sb.append("\n\n");
1257
			sb.append("Root cause:\n\n");
1258
			outputThrowable(cause, sb, false);
1260
			if (length > 0)
1262
				sb.append("\n\nComplete stack:\n\n");
1263
				for (int i = 0; i < length; i++)
1265
					outputThrowable((Throwable)al.get(i), sb, true);
1266
					sb.append("\n");
1269
			return sb.toString();
1271
		else
1273
			return "<Null Throwable>";
1277
	private static void append(AppendingStringBuffer buffer, CharSequence s, int from, int to)
1279
		if (s instanceof AppendingStringBuffer)
1282
			buffer.append(asb.getValue(), from, to - from);
1284
		else if (s instanceof StringBuffer)
1286
			buffer.append((StringBuffer)s, from, to - from);
1288
		else
1290
			buffer.append(s.subSequence(from, to));
1292
	}
Outputs the throwable and its stacktrace to the stringbuffer. If stopAtWicketSerlvet is true then the output will stop when the org.apache.wicket servlet is reached. sun.reflect. packages are filtered out.

Parameters:
cause
sb
stopAtWicketServlet
1303
	private static void outputThrowable(Throwable cause, AppendingStringBuffer sb,
1304
		boolean stopAtWicketServlet)
1306
		sb.append(cause);
1307
		sb.append("\n");
1308
		StackTraceElement[] trace = cause.getStackTrace();
1309
		for (int i = 0; i < trace.length; i++)
1311
			String traceString = trace[i].toString();
1312
			if (!(traceString.startsWith("sun.reflect.") && i > 1))
1314
				sb.append("     at ");
1315
				sb.append(traceString);
1316
				sb.append("\n");
1317
				if (stopAtWicketServlet &&
1318
					(traceString.startsWith("org.apache.wicket.protocol.http.WicketServlet") || traceString.startsWith("org.apache.wicket.protocol.http.WicketFilter")))
1320
					return;
1326
	private static int search(final CharSequence s, String searchString, int pos)
1328
		int matchIndex = -1;
1329
		if (s instanceof String)
1331
			matchIndex = ((String)s).indexOf(searchString, pos);
1333
		else if (s instanceof StringBuffer)
1335
			matchIndex = ((StringBuffer)s).indexOf(searchString, pos);
1337
		else if (s instanceof AppendingStringBuffer)
1339
			matchIndex = ((AppendingStringBuffer)s).indexOf(searchString, pos);
1341
		else
1343
			matchIndex = s.toString().indexOf(searchString, pos);
1345
		return matchIndex;
1346
	}
Convert a nibble to a hex character

Parameters:
nibble the nibble to convert.
Returns:
hex character
1355
	private static char toHex(int nibble)
1357
		return [(nibble & 0xF)];
1358
	}
Calculates the length of string in bytes, uses specified charset if provided.

Parameters:
string
charset (optional) character set to use when converting string to bytes
Returns:
length of string in bytes
1368
	public static int lengthInBytes(String string, Charset charset)
1370
		if (string == null)
1372
			throw new NullPointerException("Argument `string` cannot be null");
1374
		if (charset != null)
1376
			try
1378
				return string.getBytes(charset.name()).length;
1383
					"StringResourceStream created with unsupported charset: " + charset.name());
1386
		else
1388
			return string.getBytes().length;
1391
	}
Private constructor prevents construction. 
1396
	private Strings()
New to GrepCode? Check out our FAQ X