+ Map<SchemaPath, List<AugmentationSchema>> augmentationsGrouped =
+ usesNode.getAugmentations().stream().collect(Collectors.groupingBy(AugmentationSchema::getTargetPath));
+ for (Map.Entry<SchemaPath, List<AugmentationSchema>> schemaPathAugmentListEntry : augmentationsGrouped.entrySet()) {
+ genCtx = AugmentToGenType.usesAugmentationToGenTypes(schemaContext, basePackageName,
+ schemaPathAugmentListEntry.getValue(), module,
+ usesNode, node, genCtx, genTypeBuilders, verboseClassComments, typeProvider, namespaceType);
+ for (AugmentationSchema augSchema : schemaPathAugmentListEntry.getValue()) {
+ genCtx = processUsesAugments(schemaContext, augSchema, module, genCtx, genTypeBuilders,
+ verboseClassComments, typeProvider, namespaceType);
+ }
+ }
+ }
+ return genCtx;
+ }
+
+ private static QName createQNameFromSuperNode(final Object node, final SchemaNode superChildNode) {
+ QName childNodeQName = null;
+ if (node instanceof Module) {
+ childNodeQName = QName.create(((Module)node).getNamespace(), ((Module)node).getRevision(),
+ superChildNode.getQName().getLocalName());
+ } else if (node instanceof SchemaNode) {
+ childNodeQName = QName.create(((SchemaNode)node).getQName(), superChildNode.getQName().getLocalName());
+ } else {
+ throw new IllegalArgumentException("Not support node type:" + node.toString());
+ }
+
+ return childNodeQName;
+ }
+
+ static void addUsesImplements(final SchemaNode superNode, final Module superModule,
+ final Object node, final Module module, final SchemaContext schemaContext,
+ Map<Module, ModuleContext> genCtx, final BindingNamespaceType namespaceType) {
+
+ if (superNode instanceof DataNodeContainer) {
+ for (DataSchemaNode superChildNode : ((DataNodeContainer)superNode).getChildNodes()) {
+ if (superChildNode instanceof DataNodeContainer || superChildNode instanceof ChoiceSchemaNode) {
+ final QName childQName = createQNameFromSuperNode(node, superChildNode);
+ DataSchemaNode childNode = ((DataNodeContainer)node).getDataChildByName(childQName);
+ Preconditions.checkNotNull(childNode, node.toString() + "->" + childQName.toString());
+
+ final GeneratedTypeBuilder type = genCtx.get(module).getChildNode(childNode.getPath());
+ final GeneratedTypeBuilder superType = genCtx.get(superModule).getChildNode(superChildNode.getPath());
+
+ //TODO:delete this after supporting uses augment
+ if (type == null || superType == null) {
+ return;
+ }
+ Preconditions.checkNotNull(type, module.toString() + "->" + childNode.getPath().toString());
+ Preconditions.checkNotNull(superType, superModule.toString() + "->" + superChildNode.getPath().toString());
+ type.addImplementsType(superType);
+ if (superChildNode instanceof ListSchemaNode
+ && !((ListSchemaNode) superChildNode).getKeyDefinition().isEmpty()) {
+ if (namespaceType.equals(BindingNamespaceType.Grouping)) {
+ genCtx.get(module).getKeyType(childNode.getPath())
+ .addImplementsType(genCtx.get(superModule).getKeyType(superChildNode.getPath()));
+ } else if (namespaceType.equals(BindingNamespaceType.Data)) {
+ genCtx.get(module).getKeyGenTO(childNode.getPath())
+ .addImplementsType(genCtx.get(superModule).getKeyType(superChildNode.getPath()));
+ }
+ }
+ addUsesImplements(superChildNode, superModule, childNode, module, schemaContext, genCtx, namespaceType);
+ }
+ }
+ } else if (superNode instanceof ChoiceSchemaNode) {
+ for (ChoiceCaseNode superCaseNode : ((ChoiceSchemaNode)superNode).getCases()) {
+ final QName childQName = createQNameFromSuperNode(node, superCaseNode);
+ ChoiceCaseNode caseNode = ((ChoiceSchemaNode)node).getCaseNodeByName(childQName);
+ Preconditions.checkNotNull(caseNode, node.toString() + "->" + childQName.toString());
+
+ final GeneratedTypeBuilder type = genCtx.get(module).getCase(caseNode.getPath());
+ final GeneratedTypeBuilder superType = genCtx.get(superModule).getCase(superCaseNode.getPath());
+ Preconditions.checkNotNull(type, module.toString() + "->" + caseNode.getPath().toString());
+ Preconditions.checkNotNull(superType, superModule.toString() + "->" + superCaseNode.getPath().toString());
+ type.addImplementsType(superType);
+ addUsesImplements(superCaseNode, superModule, caseNode, module, schemaContext, genCtx, namespaceType);
+ }
+ } else {
+ throw new IllegalArgumentException("Not support super node :" + superNode.toString());
+ }
+ }
+
+ private static GroupingDefinition findGroupingNodeFromUses(final Module module, final SchemaContext schemaContext,
+ final Object parentNode, final UsesNode usesNode) {
+ SchemaNode groupingNode;
+ if (parentNode instanceof Module) {
+ final Module superModule = schemaContext.findModuleByNamespaceAndRevision(
+ usesNode.getGroupingPath().getLastComponent().getModule().getNamespace(),
+ usesNode.getGroupingPath().getLastComponent().getModule().getRevision());
+ groupingNode = superModule.getGroupings()
+ .stream().filter(grouping -> grouping.getPath().equals(usesNode.getGroupingPath()))
+ .findFirst().orElse(null);
+ } else {
+ //FIXME: Schema path is not unique for Yang 1.1, findDataSchemaNode always does search from data node first.
+ groupingNode = SchemaContextUtil.findDataSchemaNode(schemaContext, usesNode.getGroupingPath());
+ }
+ Preconditions.checkNotNull(groupingNode, module.toString() + "->"
+ + usesNode.getGroupingPath().toString());
+ Preconditions.checkState(groupingNode instanceof GroupingDefinition,
+ module.toString() + "->" + usesNode.getGroupingPath().toString());
+ return (GroupingDefinition) groupingNode;
+ }
+
+ static Map<Module, ModuleContext> processUsesImplements(final Object node, final Module module,
+ final SchemaContext schemaContext, Map<Module, ModuleContext> genCtx, final BindingNamespaceType namespaceType) {
+ if (node instanceof DataNodeContainer) {
+ for (final UsesNode usesNode : ((DataNodeContainer)node).getUses()) {
+ final GroupingDefinition grouping = findGroupingNodeFromUses(module, schemaContext, node, usesNode);
+ final Module superModule = SchemaContextUtil.findParentModule(schemaContext, grouping);
+ addUsesImplements(grouping, superModule, node, module, schemaContext, genCtx, namespaceType);