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
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231 | package Torello.Java;
import static Torello.Java.StrCmpr.AND;
import static Torello.Java.StrCmpr.OR;
import static Torello.Java.StrCmpr.XOR;
import static Torello.Java.StrCmpr.NAND;
class CmprCN
{
// This method remains 'protected'} because it utilizes a specialized Loop-Control
// Variable Class Version of 'LV'}. It is used internally by the search methods above.
static boolean contains(
final String srcStr,
final LV l,
final String compareStr
)
{
// String.regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)
// Tests if two string regions are equal. A substring of this String object is
// compared to a substring of the argument other. The result is true if these substrings
// represent character sequences that are the same, ignoring case if and only if ignoreCase
// is true.
final int compareStrLen = compareStr.length();
final int loopLen = l.end - compareStrLen;
if ((l.end - l.start) < compareStrLen) return false;
for (int i=l.start; i <= loopLen; i++)
if (srcStr.regionMatches(i, compareStr, 0, compareStrLen))
return true;
return false;
}
// This method remains 'protected'} because it utilizes a specialized Loop-Control
// Variable Class Version of 'LV'}. It is used internally by the search methods above.
static boolean containsIgnoreCase(
final String srcStr,
final LV l,
final String compareStr
)
{
// String.regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)
// Tests if two string regions are equal. A substring of this String object is
// compared to a substring of the argument other. The result is true if these substrings
// represent character sequences that are the same, ignoring case if and only if ignoreCase
// is true.
final int compareStrLen = compareStr.length();
final int loopLen = l.end - compareStrLen;
if ((l.end - l.start) < compareStrLen) return false;
for (int i=l.start; i <= loopLen; i++)
if (srcStr.regionMatches(true, i, compareStr, 0, compareStrLen))
return true;
return false;
}
// This is sort-of overkill. It is better to error in favor of caution, than to pretend.
// I guess... :)
private static final String CONTAINS_EX =
"The value passed to parameter 'booleanOperation' was [BOOL]." +
"However, this parameter is intended to must be chosen from one of the four boolean " +
"static-constants available in this class. Valid values for this parameter include: " +
"StrCmpr.AND, StrCmpr.OR, StrCmpr.XOR and StrCmpr.NAND.";
/**
* Implementing a 'contains' is more efficient by performing only one loop iteration.
* Therefore, the methods that implement some variant of the String.contains method
* will use this general-purpose contains-testing method.
* @param ignoresCase This is used to signify whether to ignore case when performing the
* String-comparison operations.
* @param booleanOperation This is designed to take one of four values. This method will
* throw an exception if it does not.
* @param l Loop end-point parameter
* @param srcStr Any non-null instance of java.lang.String
* @param cmpStrs This is one (or many) java String's, each of which shall be
* compared to the ending of 'srcStr'.
* @return The appropriate response based on the inputs for boolean logic.
*/
static boolean CONTAINS(
final boolean ignoresCase,
final byte booleanOperation,
final LV l,
final String srcStr,
final String[] cmpStrs
)
{
// Check each of the compare-strs first. It will provide a better exception message
for (String s : cmpStrs)
if (s == null) throw new NullPointerException
("One of the elements of 'compareStr' was null");
if ((booleanOperation < 0) || (booleanOperation > 3))
throw new IllegalArgumentException
(CONTAINS_EX.replace("BOOL", "" + booleanOperation));
int count = (booleanOperation == XOR) ? 0 : cmpStrs.length;
// cmpStrs = cmpStrs.clone();
// Iterate each character in the String, and use it as the start to "regionMatches"
for (int i=l.start; i < l.end; i++)
INNER:
// Iterate each of the "compareison strings" - each are passed to "regionMatches"
for (int j=0; j < cmpStrs.length; j++)
// The Strings in Compare-Str are sometimes set to null, if they are skip them
if (cmpStrs[j] != null)
if (srcStr.regionMatches(ignoresCase, i, cmpStrs[j], 0, cmpStrs[j].length()))
switch (booleanOperation)
{
case AND :
cmpStrs[j]=null; // no need to check for it again
if (--count == 0) return true;
else continue INNER; // test-all cmpStrs
case XOR :
cmpStrs[j]=null; // no need to check for it again
if (++count > 1) return false;
else continue INNER; // test-all cmpStrs
case OR : return true;
case NAND : return false;
}
switch(booleanOperation)
{
case AND : return false;
case OR : return false;
case XOR : return count == 1;
case NAND : return true;
}
// Already Checked boolean-operation, there is no way to reach this line of code.
throw new UnreachableError();
}
/**
* Implementing a 'contains' is more efficient by performing only one loop iteration.
* Therefore, the methods that implement some variant of the String.contains method
* will use this general-purpose contains-testing method.
* @param ignoresCase This is used to signify whether to ignore case when performing the
* String-comparison operations.
* @param booleanOperation This is designed to take one of four values. This method will
* throw an exception if it does not.
* @param srcStr Any non-null instance of java.lang.String
* @param cmpStrs This is one (or many) java String's, each of which shall be
* compared to the ending of 'srcStr'.
* @return The appropriate response based on the inputs for boolean logic.
*/
static boolean CONTAINS(
final boolean ignoresCase,
final byte booleanOperation,
final String srcStr,
final String[] cmpStrs
)
{
// Check each of the compare-strs first. It will provide a better exception message
for (String s : cmpStrs)
if (s == null) throw new NullPointerException
("One of the elements of 'compareStr' was null");
if ((booleanOperation < 0) || (booleanOperation > 3))
throw new IllegalArgumentException
(CONTAINS_EX.replace("BOOL", "" + booleanOperation));
final int len = srcStr.length();
int count = (booleanOperation == XOR) ? 0 : cmpStrs.length;
// cmpStrs = cmpStrs.clone();
// Iterate each character in the String, and use it as the start to "regionMatches"
for (int i=0; i < len; i++)
INNER:
// Iterate each of the "compareison strings" - each are passed to "regionMatches"
for (int j=0; j < cmpStrs.length; j++)
// The Strings in Compare-Str are sometimes set to null, if they are skip them
if (cmpStrs[j] != null)
if (srcStr.regionMatches(ignoresCase, i, cmpStrs[j], 0, cmpStrs[j].length()))
switch (booleanOperation)
{
case AND :
cmpStrs[j]=null; // no need to check for it again
if (--count == 0) return true;
else continue INNER; // test-all cmpStrs
case XOR :
cmpStrs[j]=null; // no need to check for it again
if (++count > 1) return false;
else continue INNER; // test-all cmpStrs
case OR : return true;
case NAND : return false;
}
switch(booleanOperation)
{
case AND : return false;
case OR : return false;
case XOR : return count == 1;
case NAND : return true;
}
// Already Checked boolean-operation, there is no way to reach this line of code.
throw new UnreachableError();
}
}
|