/** * 根据用户提供的json path,寻址Character对象 * * @return Character对象,如果path不存在或者Character不存在,返回null */ public Character getChar(final String path) { String result = this.getString(path); if (null == result) { return null; } try { return CharUtils.toChar(result); } catch (Exception e) { throw DataXException.asDataXException( CommonErrorCode.CONFIG_ERROR, String.format("任务读取配置文件出错. 因为配置文件路径[%s] 值非法,期望是字符类型: %s. 请检查您的配置并作出修改.", path, e.getMessage())); } }
/** * Replaces characters preceded by underscores with uppercase version, eg: * * 'hello_world' => 'helloWorld' 'hello_World' => 'helloWorld' 'hello__world' => 'hello_World' */ public static String formatCamelCase(String name) { StringBuilder formatted = new StringBuilder(); for (int i = 0; i < name.length(); i++) { char ci = name.charAt(i); if (i < name.length() - 1 && ci == '_' && CharUtils.isAscii(ci)) { char cii = name.charAt(i + 1); if (CharUtils.isAsciiAlphaLower(cii)) { formatted.append(StringUtils.upperCase(String.valueOf(cii))); i++; } } else { formatted.append(name.charAt(i)); } } return formatted.toString(); }
/** * Takes in a name pattern from the browscap.csv file, * and returns a Regex representation of it. * @param namePattern the name pattern * @return regex for the name pattern */ public static String toRegex(String namePattern) { final StringBuilder patternBuilder = new StringBuilder(); patternBuilder.append("^"); for (final char c : namePattern.toCharArray()) { switch (c) { case '*': patternBuilder.append(".*?"); break; case '?': patternBuilder.append("."); break; default: if(CharUtils.isAsciiAlphanumeric(c) || c==' '){ //The char c is either an alphabet,or a number or a whitespace,and NOT a regex wildcard. patternBuilder.append(c); }else { patternBuilder.append("\\").append(c); } } } patternBuilder.append("$"); final String pattern = patternBuilder.toString().toLowerCase(); return pattern; }
private boolean isAscii(String text) { char j; if(text==null) return true; for(int i=0; i<text.length();i++) { if(CharUtils.isAscii(text.charAt(i))) continue; else { j= text.charAt(i); } return false; } return true; }
static char lastCharForColumn(int column, int[] splitIndexes, String line) { boolean pairedQuote = true; int currentColumn = splitIndexes.length - 1; final int lastLineIndex = line.length() - 1; char currentChar; for (int i = lastLineIndex; i >= 0; --i) { currentChar = line.charAt(i); if (currentChar == '"') { pairedQuote = !pairedQuote; } else if (currentChar == ',' && pairedQuote) { splitIndexes[currentColumn] = i; --currentColumn; continue; } if (currentColumn == column && pairedQuote && !CharUtils.isAsciiControl(currentChar)) { return currentChar; } } return '\0'; }
@Override public long write(Sample sample) { Validate.validState(writer != null, "No writer set! Call setWriter() first!"); StringBuilder row = new StringBuilder(); char[] specials = new char[] { separator, CSVSaveService.QUOTING_CHAR, CharUtils.CR, CharUtils.LF }; for (int i = 0; i < columnCount; i++) { String data = sample.getData(i); row.append(CSVSaveService.quoteDelimiters(data, specials)) .append(separator); } row.setLength(row.length() - 1); writer.println(row.toString()); sampleCount++; return sampleCount; }
/** * 文字と数字の混ざった文字列から、数字のみを取り出してLongを作成します。 * 主に、外部で採番されたIDから数字のIDを作成するために使用します。 * * @param stringWithNumber * @return */ public static Long extractNumberString(Long headerNumber, String stringWithNumber) { StringBuilder sb = new StringBuilder(30); if (headerNumber != null) { sb.append(headerNumber.longValue()); } for (int i = 0; i < stringWithNumber.length(); i++) { if (CharUtils.isAsciiNumeric(stringWithNumber.charAt(i))) { sb.append(stringWithNumber.charAt(i)); } } if (sb.length() == 0) { return NumberUtils.LONG_ZERO; } else if(sb.length() >= 19) { // 19桁以上の場合は先頭の18文字を使用する return Long.valueOf(sb.substring(0, 18)); } else { return Long.valueOf(sb.toString()); } }
public static String buildSafeFileName(String fileName) { char[] fileNameChars = FilenameUtils.getName(fileName).toCharArray(); StrBuilder fileNameBuilder = new StrBuilder(fileNameChars.length); char fileNameChar; for (int a = 0; a < fileNameChars.length; a++) { if (!CharUtils.isAscii((fileNameChar = fileNameChars[a]))) { continue; } if (Character.isWhitespace(fileNameChar)) { while (((a + 1) < fileNameChars.length) && Character.isWhitespace(fileNameChars[(a + 1)])) { a++; } if (!fileNameBuilder.isEmpty() && ((a + 2) < fileNameChars.length)) { fileNameBuilder.append(StringUtils.SPACE); } } else if (Character.isLetterOrDigit(fileNameChar) || (fileNameChar == CrigttStringUtils.HYPHEN_CHAR) || (fileNameChar == CrigttStringUtils.PERIOD_CHAR) || (fileNameChar == CrigttStringUtils.UNDERSCORE_CHAR)) { fileNameBuilder.append(fileNameChar); } } return fileNameBuilder.build(); }
public static String char2TeX(int codePoint) { if ( MAP == null){ buildMap(); } if (CharUtils.isAsciiPrintable((char) codePoint)) { return CharUtils.toString((char) codePoint); } final String tex = MAP.get(codePoint); if (tex != null) { if (tex.endsWith("}") || tex.length() == 1) { return tex; } return "{" + tex + "}"; } LOGGER.debug("invalid char", codePoint); return ""; }
/** * Updates the length of the builder by either dropping the last characters * or adding filler of Unicode zero. * * @param length the length to set to, must be zero or positive * @return this, to enable chaining * @throws IndexOutOfBoundsException if the length is negative */ public StrBuilder setLength(final int length) { if (length < 0) { throw new StringIndexOutOfBoundsException(length); } if (length < size) { size = length; } else if (length > size) { ensureCapacity(length); final int oldEnd = size; final int newEnd = length; size = length; for (int i = oldEnd; i < newEnd; i++) { buffer[i] = CharUtils.NUL; } } return this; }
public static String encode(String string) { try { StringBuilder builder = new StringBuilder(); for (int i = 0; i < string.length();) { int codePoint = string.codePointAt(i); String symbol = codePointToSymbol(codePoint); char[] chars = symbol.toCharArray(); if (chars.length == 1 && CharUtils.isAscii(chars[0])) { builder.append(StringEscapeUtils.escapeHtml4(Character.toString(chars[0]))); } else { builder.append(symbol); } i += chars.length; } return builder.toString(); } catch (Throwable t) { Log.exception(t); return string; } }
/** * @param h Bookmark * @return User comment for bookmark or null */ public String getComment(final Host h) { if(StringUtils.isNotBlank(h.getComment())) { return StringUtils.remove(StringUtils.remove(h.getComment(), CharUtils.LF), CharUtils.CR); } return null; }
public void parse(char c) { if(CharUtils.isAsciiNumeric(c)) { int intValue = CharUtils.toIntValue(c); this.read = (intValue & 4) > 0; this.write = (intValue & 2) > 0; this.execute = (intValue & 1) > 0; } else { if(c == MULTIPLE_VALUES) { this.read = this.write = this.execute = null; } } }
public int getCapsCount() { int count = 0; for (int i = 0, l = message.length(); i < l; ++i) { if (CharUtils.isAsciiAlphaUpper(message.charAt(i))) { ++count; } } return count; }
public static String nonAsciiToUnicode ( String s ) { StringBuffer sb = new StringBuffer( s.length() ); for ( Character c : s.toCharArray() ) { if ( ! CharUtils.isAscii( c ) ) { sb.append( CharUtils.unicodeEscaped( c ) ); } else { sb.append( c ); } } return sb.toString(); }
private String generateNameFromClass(Class<?> doubleClass) { final String className = doubleClass.getSimpleName(); final String classFirstLetter = CharUtils.toString(className.charAt(0)); final String restOfClassName =StringUtils.substring(doubleClass.getSimpleName(), 1); return classFirstLetter.toLowerCase() + restOfClassName; }
/** * Replaces all non alphanumeric characters in input string with {@link * ApiNameGenerator#API_NAME_FILLER_CHAR} */ private static String replaceNonAlphanumericChars(String input, boolean allowDots) { StringBuilder alphaNumeric = new StringBuilder(); for (char hostnameChar : input.toCharArray()) { if (CharUtils.isAsciiAlphanumeric(hostnameChar) || (allowDots && hostnameChar == SEPARATOR)) { alphaNumeric.append(hostnameChar); } else { alphaNumeric.append(API_NAME_FILLER_CHAR); } } return alphaNumeric.toString(); }
private static boolean startsWithAlphaOrUnderscore(String string) { if (Strings.isNullOrEmpty(string)) { return false; } char firstCharacter = string.charAt(0); return CharUtils.isAsciiAlpha(firstCharacter) || firstCharacter == API_NAME_FILLER_CHAR; }
public String normalizeWorldName(String worldName) { char[] array = StringUtils.stripAccents(worldName).toCharArray(); char[] result = new char[array.length]; for (int i = 0; i < array.length; i++) { char c = array[i]; if (CharUtils.isAsciiAlphanumeric(c)) { result[i] = Character.toLowerCase(c); } else { result[i] = SLUG_MAGIC_KEY; } } return String.valueOf(result); }
private static int findLineFeedIndex(String line) { for (int i = line.length() - 1; i >= 0; --i) { if (!CharUtils.isAsciiControl(line.charAt(i))) { return i + 1; } } throw new IllegalArgumentException("line <<" + line + ">> is empty or contains only control characters"); }
/** * Gets the DDL character value based on the specified configured character value. This method supports UTF-8 encoded strings and will "Hive" escape any * non-ASCII printable characters using '\(value)'. * * @param string the configured character value. * @param escapeSingleBackslash specifies if we need to escape a single backslash character with an extra backslash * * @return the DDL character value. */ public String getDdlCharacterValue(String string, boolean escapeSingleBackslash) { // Assume the empty string for the return value. StringBuilder returnValueStringBuilder = new StringBuilder(); // If we have an actual character, set the return value based on our rules. if (StringUtils.isNotEmpty(string)) { // Convert the string to UTF-8 so we can the proper characters that were sent via XML. String utf8String = new String(string.getBytes(Charsets.UTF_8), Charsets.UTF_8); // Loop through each character and add each one to the return value. for (int i = 0; i < utf8String.length(); i++) { // Default to the character itself. Character character = string.charAt(i); String nextValue = character.toString(); // If the character isn't ASCII printable, then "Hive" escape it. if (!CharUtils.isAsciiPrintable(character)) { // If the character is unprintable, then display it as the ASCII octal value in \000 format. nextValue = String.format("\\%03o", (int) character); } // Add this character to the return value. returnValueStringBuilder.append(nextValue); } // Check if we need to escape a single backslash character with an extra backslash. if (escapeSingleBackslash && returnValueStringBuilder.toString().equals("\\")) { returnValueStringBuilder.append('\\'); } } // Return the value. return returnValueStringBuilder.toString(); }
public OmKeyEvent(Map<String, Object> obj) { alt = TRUE.equals(obj.get("alt")); ctrl = TRUE.equals(obj.get("ctrl")); shift = TRUE.equals(obj.get("shift")) || isUpperCase(ch); ch = (char)getInt(obj, "char"); key = inKey = getInt(obj, "key"); Integer _key = null; if (CharUtils.isAsciiPrintable(ch)) { boolean alpha = Character.isAlphabetic(ch); if (alpha) { // can't be combined due to different types key = getKeyStroke(toUpperCase(ch), 0).getKeyCode(); } else { key = getKeyStroke(Character.valueOf(ch), 0).getKeyCode(); } if (key == 0) { _key = CHAR_MAP.get(ch); if (_key == null) { // fallback key = inKey; } } if (!alpha && _key == null) { _key = KEY_MAP.get(key); } } else { _key = KEY_MAP.get(key); } this.key = _key == null ? key : _key; log.debug("sequence:: shift {}, ch {}, orig {} -> key {}({}), map {}", shift, ch == 0 ? ' ' : ch, inKey, key, Integer.toHexString(key), _key); }
private static boolean isAsciiAlpha( String value ) { for (char c : value.toCharArray()) { if (!CharUtils.isAsciiAlpha( c )) return false; } return true; }
private static boolean isAsciiAlphanumeric( String value ) { for (char c : value.toCharArray()) { if (!CharUtils.isAsciiAlphanumeric( c )) return false; } return true; }
private static boolean isAsciiNumeric( String value ) { for (char c : value.toCharArray()) { if (!CharUtils.isAsciiNumeric( c )) return false; } return true; }
public static boolean isJavaIdentifier(final String value) { if (StringUtils.isBlank(value)) { return false; } if (!SourceVersion.isIdentifier(value) || SourceVersion.isKeyword(value)) { return false; } for (int i = 0; i < value.length(); i++) { if (!CharUtils.isAsciiPrintable(value.charAt(i))) { return false; } } return true; }
private static List<String> listOfStrings(char from, int amount) { List<String> result = Lists.newArrayListWithCapacity(amount); for (char c = from; c < from + amount; c++) { result.add(CharUtils.toString(c)); } return result; }
private static String codePointToString(int codePoint) { if (Character.isBmpCodePoint(codePoint)) { return CharUtils.toString((char) codePoint); } char[] chars = Character.toChars(codePoint); return new String(chars); }
/** * Returns the order for a single character. The order is digits, * then alpha, then non-ascii. If {@code pos} >= * {@code ca.length}, then the order is the same as for digits. * * @param ca the character array * @param pos the position in the character array * @return the order for the given character */ @Override protected int order(final char[] ca, final int pos) { if (pos >= ca.length) { return 0; } final char c = ca[pos]; return CharUtils.isAsciiNumeric(c) ? 0 : CharUtils.isAsciiAlpha(c) ? c : c + NON_ASCII_OFFSET; }
/** * Returns the order for a single character. The order is ~, then digits, * then alpha, then non-ascii. If {@code pos} >= * {@code ca.length}, then the order is the same as for digits. * * @param ca the character array * @param pos the position in the character array * @return the order for the given character */ @Override protected int order(final char[] ca, final int pos) { if (pos >= ca.length) { return 0; } final char c = ca[pos]; return c == '~' ? -1 : CharUtils.isAsciiNumeric(c) ? 0 : CharUtils.isAsciiAlpha(c) ? c : c + NON_ASCII_OFFSET; }
private static String replaceNonAscii(String valueToPrint) { StringBuilder result = new StringBuilder(); for (int i = 0; i < valueToPrint.length(); i++) { if (CharUtils.isAscii(valueToPrint.charAt(i))) { result.append(valueToPrint.charAt(i)); } else { result.append("?"); } } return result.toString(); }
/** * <p>Swaps the case of a String using a word based algorithm.</p> * * <ul> * <li>Upper case character converts to Lower case</li> * <li>Title case character converts to Lower case</li> * <li>Lower case character after Whitespace or at start converts to Title case</li> * <li>Other Lower case character converts to Upper case</li> * </ul> * * <p>Whitespace is defined by {@link Character#isWhitespace(char)}. * A <code>null</code> input String returns <code>null</code>.</p> * * <pre> * StringUtils.swapCase(null) = null * StringUtils.swapCase("") = "" * StringUtils.swapCase("The dog has a BONE") = "tHE DOG HAS A bone" * </pre> * * @param str the String to swap case, may be null * @return the changed String, <code>null</code> if null String input */ @GwtIncompatible("incompatible method") public static String swapCase(final String str) { if (StringUtils.isEmpty(str)) { return str; } final char[] buffer = str.toCharArray(); boolean whitespace = true; for (int i = 0; i < buffer.length; i++) { final char ch = buffer[i]; if (Character.isUpperCase(ch)) { buffer[i] = Character.toLowerCase(ch); whitespace = false; } else if (Character.isTitleCase(ch)) { buffer[i] = Character.toLowerCase(ch); whitespace = false; } else if (Character.isLowerCase(ch)) { if (whitespace) { buffer[i] = Character.toTitleCase(ch); whitespace = false; } else { buffer[i] = Character.toUpperCase(ch); } } else { whitespace = CharUtils.isWhitespace(ch); } } return new String(buffer); }
/** * Is the character a delimiter. * * @param ch the character to check * @param delimiters the delimiters * @return true if it is a delimiter */ private static boolean isDelimiter(final char ch, final char[] delimiters) { if (delimiters == null) { return CharUtils.isWhitespace(ch); } for (final char delimiter : delimiters) { if (ch == delimiter) { return true; } } return false; }
@Test public void csvEscaperCRTest() throws IOException { final CsvTranslators.CsvEscaper escaper = new CsvTranslators.CsvEscaper(); final Writer writer = new StringWriter(); final String input = "hi,this,is,a,CR,test" + String.valueOf(CharUtils.CR); escaper.translateWhole(input, writer); final String data = writer.toString(); assertThat(data).isEqualTo("\"hi,this,is,a,CR,test" + String.valueOf(CharUtils.CR) + "\""); }
@Test public void csvEscaperLFTest() throws IOException { final CsvTranslators.CsvEscaper escaper = new CsvTranslators.CsvEscaper(); final Writer writer = new StringWriter(); final String input = "hi,this,is,a,LF,test" + String.valueOf(CharUtils.LF); escaper.translateWhole(input, writer); final String data = writer.toString(); assertThat(data).isEqualTo("\"hi,this,is,a,LF,test" + String.valueOf(CharUtils.LF) + "\""); }
public static void main(String args[]) { CommandLineInputHandler commandLineInputHandler = new CommandLineInputHandler(); char command = DEFAULT_INPUT; while (CommandLineInput.EXIT.getShortCmd() != command) { commandLineInputHandler.printOptions(); String input = commandLineInputHandler.readInput(); System.out.println("-----> " + CharUtils.toChar(input, DEFAULT_INPUT)); command = CharUtils.toChar(input, DEFAULT_INPUT); CommandLineInput commandLineInput = CommandLineInput.getCommandLineInputForInput(command); commandLineInputHandler.processInput(commandLineInput); } }