private static void generateNameByString(
Set<String> possibleNames,
String value,
NameValidator validator,
boolean forStaticVariable,
Project project) {
if (!JavaPsiFacade.getInstance(project).getNameHelper().isIdentifier(value)) return;
if (forStaticVariable) {
StringBuilder buffer = new StringBuilder(value.length() + 10);
char[] chars = new char[value.length()];
value.getChars(0, value.length(), chars, 0);
boolean wasLow = Character.isLowerCase(chars[0]);
buffer.append(Character.toUpperCase(chars[0]));
for (int i = 1; i < chars.length; i++) {
if (Character.isUpperCase(chars[i])) {
if (wasLow) {
buffer.append('_');
wasLow = false;
}
} else {
wasLow = true;
}
buffer.append(Character.toUpperCase(chars[i]));
}
possibleNames.add(validator.validateName(buffer.toString(), true));
} else {
possibleNames.add(validator.validateName(value, true));
}
}
static ByteStream pack(String format, FormatDef[] f, int size, int start, PyObject[] args) {
ByteStream res = new ByteStream();
int i = start;
int len = format.length();
for (int j = 0; j < len; j++) {
char c = format.charAt(j);
if (j == 0 && (c == '@' || c == '<' || c == '>' || c == '=' || c == '!')) continue;
if (Character.isWhitespace(c)) continue;
int num = 1;
if (Character.isDigit(c)) {
num = Character.digit(c, 10);
while (++j < len && Character.isDigit((c = format.charAt(j))))
num = num * 10 + Character.digit(c, 10);
if (j >= len) break;
}
FormatDef e = getentry(c, f);
// Fill pad bytes with zeros
int nres = align(res.size(), e) - res.size();
while (nres-- > 0) res.writeByte(0);
i += e.doPack(res, num, i, args);
}
if (i < args.length) throw StructError("too many arguments for pack format");
return res;
}
static Integer helper(int i, StringBuilder sb, String s) {
if (i == s.length()) {
return decode(sb.toString());
}
if (!Character.isLetter(s.charAt(i))) {
sb.append(s.charAt(i));
Integer result = helper(i + 1, sb, s);
if (result != null) {
return result;
}
} else {
char ch = s.charAt(i);
sb.append(Character.toUpperCase(ch));
Integer result = helper(i + 1, sb, s);
if (result != null) {
return result;
}
sb.deleteCharAt(sb.length() - 1);
sb.append(Character.toLowerCase(ch));
result = helper(i + 1, sb, s);
if (result != null) {
return result;
}
sb.deleteCharAt(sb.length() - 1);
}
return null;
}
private List getSubpaths(String paramString) {
int i = 0;
int j = paramString.length();
ArrayList localArrayList = new ArrayList();
while (i < j) {
while ((i < j) && (Character.isWhitespace(paramString.charAt(i)))) i++;
if (i >= j) continue;
int k = i;
int m = k;
String str = null;
while (i < j) {
char c = paramString.charAt(i);
if ((c == '\\') && (i + 1 < j) && (paramString.charAt(i + 1) == ' ')) {
if (str == null) str = paramString.substring(m, i);
else str = str + paramString.substring(m, i);
i++;
m = i;
} else {
if (Character.isWhitespace(c)) break;
}
i++;
}
if (m != i)
if (str == null) str = paramString.substring(m, i);
else str = str + paramString.substring(m, i);
localArrayList.add(str);
}
return localArrayList;
}
public static boolean isFormat(String str, String... format) {
if (str.length() == 0) return format.length == 1 && format[0].equals("");
char[] charset = str.toCharArray();
int c = 0;
for (int i = 0; i < format.length; i++) {
String form = format[i];
if (form.equals(NUMBERS)) {
if (c >= charset.length) return false;
if (!Character.isDigit(charset[c])) {
if (charset[c] == '.') {
if (c + 1 >= charset.length || !Character.isDigit(charset[c + 1])) return false;
} else return false;
}
while (c < charset.length - 1
&& (Character.isDigit(charset[c + 1]) || charset[c + 1] == '.')) c++;
c++;
} else if (form.equals(LETTERS)) {
if (c >= charset.length || !Character.isLetter(charset[c])) return false;
while (c < charset.length - 1 && Character.isLetter(charset[c + 1])) c++;
c++;
} else {
char[] formchars = form.toCharArray();
if (formchars.length > charset.length - c) return false;
for (int ch = 0; ch < formchars.length; ch++) {
if (formchars[ch] != charset[c]) return false;
c++;
}
}
}
return c == charset.length;
}
/**
* @param number1
* @param number2
* @return
*/
public static String addNums(String number1, String number2) {
char[] num1char = number1.toCharArray();
char[] num2char = number2.toCharArray();
if (num1char.length > num2char.length) {
num2char = formatLength(num1char, num2char);
} else if (num1char.length < num2char.length) {
num1char = formatLength(num2char, num1char);
}
final char[] addition = new char[num1char.length + 1];
char carry = '0';
for (int i = num1char.length - 1; i >= 0; i--) {
int sum =
Character.getNumericValue(num1char[i])
+ Character.getNumericValue(num2char[i])
+ Character.getNumericValue(carry);
char[] csum = String.valueOf(sum).toCharArray();
carry = '0';
if (csum.length > 1 && i == 0) {
addition[i + 1] = csum[1];
addition[0] = csum[0];
} else if (csum.length > 1) {
carry = csum[0];
addition[i + 1] = csum[1];
} else {
addition[i + 1] = csum[0];
}
}
return String.valueOf(addition);
}
public static int correctSubStringLen(String input, int len) {
if (Character.isHighSurrogate(input.charAt(len - 1))) {
assert input.length() >= len + 1 && Character.isLowSurrogate(input.charAt(len));
return len + 1;
}
return len;
}
/**
* Tests if the string ends with the specified suffix.
*
* @param text the string to test.
* @param suffix the suffix.
* @return <code>true</code> if the character sequence represented by the argument is a suffix of
* the character sequence represented by this object; <code>false</code> otherwise. Note that
* the result will be <code>true</code> if the suffix is the empty string or is equal to this
* <code>String</code> object as determined by the {@link #equals(Object)} method. If the text
* or suffix argument is null <code>false</code> is returned.
*/
public static boolean endsWithIgnoreCase(final String text, final String suffix) {
if (isEmpty(text)) {
return false;
}
if (suffix == null) {
return false;
}
int textLength = text.length();
int suffixLength = suffix.length();
if (suffixLength == 0) {
return true;
}
if (suffixLength > textLength) {
return false;
}
int offset = textLength - suffixLength;
char[] chArray = suffix.toCharArray();
for (int i = 0; i != chArray.length; ++i) {
char ch1 = chArray[i];
char ch2 = text.charAt(offset + i);
if (ch1 == ch2 || Character.toLowerCase(ch1) == Character.toLowerCase(ch2)) {
// continue
} else {
return false;
}
}
return true;
}
public int calculate(String s) {
Stack<Integer> stack = new Stack<Integer>();
int num = 0;
char sign = '+';
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
if (Character.isDigit(c)) {
num = num * 10 + (c - '0');
}
if (i == s.length() - 1 || !Character.isDigit(c) && c != ' ') {
switch (sign) {
case '+':
stack.push(+num);
break;
case '-':
stack.push(-num);
break;
case '*':
stack.push(stack.pop() * num);
break;
case '/':
stack.push(stack.pop() / num);
break;
}
sign = c;
num = 0;
}
}
int result = 0;
while (!stack.isEmpty()) result += stack.pop();
return result;
}
/**
* Returns the Unicode code point of the character at the given index.
*
* <p>Unlike {@link Character#codePointAt(CharSequence, int)} or {@link String#codePointAt(int)}
* this method will never fail silently when encountering an invalid surrogate pair.
*
* <p>The behaviour of this method is as follows:
*
* <ol>
* <li>If {@code index >= end}, {@link IndexOutOfBoundsException} is thrown.
* <li><b>If the character at the specified index is not a surrogate, it is returned.</b>
* <li>If the first character was a high surrogate value, then an attempt is made to read the
* next character.
* <ol>
* <li><b>If the end of the sequence was reached, the negated value of the trailing high
* surrogate is returned.</b>
* <li><b>If the next character was a valid low surrogate, the code point value of the
* high/low surrogate pair is returned.</b>
* <li>If the next character was not a low surrogate value, then {@link
* IllegalArgumentException} is thrown.
* </ol>
* <li>If the first character was a low surrogate value, {@link IllegalArgumentException} is
* thrown.
* </ol>
*
* @param seq the sequence of characters from which to decode the code point
* @param index the index of the first character to decode
* @param end the index beyond the last valid character to decode
* @return the Unicode code point for the given index or the negated value of the trailing high
* surrogate character at the end of the sequence
*/
protected static final int codePointAt(CharSequence seq, int index, int end) {
if (index < end) {
char c1 = seq.charAt(index++);
if (c1 < Character.MIN_HIGH_SURROGATE || c1 > Character.MAX_LOW_SURROGATE) {
// Fast path (first test is probably all we need to do)
return c1;
} else if (c1 <= Character.MAX_HIGH_SURROGATE) {
// If the high surrogate was the last character, return its inverse
if (index == end) {
return -c1;
}
// Otherwise look for the low surrogate following it
char c2 = seq.charAt(index);
if (Character.isLowSurrogate(c2)) {
return Character.toCodePoint(c1, c2);
}
throw new IllegalArgumentException(
"Expected low surrogate but got char '"
+ c2
+ "' with value "
+ (int) c2
+ " at index "
+ index);
} else {
throw new IllegalArgumentException(
"Unexpected low surrogate character '"
+ c1
+ "' with value "
+ (int) c1
+ " at index "
+ (index - 1));
}
}
throw new IndexOutOfBoundsException("Index exceeds specified range");
}
public String generateValidIdString(String base) {
if (base == null) {
throw new IllegalArgumentException(base);
}
int n = base.length();
if (n < 1) {
throw new IllegalArgumentException(base);
}
StringBuilder newId = new StringBuilder();
for (int i = 0; i < n; i++) {
char c = base.charAt(i);
if (i == 0) {
if (!Character.isLetter(c) && (c != '_')) {
newId.append("_");
} else {
newId.append(c);
}
} else {
if (!Character.isLetter(c) && !Character.isDigit(c) && (c != '-') && (c != '_')) {
newId.append("_");
} else {
newId.append(c);
}
}
}
return newId.toString();
}
private static String createRegexForReplace(String toFind) {
char[] find = toFind.toCharArray();
StringBuilder regexString = new StringBuilder();
for (char f : find) {
int d = f;
if ((d >= 65 && d <= 90) || (d >= 97 && d <= 122)) {
regexString.append("[");
regexString.append(Character.toString((char) d));
int temp = d;
if (Character.isLowerCase(f)) {
temp = d - 32;
} else {
temp = d + 32;
}
regexString.append(Character.toString((char) temp));
regexString.append("]");
} else if (d == 32) {
regexString.append("[\\s]");
} else {
regexString.append("[");
regexString.append(f);
regexString.append("]");
}
}
return regexString.toString();
}
private Comparable[] makeGroups(String s) {
List<Comparable> l = new ArrayList<Comparable>();
boolean isNumber = false;
StringBuilder sb = new StringBuilder();
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
if (sb.length() > 0) {
char last = sb.charAt(sb.length() - 1);
if ((Character.isDigit(c) && Character.isDigit(last))
|| (!Character.isDigit(c) && !Character.isDigit(last))) {
} else {
if (isNumber) {
l.add(new BigInteger(sb.toString()));
} else {
l.add(sb.toString());
}
sb.setLength(0);
}
}
sb.append(c);
isNumber = Character.isDigit(c);
}
if (sb.length() > 0) {
if (isNumber) {
l.add(new BigInteger(sb.toString()));
} else {
l.add(sb.toString());
}
}
Comparable[] cs = new Comparable[l.size()];
return l.toArray(cs);
}
/*
* jan = 9 + 0 + 13 = 22 feb = 5 + 4 + 1 = 10 mar = 12 + 0 + 17 = 29 apr = 0
* + 15 + 17 = 32 may = 12 + 0 + 24 = 36 jun = 9 + 20 + 13 = 42 jul = 9 + 20
* + 11 = 40 aug = 0 + 20 + 6 = 26 sep = 18 + 4 + 15 = 37 oct = 14 + 2 + 19
* = 35 nov = 13 + 14 + 21 = 48 dec = 3 + 4 + 2 = 9
*/
private static int getMonth(String monthString) {
int hash =
Character.toLowerCase(monthString.charAt(0))
+ Character.toLowerCase(monthString.charAt(1))
+ Character.toLowerCase(monthString.charAt(2))
- 3 * 'a';
switch (hash) {
case 22:
return Calendar.JANUARY;
case 10:
return Calendar.FEBRUARY;
case 29:
return Calendar.MARCH;
case 32:
return Calendar.APRIL;
case 36:
return Calendar.MAY;
case 42:
return Calendar.JUNE;
case 40:
return Calendar.JULY;
case 26:
return Calendar.AUGUST;
case 37:
return Calendar.SEPTEMBER;
case 35:
return Calendar.OCTOBER;
case 48:
return Calendar.NOVEMBER;
case 9:
return Calendar.DECEMBER;
default:
throw new IllegalArgumentException();
}
}
/**
* Encodes byte into its quoted-printable representation.
*
* @param b byte to encode
* @param buffer the buffer to write to
*/
private static final void encodeQuotedPrintable(int b, ByteArrayOutputStream buffer) {
buffer.write(ESCAPE_CHAR);
char hex1 = Character.toUpperCase(Character.forDigit((b >> 4) & 0xF, 16));
char hex2 = Character.toUpperCase(Character.forDigit(b & 0xF, 16));
buffer.write(hex1);
buffer.write(hex2);
}
private boolean compare_Character(int operation, char charval, Object value2) {
if (operation == SUBSTRING) {
return false;
}
char charval2;
try {
charval2 = ((String) value2).charAt(0);
} catch (IndexOutOfBoundsException e) {
return false;
}
switch (operation) {
case EQUAL:
{
return charval == charval2;
}
case APPROX:
{
return (charval == charval2)
|| (Character.toUpperCase(charval) == Character.toUpperCase(charval2))
|| (Character.toLowerCase(charval) == Character.toLowerCase(charval2));
}
case GREATER:
{
return charval >= charval2;
}
case LESS:
{
return charval <= charval2;
}
}
return false;
}
private void finishComposition() {
int len = buffer.length();
if (len == 6 && format != SPECIAL_ESCAPE) {
char codePoint = (char) getCodePoint(buffer, 2, 5);
if (Character.isValidCodePoint(codePoint) && codePoint != 0xFFFF) {
buffer.setLength(0);
buffer.append(codePoint);
sendCommittedText();
return;
}
} else if (len == 8 && format == SPECIAL_ESCAPE) {
int codePoint = getCodePoint(buffer, 2, 7);
if (Character.isValidCodePoint(codePoint) && codePoint != 0xFFFF) {
buffer.setLength(0);
buffer.appendCodePoint(codePoint);
sendCommittedText();
return;
}
} else if (len == 12 && format == SURROGATE_PAIR) {
char[] codePoint = {(char) getCodePoint(buffer, 2, 5), (char) getCodePoint(buffer, 8, 11)};
if (Character.isHighSurrogate(codePoint[0]) && Character.isLowSurrogate(codePoint[1])) {
buffer.setLength(0);
buffer.append(codePoint);
sendCommittedText();
return;
}
}
beep();
}
/** NOTE: The sourceX2 is exclusive. */
public void copyInterval(TerminalRow line, int sourceX1, int sourceX2, int destinationX) {
final int x1 = line.findStartOfColumn(sourceX1);
final int x2 = line.findStartOfColumn(sourceX2);
boolean startingFromSecondHalfOfWideChar =
(sourceX1 > 0 && line.wideDisplayCharacterStartingAt(sourceX1 - 1));
final char[] sourceChars =
(this == line) ? Arrays.copyOf(line.mText, line.mText.length) : line.mText;
int latestNonCombiningWidth = 0;
for (int i = x1; i < x2; i++) {
char sourceChar = sourceChars[i];
int codePoint =
Character.isHighSurrogate(sourceChar)
? Character.toCodePoint(sourceChar, sourceChars[++i])
: sourceChar;
if (startingFromSecondHalfOfWideChar) {
// Just treat copying second half of wide char as copying whitespace.
codePoint = ' ';
startingFromSecondHalfOfWideChar = false;
}
int w = WcWidth.width(codePoint);
if (w > 0) {
destinationX += latestNonCombiningWidth;
sourceX1 += latestNonCombiningWidth;
latestNonCombiningWidth = w;
}
setChar(destinationX, codePoint, line.getStyle(sourceX1));
}
}
protected static String addUnderscores(String name, boolean pluralize) {
StringBuffer buf = new StringBuffer(name.replace('.', '_'));
for (int i = 1; i < buf.length() - 1; i++) {
if (Character.isLowerCase(buf.charAt(i - 1))
&& Character.isUpperCase(buf.charAt(i))
&& Character.isLowerCase(buf.charAt(i + 1))) {
buf.insert(i++, '_');
}
}
if (pluralize) {
String[] splitTableNameFragments = buf.toString().toLowerCase().split("_");
StringBuffer buf2 = new StringBuffer();
for (int i = 0; i < splitTableNameFragments.length; i++) {
if (i < (splitTableNameFragments.length - 1)) {
buf2.append(splitTableNameFragments[i]);
buf2.append("_");
} else {
buf2.append(English.plural(splitTableNameFragments[i]));
}
}
return buf2.toString().toUpperCase();
}
return buf.toString().toUpperCase();
}
private boolean add(char[] chars, V newValue, int offset, int length) {
if (offset == length) {
this.value = newValue;
boolean wasAlreadyAKey = this.key != null;
this.key = new String(chars);
return !wasAlreadyAKey;
}
char nextChar = chars[offset];
AbbreviationMap<V> child = (AbbreviationMap<V>) this.children.get(Character.valueOf(nextChar));
if (child == null) {
child = new AbbreviationMap<V>();
this.children.put(Character.valueOf(nextChar), child);
}
boolean newKeyAdded = child.add(chars, newValue, offset + 1, length);
if (newKeyAdded) {
this.keysBeyond += 1;
}
if (this.key == null) {
this.value = (this.keysBeyond > 1 ? null : newValue);
}
return newKeyAdded;
}
/**
* Segments the paragraph to sentences according to currently setup rules.
*
* <p>Bugfix for <a href="http://sourceforge.net/support/tracker.php?aid=1288742">issue
* 1288742</a>: Sentences are returned without spaces in the beginning and at the end of a
* sentence.
*
* <p>An additional list with space information is returned to be able to glue translation
* together with the same spaces between them as in original paragraph.
*
* @param paragraph the paragraph text
* @param spaces list to store information about spaces between sentences
* @param brules list to store rules that account to breaks
* @return list of sentences (String objects)
*/
public static List<String> segment(
Language lang, String paragraph, List<StringBuffer> spaces, List<Rule> brules) {
List<String> segments = breakParagraph(lang, paragraph, brules);
List<String> sentences = new ArrayList<String>(segments.size());
if (spaces == null) spaces = new ArrayList<StringBuffer>();
spaces.clear();
for (String one : segments) {
int len = one.length();
int b = 0;
StringBuffer bs = new StringBuffer();
while (b < len && Character.isWhitespace(one.charAt(b))) {
bs.append(one.charAt(b));
b++;
}
int e = len - 1;
StringBuffer es = new StringBuffer();
while (e >= b && Character.isWhitespace(one.charAt(e))) {
es.append(one.charAt(e));
e--;
}
es.reverse();
String trimmed = one.substring(b, e + 1);
sentences.add(trimmed);
if (spaces != null) {
spaces.add(bs);
spaces.add(es);
}
}
return sentences;
}
@Override
public boolean consume(CodeReader code, Lexer lexer) {
if (!Character.isJavaIdentifierStart(code.peek())) {
return false;
}
int line = code.getCursor().getLine();
int column = code.getCursor().getColumn();
while (Character.isJavaIdentifierPart(code.peek())) {
tmpBuilder.append((char) code.pop());
}
String word = tmpBuilder.toString();
TokenType keywordType = keywordsMap.get(word);
Token token =
tokenBuilder
.setType(keywordType == null ? GenericTokenType.IDENTIFIER : keywordType)
.setValueAndOriginalValue(word, word)
.setURI(lexer.getURI())
.setLine(line)
.setColumn(column)
.build();
lexer.addToken(token);
tmpBuilder.delete(0, tmpBuilder.length());
return true;
}
public Node toYamlNode(Representer representer) throws IOException {
final Map values = new HashMap();
final Method[] ems = data.getClass().getMethods();
for (int i = 0, j = ems.length; i < j; i++) {
if (ems[i].getParameterTypes().length == 0) {
final String name = ems[i].getName();
if (name.equals("getClass")) {
continue;
}
String pname = null;
if (name.startsWith("get")) {
pname = "" + Character.toLowerCase(name.charAt(3)) + name.substring(4);
} else if (name.startsWith("is")) {
pname = "" + Character.toLowerCase(name.charAt(2)) + name.substring(3);
}
if (null != pname) {
try {
values.put(pname, ems[i].invoke(data, new Object[0]));
} catch (final Exception exe) {
values.put(pname, null);
}
}
}
}
return representer.map(taguri(), values, false);
}
private int findalias(String sentence, int position) {
int i = position - 1;
int s = 0;
while (i > 0) {
char c = sentence.charAt(i);
if (s == 0) {
if (c == '.') {
s = 1;
} else {
return -1;
}
} else if (s == 1) {
if (Character.isLetterOrDigit(c)) {
s = 2;
} else {
return -1;
}
} else if (s == 2) {
if (!Character.isLetterOrDigit(c)) {
if (Character.isWhitespace(c) || c == ')' || c == '(') {
return i + 1;
} else {
return -1;
}
}
}
i--;
}
return -1;
}
/**
* Returns the numeric {@code int} value of a {@code char}
*
* @param value the input {@code char} to be parsed
* @return the numeric {@code int} value represented by the character.
* @throws NumberFormatException in case character is not a digit
*/
protected int extractDigit(char value) throws NumberFormatException {
if (Character.isDigit(value)) {
return Character.digit(value, DEC_RADIX);
} else {
throw log.getCharacterIsNotADigitException(value);
}
}
/**
* Creates a new word correction proposal.
*
* @param word the corrected word
* @param arguments the problem arguments associated with the spelling problem
* @param offset the offset in the document where to apply the proposal
* @param length the length in the document to apply the proposal
* @param context the invocation context for this proposal
* @param relevance the relevance of this proposal
*/
public WordCorrectionProposal(
final String word,
final String[] arguments,
final int offset,
final int length,
final IInvocationContext context,
final int relevance) {
fWord =
Character.isUpperCase(arguments[0].charAt(0))
? Character.toUpperCase(word.charAt(0)) + word.substring(1)
: word;
fOffset = offset;
fLength = length;
fContext = context;
fRelevance = relevance;
final StringBuffer buffer = new StringBuffer(80);
buffer.append("...<br>"); // $NON-NLS-1$
buffer.append(getHtmlRepresentation(arguments[1]));
buffer.append("<b>"); // $NON-NLS-1$
buffer.append(getHtmlRepresentation(fWord));
buffer.append("</b>"); // $NON-NLS-1$
buffer.append(getHtmlRepresentation(arguments[2]));
buffer.append("<br>..."); // $NON-NLS-1$
fLine = buffer.toString();
}
static int calcsize(String format, FormatDef[] f) {
int size = 0;
int len = format.length();
for (int j = 0; j < len; j++) {
char c = format.charAt(j);
if (j == 0 && (c == '@' || c == '<' || c == '>' || c == '=' || c == '!')) continue;
if (Character.isWhitespace(c)) continue;
int num = 1;
if (Character.isDigit(c)) {
num = Character.digit(c, 10);
while (++j < len && Character.isDigit((c = format.charAt(j)))) {
int x = num * 10 + Character.digit(c, 10);
if (x / 10 != num) throw StructError("overflow in item count");
num = x;
}
if (j >= len) break;
}
FormatDef e = getentry(c, f);
int itemsize = e.size;
size = align(size, e);
int x = num * itemsize;
size += x;
if (x / itemsize != num || size < 0) throw StructError("total struct size too long");
}
return size;
}
/**
* @ensures: if input file is read, a String is filled with words from file and searched in
* dictionary list, and if found increase words found counter, otherwise increase words not
* found. Otherwise error reading file
*/
public void readFileOliver() {
try {
FileInputStream inf = new FileInputStream(new File("oliver.txt"));
char let;
String str = "";
String key = "";
int n = 0;
while ((n = inf.read()) != -1) {
let = (char) n;
if (Character.isLetter(let)) {
str += Character.toLowerCase(let);
}
if ((Character.isWhitespace(let) || let == '-') && !str.isEmpty()) {
key = str;
str = "";
boolean a = dictionary[(int) key.charAt(0) - 97].contains(key);
if (a == true) {
counter = dictionary[(int) key.charAt(0) - 97].indexOf(key);
counterWFound++;
counterWFCompared += counter;
} else {
counter =
dictionary[(int) key.charAt(0) - 97].indexOf(
dictionary[(int) key.charAt(0) - 97].getLast());
counterWNotFound++;
counterWNFCompared += counter;
}
}
}
inf.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public static String getOrthographyValue(String content) {
if (content == null || content.isEmpty()) return null;
Set<Integer> types = new HashSet<Integer>();
for (int i = 1; i < content.length(); i++) {
char c = content.charAt(i);
types.add(Character.getType(c));
}
// we are ignoring spaces
types.remove(Character.getType(' '));
// we are ignoring CONTROL chars
types.remove(Character.getType(':'));
if (Character.getType(content.charAt(0)) == Character.UPPERCASE_LETTER) {
if (lowerCaseTypesSet.containsAll(types)) return "upperInitial";
}
types.add(Character.getType(content.charAt(0)));
if (upperCaseTypesSet.containsAll(types)) return "allCaps";
if (lowerCaseTypesSet.containsAll(types)) return "lowercase";
if (mixedCaseTypesSet.containsAll(types)) return "mixedCaps";
return null;
}
public static String capitalizeFirstCharacter(String s) {
if (s != null && s.isEmpty() == false && Character.isLowerCase(s.charAt(0))) {
return Character.toUpperCase(s.charAt(0)) + s.substring(1);
} else {
return s;
}
}