public static void checkReferences(ListOverlay<?> list, ValidationResults results) { Overlay<?> listAdapter = Overlay.of(list); for (int i = 0; i < list.size(); i++) { if (listAdapter.isReference(i)) { checkReference(listAdapter.getReference(i), results, Overlay.of(list, i)); } } }
@Override public String getKey() { return overlay.getParent() instanceof MapOverlay<?> ? overlay.getPathInParent() : null; }
private String getPathString(Parameter parameter) { PropertiesOverlay<?> parent = Overlay.of(parameter).getParentPropertiesOverlay(); while (parent != null && !(parent instanceof Path)) { parent = Overlay.of(parent).getParentPropertiesOverlay(); } return parent != null && parent instanceof Path ? Overlay.getPathInParent(parent) : null; }
public static void checkReferences(PropertiesOverlay<?> props, ValidationResults results) { if (props._isElaborated()) { Overlay<?> propsAdapter = Overlay.of(props); for (String name : propsAdapter.getPropertyNames()) { if (propsAdapter.isReference(name)) { checkReference(propsAdapter.getReference(name), results, Overlay.of(props, name, Object.class)); } } } }
@SafeVarargs public final <F> Overlay<F> validateField(String name, boolean required, Class<F> fieldClass, Validator<F> validator, Consumer<Overlay<F>>... otherChecks) { @SuppressWarnings("unchecked") PropertiesOverlay<V> propValue = (PropertiesOverlay<V>) value.get(); Overlay<F> field = Overlay.of(propValue, name, fieldClass); checkJsonType(field, getAllowedJsonTypes(field), results); checkMissing(field, required); if (field != null && field.isPresent() && validator != null) { validator.validate(field); for (Consumer<Overlay<F>> otherCheck : otherChecks) { otherCheck.accept(field); } } return field; }
public <X> Overlay<Map<String, X>> validateMapField(String name, boolean nonEmpty, boolean unique, Class<X> valueClass, Validator<X> valueValidator) { @SuppressWarnings("unchecked") Overlay<Map<String, X>> map = (Overlay<Map<String, X>>) (Object) Overlay.of((PropertiesOverlay<V>) value.get(), name, Map.class); validateMap(map, nonEmpty, unique, valueValidator); return map; }
private String interpolate(final String pattern) { String result = pattern.replaceAll("\\$\\{TypeName\\}", this.type.getName()); result = result.replaceAll("\\$\\{RealizationRuleName\\}", Overlay.<Base>of(this.rule).getPathInParent()); return result; }
public void checkAllSchemesDefined(Overlay<Map<String, SecurityParameter>> requirements) { OpenApi3 model = value.getModel(); Set<String> definedSchemes = model.getSecuritySchemes().keySet(); MapOverlay<SecurityParameter> mapOverlay = Overlay.getMapOverlay(requirements); for (String name : mapOverlay.keySet()) { if (!definedSchemes.contains(name)) { results.addError(msg(UnkSecScheme, name), Overlay.of(mapOverlay, name)); } } } }
void checkExampleExclusion(Overlay<Map<String, Example>> examples, Overlay<Object> example) { boolean examplesPresent = examples != null && examples.isPresent() && Overlay.getMapOverlay(examples).size() > 0; boolean examplePresent = example != null && example.isPresent(); if (examplesPresent && examplePresent) { results.addError("ExmplExclusion|The 'example' and 'exmaples' properties may not both appear", value); } } }
void checkMissing(Overlay<?> field, boolean required) { if (required && (field == null || !field.isPresent())) { results.addError(msg(MissingField, field.getPathInParent()), value); } }
private Operation checkValidOperation(Link link) { String opId = link.getOperationId(); String operationRef = link.getOperationRef(); Operation op = null; if (opId == null && operationRef == null) { results.addError(msg(NoOpIdNoOpRefInLink), value); } else if (opId != null && operationRef != null) { results.addError(msg(OpIdAndOpRefInLink), value); } if (opId != null) { op = findOperationById(Overlay.of(link).getModel(), opId); if (op == null) { results.addError(msg(OpIdNotFound, opId), value); } } String relativePath = getRelativePath(operationRef, results); if (relativePath != null) { op = findOperationByPath(Overlay.of(link).getModel(), relativePath, results); if (op == null) { results.addError(msg(OpPathNotFound, operationRef), value); } } return op; }
public static PropertiesOverlay<?> getPropertiesOverlay(Overlay<PropertiesOverlay<?>> overlay) { if (overlay.getOverlay() instanceof PropertiesOverlay) { return (PropertiesOverlay<?>) overlay.getOverlay(); } else { return null; } }
public static <X> MapOverlay<X> getMapOverlay(Overlay<Map<String, X>> overlay) { if (overlay.getOverlay() instanceof MapOverlay) { MapOverlay<X> castOverlay = getSidebandOverlay(overlay.get()); return castOverlay; } else { return null; } }
public Overlay<Map<String, Object>> validateExtensions(Map<String, Object> extensions, String crumb) { Overlay<Map<String, Object>> mapOverlay = Overlay.of(extensions); validateMap(mapOverlay, false, false, null); return mapOverlay; }
@Override public void runValidations() { MapOverlay<T> mapOverlay = Overlay.getMapOverlay(value); if (valueValidator != null) { for (String key : mapOverlay.keySet()) { valueValidator.validate(Overlay.of(mapOverlay, key)); } } } }
@Override public void runValidations() { if (itemValidator != null) { ListOverlay<T> list = Overlay.getListOverlay(value); for (int i = 0; i < list.size(); i++) { itemValidator.validate(Overlay.of(list, i)); } } } }
private <X> void checkListNotEmpty(Overlay<List<X>> list, boolean nonEmpty) { if (nonEmpty) { ListOverlay<X> listOverlay = Overlay.getListOverlay(list); if (list != null && !list.isPresent()) { if (nonEmpty && listOverlay.size() == 0) { results.addError(msg(EmptyList), list); } } } }
private void checkContentType() { if (value.getPathInParent().equalsIgnoreCase("Content-Type")) { results.addWarning(msg(IgnContType), value); } } }