import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
+import javax.annotation.Nullable;
import org.opendaylight.mdsal.binding.javav2.generator.context.ModuleContext;
import org.opendaylight.mdsal.binding.javav2.generator.spi.TypeProvider;
import org.opendaylight.mdsal.binding.javav2.generator.util.BindingGeneratorUtil;
return module.equals(originalModule);
}
- static GeneratedTypeBuilder addDefaultInterfaceDefinition(final String basePackageName, final SchemaNode
- schemaNode, final Module module, final Map<Module, ModuleContext> genCtx, final SchemaContext schemaContext,
- final boolean verboseClassComments, final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders,
- final TypeProvider typeProvider, final BindingNamespaceType namespaceType) {
- return addDefaultInterfaceDefinition(basePackageName, schemaNode, null, module, genCtx, schemaContext,
- verboseClassComments, genTypeBuilders, typeProvider , namespaceType);
- }
-
private static QName createQNameFromSuperNode(final Module module, final Object node, final SchemaNode superChildNode) {
QName childNodeQName = null;
if (node instanceof Module) {
* string contains the module package name
* @param schemaNode
* schema node for which is created generated type builder
- * @param parent
- * parent type (can be null)
+ * @param childOf
+ * parent generated type of data tree node, which should be
+ * set null if current schema node is not a data tree node.
* @param schemaContext schema context
* @return generated type builder <code>schemaNode</code>
*/
- private static GeneratedTypeBuilder addDefaultInterfaceDefinition(final String basePackageName, final SchemaNode
- schemaNode, final Type parent, final Module module, final Map<Module, ModuleContext> genCtx,
+ public static GeneratedTypeBuilder addDefaultInterfaceDefinition(final String basePackageName, final SchemaNode
+ schemaNode, @Nullable final Type childOf, final Module module, final Map<Module, ModuleContext> genCtx,
final SchemaContext schemaContext, final boolean verboseClassComments, final Map<String, Map<String,
GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider, final BindingNamespaceType namespaceType) {
GeneratedTypeBuilder it = addRawInterfaceDefinition(basePackageName, schemaNode, schemaContext, "", "",
verboseClassComments, genTypeBuilders, namespaceType, genCtx.get(module));
+
if (namespaceType.equals(BindingNamespaceType.Data)) {
- if (parent == null) {
+ if (childOf == null) {
it.addImplementsType(BindingTypes.TREE_NODE);
} else {
if (!(schemaNode instanceof ListSchemaNode) ||
((ListSchemaNode) schemaNode).getKeyDefinition().isEmpty()) {
- it.addImplementsType(parameterizedTypeFor(BindingTypes.TREE_CHILD_NODE, parent, parameterizedTypeFor
- (BindingTypes.ITEM, it)));
+ it.addImplementsType(parameterizedTypeFor(BindingTypes.TREE_CHILD_NODE, childOf,
+ parameterizedTypeFor(BindingTypes.ITEM, it)));
}
- it.addImplementsType(parameterizedTypeFor(BindingTypes.INSTANTIABLE, it));
}
- if (!(schemaNode instanceof GroupingDefinition)) {
- it.addImplementsType(BindingTypes.augmentable(it));
+ if (!(schemaNode instanceof CaseSchemaNode)) {
+ it.addImplementsType(parameterizedTypeFor(BindingTypes.INSTANTIABLE, it));
}
+
+ it.addImplementsType(BindingTypes.augmentable(it));
} else {
it.addImplementsType(BindingTypes.TREE_NODE);
}
verboseClassComments, genTypeBuilders, typeProvider, BindingNamespaceType.Data);
annotateDeprecatedIfNecessary(notification.getStatus(), notificationInterface);
notificationInterface.addImplementsType(NOTIFICATION);
- notificationInterface.addImplementsType(parameterizedTypeFor(BindingTypes.INSTANTIABLE, notificationInterface));
genCtx.get(module).addChildNodeType(notification, notificationInterface);
// Notification object
listToGenType(module, basePackageName, typeBuilder, childOf, (ListSchemaNode) node, schemaContext,
verboseClassComments, genCtx, genTypeBuilders, typeProvider, namespaceType);
} else if (node instanceof ChoiceSchemaNode) {
- choiceToGenType(module, schemaContext, verboseClassComments, basePackageName, typeBuilder,
+ choiceToGenType(module, schemaContext, verboseClassComments, basePackageName, typeBuilder, childOf,
(ChoiceSchemaNode) node, genTypeBuilders, genCtx, typeProvider, namespaceType);
} else if (node instanceof AnyXmlSchemaNode || node instanceof AnyDataSchemaNode) {
resolveAnyNodeAsMethod(schemaContext, typeBuilder, genCtx, node, module, typeProvider);
* </ul>
*/
private static void choiceToGenType(final Module module, final SchemaContext schemaContext, final boolean
- verboseClasssComments, final String basePackageName, final GeneratedTypeBuilder parent, final
- ChoiceSchemaNode choiceNode, final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders,
- final Map<Module, ModuleContext> genCtx, final TypeProvider typeProvider, final BindingNamespaceType namespaceType) {
+ verboseClasssComments, final String basePackageName, final GeneratedTypeBuilder parent,
+ final GeneratedTypeBuilder childOf, final ChoiceSchemaNode choiceNode,
+ final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders,
+ final Map<Module, ModuleContext> genCtx, final TypeProvider typeProvider,
+ final BindingNamespaceType namespaceType) {
checkArgument(basePackageName != null, "Base Package Name cannot be NULL.");
checkArgument(choiceNode != null, "Choice Schema Node cannot be NULL.");
final GeneratedTypeBuilder choiceTypeBuilder = addRawInterfaceDefinition(basePackageName, choiceNode,
- schemaContext, "", "", verboseClasssComments, genTypeBuilders, namespaceType, genCtx.get(module));
+ schemaContext, "", "", verboseClasssComments, genTypeBuilders, namespaceType, genCtx.get(module));
constructGetter(parent, choiceNode.getQName().getLocalName(),
choiceNode.getDescription().orElse(null), choiceTypeBuilder, choiceNode.getStatus());
+ choiceTypeBuilder.setParentTypeForBuilder(childOf);
if (namespaceType.equals(BindingNamespaceType.Data)) {
choiceTypeBuilder.addImplementsType(parameterizedTypeFor(BindingTypes.INSTANTIABLE, choiceTypeBuilder));
}
final Type identifiableMarker = Types.parameterizedTypeFor(IDENTIFIABLE, genTOBuilder);
genTOBuilder.addImplementsType(IDENTIFIER);
genType.addImplementsType(identifiableMarker);
- genType.addImplementsType(parameterizedTypeFor(BindingTypes.TREE_CHILD_NODE, parent, parameterizedTypeFor
+ genType.addImplementsType(parameterizedTypeFor(BindingTypes.TREE_CHILD_NODE, childOf, parameterizedTypeFor
(BindingTypes.IDENTIFIABLE_ITEM, genType, genTOBuilder)));
}
* </ul>
*/
private static void generateTypesFromChoiceCases(final Module module, final SchemaContext schemaContext,
- final Map<Module, ModuleContext> genCtx, final String basePackageName, final Type refChoiceType,
- final ChoiceSchemaNode choiceNode, final boolean verboseClassComments, final TypeProvider typeProvider,
- final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final BindingNamespaceType namespaceType) {
+ final Map<Module, ModuleContext> genCtx, final String basePackageName, final GeneratedType refChoiceType,
+ final ChoiceSchemaNode choiceNode, final boolean verboseClassComments,
+ final TypeProvider typeProvider, final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders,
+ final BindingNamespaceType namespaceType) {
checkArgument(basePackageName != null, "Base Package Name cannot be NULL.");
checkArgument(refChoiceType != null, "Referenced Choice Type cannot be NULL.");
checkArgument(choiceNode != null, "ChoiceNode cannot be NULL.");
for (final CaseSchemaNode caseNode : choiceNode.getCases().values()) {
if (caseNode != null && resolveDataSchemaNodesCheck(module, schemaContext, caseNode)) {
final GeneratedTypeBuilder caseTypeBuilder = addDefaultInterfaceDefinition(basePackageName, caseNode,
- module, genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider, namespaceType);
+ null, module, genCtx, schemaContext, verboseClassComments,
+ genTypeBuilders, typeProvider, namespaceType);
caseTypeBuilder.addImplementsType(refChoiceType);
- caseTypeBuilder.setParentTypeForBuilder(refChoiceType);
+ caseTypeBuilder.setParentTypeForBuilder(refChoiceType.getParentTypeForBuilder());
annotateDeprecatedIfNecessary(caseNode.getStatus(), caseTypeBuilder);
genCtx.get(module).addCaseType(caseNode.getPath(), caseTypeBuilder);
- genCtx.get(module).addChoiceToCaseMapping(refChoiceType, caseTypeBuilder, caseNode);
- final Iterable<DataSchemaNode> caseChildNodes = caseNode.getChildNodes();
- if (caseChildNodes != null) {
- final SchemaPath choiceNodeParentPath = choiceNode.getPath().getParent();
-
- if (!Iterables.isEmpty(choiceNodeParentPath.getPathFromRoot())) {
- SchemaNode parent = findDataSchemaNode(schemaContext, choiceNodeParentPath);
-
- if (parent instanceof AugmentationSchemaNode) {
- final AugmentationSchemaNode augSchema = (AugmentationSchemaNode) parent;
- final SchemaPath targetPath = augSchema.getTargetPath();
- SchemaNode targetSchemaNode = findDataSchemaNode(schemaContext, targetPath);
- if (targetSchemaNode instanceof DataSchemaNode
- && ((DataSchemaNode) targetSchemaNode).isAddedByUses()) {
- if (targetSchemaNode instanceof DerivableSchemaNode) {
- targetSchemaNode = ((DerivableSchemaNode) targetSchemaNode).getOriginal().orElse(null);
- }
- if (targetSchemaNode == null) {
- throw new IllegalStateException(
- "Failed to find target node from grouping for augmentation " + augSchema
- + " in module " + module.getName());
- }
- }
- parent = targetSchemaNode;
- }
-
- Preconditions.checkState(parent != null, "Could not find Choice node parent %s",
- choiceNodeParentPath);
- GeneratedTypeBuilder childOfType = findChildNodeByPath(parent.getPath(), genCtx);
- if (childOfType == null) {
- childOfType = findGroupingByPath(parent.getPath(), genCtx);
- }
- resolveDataSchemaNodes(module, basePackageName, caseTypeBuilder, childOfType, caseChildNodes,
- genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider, namespaceType);
- } else {
- final GeneratedTypeBuilder moduleType = genCtx.get(module).getModuleNode();
- Preconditions.checkNotNull(moduleType, "Module type can not be null.");
- resolveDataSchemaNodes(module, basePackageName, caseTypeBuilder, moduleType, caseChildNodes,
- genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider, namespaceType);
- }
- processUsesImplements(caseNode, module, schemaContext, genCtx, namespaceType);
+ if (namespaceType.equals(BindingNamespaceType.Data)) {
+ genCtx.get(module).addChoiceToCaseMapping(refChoiceType, caseTypeBuilder, caseNode);
}
+
+ resolveDataSchemaNodes(module, basePackageName, caseTypeBuilder,
+ (GeneratedTypeBuilder) refChoiceType.getParentTypeForBuilder(), caseNode.getChildNodes(),
+ genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider, namespaceType);
+ processUsesImplements(caseNode, module, schemaContext, genCtx, namespaceType);
}
}
}
listToGenType(module, basePackageName, typeBuilder, typeBuilder, (ListSchemaNode) schemaNode,
schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider, namespaceType);
} else if (schemaNode instanceof ChoiceSchemaNode) {
- choiceToGenType(module, schemaContext, verboseClassComments, basePackageName, typeBuilder,
+ choiceToGenType(module, schemaContext, verboseClassComments, basePackageName, typeBuilder, typeBuilder,
(ChoiceSchemaNode) schemaNode, genTypeBuilders, genCtx, typeProvider, namespaceType);
}
}
listToGenType(module, basePackageName, typeBuilder, typeBuilder, (ListSchemaNode) schemaNode,
schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider, namespaceType);
} else if (schemaNode instanceof ChoiceSchemaNode) {
- choiceToGenType(module, schemaContext, verboseClassComments, basePackageName, typeBuilder,
+ choiceToGenType(module, schemaContext, verboseClassComments, basePackageName, typeBuilder, typeBuilder,
(ChoiceSchemaNode) schemaNode, genTypeBuilders, genCtx, typeProvider, namespaceType);
}
}
private static Map<Module, ModuleContext> groupingToGenType(final String basePackageName, final GroupingDefinition grouping, final Module
module, Map<Module, ModuleContext> genCtx, final SchemaContext schemaContext, final boolean
verboseClassComments, final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider) {
- final GeneratedTypeBuilder genType = addDefaultInterfaceDefinition(basePackageName, grouping, module, genCtx,
+ final GeneratedTypeBuilder genType = addDefaultInterfaceDefinition(basePackageName, grouping, null, module, genCtx,
schemaContext, verboseClassComments, genTypeBuilders, typeProvider, BindingNamespaceType.Grouping);
annotateDeprecatedIfNecessary(grouping.getStatus(), genType);
genCtx.get(module).addGroupingType(grouping, genType);
Code Review / mdsal.git / blobdiff