public void generateAutoRealizations(ZenModel model) { for (ResourceAPI resourceAPI : model.getResourceAPIs()) { new RealizationProcessor(resourceAPI).generateAutoRealizations(); } }
protected void processResource(ResourceDefinition resource) { if (resource instanceof ObjectResource) { processObjectResource((ObjectResource) resource); } else if (resource instanceof CollectionResource) { processCollectionResource((CollectionResource) resource); } }
public void checkAutoRealizationNameCollisions(ZenModel model) { for (ResourceAPI resourceAPI : model.getResourceAPIs()) { RealizationProcessor processor = new RealizationProcessor(resourceAPI); try { processor.generateAutoRealizations(); } catch (RealizationModelParseException e) { // ignore return; } IRealizationProcessor realizationProcessor = processor.getRealizationProcessor(); if (realizationProcessor instanceof AutoRealizationProcessor) { ((AutoRealizationProcessor) realizationProcessor) // .getRegistry() // .getNameCollisions() // .ifPresent(collisions -> { String message = collisions.keySet() // .stream() // .map(key -> key + " for realizations " + collisions.get(key)) // .collect(Collectors.joining(" and ")); error("Name collisions detected, " + message, model, RapidmlPackage.Literals.ZEN_MODEL__RESOURCE_AP_IS); }); } } }
protected void processCollectionResource(CollectionResource collectionResource) { maybeSetWithDefaultRealization(collectionResource); RealizationRule rule = null; if (collectionResource.isWithDefaultRealization()) { rule = autoRealizationProcessor.processCollectionResource(collectionResource); if (rule != null) { storeAutoRealization(collectionResource).accept(rule); } } // This sets collectionResource.getResourceRealizationKind() boolean hasRealizationRule = rule != null; generateImplicitCollectionLinks(collectionResource, hasRealizationRule); boolean isReferenceLinkList = collectionResource .getResourceRealizationKind() == CollectionRealizationEnum.REFERENCE_LINK_LIST; if (!isReferenceLinkList) { processNestedReferenceTreatments(collectionResource, collectionResource); if (!collectionResource.isDefault()) { referenceTreatmentNormalizer.normalizeUserDefinedReferenceTreatments(collectionResource, collectionResource.getDataType()); } } }
Structure type = realizationContainer.getActualType(); .filter(isIncluded(realizationContainer.getProperties()).and(isNotDefined(realizationContainer))); processReferenceProperty(reference, contextResourceOrMessage)// .ifPresent(referenceTreatment -> { realizationContainer.getReferenceTreatments().add(referenceTreatment); .forEach(e -> processNestedReferenceTreatments(e.getReferenceRealization(), contextResourceOrMessage));
protected void processObjectResource(ObjectResource objectResource) { maybeSetWithDefaultRealization(objectResource); if (!objectResource.isDefault()) { referenceTreatmentNormalizer.normalizeUserDefinedReferenceTreatments(objectResource, objectResource.getDataType()); } if (objectResource.isWithDefaultRealization()) { RealizationRule rule = autoRealizationProcessor.processObjectResource(objectResource); if (rule != null) { storeAutoRealization(objectResource).accept(rule); } } processNestedReferenceTreatments(objectResource, objectResource); }
public void generateAutoRealizations() { for (ResourceDefinition resource : resourceAPI.getOwnedResourceDefinitions()) { processResource(resource); for (Method method : resource.getMethods()) { processMessage(method.getRequest()); for (TypedMessage message : method.getResponses()) { processMessage(message); } } } }
protected void processMessage(TypedMessage message) { if (message.getActualType() == null) { // no realization processing required for a dataless message return; } maybeSetWithDefaultRealization(message); if (message.getResourceType() instanceof ServiceDataResource // instanceof also checks for non-null && ((ServiceDataResource) message.getResourceType()).isWithDefaultRealization()) { message.setWithDefaultRealization(true); message.setEffectiveRealization( ((ServiceDataResource) message.getResourceType()).getEffectiveRealization()); } if (message.getResourceType() != null) { // should re-use realization of the resource return; } if (message.isWithDefaultRealization()) { RealizationRule rule = autoRealizationProcessor.processMessage(message); if (rule != null) { storeAutoRealization(message).accept(rule); } } if (message.getActualType() != null) { referenceTreatmentNormalizer.normalizeUserDefinedReferenceTreatments(message, message.getActualType()); } processNestedReferenceTreatments(message, message); }