/** * Parses a String into a Character. * * @param charStr String to parse * * @return Parsed Character * @throws IllegalArgumentException if the String doesn't have length 1 */ public static Character charFrom(String charStr) { return CHARACTER_PARSER.valueOf(charStr); }
/** * Parses a String into a Double. * * @param numberString String to parse * * @return Parsed Double */ private static Double doubleFrom(String numberString) { return DOUBLE_PARSER.valueOf(numberString); }
@Override protected T createFrom(String toParse) { return parser.valueOf(toParse); } }
@Override protected Method createFrom(String toParse) { return METHOD_PARSER.valueOf(toParse); }
@Override protected Class createFrom(String toParse) { return ValueParserConstants.CLASS_PARSER.valueOf(toParse); }
@Override protected Float createFrom(String value) { return FLOAT_PARSER.valueOf(value); }
@Override protected V createFrom(String toParse) { return parser.valueOf(toParse); }
@Override public Class<?> createFrom(String valueString) { return ValueParserConstants.CLASS_PARSER.valueOf(valueString); }
@Override public Boolean createFrom(String propertyString) throws IllegalArgumentException { return BOOLEAN_PARSER.valueOf(propertyString); }
@Override public Method createFrom(String valueString) throws IllegalArgumentException { return METHOD_PARSER.valueOf(valueString); }
@Override protected Integer createFrom(String value) { return INTEGER_PARSER.valueOf(value); }
@Override protected Boolean createFrom(String toParse) { return BOOLEAN_PARSER.valueOf(toParse); }
/** * Constructor for MethodProperty using a string as a default value. * * @param theName Name of the property * @param theDescription Description * @param defaultMethodStr Default value, that will be parsed into a Method object * @param legalPackageNames Legal packages * @param theUIOrder UI order * * @deprecated will be removed in 7.0.0 */ public MethodProperty(String theName, String theDescription, String defaultMethodStr, String[] legalPackageNames, float theUIOrder) { this(theName, theDescription, METHOD_PARSER.valueOf(defaultMethodStr), legalPackageNames, theUIOrder, false); }
/** * Constructor for TypeProperty using a string as default value. * * @param theName String * @param theDescription String * @param defaultTypeStr String * @param legalPackageNames String[] * @param theUIOrder float * * @throws IllegalArgumentException if the default string could not be parsed into a Class * @deprecated will be removed in 7.0.0 */ public TypeProperty(String theName, String theDescription, String defaultTypeStr, String[] legalPackageNames, float theUIOrder) { this(theName, theDescription, ValueParserConstants.CLASS_PARSER.valueOf(defaultTypeStr), legalPackageNames, theUIOrder, false); }
/** * Parses a string into a list of values of type {@literal <U>}. * * @param toParse The string to parse * @param delimiter The delimiter to use * @param extractor The function mapping a string to an instance of {@code <U>} * @param <U> The type of the values to parse * * @return A list of values */ // FUTURE 1.8 : use java.util.function.Function<String, U> in place of ValueParser<U>, // replace ValueParser constants with static functions static <U> List<U> parsePrimitives(String toParse, char delimiter, ValueParser<U> extractor) { String[] values = StringUtils.split(toParse, delimiter); List<U> result = new ArrayList<>(); for (String s : values) { result.add(extractor.valueOf(s)); } return result; }
@Override protected void populate(T builder, Map<PropertyDescriptorField, String> fields) { super.populate(builder, fields); builder.defaultValue(parser.valueOf(fields.get(PropertyDescriptorField.DEFAULT_VALUE))); }
@Override protected void populate(T builder, Map<PropertyDescriptorField, String> fields) { super.populate(builder, fields); char delim = delimiterIn(fields, builder.multiValueDelimiter); builder.delim(delim).defaultValues(ValueParserConstants.multi(parser, delim) .valueOf(fields.get(PropertyDescriptorField.DEFAULT_VALUE))); }
private void registerTypeDependentValidators(PropertyTypeId typeId) { Validator<String> valueValidator = (c, val) -> ValidationResult.fromErrorIf(valueField, "The value couldn't be parsed", Try.tryGet(() -> getValueParser(typeId).valueOf(getValue())).isFailure()); validationSupport.registerValidator(valueField, valueValidator); }