/** * <p>Checks if the CharSequence contains only certain characters.</p> * * <p>A {@code null} CharSequence will return {@code false}. * A {@code null} valid character String will return {@code false}. * An empty String (length()=0) always returns {@code true}.</p> * * <pre> * StringUtils.containsOnly(null, *) = false * StringUtils.containsOnly(*, null) = false * StringUtils.containsOnly("", *) = true * StringUtils.containsOnly("ab", "") = false * StringUtils.containsOnly("abab", "abc") = true * StringUtils.containsOnly("ab1", "abc") = false * StringUtils.containsOnly("abz", "abc") = false * </pre> * * @param cs the CharSequence to check, may be null * @param validChars a String of valid chars, may be null * @return true if it only contains valid chars and is non-null * @since 2.0 * @since 3.0 Changed signature from containsOnly(String, String) to containsOnly(CharSequence, String) */ public static boolean containsOnly(final CharSequence cs, final String validChars) { if (cs == null || validChars == null) { return false; } return containsOnly(cs, validChars.toCharArray()); }
protected String getConstantName(String nodeName, String customName) { if (isNotBlank(customName)) { return customName; } List<String> enumNameGroups = new ArrayList<>(asList(splitByCharacterTypeCamelCase(nodeName))); String enumName = ""; for (Iterator<String> iter = enumNameGroups.iterator(); iter.hasNext();) { if (containsOnly(ruleFactory.getNameHelper().replaceIllegalCharacters(iter.next()), "_")) { iter.remove(); } } enumName = upperCase(join(enumNameGroups, "_")); if (isEmpty(enumName)) { enumName = "__EMPTY__"; } else if (Character.isDigit(enumName.charAt(0))) { enumName = "_" + enumName; } return enumName; }
@Test public void testContainsOnly_CharArray() { final String str1 = "a"; final String str2 = "b"; final String str3 = "ab"; final char[] chars1= {'b'}; final char[] chars2= {'a'}; final char[] chars3= {'a', 'b'}; final char[] emptyChars = new char[0]; assertFalse(StringUtils.containsOnly(null, (char[]) null)); assertFalse(StringUtils.containsOnly("", (char[]) null)); assertFalse(StringUtils.containsOnly(null, emptyChars)); assertFalse(StringUtils.containsOnly(str1, emptyChars)); assertTrue(StringUtils.containsOnly("", emptyChars)); assertTrue(StringUtils.containsOnly("", chars1)); assertFalse(StringUtils.containsOnly(str1, chars1)); assertTrue(StringUtils.containsOnly(str1, chars2)); assertTrue(StringUtils.containsOnly(str1, chars3)); assertTrue(StringUtils.containsOnly(str2, chars1)); assertFalse(StringUtils.containsOnly(str2, chars2)); assertTrue(StringUtils.containsOnly(str2, chars3)); assertFalse(StringUtils.containsOnly(str3, chars1)); assertFalse(StringUtils.containsOnly(str3, chars2)); assertTrue(StringUtils.containsOnly(str3, chars3)); }
@Test public void testContainsOnly_String() { final String str1 = "a"; final String str2 = "b"; final String str3 = "ab"; final String chars1= "b"; final String chars2= "a"; final String chars3= "ab"; assertFalse(StringUtils.containsOnly(null, (String) null)); assertFalse(StringUtils.containsOnly("", (String) null)); assertFalse(StringUtils.containsOnly(null, "")); assertFalse(StringUtils.containsOnly(str1, "")); assertTrue(StringUtils.containsOnly("", "")); assertTrue(StringUtils.containsOnly("", chars1)); assertFalse(StringUtils.containsOnly(str1, chars1)); assertTrue(StringUtils.containsOnly(str1, chars2)); assertTrue(StringUtils.containsOnly(str1, chars3)); assertTrue(StringUtils.containsOnly(str2, chars1)); assertFalse(StringUtils.containsOnly(str2, chars2)); assertTrue(StringUtils.containsOnly(str2, chars3)); assertFalse(StringUtils.containsOnly(str3, chars1)); assertFalse(StringUtils.containsOnly(str3, chars2)); assertTrue(StringUtils.containsOnly(str3, chars3)); }
.getMessage(value, spec)); if (!StringUtils.containsOnly(specParts[0], VALID_TARGETS)) { throw new IllegalArgumentException(ExceptionMessage.INVALID_MODE_TARGETS .getMessage(value, spec, specParts[0])); if (!StringUtils.containsOnly(specParts[1], VALID_PERMISSIONS)) { throw new IllegalArgumentException(ExceptionMessage.INVALID_MODE_PERMISSIONS .getMessage(value, spec, specParts[1]));
@Test public void testRepeat_StringInt() { assertNull(StringUtils.repeat(null, 2)); assertEquals("", StringUtils.repeat("ab", 0)); assertEquals("", StringUtils.repeat("", 3)); assertEquals("aaa", StringUtils.repeat("a", 3)); assertEquals("", StringUtils.repeat("a", -2)); assertEquals("ababab", StringUtils.repeat("ab", 3)); assertEquals("abcabcabc", StringUtils.repeat("abc", 3)); final String str = StringUtils.repeat("a", 10000); // bigger than pad limit assertEquals(10000, str.length()); assertTrue(StringUtils.containsOnly(str, 'a')); }
@Test public void testRightPad_StringIntChar() { assertNull(StringUtils.rightPad(null, 5, ' ')); assertEquals(" ", StringUtils.rightPad("", 5, ' ')); assertEquals("abc ", StringUtils.rightPad("abc", 5, ' ')); assertEquals("abc", StringUtils.rightPad("abc", 2, ' ')); assertEquals("abc", StringUtils.rightPad("abc", -1, ' ')); assertEquals("abcxx", StringUtils.rightPad("abc", 5, 'x')); final String str = StringUtils.rightPad("aaa", 10000, 'a'); // bigger than pad length assertEquals(10000, str.length()); assertTrue(StringUtils.containsOnly(str, 'a')); }
@Test public void testLeftPad_StringIntChar() { assertNull(StringUtils.leftPad(null, 5, ' ')); assertEquals(" ", StringUtils.leftPad("", 5, ' ')); assertEquals(" abc", StringUtils.leftPad("abc", 5, ' ')); assertEquals("xxabc", StringUtils.leftPad("abc", 5, 'x')); assertEquals("\uffff\uffffabc", StringUtils.leftPad("abc", 5, '\uffff')); assertEquals("abc", StringUtils.leftPad("abc", 2, ' ')); final String str = StringUtils.leftPad("aaa", 10000, 'a'); // bigger than pad length assertEquals(10000, str.length()); assertTrue(StringUtils.containsOnly(str, 'a')); }
/** * Checks whether a word is written in Turkish alphabet or not. * * @param word the word to check its letters * @return whether contains only Turkish letters or not. */ public boolean turkish(String word) { return StringUtils.containsOnly(word, ALPHABET); }
public static boolean only(CharSequence cs, String validChars) { return StringUtils.containsOnly(cs, validChars); }
public static boolean only(CharSequence cs, char... valid) { return StringUtils.containsOnly(cs, valid); }
private static boolean isHash(String p) { return StringUtils.containsOnly(p, "0123456789m"); }
/** * Identifies words with only Greek lowercase characters. * * @param input * The string that will examine * @return true if the string contains only Greek characters */ private boolean identifyGreekWord(String input) { if (StringUtils.containsOnly(input, GREEK_CHARACTERS)) { return true; } else { return false; } } }
private static void checkFlags(String flags) { if ( flags == null ) return; // F&O spec defines regex: Can only contain s, m, i, x, q // Not all are supported by all regex engines. if ( ! StringUtils.containsOnly(flags, "smixq") ) throw new ExprEvalException("REGEX: Only 'smixq' are legal as pattern flags: got \""+FmtUtils.stringEsc(flags)+"\""); }
protected String getConstantName(String nodeName, String customName) { if (isNotBlank(customName)) { return customName; } List<String> enumNameGroups = new ArrayList<>(asList(splitByCharacterTypeCamelCase(nodeName))); String enumName = ""; for (Iterator<String> iter = enumNameGroups.iterator(); iter.hasNext();) { if (containsOnly(ruleFactory.getNameHelper().replaceIllegalCharacters(iter.next()), "_")) { iter.remove(); } } enumName = upperCase(join(enumNameGroups, "_")); if (isEmpty(enumName)) { enumName = "__EMPTY__"; } else if (Character.isDigit(enumName.charAt(0))) { enumName = "_" + enumName; } return enumName; }
@Override public void end() { String noteText = writer.getTempStoreString(); if (noteText.length()>0) { if (!StringUtils.containsOnly(noteText, "[];()., ")) { Note note = new Note(verseInfo.currentVerseNo, currentNoteRef, noteText, NoteType.TYPE_GENERAL, null, null); notesList.add(note); } // and clear the buffer writer.clearTempStore(); } isInNote = false; writer.finishWritingToTempStore(); }
public static boolean containsOnly(ActionContext actionContext){ Thing self = actionContext.getObject("self"); CharSequence cs1 = (CharSequence) self.doAction("getCs", actionContext); String validChars = (String) self.doAction("getValidChars", actionContext); return StringUtils.containsOnly(cs1, validChars); }
public void validateUserName(FacesContext context, UIComponent component, Object value) { if (!(value instanceof String) || !StringUtils.containsOnly((String) value, VALID_CHARS)) { FacesMessage message = new FacesMessage(FacesMessage.SEVERITY_ERROR, ComponentUtils.translate(context, "label.userManager.wrong.username"), null); // also add global message context.addMessage(null, message); throw new ValidatorException(message); } }
public void validateGroupName(FacesContext context, UIComponent component, Object value) { if (!(value instanceof String) || !StringUtils.containsOnly((String) value, VALID_CHARS)) { FacesMessage message = new FacesMessage(FacesMessage.SEVERITY_ERROR, ComponentUtils.translate(context, "label.groupManager.wrongGroupName"), null); ((EditableValueHolder) component).setValid(false); context.addMessage(component.getClientId(context), message); // also add global message context.addMessage(null, message); } }
void call() { final boolean extracted = processPhoneNumber(); if (extracted == true) { return; } if (StringUtils.containsOnly(form.getPhoneNumber(), "0123456789+-/() ") == false) { form.addError("address.phoneCall.number.invalid"); return; } form.setPhoneNumber(extractPhonenumber(form.getPhoneNumber())); callNow(); }