public static String join(Iterable<String> iterable, String seperator){ return join(iterable, STRING_JOINER, seperator); }
public static File findFirstThatExist(String... paths) { for (String path : paths) { if (!StringUtil.isEmpty(path)) { File file = new File(path); if (file.exists()) return file; } } return null; }
public static boolean endsWithIgnoreCase(String text, String suffix) { int l1 = text.length(); int l2 = suffix.length(); if (l1 < l2) return false; for (int i = l1 - 1; i >= l1 - l2; i--) { if (!charsEqualIgnoreCase(text.charAt(i), suffix.charAt(i + l2 - l1))) { return false; } } return true; }
@Override public void error(String message, Throwable t, String... details) { String detailString = StringUtil.join(details, "\n"); if (!detailString.isEmpty()) { detailString = "\nDetails: " + detailString; } if (firstException == null) { String mess = "Logger errors occurred. See IDEA logs for details. " + (StringUtil.isEmpty(message) ? "" : "Error message is '" + message + "'"); firstException = new Exception(mess + detailString, t); } logger4J.error(message + detailString, t); logErrorHeader(); }
public static boolean containsIgnoreCase(String where, String what) { return indexOfIgnoreCase(where, what, 0) >= 0; }
public boolean isFloat() { if(isFloat == AlmostBoolean.MAYBE){ if(StringUtil.isFloat(value)) isFloat = AlmostBoolean.YES; else isFloat = AlmostBoolean.NO; } return isFloat.decide(false); }
public static byte[] loadFileBytes(File file) throws IOException { byte[] bytes; try (InputStream stream = new FileInputStream(file)) { final long len = file.length(); if (len < 0) { throw new IOException("File length reported negative, probably doesn't exist"); } if (len > 20 * 1024 * 1024) { throw new IOException("File is to big: " + StringUtil.humanReadableBytes(len)); } bytes = IOUtil.loadBytes(stream, (int) len); } return bytes; }
public static String join(String[] array, String seperator){ return join(array, STRING_JOINER, seperator); }
public static int indexOfIgnoreCase(String where, String what, int fromIndex) { int targetCount = what.length(); int sourceCount = where.length(); if (fromIndex >= sourceCount) { return targetCount == 0 ? sourceCount : -1; } if (fromIndex < 0) { fromIndex = 0; } if (targetCount == 0) { return fromIndex; } char first = what.charAt(0); int max = sourceCount - targetCount; for (int i = fromIndex; i <= max; i++) { if (!charsEqualIgnoreCase(where.charAt(i), first)) { while (++i <= max && !charsEqualIgnoreCase(where.charAt(i), first)) ; } if (i <= max) { int j = i + 1; int end = j + targetCount - 1; for (int k = 1; j < end && charsEqualIgnoreCase(where.charAt(j), what.charAt(k)); j++, k++) ; if (j == end) { return i; } } } return -1; }
@Override public void error(String message, Throwable t, String... details) { String fullMessage = details.length > 0 ? message + "\nDetails: " + StringUtil.join(details, "\n") : message; logger4J.error(fullMessage, t); }
public static String getJVMArgs() { List<String> arguments = ManagementFactory.getRuntimeMXBean().getInputArguments(); if (arguments != null) { return StringUtil.join(arguments, " "); } return "Unknown or not present"; }
private static void printSection(String section) { int length = (45 - section.length() - 2) / 2; String prefix = length <= 0 ? "" : StringUtil.join(Collections.nCopies(length, "-"), ""); logger.info(prefix + "[" + section + "]" + prefix); }
@Override public <P extends ParsingHandle> P getHandleByClass(Class<P> clazz) { for (ParsingHandle handle : handles) { if (clazz == handle.getClass()) { return (P) handle; } } throw new NoHandleFoundException(clazz.getName() + " is not in " + StringUtil.join(handles, obj -> obj.getClass().getName(), ", ")); }
public Object getValueByName(Object obj, String varName) throws IllegalAccessException, InvocationTargetException { Method method = methods.get(varName); if (method != null) { method.setAccessible(true); return method.invoke(obj); } Field field = fields.get(varName); if (field != null) { field.setAccessible(true); return field.get(obj); } throw new ManipulationException("Could not find value for " + varName + " valid names are " + StringUtil.join(Stream.concat(fields.keySet().stream(), methods.keySet().stream()).collect(Collectors.toSet()), ", ")); }
private String buildFilter(Filters.Filter filter) { Filters.FilterType type = filter.type; if (filter instanceof Filters.ComplexFilter) { return StringUtil.join(((Filters.ComplexFilter) filter).getFilters(), this::buildFilter, type.name()); } String operator = filterTypes.get(type); Filters.ValueFilter valueFilter = (Filters.ValueFilter) filter; return valueFilter.field + operator + valueFilter.getObject().toString(); }
private static void printImportantSection(String name) { String prefix = StringUtil.join(Collections.nCopies(45, "-"), ""); logger.info(prefix); printSection(name); logger.info(prefix); }
@Override public Collection<? extends HttpHandler> search() { List<AnnotationHandler> handlers = new ArrayList<>(); if (webServer.getConfig().getData(WebConfig.SEARCH_ANNOTATION_HANDLERS)) { for (Object obj : classCollector.collectAllInstances()) { add(obj, handlers); } } for (Object obj : getAll()) { add(obj, handlers); } logger.info("Found Annotation Handlers (" + handlers.size() + "/" + classCollector.totalResults() + "): " + StringUtil.join(handlers, handler -> handler.getHandlerObj().getClass().getSimpleName(), ", ")); return handlers; }