private static boolean isPrimitive(final ParameterMeta next) { return Stream .of(ParameterMeta.Type.STRING, ParameterMeta.Type.BOOLEAN, ParameterMeta.Type.ENUM, ParameterMeta.Type.NUMBER) .anyMatch(v -> v == next.getType()); }
private JsonValue onArrayPrimitive(final ParameterMeta itemDef, final ArrayEntry e) { final String value = e.entry.getValue(); switch (itemDef.getType()) { case BOOLEAN: return Boolean.parseBoolean(value.trim()) ? JsonValue.TRUE : JsonValue.FALSE; case NUMBER: final Double number = Double.valueOf(value.trim()); return number == number.longValue() ? jsonp.createValue(number.longValue()) : jsonp.createValue(number); case ENUM: case STRING: return jsonp.createValue(value); default: throw new IllegalArgumentException("Unsupported structure in " + "array: " + itemDef.getType()); } }
public String findDefault(final Object instance, final ParameterMeta param) { if (instance == null) { return null; } final ParameterMeta.Type type = param.getType(); switch (type) { case OBJECT: return null; case ENUM: return Enum.class.cast(instance).name(); case STRING: case NUMBER: case BOOLEAN: return String.valueOf(instance); case ARRAY: // can be enhanced if (!param.getNestedParameters().isEmpty()) { return null; } else if (Collection.class.isInstance(instance)) { return ((Collection<Object>) instance).stream().map(String::valueOf).collect(joining(",")); } else { // primitives return String.valueOf(instance); } default: throw new IllegalArgumentException("Unsupported type: " + param.getType()); } }
private Stream<AbstractMap.SimpleEntry<String, ParameterMeta>> toFlatNonPrimitivConfig(final List<ParameterMeta> config) { if (config == null || config.isEmpty()) { return empty(); } return config .stream() .filter(Objects::nonNull) .filter(p -> OBJECT.equals(p.getType()) || isArrayOfObject(p)) .filter(p -> p.getNestedParameters() != null) .flatMap(p -> concat(of(new AbstractMap.SimpleEntry<>(toJavaType(p).getName(), p)), toFlatNonPrimitivConfig(p.getNestedParameters()))); }
private String findDefault(final ParameterMeta p, final DefaultValueInspector.Instance instance) { if (instance == null || instance.getValue() == null || instance.isCreated()) { return null; } switch (p.getType()) { case NUMBER: case BOOLEAN: case STRING: case ENUM: return ofNullable(instance.getValue()) .map(String::valueOf) .map(it -> it.isEmpty() ? "<empty>" : it) .orElse(null); case ARRAY: return String .valueOf(Collection.class.isInstance(instance.getValue()) ? Collection.class.cast(instance.getValue()).size() : Array.getLength(instance.getValue())); case OBJECT: default: return null; } }
switch (param.getType()) { case OBJECT: return map(param.getNestedParameters(), value, indexes);
private Class<?> toJavaType(final ParameterMeta p) { if (p.getType().equals(OBJECT) || p.getType().equals(ENUM)) { if (Class.class.isInstance(p.getJavaType())) { return Class.class.cast(p.getJavaType()); } throw new IllegalArgumentException("Unsupported type for parameter " + p.getPath() + " (from " + p.getSource().declaringClass() + "), ensure it is a Class<?>"); } if (p.getType().equals(ARRAY) && ParameterizedType.class.isInstance(p.getJavaType())) { final ParameterizedType parameterizedType = ParameterizedType.class.cast(p.getJavaType()); final Type[] arguments = parameterizedType.getActualTypeArguments(); if (arguments.length == 1 && Class.class.isInstance(arguments[0])) { return Class.class.cast(arguments[0]); } throw new IllegalArgumentException("Unsupported type for parameter " + p.getPath() + " (from " + p.getSource().declaringClass() + "), " + "ensure it is a ParameterizedType with one argument"); } throw new IllegalStateException("Parameter '" + p.getName() + "' is not an object."); }
final String name = definition.getName(); final String newPath = contextualPrefix + (contextualPrefix.isEmpty() ? "" : ".") + name; switch (definition.getType()) { case OBJECT: { onObject(definitions, definition, config, json, name, newPath);
private ParameterMeta translate(final ParameterMeta config, final int replacedPrefixLen, final String newPrefix) { return new ParameterMeta(config.getSource(), config.getJavaType(), config.getType(), newPrefix + config.getPath().substring(replacedPrefixLen), config.getPath().length() == replacedPrefixLen ? newPrefix : config.getName(), config.getI18nPackages(), config .getNestedParameters() .stream() .map(it -> translate(it, replacedPrefixLen, newPrefix)) .collect(toList()), config.getProposals(), config.getMetadata(), config.isLogMissingResourceBundle()); } }
final String path = sanitizePropertyName(p.getPath()); final String name = sanitizePropertyName(p.getName()); final String type = p.getType().name(); final boolean isEnum = p.getType() == ParameterMeta.Type.ENUM; PropertyValidation validation = propertyValidationService.map(p.getMetadata()); if (isEnum) {