@Override protected String apply(String value, Locale unused) { return StringUtils.uncapitalize(value); } }
protected MutableHistogram(String name, String description, long maxExpected) { this.name = StringUtils.capitalize(name); this.desc = StringUtils.uncapitalize(description); this.histogram = new HistogramImpl(); }
private String mergeCompound(String str, boolean uncapitalizeMidWords) { String[] stringParts = str.split(" "); StringBuilder sb = new StringBuilder(); for (int k = 0; k < stringParts.length; k++) { if (isHyphenIgnored() || !"-".equals(stringParts[k])) { if (k == 0) { sb.append(stringParts[0]); } else { sb.append(uncapitalizeMidWords ? StringUtils.uncapitalize(stringParts[k]) : stringParts[k]); } } } return sb.toString(); }
/** * Constructor for {@link MutableRollingAverages}. * @param metricValueName */ public MutableRollingAverages(String metricValueName) { if (metricValueName == null) { metricValueName = ""; } avgInfoNameTemplate = "[%s]" + "RollingAvg" + StringUtils.capitalize(metricValueName); avgInfoDescTemplate = "Rolling average " + StringUtils.uncapitalize(metricValueName) +" for "+ "%s"; numWindows = NUM_WINDOWS_DEFAULT; scheduledTask = SCHEDULER.scheduleAtFixedRate(new RatesRoller(this), WINDOW_SIZE_MS_DEFAULT, WINDOW_SIZE_MS_DEFAULT, TimeUnit.MILLISECONDS); }
private Map<String, AnalyzedTokenReadings> getStringToTokenMap(Queue<AnalyzedTokenReadings> prevTokens, List<String> stringsToCheck, List<String> origStringsToCheck) { StringBuilder sb = new StringBuilder(); Map<String, AnalyzedTokenReadings> stringToToken = new HashMap<>(); int j = 0; boolean isFirstSentStart = false; for (AnalyzedTokenReadings atr : prevTokens) { sb.append(' '); sb.append(atr.getToken()); if (j == 0) { isFirstSentStart = atr.hasPosTag(JLanguageTool.SENTENCE_START_TAGNAME); } if (j >= 1) { String stringToCheck = normalize(sb.toString()); if (sentenceStartsWithUpperCase && isFirstSentStart) { stringToCheck = StringUtils.uncapitalize(stringToCheck); } stringsToCheck.add(stringToCheck); origStringsToCheck.add(sb.toString().trim()); if (!stringToToken.containsKey(stringToCheck)) { stringToToken.put(stringToCheck, atr); } } j++; } return stringToToken; }
@SuppressWarnings("rawtypes") @Override public List<Job> getSysCronClazz(Job job) { Reflections reflections = new Reflections("cc.mrbird.job.task"); List<Job> jobList = new ArrayList<>(); Set<Class<?>> annotated = reflections.getTypesAnnotatedWith(CronTag.class); for (Class cls : annotated) { String clsSimpleName = cls.getSimpleName(); Method[] methods = cls.getDeclaredMethods(); for (Method method : methods) { Job job1 = new Job(); String methodName = method.getName(); Parameter[] methodParameters = method.getParameters(); String params = String.format("%s(%s)", methodName, Arrays.stream(methodParameters).map(item -> item.getType().getSimpleName() + " " + item.getName()).collect(Collectors.joining(", "))); job1.setBeanName(StringUtils.uncapitalize(clsSimpleName)); job1.setMethodName(methodName); job1.setParams(params); jobList.add(job1); } } return jobList; }
@Test public void testReCapitalize() { // reflection type of tests: Sentences. assertEquals("uncapitalize(capitalize(String)) failed", SENTENCE_UNCAP, StringUtils.uncapitalize(StringUtils.capitalize(SENTENCE_UNCAP))); assertEquals("capitalize(uncapitalize(String)) failed", SENTENCE_CAP, StringUtils.capitalize(StringUtils.uncapitalize(SENTENCE_CAP))); // reflection type of tests: One word. assertEquals("uncapitalize(capitalize(String)) failed", FOO_UNCAP, StringUtils.uncapitalize(StringUtils.capitalize(FOO_UNCAP))); assertEquals("capitalize(uncapitalize(String)) failed", FOO_CAP, StringUtils.capitalize(StringUtils.uncapitalize(FOO_CAP))); }
String usName = StringUtils.capitalize(sampleName); String uvName = StringUtils.capitalize(valueName); String desc = StringUtils.uncapitalize(description); String lsName = StringUtils.uncapitalize(sampleName); String lvName = StringUtils.uncapitalize(valueName);
@Test public void testUnCapitalize() { assertNull(StringUtils.uncapitalize(null)); assertEquals("uncapitalize(String) failed", FOO_UNCAP, StringUtils.uncapitalize(FOO_CAP)); assertEquals("uncapitalize(string) failed", FOO_UNCAP, StringUtils.uncapitalize(FOO_UNCAP)); assertEquals("uncapitalize(empty-string) failed", "", StringUtils.uncapitalize("")); assertEquals("uncapitalize(single-char-string) failed", "x", StringUtils.uncapitalize("X")); // Examples from uncapitalize Javadoc assertEquals("cat", StringUtils.uncapitalize("cat")); assertEquals("cat", StringUtils.uncapitalize("Cat")); assertEquals("cAT", StringUtils.uncapitalize("CAT")); }
@Override public PropertyConstraint<Iterable<? extends U>> toCollectionConstraint() { final PropertyConstraint<U> thisValidator = this; return ConstraintFactory.<Iterable<? extends U>>fromPredicate( new Predicate<Iterable<? extends U>>() { @Override public boolean test(Iterable<? extends U> us) { for (U u : us) { if (!thisValidator.test(u)) { return false; } } return true; } }, "Components " + StringUtils.uncapitalize(thisValidator.getConstraintDescription()) ); } };
.append(StringUtils.uncapitalize(propName)) .append(" shouldBe ") .append(stringVal);
/** * Construct a sample statistics metric * @param name of the metric * @param description of the metric * @param sampleName of the metric (e.g. "Ops") * @param valueName of the metric (e.g. "Time", "Latency") * @param extended create extended stats (stdev, min/max etc.) by default. */ public MutableStat(String name, String description, String sampleName, String valueName, boolean extended) { String ucName = StringUtils.capitalize(name); String usName = StringUtils.capitalize(sampleName); String uvName = StringUtils.capitalize(valueName); String desc = StringUtils.uncapitalize(description); String lsName = StringUtils.uncapitalize(sampleName); String lvName = StringUtils.uncapitalize(valueName); numInfo = info(ucName +"Num"+ usName, "Number of "+ lsName +" for "+ desc); iNumInfo = info(ucName +"INum"+ usName, "Interval number of "+ lsName +" for "+ desc); avgInfo = info(ucName +"Avg"+ uvName, "Average "+ lvName +" for "+ desc); stdevInfo = info(ucName +"Stdev"+ uvName, "Standard deviation of "+ lvName +" for "+ desc); iMinInfo = info(ucName +"IMin"+ uvName, "Interval min "+ lvName +" for "+ desc); iMaxInfo = info(ucName + "IMax"+ uvName, "Interval max "+ lvName +" for "+ desc); minInfo = info(ucName +"Min"+ uvName, "Min "+ lvName +" for "+ desc); maxInfo = info(ucName +"Max"+ uvName, "Max "+ lvName +" for "+ desc); this.extended = extended; }
public <T> T deserializer(HttpRequest request, String json, Class<? extends DTO<T>> dtoClass) { T result = null; try { String validationErrors = "", schema = ""; if (dtoClass.isAssignableFrom(HttpResponseDTO.class)) { validationErrors = httpResponseValidator.isValid(json); schema = httpResponseValidator.getSchema(); } else if (dtoClass.isAssignableFrom(HttpRequestDTO.class)) { validationErrors = httpRequestValidator.isValid(json); schema = httpRequestValidator.getSchema(); } if (StringUtils.isEmpty(validationErrors)) { result = objectMapper.readValue(json, dtoClass).buildObject(); } else { mockServerLogger.error(request, "validation failed:{}" + StringUtils.uncapitalize(dtoClass.getSimpleName()) + ":{}", validationErrors, json); } } catch (Exception e) { mockServerLogger.error(request, e, "Exception transforming json:{}", json); } return result; } }
@Override public void snapshot(MetricsRecordBuilder builder, boolean all) { if (all || changed()) { for (final Entry<String, LinkedBlockingDeque<SumAndCount>> entry : averages.entrySet()) { final String name = entry.getKey(); final MetricsInfo avgInfo = info( String.format(avgInfoNameTemplate, StringUtils.capitalize(name)), String.format(avgInfoDescTemplate, StringUtils.uncapitalize(name))); double totalSum = 0; long totalCount = 0; for (final SumAndCount sumAndCount : entry.getValue()) { totalCount += sumAndCount.getCount(); totalSum += sumAndCount.getSum(); } if (totalCount != 0) { builder.addGauge(avgInfo, totalSum / totalCount); } } if (changed()) { clearChanged(); } } }
@UserFunction @Description("apoc.text.decapitalizeAll(text) YIELD value - decapitalize the first letter of all words") public String decapitalizeAll(@Name("text") String text) { String[] parts = text.split(" "); StringBuilder output = new StringBuilder(); for (String part : parts) { output.append( StringUtils.uncapitalize(part) + " " ); } return output.toString().trim(); }
@Override public void setAsText(String text) throws IllegalArgumentException { if (text == null || "".equals(text)) { setValue(null); } // Symbol names never start with a capital text = StringUtils.uncapitalize(text); setValue(new JavaSymbolName(text)); } }
/** * This method provides the getModelAttributeMethod() method * * @return MethodMetadata */ private MethodMetadata getModelAttributeMethod() { return getModelAttributeMethod(StringUtils.uncapitalize(entity.getSimpleTypeName()), serviceMetadata, controllerMetadata.getServiceField()); }
@UserFunction @Description("apoc.text.decapitalize(text) YIELD value - decapitalize the first letter of the word") public String decapitalize(@Name("text") String text) { return StringUtils.uncapitalize(text); }
private JavaSymbolName getCollaboratingFieldName(final JavaType entity, final Set<ClassOrInterfaceTypeDetails> dataOnDemandClasses) { JavaSymbolName symbolName = null; JavaType collaboratingType = getCollaboratingType(entity, dataOnDemandClasses); if (collaboratingType != null) { symbolName = new JavaSymbolName(StringUtils.uncapitalize(collaboratingType.getSimpleTypeName())); } return symbolName; }
/** * Creates target class field for initializing in tests. * * @return {@link FieldMetadataBuilder} for building field into ITD. */ private FieldMetadataBuilder getTargetClassField(JavaType targetType) { FieldMetadataBuilder fieldBuilder = new FieldMetadataBuilder(getId(), Modifier.PRIVATE, new JavaSymbolName( StringUtils.uncapitalize(targetType.getSimpleTypeName())), targetType, null); return fieldBuilder; }