Preconditions.checkState(module.getAugmentations() != null, "Augmentations Set cannot be NULL.");
final String basePackageName = BindingMapping.getRootPackageName(module);
- final List<AugmentationSchema> augmentations = resolveAugmentations(module);
+ final List<AugmentationSchema> augmentations = resolveAugmentations(module, schemaContext);
Map<Module, ModuleContext> resultCtx = genCtx;
//let's group augments by target path
verboseClassComments, resultCtx, genTypeBuilders, typeProvider);
for (AugmentationSchema augSchema : schemaPathAugmentListEntry.getValue()) {
- GenHelperUtil.processUsesAugments(schemaContext, augSchema, module, genCtx,
- genTypeBuilders, verboseClassComments, typeProvider);
+ GenHelperUtil.processUsesImplements(augSchema, module, schemaContext, genCtx, BindingNamespaceType.Data);
}
}
* @throws IllegalStateException
* if set of module augmentations is null
*/
- private static List<AugmentationSchema> resolveAugmentations(final Module module) {
+ private static List<AugmentationSchema> resolveAugmentations(final Module module, final SchemaContext schemaContext) {
Preconditions.checkArgument(module != null, "Module reference cannot be NULL.");
Preconditions.checkState(module.getAugmentations() != null, "Augmentations Set cannot be NULL.");
final Set<AugmentationSchema> augmentations = module.getAugmentations();
- final List<AugmentationSchema> sortedAugmentations = new ArrayList<>(augmentations);
+ final List<AugmentationSchema> sortedAugmentations = new ArrayList<>(augmentations).stream()
+ .filter(aug -> !module.equals(findAugmentTargetModule(schemaContext, aug)))
+ .collect(Collectors.toList());
Collections.sort(sortedAugmentations, AUGMENT_COMP);
return sortedAugmentations;
}
+ public static Module findAugmentTargetModule(final SchemaContext schemaContext , final AugmentationSchema aug) {
+ Preconditions.checkNotNull(aug, "Augmentation schema can not be null.");
+ final QName first = aug.getTargetPath().getPathFromRoot().iterator().next();
+ return schemaContext.findModuleByNamespaceAndRevision(first.getNamespace(), first.getRevision());
+ }
+
/**
* Converts <code>augSchema</code> to list of <code>Type</code> which
* contains generated type for augmentation. In addition there are also
throw new NullPointerException("Target type not yet generated: " + targetSchemaNode);
}
- final String augmentNamespacePackageName =
- BindingGeneratorUtil.packageNameForAugmentedGeneratedType(basePackageName, targetPath);
+ final String augmentPackageName =
+ BindingGeneratorUtil.packageNameWithNamespacePrefix(basePackageName, BindingNamespaceType.Data);
if (!(targetSchemaNode instanceof ChoiceSchemaNode)) {
- genCtx = GenHelperUtil.addRawAugmentGenTypeDefinition(module, augmentNamespacePackageName,
- targetTypeBuilder.toInstance(), schemaPathAugmentListEntry.getValue(), genTypeBuilders, genCtx,
- schemaContext, verboseClassComments, typeProvider);
+ genCtx = GenHelperUtil.addRawAugmentGenTypeDefinition(module, augmentPackageName,
+ targetTypeBuilder.toInstance(), targetSchemaNode, schemaPathAugmentListEntry.getValue(), genTypeBuilders, genCtx,
+ schemaContext, verboseClassComments, typeProvider, BindingNamespaceType.Data);
} else {
genCtx = generateTypesFromAugmentedChoiceCases(schemaContext, module, basePackageName,
targetTypeBuilder.toInstance(), (ChoiceSchemaNode) targetSchemaNode,
schemaPathAugmentListEntry.getValue(),
- null, genCtx, verboseClassComments, genTypeBuilders, typeProvider);
+ null, genCtx, verboseClassComments, genTypeBuilders, typeProvider,
+ BindingNamespaceType.Data);
}
return genCtx;
}
+ @Deprecated
static Map<Module, ModuleContext> usesAugmentationToGenTypes(final SchemaContext schemaContext,
final String augmentPackageName, final List<AugmentationSchema> schemaPathAugmentListEntry, final Module module,
final UsesNode usesNode, final DataNodeContainer usesNodeParent, Map<Module, ModuleContext> genCtx,
Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final boolean verboseClassComments,
- final TypeProvider typeProvider) {
+ final TypeProvider typeProvider, final BindingNamespaceType namespaceType) {
Preconditions.checkArgument(augmentPackageName != null, "Package Name cannot be NULL.");
Preconditions.checkArgument(schemaPathAugmentListEntry != null,
(AugmentationSchema)usesNodeParent);
}
genCtx = GenHelperUtil.addRawAugmentGenTypeDefinition(module, packageName,
- targetTypeBuilder.toInstance(), schemaPathAugmentListEntry, genTypeBuilders, genCtx,
- schemaContext, verboseClassComments, typeProvider);
+ targetTypeBuilder.toInstance(), targetSchemaNode, schemaPathAugmentListEntry, genTypeBuilders, genCtx,
+ schemaContext, verboseClassComments, typeProvider, namespaceType);
return genCtx;
} else {
genCtx = generateTypesFromAugmentedChoiceCases(schemaContext, module, augmentPackageName,
targetTypeBuilder.toInstance(), (ChoiceSchemaNode) targetSchemaNode,
schemaPathAugmentListEntry,
- usesNodeParent, genCtx, verboseClassComments, genTypeBuilders, typeProvider);
+ usesNodeParent, genCtx, verboseClassComments, genTypeBuilders, typeProvider, namespaceType);
return genCtx;
}
}
final List<AugmentationSchema> schemaPathAugmentListEntry,
final DataNodeContainer usesNodeParent,
Map<Module, ModuleContext> genCtx, final boolean verboseClassComments,
- Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider) {
+ Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider,
+ final BindingNamespaceType namespaceType) {
Preconditions.checkArgument(basePackageName != null, "Base Package Name cannot be NULL.");
Preconditions.checkArgument(targetType != null, "Referenced Choice Type cannot be NULL.");
Preconditions.checkArgument(schemaPathAugmentListEntry != null, "Set of Choice Case Nodes cannot be NULL.");
for (final AugmentationSchema augmentationSchema : schemaPathAugmentListEntry) {
for (final DataSchemaNode caseNode : augmentationSchema.getChildNodes()) {
if (caseNode != null) {
- final String packageName = BindingGeneratorUtil.packageNameForGeneratedType(basePackageName,
- caseNode.getPath(), BindingNamespaceType.Data);
- final GeneratedTypeBuilder caseTypeBuilder = GenHelperUtil.addDefaultInterfaceDefinition(packageName,
- caseNode, module, genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider);
+ final GeneratedTypeBuilder caseTypeBuilder = GenHelperUtil.addDefaultInterfaceDefinition(basePackageName,
+ caseNode, module, genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider,
+ namespaceType);
caseTypeBuilder.addImplementsType(targetType);
SchemaNode parent;
final Iterable<DataSchemaNode> childNodes = node.getChildNodes();
if (childNodes != null) {
GenHelperUtil.resolveDataSchemaNodes(module, basePackageName, caseTypeBuilder, childOfType,
- childNodes, genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider);
+ childNodes, genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider,
+ namespaceType);
}
genCtx.get(module).addCaseType(caseNode.getPath(), caseTypeBuilder);
genCtx.get(module).addChoiceToCaseMapping(targetType, caseTypeBuilder, node);