1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
|
package bjc.utils.funcutils;
import com.ibm.icu.text.BreakIterator;
import java.util.Deque;
/**
* Utility methods for operations on strings
*
* @author ben
*
*/
public class StringUtils {
/**
* Check if a string consists only of one or more matches of a regular
* expression
*
* @param input
* The string to check
* @param rRegex
* The regex to see if the string only contains matches of
* @return Whether or not the string consists only of multiple matches of
* the provided regex
*/
public static boolean containsOnly(String input, String rRegex) {
if (input == null)
throw new NullPointerException("Input must not be null");
else if (rRegex == null)
throw new NullPointerException("Regex must not be null");
/*
* This regular expression is fairly simple.
*
* First, we match the beginning of the string. Then, we start a
* non-capturing group whose contents are the passed in regex. That
* group is then matched one or more times and the pattern matches to
* the end of the string
*/
return input.matches("\\A(?:" + rRegex + ")+\\Z");
}
/**
* Indent the string being built in a StringBuilder n levels
*
* @param builder
* The builder to indent in
* @param levels
* The number of levels to indent
*/
public static void indentNLevels(StringBuilder builder, int levels) {
for (int i = 0; i < levels; i++) {
builder.append("\t");
}
}
/**
* Print out a deque with a special case for easily showing a deque is empty
*
* @param <ContainedType>
* The type in the deque
* @param queue
* The deque to print
* @return A string version of the deque, with allowance for an empty deque
*/
public static <ContainedType> String printDeque(Deque<ContainedType> queue) {
return queue.isEmpty() ? "(none)" : queue.toString();
}
/**
* Converts a sequence to an English list.
*
* @param objects
* The sequence to convert to an English list.
* @param join
* The string to use for separating the last element from the
* rest.
* @param comma
* The string to use as a comma
*
* @return The sequence as an English list.
*/
public static String toEnglishList(Object[] objects, String join, String comma) {
if (objects == null) {
throw new NullPointerException("Sequence must not be null");
}
StringBuilder sb = new StringBuilder();
String joiner = join;
String coma = comma;
switch (objects.length) {
case 0:
/*
* Empty list.
*/
break;
case 1:
/*
* One item.
*/
sb.append(objects[0].toString());
break;
case 2:
/*
* Two items.
*/
sb.append(objects[0].toString());
sb.append(" " + joiner + " ");
sb.append(objects[1].toString());
break;
default:
/*
* Three or more items.
*/
for (int i = 0; i < objects.length - 1; i++) {
sb.append(objects[i].toString());
sb.append(coma + " ");
}
/*
* Uncomment this to remove serial commas.
*
* int lc = sb.length() - 1;
*
* sb.delete(lc - coma.length(), lc);
*/
sb.append(joiner + " ");
sb.append(objects[objects.length - 1].toString());
}
return sb.toString();
}
/**
* Converts a sequence to an English list.
*
* @param objects
* The sequence to convert to an English list.
* @param join
* The string to use for separating the last element from the
* rest.
*
* @return The sequence as an English list.
*/
public static String toEnglishList(Object[] objects, String join) {
return toEnglishList(objects, join, ",");
}
/**
* Converts a sequence to an English list.
*
* @param objects
* The sequence to convert to an English list.
* @param and
* Whether to use 'and' or 'or'.
*
* @return The sequence as an English list.
*/
public static String toEnglishList(Object[] objects, boolean and) {
if (and) {
return toEnglishList(objects, "and");
} else {
return toEnglishList(objects, "or");
}
}
/**
* Count the number of graphemes in a string.
*
* @param value
* The string to check.
*
* @return The number of graphemes in the string.
*/
public static int graphemeCount(String value) {
BreakIterator it = BreakIterator.getCharacterInstance();
it.setText(value);
int count = 0;
while (it.next() != BreakIterator.DONE) {
count++;
}
return count;
}
}
|
