protected void parseFields(ObjectType type, DslElementSyntax typeDsl, Map<String, ParameterRole> parametersRole) { type.getFields().forEach(f -> parseField(type, typeDsl, f, parametersRole)); }
@Override public void visitObject(ObjectType objectType) { if (objectType.getMetadataFormat() != JAVA) { return; } final String clazz = getId(objectType).orElse(null); if (clazz == null || relativeClasses.contains(clazz)) { return; } Optional<ClassInformationAnnotation> classInformation = objectType.getAnnotation(ClassInformationAnnotation.class); classInformation .ifPresent(classInformationAnnotation -> relativeClasses .addAll(classInformationAnnotation.getGenericTypes())); relativeClasses.add(clazz); objectType.getFields().forEach(objectFieldType -> objectFieldType.accept(this)); objectType.getOpenRestriction().ifPresent(t -> t.accept(this)); }
private void createObjectValueFromType(ObjectType objectType, ParameterObjectValue.Builder objectValue, ConfigLine config, DslElementSyntax paramDsl) { getId(objectType).ifPresent(objectValue::ofType); objectType.getFieldByName(CONFIG_ATTRIBUTE_NAME) .map(f -> config.getConfigAttributes().get(CONFIG_ATTRIBUTE_NAME)) .ifPresent(configRef -> objectValue.withParameter(CONFIG_ATTRIBUTE_NAME, ParameterSimpleValue.of(configRef.getValue(), STRING))); copyExplicitAttributes(config.getConfigAttributes(), objectValue, objectType); config.getChildren().forEach(fieldConfig -> objectType.getFields().stream() .filter(fieldType -> paramDsl.getContainedElement(getLocalPart(fieldType)) .map(fieldDsl -> fieldDsl.getElementName().equals(fieldConfig.getIdentifier())).orElse(false)) .findFirst() .ifPresent(fieldType -> fieldType.getValue().accept( getParameterDeclarerVisitor(fieldConfig, paramDsl .getContainedElement(getLocalPart(fieldType)) .get(), fieldValue -> objectValue .withParameter(getLocalPart(fieldType), fieldValue))))); }
@Override public void visitObject(ObjectType objectType) { type = new DefaultObjectType(objectType.getFields(), objectType.isOrdered(), objectType.getOpenRestriction().orElse(null), objectType.getMetadataFormat(), getAllTypeAnnotationsMap()); }
@Override public void visitObject(ObjectType objectType) { if (objectType.isOpen()) { objectType.getOpenRestriction().get().accept(this); } else { declarer.withType(objectType); } }
@Override public void visitObject(ObjectType objectType) { if (!registeredTypes.contains(objectType)) { registeredTypes.add(objectType); objectType.getAnnotation(StereotypeTypeAnnotation.class).ifPresent(a -> a.resolveStereotypes(resolver)); objectType.getFields().forEach(f -> f.getValue().accept(this)); } }
@Override public void visitObject(ObjectType objectType) { if (!visitedTypes.add(objectType)) { return; } if (isMap(objectType)) { objectType.getAnnotation(ClassInformationAnnotation.class) .filter(classInformation -> !classInformation.getGenericTypes().isEmpty()) .filter(classInformation -> !Objects.equals(classInformation.getGenericTypes().get(0), String.class.getName())) .ifPresent(classInformation -> problemsReporter.addError(new Problem(parameter, format( "Parameter '%s' is of type '%s' and its key type is not %s ", parameter.getName(), getType(objectType).getName(), String.class.getName())))); objectType.getOpenRestriction().get().accept(this); } else { parameter.getModelProperty(ExtensionParameterDescriptorModelProperty.class) .map(descriptor -> descriptor.getExtensionParameter().getType()) .ifPresent(type -> { final String typeName = type.getName(); type.getFields() .forEach(field -> checkInvalidFieldAnnotations(parameter, typeName, field, ConfigOverride.class, ComponentId.class, MetadataKeyId.class, MetadataKeyPart.class)); }); } objectType.getFields().forEach(f -> f.getValue().accept(this)); }
@Override public void visitObject(ObjectType objectType) { if (!isCustomStaticType(objectType)) { objectType.getOpenRestriction().ifPresent(t -> checkValidType(component, extensionModel, t, problemsReporter)); checkValidType(component, extensionModel, objectType, problemsReporter); } }
private void writeObject(ObjectType objectType) { if (objectType.isOrdered()) { content.append("{"); indent(); newLine(); final Collection<ObjectFieldType> fields = objectType.getFields(); int i = 0; for (ObjectFieldType field : fields) { i++; Optional<MetadataType> openRestriction = objectType.getOpenRestriction(); if (openRestriction.isPresent()) { if (!fields.isEmpty()) { writeIndent(); content.append("}"); if (objectType.isOrdered()) { content.append("}");
@Override public void visitObject(ObjectType objectType) { boolean canBeGlobal = objectType.getAnnotation(TypeDslAnnotation.class) .map(TypeDslAnnotation::allowsTopLevelDefinition).orElse(false); if (canBeGlobal) { getHashedGlobal(value).ifPresent(reference::set); } }
private MetadataType getMetadataTypeFromObjectType(ObjectType objectMetadataType, String configParamName, String modelParamName) { MetadataType childMetadataType; Optional<ObjectFieldType> fieldByName = objectMetadataType.getFieldByName(configParamName); if (fieldByName.isPresent()) { ObjectFieldType objectFieldType = fieldByName.get(); if (objectFieldType.getValue() instanceof ObjectType) { childMetadataType = objectFieldType; } else if (objectFieldType.getValue() instanceof org.mule.metadata.api.model.SimpleType) { childMetadataType = objectFieldType.getValue(); } else if (objectFieldType.getValue() instanceof UnionType) { childMetadataType = getChildMetadataTypeFromUnion((UnionType) objectFieldType.getValue(), modelParamName); } else { throw new IllegalStateException("Unsupported attribute type: " + objectFieldType.getValue().getClass().getName()); } } else { childMetadataType = getMetadataTypeFromFlattenedFields(objectMetadataType, modelParamName); } return childMetadataType; }
private void resolveStereotype(ObjectType type, Function<Class<? extends StereotypeDefinition>, StereotypeModel> resolver) { type.accept(new MetadataTypeVisitor() { // This is created to avoid a recursive types infinite loop, producing an StackOverflow when resolving the stereotypes. private List<MetadataType> registeredTypes = new LinkedList<>(); @Override public void visitObject(ObjectType objectType) { if (!registeredTypes.contains(objectType)) { registeredTypes.add(objectType); objectType.getAnnotation(StereotypeTypeAnnotation.class).ifPresent(a -> a.resolveStereotypes(resolver)); objectType.getFields().forEach(f -> f.getValue().accept(this)); } } @Override public void visitArrayType(ArrayType arrayType) { arrayType.getType().accept(this); } @Override public void visitUnion(UnionType unionType) { unionType.getTypes().forEach(t -> t.accept(this)); } @Override public void visitIntersection(IntersectionType intersectionType) { intersectionType.getTypes().forEach(t -> t.accept(this)); } }); }
private void checkValidType(ConnectableComponentModel componentModel, ExtensionModel extensionModel, MetadataType metadataType, ProblemsReporter problemsReporter) { String componentTypeName = getComponentModelTypeName(componentModel); getType(metadataType).ifPresent(type -> { String declarationMessageModifier = ""; MetadataType modelType = componentModel.getOutput().getType(); if (modelType instanceof ArrayType) { declarationMessageModifier = "a collection of "; } else if (modelType instanceof ObjectType && ((ObjectType) modelType).isOpen()) { declarationMessageModifier = "a map of "; } if (Object.class.equals(type)) { problemsReporter.addError(new Problem(extensionModel, format("%s '%s' declares %s'%s' as its return type. Components that return a type " + "such as Object or Map (or a collection of any of those) must have defined an OutputResolver", capitalize(componentTypeName), componentModel.getName(), declarationMessageModifier, type))); } else if (isInvalidInterface(metadataType, type)) { problemsReporter.addError(new Problem(extensionModel, format("%s '%s' declares %s'%s' as its return type. Components that return an interface " + "(or a collection of interfaces) must have defined an OutputResolver", capitalize(componentTypeName), componentModel.getName(), declarationMessageModifier, type))); } }); }
private List<XmlExtensionElementDocumentation> getTypesDocumentation(ExtensionModel extensionModel) { List<XmlExtensionElementDocumentation> types = new ArrayList<>(); extensionModel.getTypes().forEach(type -> ExtensionMetadataTypeUtils.getId(type) .ifPresent(id -> { XmlExtensionElementDocumentation element = new XmlExtensionElementDocumentation(); element.setName(id); element.setDescription(type.getAnnotation(DescriptionAnnotation.class) .map(DescriptionAnnotation::getValue).orElse("")); element.setParameters(type.getFields().stream() .map(f -> new XmlExtensionParameterDocumentation(getAlias(f), f.getAnnotation(DescriptionAnnotation.class) .map(DescriptionAnnotation::getValue).orElse(""))) .collect(toList())); types.add(element); })); return types; }
@Override public void visitObject(ObjectType objectType) { type = new DefaultObjectType(objectType.getFields(), objectType.isOrdered(), objectType.getOpenRestriction().orElse(null), objectType.getMetadataFormat(), getAllTypeAnnotationsMap()); }
private void assertDictionary(MetadataType metadataType, Class<?> valueType) { assertThat(metadataType, is(instanceOf(ObjectType.class))); ObjectType dictionaryType = (ObjectType) metadataType; assertType(dictionaryType, Map.class); assertThat(dictionaryType.getOpenRestriction().isPresent(), is(true)); assertType(dictionaryType.getOpenRestriction().get(), valueType); }
private void createWrappedObject(ObjectType objectType, ParameterObjectValue.Builder objectValue, ConfigLine config) { ConfigLine wrappedConfig = config.getChildren().get(0); DslSyntaxResolver wrappedElementResolver = resolvers.get(getNamespace(wrappedConfig)); Set<ObjectType> subTypes = context.getTypeCatalog().getSubTypes(objectType); if (!subTypes.isEmpty()) { subTypes.stream() .filter(subType -> wrappedElementResolver.resolve(subType) .map(dsl -> dsl.getElementName().equals(wrappedConfig.getIdentifier())) .orElse(false)) .findFirst() .ifPresent(subType -> createObjectValueFromType(subType, objectValue, wrappedConfig, wrappedElementResolver.resolve(subType).get())); } else if (objectType.getAnnotation(ExtensibleTypeAnnotation.class).isPresent()) { createObjectValueFromType(objectType, objectValue, wrappedConfig, wrappedElementResolver.resolve(objectType).get()); } }
@Override public void visitObject(ObjectType objectType) { if (objectType.isOpen()) { objectType.getOpenRestriction().get().accept(this); } else { declarer.withType(objectType); } }
@Override public Optional<MetadataType> getVariableType(String varName) { return getVariables().getFieldByName(varName).map(ObjectFieldType::getValue); }
type.accept(getParameterDeclarerVisitor(configLine, dsl.resolve(type).get(), value -> topLevelParameter.withValue((ParameterObjectValue) value)));