X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=binding%2Fmdsal-binding-generator-impl%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fmdsal%2Fbinding%2Fgenerator%2Fimpl%2FAbstractTypeGenerator.java;h=eb7d3c002963ca212351910c4c812274b9d8414f;hb=f9eceb5081877db3fc3f840c44e943605f3f4335;hp=460b566906f545a831ce88e5617479fc99a0f3ea;hpb=0821a955429566cec7549aefea11d38745abdcf8;p=mdsal.git diff --git a/binding/mdsal-binding-generator-impl/src/main/java/org/opendaylight/mdsal/binding/generator/impl/AbstractTypeGenerator.java b/binding/mdsal-binding-generator-impl/src/main/java/org/opendaylight/mdsal/binding/generator/impl/AbstractTypeGenerator.java index 460b566906..eb7d3c0029 100644 --- a/binding/mdsal-binding-generator-impl/src/main/java/org/opendaylight/mdsal/binding/generator/impl/AbstractTypeGenerator.java +++ b/binding/mdsal-binding-generator-impl/src/main/java/org/opendaylight/mdsal/binding/generator/impl/AbstractTypeGenerator.java @@ -19,22 +19,31 @@ import static org.opendaylight.mdsal.binding.model.util.BindingTypes.DATA_OBJECT import static org.opendaylight.mdsal.binding.model.util.BindingTypes.DATA_ROOT; import static org.opendaylight.mdsal.binding.model.util.BindingTypes.NOTIFICATION; import static org.opendaylight.mdsal.binding.model.util.BindingTypes.NOTIFICATION_LISTENER; +import static org.opendaylight.mdsal.binding.model.util.BindingTypes.QNAME; import static org.opendaylight.mdsal.binding.model.util.BindingTypes.ROUTING_CONTEXT; import static org.opendaylight.mdsal.binding.model.util.BindingTypes.RPC_INPUT; import static org.opendaylight.mdsal.binding.model.util.BindingTypes.RPC_OUTPUT; import static org.opendaylight.mdsal.binding.model.util.BindingTypes.RPC_SERVICE; import static org.opendaylight.mdsal.binding.model.util.BindingTypes.action; import static org.opendaylight.mdsal.binding.model.util.BindingTypes.augmentable; +import static org.opendaylight.mdsal.binding.model.util.BindingTypes.augmentation; import static org.opendaylight.mdsal.binding.model.util.BindingTypes.childOf; import static org.opendaylight.mdsal.binding.model.util.BindingTypes.choiceIn; import static org.opendaylight.mdsal.binding.model.util.BindingTypes.identifiable; import static org.opendaylight.mdsal.binding.model.util.BindingTypes.identifier; +import static org.opendaylight.mdsal.binding.model.util.BindingTypes.instanceNotification; import static org.opendaylight.mdsal.binding.model.util.BindingTypes.keyedListAction; +import static org.opendaylight.mdsal.binding.model.util.BindingTypes.keyedListNotification; +import static org.opendaylight.mdsal.binding.model.util.BindingTypes.opaqueObject; import static org.opendaylight.mdsal.binding.model.util.BindingTypes.rpcResult; import static org.opendaylight.mdsal.binding.model.util.Types.BOOLEAN; +import static org.opendaylight.mdsal.binding.model.util.Types.STRING; +import static org.opendaylight.mdsal.binding.model.util.Types.classType; import static org.opendaylight.mdsal.binding.model.util.Types.listTypeFor; import static org.opendaylight.mdsal.binding.model.util.Types.listenableFutureTypeFor; -import static org.opendaylight.mdsal.binding.model.util.Types.typeForClass; +import static org.opendaylight.mdsal.binding.model.util.Types.mapTypeFor; +import static org.opendaylight.mdsal.binding.model.util.Types.primitiveVoidType; +import static org.opendaylight.mdsal.binding.model.util.Types.wildcardTypeFor; import static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.findDataSchemaNode; import static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.findNodeInSchemaContext; import static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.findParentModule; @@ -45,6 +54,7 @@ import edu.umd.cs.findbugs.annotations.SuppressFBWarnings; import java.util.AbstractMap.SimpleImmutableEntry; import java.util.ArrayList; import java.util.Collection; +import java.util.Collections; import java.util.Comparator; import java.util.HashMap; import java.util.HashSet; @@ -52,13 +62,16 @@ import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Optional; -import java.util.Set; +import org.eclipse.jdt.annotation.NonNull; import org.eclipse.jdt.annotation.Nullable; import org.opendaylight.mdsal.binding.model.api.AccessModifier; import org.opendaylight.mdsal.binding.model.api.Constant; +import org.opendaylight.mdsal.binding.model.api.DefaultType; +import org.opendaylight.mdsal.binding.model.api.Enumeration; import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject; import org.opendaylight.mdsal.binding.model.api.GeneratedType; import org.opendaylight.mdsal.binding.model.api.JavaTypeName; +import org.opendaylight.mdsal.binding.model.api.MethodSignature.ValueMechanics; import org.opendaylight.mdsal.binding.model.api.ParameterizedType; import org.opendaylight.mdsal.binding.model.api.Restrictions; import org.opendaylight.mdsal.binding.model.api.Type; @@ -71,19 +84,19 @@ import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilde import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilderBase; import org.opendaylight.mdsal.binding.model.api.type.builder.MethodSignatureBuilder; import org.opendaylight.mdsal.binding.model.api.type.builder.TypeMemberBuilder; +import org.opendaylight.mdsal.binding.model.util.BaseYangTypes; import org.opendaylight.mdsal.binding.model.util.BindingGeneratorUtil; -import org.opendaylight.mdsal.binding.model.util.ReferencedTypeImpl; import org.opendaylight.mdsal.binding.model.util.TypeConstants; -import org.opendaylight.mdsal.binding.model.util.Types; import org.opendaylight.mdsal.binding.model.util.generated.type.builder.GeneratedPropertyBuilderImpl; import org.opendaylight.mdsal.binding.spec.naming.BindingMapping; import org.opendaylight.mdsal.binding.yang.types.AbstractTypeProvider; -import org.opendaylight.mdsal.binding.yang.types.BaseYangTypes; import org.opendaylight.mdsal.binding.yang.types.GroupingDefinitionDependencySort; import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.common.QNameModule; import org.opendaylight.yangtools.yang.model.api.ActionDefinition; import org.opendaylight.yangtools.yang.model.api.ActionNodeContainer; +import org.opendaylight.yangtools.yang.model.api.AnydataSchemaNode; +import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode; import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode; import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode; import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode; @@ -92,6 +105,8 @@ import org.opendaylight.yangtools.yang.model.api.DataNodeContainer; import org.opendaylight.yangtools.yang.model.api.DataSchemaNode; import org.opendaylight.yangtools.yang.model.api.DerivableSchemaNode; import org.opendaylight.yangtools.yang.model.api.DocumentedNode; +import org.opendaylight.yangtools.yang.model.api.DocumentedNode.WithStatus; +import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext; import org.opendaylight.yangtools.yang.model.api.GroupingDefinition; import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode; import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode; @@ -100,19 +115,18 @@ import org.opendaylight.yangtools.yang.model.api.ListSchemaNode; import org.opendaylight.yangtools.yang.model.api.Module; import org.opendaylight.yangtools.yang.model.api.ModuleImport; import org.opendaylight.yangtools.yang.model.api.NotificationDefinition; +import org.opendaylight.yangtools.yang.model.api.NotificationNodeContainer; import org.opendaylight.yangtools.yang.model.api.RpcDefinition; -import org.opendaylight.yangtools.yang.model.api.SchemaContext; import org.opendaylight.yangtools.yang.model.api.SchemaNode; import org.opendaylight.yangtools.yang.model.api.SchemaPath; -import org.opendaylight.yangtools.yang.model.api.Status; import org.opendaylight.yangtools.yang.model.api.TypeDefinition; import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode; import org.opendaylight.yangtools.yang.model.api.UsesNode; +import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier; import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition; import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition; import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint; import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition; -import org.opendaylight.yangtools.yang.model.util.DataNodeIterator; import org.opendaylight.yangtools.yang.model.util.ModuleDependencySort; import org.opendaylight.yangtools.yang.model.util.SchemaNodeUtils; import org.opendaylight.yangtools.yang.model.util.type.CompatUtils; @@ -130,8 +144,8 @@ abstract class AbstractTypeGenerator { * Comparator based on augment target path. */ private static final Comparator AUGMENT_COMP = (o1, o2) -> { - final Iterator thisIt = o1.getTargetPath().getPathFromRoot().iterator(); - final Iterator otherIt = o2.getTargetPath().getPathFromRoot().iterator(); + final Iterator thisIt = o1.getTargetPath().getNodeIdentifiers().iterator(); + final Iterator otherIt = o2.getTargetPath().getNodeIdentifiers().iterator(); while (thisIt.hasNext()) { if (!otherIt.hasNext()) { @@ -174,14 +188,14 @@ abstract class AbstractTypeGenerator { /** * Holds reference to schema context to resolve data of augmented element when creating augmentation builder. */ - private final SchemaContext schemaContext; + private final @NonNull EffectiveModelContext schemaContext; /** * Holds renamed elements. */ private final Map renames; - AbstractTypeGenerator(final SchemaContext context, final AbstractTypeProvider typeProvider, + AbstractTypeGenerator(final EffectiveModelContext context, final AbstractTypeProvider typeProvider, final Map renames) { this.schemaContext = requireNonNull(context); this.typeProvider = requireNonNull(typeProvider); @@ -196,6 +210,10 @@ abstract class AbstractTypeGenerator { contexts.forEach(this::allAugmentsToGenTypes); } + final @NonNull EffectiveModelContext schemaContext() { + return schemaContext; + } + final Collection moduleContexts() { return genCtx.values(); } @@ -213,7 +231,7 @@ abstract class AbstractTypeGenerator { abstract void addCodegenInformation(GeneratedTypeBuilderBase genType, Module module, SchemaNode node); abstract void addCodegenInformation(GeneratedTypeBuilder interfaceBuilder, Module module, String description, - Set nodes); + Collection nodes); abstract void addComment(TypeMemberBuilder genType, DocumentedNode node); @@ -222,15 +240,17 @@ abstract class AbstractTypeGenerator { genCtx.put(module.getQNameModule(), context); allTypeDefinitionsToGenTypes(context); groupingsToGenTypes(context, module.getGroupings()); - rpcMethodsToGenType(context); allIdentitiesToGenTypes(context); - notificationsToGenType(context); if (!module.getChildNodes().isEmpty()) { final GeneratedTypeBuilder moduleType = moduleToDataType(context); context.addModuleNode(moduleType); - resolveDataSchemaNodes(context, moduleType, moduleType, module.getChildNodes()); + resolveDataSchemaNodes(context, moduleType, moduleType, module.getChildNodes(), false); } + + // Resolve RPCs and notifications only after we have created instantiated tree + rpcMethodsToGenType(context); + notificationsToGenType(context); return context; } @@ -251,11 +271,8 @@ abstract class AbstractTypeGenerator { private void allTypeDefinitionsToGenTypes(final ModuleContext context) { final Module module = context.module(); checkArgument(module.getName() != null, "Module name cannot be NULL."); - final DataNodeIterator it = new DataNodeIterator(module); - final List> typeDefinitions = it.allTypedefs(); - checkState(typeDefinitions != null, "Type Definitions for module %s cannot be NULL.", module.getName()); - for (final TypeDefinition typedef : typeDefinitions) { + for (final TypeDefinition typedef : SchemaNodeUtils.getAllTypeDefinitions(module)) { if (typedef != null) { final Type type = typeProvider.generatedTypeForExtendedDefinitionType(typedef, typedef); if (type != null) { @@ -267,12 +284,13 @@ abstract class AbstractTypeGenerator { } private GeneratedTypeBuilder processDataSchemaNode(final ModuleContext context, final Type baseInterface, - final DataSchemaNode node) { + final DataSchemaNode node, final boolean inGrouping) { if (node.isAugmenting() || node.isAddedByUses()) { return null; } final GeneratedTypeBuilder genType = addDefaultInterfaceDefinition(context, node, baseInterface); - annotateDeprecatedIfNecessary(node.getStatus(), genType); + defaultImplementedInterace(genType); + annotateDeprecatedIfNecessary(node, genType); final Module module = context.module(); genType.setModuleName(module.getName()); @@ -281,62 +299,75 @@ abstract class AbstractTypeGenerator { if (node instanceof DataNodeContainer) { context.addChildNodeType(node, genType); groupingsToGenTypes(context, ((DataNodeContainer) node).getGroupings()); - processUsesAugments((DataNodeContainer) node, context); + processUsesAugments((DataNodeContainer) node, context, inGrouping); } return genType; } private void containerToGenType(final ModuleContext context, final GeneratedTypeBuilder parent, - final Type baseInterface, final ContainerSchemaNode node) { - final GeneratedTypeBuilder genType = processDataSchemaNode(context, baseInterface, node); + final Type baseInterface, final ContainerSchemaNode node, final boolean inGrouping) { + final GeneratedTypeBuilder genType = processDataSchemaNode(context, baseInterface, node, inGrouping); if (genType != null) { constructGetter(parent, genType, node); - resolveDataSchemaNodes(context, genType, genType, node.getChildNodes()); - actionsToGenType(context, genType, node, null); + resolveDataSchemaNodes(context, genType, genType, node.getChildNodes(), inGrouping); + actionsToGenType(context, genType, node, null, inGrouping); + notificationsToGenType(context, genType, node, null, inGrouping); } } private void listToGenType(final ModuleContext context, final GeneratedTypeBuilder parent, - final Type baseInterface, final ListSchemaNode node) { - final GeneratedTypeBuilder genType = processDataSchemaNode(context, baseInterface, node); + final Type baseInterface, final ListSchemaNode node, final boolean inGrouping) { + final GeneratedTypeBuilder genType = processDataSchemaNode(context, baseInterface, node, inGrouping); if (genType != null) { - final ParameterizedType listType = listTypeFor(genType); - constructGetter(parent, listType, node); - constructNonnull(parent, listType, node); - final List listKeys = listKeys(node); - final GeneratedTOBuilder genTOBuilder = resolveListKeyTOBuilder(context, node); - if (genTOBuilder != null) { - final Type identifierMarker = identifier(genType); - final Type identifiableMarker = identifiable(genTOBuilder); - genTOBuilder.addImplementsType(identifierMarker); - genType.addImplementsType(identifiableMarker); + final GeneratedTOBuilder keyTypeBuilder; + if (!listKeys.isEmpty()) { + keyTypeBuilder = typeProvider.newGeneratedTOBuilder(JavaTypeName.create( + packageNameForGeneratedType(context.modulePackageName(), node.getPath()), + BindingMapping.getClassName(node.getQName().getLocalName() + "Key"))) + .addImplementsType(identifier(genType)); + genType.addImplementsType(identifiable(keyTypeBuilder)); + } else { + keyTypeBuilder = null; + } + // Decide whether to generate a List or a Map + final ParameterizedType listType; + if (keyTypeBuilder != null && !node.isUserOrdered()) { + listType = mapTypeFor(keyTypeBuilder, genType); + } else { + listType = listTypeFor(genType); } - actionsToGenType(context, genType, node, genTOBuilder); + + constructGetter(parent, listType, node).setMechanics(ValueMechanics.NULLIFY_EMPTY); + constructNonnull(parent, listType, node); + + actionsToGenType(context, genType, node, keyTypeBuilder, inGrouping); + notificationsToGenType(context, genType, node, keyTypeBuilder, inGrouping); for (final DataSchemaNode schemaNode : node.getChildNodes()) { if (!schemaNode.isAugmenting()) { - addSchemaNodeToListBuilders(context, schemaNode, genType, genTOBuilder, listKeys); + addSchemaNodeToListBuilders(context, schemaNode, genType, keyTypeBuilder, listKeys, inGrouping); } } // serialVersionUID - if (genTOBuilder != null) { + if (keyTypeBuilder != null) { final GeneratedPropertyBuilder prop = new GeneratedPropertyBuilderImpl("serialVersionUID"); - prop.setValue(Long.toString(computeDefaultSUID(genTOBuilder))); - genTOBuilder.setSUID(prop); + prop.setValue(Long.toString(computeDefaultSUID(keyTypeBuilder))); + keyTypeBuilder.setSUID(prop); } - typeBuildersToGenTypes(context, genType, genTOBuilder); + typeBuildersToGenTypes(context, genType, keyTypeBuilder); } } - private void processUsesAugments(final DataNodeContainer node, final ModuleContext context) { + private void processUsesAugments(final DataNodeContainer node, final ModuleContext context, + final boolean inGrouping) { for (final UsesNode usesNode : node.getUses()) { for (final AugmentationSchemaNode augment : usesNode.getAugmentations()) { - usesAugmentationToGenTypes(context, augment, usesNode, node); - processUsesAugments(augment, context); + usesAugmentationToGenTypes(context, augment, usesNode, node, inGrouping); + processUsesAugments(augment, context, inGrouping); } } } @@ -385,8 +416,7 @@ abstract class AbstractTypeGenerator { checkArgument(module != null, "Module reference cannot be NULL."); checkState(module.getAugmentations() != null, "Augmentations Set cannot be NULL."); - final Set augmentations = module.getAugmentations(); - final List sortedAugmentations = new ArrayList<>(augmentations); + final List sortedAugmentations = new ArrayList<>(module.getAugmentations()); sortedAugmentations.sort(AUGMENT_COMP); return sortedAugmentations; @@ -413,17 +443,24 @@ abstract class AbstractTypeGenerator { } private void actionsToGenType(final ModuleContext context, - final Type parent, final T parentSchema, final Type keyType) { + final Type parent, final T parentSchema, final Type keyType, final boolean inGrouping) { for (final ActionDefinition action : parentSchema.getActions()) { + if (action.isAugmenting()) { + continue; + } + final GeneratedType input; final GeneratedType output; if (action.isAddedByUses()) { final ActionDefinition orig = findOrigAction(parentSchema, action).get(); - input = context.getChildNode(orig.getInput().getPath()).build(); - output = context.getChildNode(orig.getOutput().getPath()).build(); + // Original definition may live in a different module, make sure we account for that + final ModuleContext origContext = moduleContext( + orig.getPath().getPathFromRoot().iterator().next().getModule()); + input = context.addAliasType(origContext, orig.getInput(), action.getInput()); + output = context.addAliasType(origContext, orig.getOutput(), action.getOutput()); } else { - input = actionContainer(context, RPC_INPUT, action.getInput()); - output = actionContainer(context, RPC_OUTPUT, action.getOutput()); + input = actionContainer(context, RPC_INPUT, action.getInput(), inGrouping); + output = actionContainer(context, RPC_OUTPUT, action.getOutput(), inGrouping); } if (!(parentSchema instanceof GroupingDefinition)) { @@ -434,10 +471,9 @@ abstract class AbstractTypeGenerator { final GeneratedTypeBuilder builder = typeProvider.newGeneratedTypeBuilder(JavaTypeName.create( packageNameForGeneratedType(context.modulePackageName(), action.getPath()), BindingMapping.getClassName(qname))); - qnameConstant(builder, JavaTypeName.create(context.modulePackageName(), - BindingMapping.MODULE_INFO_CLASS_NAME), qname.getLocalName()); + qnameConstant(builder, context.moduleInfoType(), qname.getLocalName()); - annotateDeprecatedIfNecessary(action.getStatus(), builder); + annotateDeprecatedIfNecessary(action, builder); builder.addImplementsType(keyType != null ? keyedListAction(parent, keyType, input, output) : action(parent, input, output)); @@ -448,10 +484,12 @@ abstract class AbstractTypeGenerator { } private Optional findOrigAction(final DataNodeContainer parent, final ActionDefinition action) { + final QName qname = action.getQName(); for (UsesNode uses : parent.getUses()) { - final GroupingDefinition grp = findUsedGrouping(uses); - final Optional found = grp.getActions().stream() - .filter(act -> action.getQName().equals(act.getQName())).findFirst(); + final GroupingDefinition grp = uses.getSourceGrouping(); + // Target grouping may reside in a different module, hence we need to rebind the QName to match grouping's + // namespace + final Optional found = grp.findAction(qname.bindTo(grp.getQName().getModule())); if (found.isPresent()) { final ActionDefinition result = found.get(); return result.isAddedByUses() ? findOrigAction(grp, result) : found; @@ -462,9 +500,9 @@ abstract class AbstractTypeGenerator { } private GeneratedType actionContainer(final ModuleContext context, final Type baseInterface, - final ContainerSchemaNode schema) { - final GeneratedTypeBuilder genType = processDataSchemaNode(context, baseInterface, schema); - resolveDataSchemaNodes(context, genType, genType, schema.getChildNodes()); + final ContainerSchemaNode schema, final boolean inGrouping) { + final GeneratedTypeBuilder genType = processDataSchemaNode(context, baseInterface, schema, inGrouping); + resolveDataSchemaNodes(context, genType, genType, schema.getChildNodes(), inGrouping); return genType.build(); } @@ -487,7 +525,7 @@ abstract class AbstractTypeGenerator { private void rpcMethodsToGenType(final ModuleContext context) { final Module module = context.module(); checkArgument(module.getName() != null, "Module name cannot be NULL."); - final Set rpcDefinitions = module.getRpcs(); + final Collection rpcDefinitions = module.getRpcs(); checkState(rpcDefinitions != null, "Set of rpcs from module " + module.getName() + " cannot be NULL."); if (rpcDefinitions.isEmpty()) { return; @@ -501,13 +539,11 @@ abstract class AbstractTypeGenerator { for (final RpcDefinition rpc : rpcDefinitions) { if (rpc != null) { final String rpcName = BindingMapping.getClassName(rpc.getQName()); - final String rpcMethodName = BindingMapping.getPropertyName(rpcName); + final String rpcMethodName = BindingMapping.getRpcMethodName(rpc.getQName()); final MethodSignatureBuilder method = interfaceBuilder.addMethod(rpcMethodName); // Do not refer to annotation class, as it may not be available at runtime - // FIXME: migrate this to some other annotation type and re-enable - // - // method.addAnnotation("javax.annotation", "CheckReturnValue"); + method.addAnnotation("edu.umd.cs.findbugs.annotations", "CheckReturnValue"); addComment(method, rpc); method.addParameter( createRpcContainer(context, rpcName, rpc, verifyNotNull(rpc.getInput()), RPC_INPUT), "input"); @@ -521,15 +557,16 @@ abstract class AbstractTypeGenerator { private Type createRpcContainer(final ModuleContext context, final String rpcName, final RpcDefinition rpc, final ContainerSchemaNode schema, final Type type) { - processUsesAugments(schema, context); - final GeneratedTypeBuilder outType = addRawInterfaceDefinition( + processUsesAugments(schema, context, false); + final GeneratedTypeBuilder outType = addRawInterfaceDefinition(context, JavaTypeName.create(context.modulePackageName(), rpcName + BindingMapping.getClassName(schema.getQName())), schema); addImplementedInterfaceFromUses(schema, outType); outType.addImplementsType(type); outType.addImplementsType(augmentable(outType)); - annotateDeprecatedIfNecessary(rpc.getStatus(), outType); - resolveDataSchemaNodes(context, outType, outType, schema.getChildNodes()); + defaultImplementedInterace(outType); + annotateDeprecatedIfNecessary(rpc, outType); + resolveDataSchemaNodes(context, outType, outType, schema.getChildNodes(), false); context.addChildNodeType(schema, outType); return outType.build(); } @@ -553,7 +590,7 @@ abstract class AbstractTypeGenerator { private void notificationsToGenType(final ModuleContext context) { final Module module = context.module(); checkArgument(module.getName() != null, "Module name cannot be NULL."); - final Set notifications = module.getNotifications(); + final Collection notifications = module.getNotifications(); if (notifications.isEmpty()) { return; } @@ -563,21 +600,22 @@ abstract class AbstractTypeGenerator { for (final NotificationDefinition notification : notifications) { if (notification != null) { - processUsesAugments(notification, context); + processUsesAugments(notification, context, false); final GeneratedTypeBuilder notificationInterface = addDefaultInterfaceDefinition( context.modulePackageName(), notification, DATA_OBJECT, context); - annotateDeprecatedIfNecessary(notification.getStatus(), notificationInterface); + defaultImplementedInterace(notificationInterface); + annotateDeprecatedIfNecessary(notification, notificationInterface); notificationInterface.addImplementsType(NOTIFICATION); context.addChildNodeType(notification, notificationInterface); // Notification object resolveDataSchemaNodes(context, notificationInterface, notificationInterface, - notification.getChildNodes()); + notification.getChildNodes(), false); addComment(listenerInterface.addMethod("on" + notificationInterface.getName()) .setAccessModifier(AccessModifier.PUBLIC).addParameter(notificationInterface, "notification") - .setReturnType(Types.primitiveVoidType()), notification); + .setReturnType(primitiveVoidType()), notification); } } @@ -585,6 +623,40 @@ abstract class AbstractTypeGenerator { context.addTopLevelNodeType(listenerInterface); } + private void notificationsToGenType( + final ModuleContext context, final Type parent, final T parentSchema, final Type keyType, + final boolean inGrouping) { + final Collection notifications = parentSchema.getNotifications(); + if (notifications.isEmpty()) { + return; + } + + for (NotificationDefinition notif : notifications) { + if (notif.isAugmenting()) { + continue; + } + if (parentSchema instanceof GroupingDefinition) { + // Notifications cannot be really established, as they lack instantiation context, which would be + // completely described by an InstanceIdentifier -- hence we cannot create a binding class + continue; + } + + processUsesAugments(notif, context, false); + + final GeneratedTypeBuilder notifInterface = addDefaultInterfaceDefinition( + packageNameForGeneratedType(context.modulePackageName(), notif.getPath()), notif, DATA_OBJECT, context); + defaultImplementedInterace(notifInterface); + annotateDeprecatedIfNecessary(notif, notifInterface); + + notifInterface.addImplementsType(keyType != null ? keyedListNotification(notifInterface, parent, keyType) + : instanceNotification(notifInterface, parent)); + context.addChildNodeType(notif, notifInterface); + + // Notification object + resolveDataSchemaNodes(context, notifInterface, notifInterface, notif.getChildNodes(), false); + } + } + /** * Converts all identities of the module to the list of * Type objects. @@ -598,7 +670,7 @@ abstract class AbstractTypeGenerator { * */ private void allIdentitiesToGenTypes(final ModuleContext context) { - final Set schemaIdentities = context.module().getIdentities(); + final Collection schemaIdentities = context.module().getIdentities(); if (schemaIdentities != null && !schemaIdentities.isEmpty()) { for (final IdentitySchemaNode identity : schemaIdentities) { @@ -634,7 +706,7 @@ abstract class AbstractTypeGenerator { } final GeneratedTypeBuilder newType = typeProvider.newGeneratedTypeBuilder(name); - final Set baseIdentities = identity.getBaseIdentities(); + final Collection baseIdentities = identity.getBaseIdentities(); if (!baseIdentities.isEmpty()) { for (IdentitySchemaNode baseIdentity : baseIdentities) { JavaTypeName base = renames.get(baseIdentity); @@ -656,15 +728,14 @@ abstract class AbstractTypeGenerator { newType.setModuleName(module.getName()); newType.setSchemaPath(identity.getPath()); - qnameConstant(newType, JavaTypeName.create(context.modulePackageName(), BindingMapping.MODULE_INFO_CLASS_NAME), - identity.getQName().getLocalName()); + qnameConstant(newType, context.moduleInfoType(), identity.getQName().getLocalName()); context.addIdentityType(identity, newType); } private static Constant qnameConstant(final GeneratedTypeBuilderBase toBuilder, final JavaTypeName yangModuleInfo, final String localName) { - return toBuilder.addConstant(typeForClass(QName.class), BindingMapping.QNAME_STATIC_FIELD_NAME, + return toBuilder.addConstant(QNAME, BindingMapping.QNAME_STATIC_FIELD_NAME, new SimpleImmutableEntry<>(yangModuleInfo, localName)); } @@ -681,17 +752,20 @@ abstract class AbstractTypeGenerator { * collection of groupings from which types will be generated * */ - private void groupingsToGenTypes(final ModuleContext context, final Collection groupings) { + private void groupingsToGenTypes(final ModuleContext context, + final Collection groupings) { for (final GroupingDefinition grouping : new GroupingDefinitionDependencySort().sort(groupings)) { // Converts individual grouping to GeneratedType. Firstly generated type builder is created and every child // node of grouping is resolved to the method. final GeneratedTypeBuilder genType = addDefaultInterfaceDefinition(context, grouping); - annotateDeprecatedIfNecessary(grouping.getStatus(), genType); + narrowImplementedInterface(genType); + annotateDeprecatedIfNecessary(grouping, genType); context.addGroupingType(grouping, genType); - resolveDataSchemaNodes(context, genType, genType, grouping.getChildNodes()); + resolveDataSchemaNodes(context, genType, genType, grouping.getChildNodes(), true); groupingsToGenTypes(context, grouping.getGroupings()); - processUsesAugments(grouping, context); - actionsToGenType(context, genType, grouping, null); + processUsesAugments(grouping, context, true); + actionsToGenType(context, genType, grouping, null, true); + notificationsToGenType(context, genType, grouping, null, true); } } @@ -705,16 +779,15 @@ abstract class AbstractTypeGenerator { * @param module Module in which type should be generated * @return enumeration builder which contains data from enumTypeDef */ - private EnumBuilder resolveInnerEnumFromTypeDefinition(final EnumTypeDefinition enumTypeDef, final QName enumName, + private Enumeration resolveInnerEnumFromTypeDefinition(final EnumTypeDefinition enumTypeDef, final QName enumName, final GeneratedTypeBuilder typeBuilder, final ModuleContext context) { - if (enumTypeDef != null && typeBuilder != null && enumTypeDef.getQName().getLocalName() != null) { - final EnumBuilder enumBuilder = typeBuilder.addEnumeration(BindingMapping.getClassName(enumName)); - typeProvider.addEnumDescription(enumBuilder, enumTypeDef); - enumBuilder.updateEnumPairsFromEnumTypeDef(enumTypeDef); - context.addInnerTypedefType(enumTypeDef.getPath(), enumBuilder); - return enumBuilder; - } - return null; + final EnumBuilder enumBuilder = typeBuilder.addEnumeration(BindingMapping.getClassName(enumName)); + typeProvider.addEnumDescription(enumBuilder, enumTypeDef); + enumBuilder.updateEnumPairsFromEnumTypeDef(enumTypeDef); + final Enumeration ret = enumBuilder.toInstance(typeBuilder); + context.addTypeToSchema(ret, enumTypeDef); + context.addInnerTypedefType(enumTypeDef.getPath(), ret); + return ret; } /** @@ -757,11 +830,12 @@ abstract class AbstractTypeGenerator { checkState(augSchema.getTargetPath() != null, "Augmentation Schema does not contain Target Path (Target Path is NULL)."); - processUsesAugments(augSchema, context); - final SchemaPath targetPath = augSchema.getTargetPath(); + processUsesAugments(augSchema, context, false); + final SchemaNodeIdentifier targetPath = augSchema.getTargetPath(); SchemaNode targetSchemaNode = null; - targetSchemaNode = findDataSchemaNode(schemaContext, targetPath); + // FIXME: can we use findDataSchemaNode() instead? + targetSchemaNode = findDataSchemaNode(schemaContext, targetPath.getNodeIdentifiers()); if (targetSchemaNode instanceof DataSchemaNode && ((DataSchemaNode) targetSchemaNode).isAddedByUses()) { if (targetSchemaNode instanceof DerivableSchemaNode) { targetSchemaNode = ((DerivableSchemaNode) targetSchemaNode).getOriginal().orElse(null); @@ -775,32 +849,40 @@ abstract class AbstractTypeGenerator { throw new IllegalArgumentException("augment target not found: " + targetPath); } - GeneratedTypeBuilder targetTypeBuilder = findChildNodeByPath(targetSchemaNode.getPath()); - if (targetTypeBuilder == null) { - targetTypeBuilder = findCaseByPath(targetSchemaNode.getPath()); - } - if (targetTypeBuilder == null) { - throw new NullPointerException("Target type not yet generated: " + targetSchemaNode); + if (targetSchemaNode instanceof ChoiceSchemaNode) { + final GeneratedTypeBuilder builder = findChildNodeByPath(targetSchemaNode.getPath()); + checkState(builder != null, "Choice target type not generated for %s", targetSchemaNode); + generateTypesFromAugmentedChoiceCases(context, builder.build(), (ChoiceSchemaNode) targetSchemaNode, + augSchema.getChildNodes(), null, false); + return; } - if (!(targetSchemaNode instanceof ChoiceSchemaNode)) { - final Type targetType = new ReferencedTypeImpl(targetTypeBuilder.getIdentifier()); - addRawAugmentGenTypeDefinition(context, targetType, augSchema); - + final JavaTypeName targetName; + if (targetSchemaNode instanceof CaseSchemaNode) { + final GeneratedTypeBuilder builder = findCaseByPath(targetSchemaNode.getPath()); + checkState(builder != null, "Case target type not generated for %s", targetSchemaNode); + targetName = builder.getIdentifier(); } else { - generateTypesFromAugmentedChoiceCases(context, targetTypeBuilder.build(), - (ChoiceSchemaNode) targetSchemaNode, augSchema.getChildNodes(), null); + final GeneratedTypeBuilder builder = findChildNodeByPath(targetSchemaNode.getPath()); + if (builder == null) { + targetName = findAliasByPath(targetSchemaNode.getPath()); + checkState(targetName != null, "Target type not yet generated: %s", targetSchemaNode); + } else { + targetName = builder.getIdentifier(); + } } + + addRawAugmentGenTypeDefinition(context, DefaultType.of(targetName), augSchema, false); } private void usesAugmentationToGenTypes(final ModuleContext context, final AugmentationSchemaNode augSchema, - final UsesNode usesNode, final DataNodeContainer usesNodeParent) { + final UsesNode usesNode, final DataNodeContainer usesNodeParent, final boolean inGrouping) { checkArgument(augSchema != null, "Augmentation Schema cannot be NULL."); checkState(augSchema.getTargetPath() != null, "Augmentation Schema does not contain Target Path (Target Path is NULL)."); - processUsesAugments(augSchema, context); - final SchemaPath targetPath = augSchema.getTargetPath(); + processUsesAugments(augSchema, context, inGrouping); + final SchemaNodeIdentifier targetPath = augSchema.getTargetPath(); final SchemaNode targetSchemaNode = findOriginalTargetFromGrouping(targetPath, usesNode); if (targetSchemaNode == null) { throw new IllegalArgumentException("augment target not found: " + targetPath); @@ -819,26 +901,16 @@ abstract class AbstractTypeGenerator { addRawAugmentGenTypeDefinition(context, packageNameForAugmentedGeneratedType(context.modulePackageName(), ((SchemaNode) usesNodeParent).getPath()), - targetTypeBuilder.build(), augSchema); + targetTypeBuilder.build(), augSchema, inGrouping); } else { - addRawAugmentGenTypeDefinition(context, targetTypeBuilder.build(), augSchema); + addRawAugmentGenTypeDefinition(context, targetTypeBuilder.build(), augSchema, inGrouping); } } else { generateTypesFromAugmentedChoiceCases(context, targetTypeBuilder.build(), - (ChoiceSchemaNode) targetSchemaNode, augSchema.getChildNodes(), usesNodeParent); + (ChoiceSchemaNode) targetSchemaNode, augSchema.getChildNodes(), usesNodeParent, inGrouping); } } - private GroupingDefinition findUsedGrouping(final UsesNode uses) { - final SchemaNode targetGrouping = findNodeInSchemaContext(schemaContext, uses.getGroupingPath() - .getPathFromRoot()); - if (targetGrouping instanceof GroupingDefinition) { - return (GroupingDefinition) targetGrouping; - } - - throw new IllegalArgumentException("Failed to resolve used grouping for " + uses); - } - /** * Convenient method to find node added by uses statement. * @@ -846,14 +918,41 @@ abstract class AbstractTypeGenerator { * @param parentUsesNode parent of uses node * @return node from its original location in grouping */ - private DataSchemaNode findOriginalTargetFromGrouping(final SchemaPath targetPath, final UsesNode parentUsesNode) { - SchemaNode result = findUsedGrouping(parentUsesNode); - for (final QName node : targetPath.getPathFromRoot()) { + private static DataSchemaNode findOriginalTargetFromGrouping(final SchemaNodeIdentifier targetPath, + final UsesNode parentUsesNode) { + SchemaNode result = parentUsesNode.getSourceGrouping(); + for (final QName node : targetPath.getNodeIdentifiers()) { + // FIXME: this dispatch is rather ugly, we probably want to refactor it a bit if (result instanceof DataNodeContainer) { - final QName resultNode = node.withModule(result.getQName().getModule()); - result = ((DataNodeContainer) result).getDataChildByName(resultNode); + final QName resultNode = node.bindTo(result.getQName().getModule()); + + SchemaNode found = ((DataNodeContainer) result).getDataChildByName(resultNode); + if (found == null) { + if (result instanceof ActionNodeContainer) { + found = ((ActionNodeContainer) result).findAction(resultNode).orElse(null); + } + if (found == null && result instanceof NotificationNodeContainer) { + found = ((NotificationNodeContainer) result).findNotification(resultNode).orElse(null); + } + } + result = found; } else if (result instanceof ChoiceSchemaNode) { result = findNamedCase((ChoiceSchemaNode) result, node.getLocalName()); + } else if (result instanceof ActionDefinition) { + final ActionDefinition action = (ActionDefinition) result; + final QName resultNode = node.bindTo(result.getQName().getModule()); + + final ContainerSchemaNode input = action.getInput(); + final ContainerSchemaNode output = action.getOutput(); + if (resultNode.equals(input.getQName())) { + result = input; + } else if (resultNode.equals(output.getQName())) { + result = output; + } else { + result = null; + } + } else if (result != null) { + throw new IllegalStateException("Cannot handle " + result); } } if (result == null) { @@ -898,7 +997,7 @@ abstract class AbstractTypeGenerator { */ private GeneratedTypeBuilder addRawAugmentGenTypeDefinition(final ModuleContext context, final String augmentPackageName, final Type targetTypeRef, - final AugmentationSchemaNode augSchema) { + final AugmentationSchemaNode augSchema, final boolean inGrouping) { Map augmentBuilders = genTypeBuilders.computeIfAbsent(augmentPackageName, k -> new HashMap<>()); final String augIdentifier = getAugmentIdentifier(augSchema.getUnknownSchemaNodes()); @@ -913,28 +1012,33 @@ abstract class AbstractTypeGenerator { final GeneratedTypeBuilder augTypeBuilder = typeProvider.newGeneratedTypeBuilder( JavaTypeName.create(augmentPackageName, augTypeName)); - augTypeBuilder.addImplementsType(DATA_OBJECT); - augTypeBuilder.addImplementsType(Types.augmentationTypeFor(targetTypeRef)); - annotateDeprecatedIfNecessary(augSchema.getStatus(), augTypeBuilder); + augTypeBuilder.addImplementsType(augmentation(targetTypeRef)); + defaultImplementedInterace(augTypeBuilder); + + annotateDeprecatedIfNecessary(augSchema, augTypeBuilder); addImplementedInterfaceFromUses(augSchema, augTypeBuilder); - augSchemaNodeToMethods(context, augTypeBuilder, augSchema.getChildNodes()); + augSchemaNodeToMethods(context, augTypeBuilder, augSchema.getChildNodes(), inGrouping); + actionsToGenType(context, augTypeBuilder, augSchema, null, inGrouping); + notificationsToGenType(context, augTypeBuilder, augSchema, null, inGrouping); + augmentBuilders.put(augTypeName, augTypeBuilder); if (!augSchema.getChildNodes().isEmpty()) { context.addTypeToAugmentation(augTypeBuilder, augSchema); - } + context.addAugmentType(augTypeBuilder); return augTypeBuilder; } private GeneratedTypeBuilder addRawAugmentGenTypeDefinition(final ModuleContext context, final Type targetTypeRef, - final AugmentationSchemaNode augSchema) { - return addRawAugmentGenTypeDefinition(context, context.modulePackageName(), targetTypeRef, augSchema); + final AugmentationSchemaNode augSchema, final boolean inGrouping) { + return addRawAugmentGenTypeDefinition(context, context.modulePackageName(), targetTypeRef, augSchema, + inGrouping); } - private static String getAugmentIdentifier(final List unknownSchemaNodes) { + private static String getAugmentIdentifier(final Collection unknownSchemaNodes) { for (final UnknownSchemaNode unknownSchemaNode : unknownSchemaNodes) { final QName nodeType = unknownSchemaNode.getNodeType(); if (AUGMENT_IDENTIFIER_NAME.equals(nodeType.getLocalName()) @@ -979,12 +1083,13 @@ abstract class AbstractTypeGenerator { * child nodes) could be added to it. */ private GeneratedTypeBuilder resolveDataSchemaNodes(final ModuleContext context, final GeneratedTypeBuilder parent, - final @Nullable Type childOf, final Iterable schemaNodes) { + final @Nullable Type childOf, final Iterable schemaNodes, + final boolean inGrouping) { if (schemaNodes != null && parent != null) { final Type baseInterface = childOf == null ? DATA_OBJECT : childOf(childOf); for (final DataSchemaNode schemaNode : schemaNodes) { if (!schemaNode.isAugmenting() && !schemaNode.isAddedByUses()) { - addSchemaNodeToBuilderAsMethod(context, schemaNode, parent, baseInterface); + addSchemaNodeToBuilderAsMethod(context, schemaNode, parent, baseInterface, inGrouping); } } } @@ -1006,12 +1111,13 @@ abstract class AbstractTypeGenerator { * The getter method could be added to it. */ private GeneratedTypeBuilder augSchemaNodeToMethods(final ModuleContext context, - final GeneratedTypeBuilder typeBuilder, final Iterable schemaNodes) { + final GeneratedTypeBuilder typeBuilder, final Iterable schemaNodes, + final boolean inGrouping) { if (schemaNodes != null && typeBuilder != null) { final Type baseInterface = childOf(typeBuilder); for (final DataSchemaNode schemaNode : schemaNodes) { if (!schemaNode.isAugmenting()) { - addSchemaNodeToBuilderAsMethod(context, schemaNode, typeBuilder, baseInterface); + addSchemaNodeToBuilderAsMethod(context, schemaNode, typeBuilder, baseInterface, inGrouping); } } } @@ -1027,20 +1133,21 @@ abstract class AbstractTypeGenerator { * @param module current module */ private void addSchemaNodeToBuilderAsMethod(final ModuleContext context, final DataSchemaNode node, - final GeneratedTypeBuilder typeBuilder, final Type baseInterface) { + final GeneratedTypeBuilder typeBuilder, final Type baseInterface, final boolean inGrouping) { if (node != null && typeBuilder != null) { if (node instanceof LeafSchemaNode) { - resolveLeafSchemaNodeAsMethod(typeBuilder, (LeafSchemaNode) node, context); + resolveLeafSchemaNodeAsMethod(typeBuilder, (LeafSchemaNode) node, context, inGrouping); } else if (node instanceof LeafListSchemaNode) { - resolveLeafListSchemaNode(typeBuilder, (LeafListSchemaNode) node, context); + resolveLeafListSchemaNode(typeBuilder, (LeafListSchemaNode) node, context, inGrouping); } else if (node instanceof ContainerSchemaNode) { - containerToGenType(context, typeBuilder, baseInterface, (ContainerSchemaNode) node); + containerToGenType(context, typeBuilder, baseInterface, (ContainerSchemaNode) node, inGrouping); } else if (node instanceof ListSchemaNode) { - listToGenType(context, typeBuilder, baseInterface, (ListSchemaNode) node); + listToGenType(context, typeBuilder, baseInterface, (ListSchemaNode) node, inGrouping); } else if (node instanceof ChoiceSchemaNode) { - choiceToGeneratedType(context, typeBuilder, (ChoiceSchemaNode) node); + choiceToGeneratedType(context, typeBuilder, (ChoiceSchemaNode) node, inGrouping); + } else if (node instanceof AnyxmlSchemaNode || node instanceof AnydataSchemaNode) { + opaqueToGeneratedType(context, typeBuilder, node); } else { - // TODO: anyxml not yet supported LOG.debug("Unable to add schema node {} as method in {}: unsupported type of node.", node.getClass(), typeBuilder.getFullyQualifiedName()); } @@ -1064,24 +1171,37 @@ abstract class AbstractTypeGenerator { * */ private void choiceToGeneratedType(final ModuleContext context, final GeneratedTypeBuilder parent, - final ChoiceSchemaNode choiceNode) { - checkArgument(choiceNode != null, "Choice Schema Node cannot be NULL."); - + final ChoiceSchemaNode choiceNode, final boolean inGrouping) { if (!choiceNode.isAddedByUses()) { - final GeneratedTypeBuilder choiceTypeBuilder = addRawInterfaceDefinition( + final GeneratedTypeBuilder choiceTypeBuilder = addRawInterfaceDefinition(context, JavaTypeName.create(packageNameForGeneratedType(context.modulePackageName(), choiceNode.getPath()), BindingMapping.getClassName(choiceNode.getQName())), choiceNode); choiceTypeBuilder.addImplementsType(choiceIn(parent)); - annotateDeprecatedIfNecessary(choiceNode.getStatus(), choiceTypeBuilder); + annotateDeprecatedIfNecessary(choiceNode, choiceTypeBuilder); context.addChildNodeType(choiceNode, choiceTypeBuilder); final GeneratedType choiceType = choiceTypeBuilder.build(); - generateTypesFromChoiceCases(context, choiceType, choiceNode); + generateTypesFromChoiceCases(context, choiceType, choiceNode, inGrouping); constructGetter(parent, choiceType, choiceNode); } } + private void opaqueToGeneratedType(final ModuleContext context, final GeneratedTypeBuilder parent, + final DataSchemaNode anyNode) { + if (!anyNode.isAddedByUses()) { + final GeneratedTypeBuilder anyxmlTypeBuilder = addRawInterfaceDefinition(context, + JavaTypeName.create(packageNameForGeneratedType(context.modulePackageName(), anyNode.getPath()), + BindingMapping.getClassName(anyNode.getQName())), anyNode); + anyxmlTypeBuilder.addImplementsType(opaqueObject(anyxmlTypeBuilder)).addImplementsType(childOf(parent)); + defaultImplementedInterace(anyxmlTypeBuilder); + annotateDeprecatedIfNecessary(anyNode, anyxmlTypeBuilder); + context.addChildNodeType(anyNode, anyxmlTypeBuilder); + + constructGetter(parent, anyxmlTypeBuilder.build(), anyNode); + } + } + /** * Converts caseNodes set to list of corresponding generated types. For every case which is not * added through augment or uses is created generated type builder. The package names for the builder is @@ -1098,18 +1218,19 @@ abstract class AbstractTypeGenerator { * */ private void generateTypesFromChoiceCases(final ModuleContext context, final Type refChoiceType, - final ChoiceSchemaNode choiceNode) { + final ChoiceSchemaNode choiceNode, final boolean inGrouping) { checkArgument(refChoiceType != null, "Referenced Choice Type cannot be NULL."); checkArgument(choiceNode != null, "ChoiceNode cannot be NULL."); - for (final CaseSchemaNode caseNode : choiceNode.getCases().values()) { + for (final CaseSchemaNode caseNode : choiceNode.getCases()) { if (caseNode != null && !caseNode.isAddedByUses() && !caseNode.isAugmenting()) { final GeneratedTypeBuilder caseTypeBuilder = addDefaultInterfaceDefinition(context, caseNode); caseTypeBuilder.addImplementsType(refChoiceType); - annotateDeprecatedIfNecessary(caseNode.getStatus(), caseTypeBuilder); + defaultImplementedInterace(caseTypeBuilder); + annotateDeprecatedIfNecessary(caseNode, caseTypeBuilder); context.addCaseType(caseNode.getPath(), caseTypeBuilder); context.addChoiceToCaseMapping(refChoiceType, caseTypeBuilder, caseNode); - final Iterable caseChildNodes = caseNode.getChildNodes(); + final Iterable caseChildNodes = caseNode.getChildNodes(); if (caseChildNodes != null) { final SchemaPath choiceNodeParentPath = choiceNode.getPath().getParent(); @@ -1118,8 +1239,10 @@ abstract class AbstractTypeGenerator { if (parent instanceof AugmentationSchemaNode) { final AugmentationSchemaNode augSchema = (AugmentationSchemaNode) parent; - final SchemaPath targetPath = augSchema.getTargetPath(); - SchemaNode targetSchemaNode = findDataSchemaNode(schemaContext, targetPath); + final SchemaNodeIdentifier targetPath = augSchema.getTargetPath(); + // FIXME: can we use findDataSchemaNode? + SchemaNode targetSchemaNode = findNodeInSchemaContext(schemaContext, + targetPath.getNodeIdentifiers()); if (targetSchemaNode instanceof DataSchemaNode && ((DataSchemaNode) targetSchemaNode).isAddedByUses()) { if (targetSchemaNode instanceof DerivableSchemaNode) { @@ -1140,13 +1263,14 @@ abstract class AbstractTypeGenerator { if (childOfType == null) { childOfType = findGroupingByPath(parent.getPath()); } - resolveDataSchemaNodes(context, caseTypeBuilder, childOfType, caseChildNodes); + resolveDataSchemaNodes(context, caseTypeBuilder, childOfType, caseChildNodes, inGrouping); } else { - resolveDataSchemaNodes(context, caseTypeBuilder, moduleToDataType(context), caseChildNodes); + resolveDataSchemaNodes(context, caseTypeBuilder, moduleToDataType(context), caseChildNodes, + inGrouping); } } } - processUsesAugments(caseNode, context); + processUsesAugments(caseNode, context, inGrouping); } } @@ -1172,8 +1296,9 @@ abstract class AbstractTypeGenerator { // FIXME: nullness rules need to untangled in this method @SuppressFBWarnings("NP_NULL_ON_SOME_PATH") private void generateTypesFromAugmentedChoiceCases(final ModuleContext context, - final Type targetType, final ChoiceSchemaNode targetNode, final Iterable augmentedNodes, - final DataNodeContainer usesNodeParent) { + final Type targetType, final ChoiceSchemaNode targetNode, + final Iterable augmentedNodes, + final DataNodeContainer usesNodeParent, final boolean inGrouping) { checkArgument(targetType != null, "Referenced Choice Type cannot be NULL."); checkArgument(augmentedNodes != null, "Set of Choice Case Nodes cannot be NULL."); @@ -1181,6 +1306,7 @@ abstract class AbstractTypeGenerator { if (caseNode != null) { final GeneratedTypeBuilder caseTypeBuilder = addDefaultInterfaceDefinition(context, caseNode); caseTypeBuilder.addImplementsType(targetType); + defaultImplementedInterace(caseTypeBuilder); CaseSchemaNode node = null; final String caseLocalName = caseNode.getQName().getLocalName(); @@ -1198,9 +1324,10 @@ abstract class AbstractTypeGenerator { } else { node = findNamedCase(targetNode, caseLocalName); } - final Iterable childNodes = node.getChildNodes(); + final Iterable childNodes = node.getChildNodes(); if (childNodes != null) { - resolveDataSchemaNodes(context, caseTypeBuilder, findChildOfType(targetNode), childNodes); + resolveDataSchemaNodes(context, caseTypeBuilder, findChildOfType(targetNode), childNodes, + inGrouping); } context.addCaseType(caseNode.getPath(), caseTypeBuilder); context.addChoiceToCaseMapping(targetType, caseTypeBuilder, node); @@ -1233,7 +1360,7 @@ abstract class AbstractTypeGenerator { } private static CaseSchemaNode findNamedCase(final ChoiceSchemaNode choice, final String caseName) { - final List cases = choice.findCaseNodes(caseName); + final List cases = choice.findCaseNodes(caseName); return cases.isEmpty() ? null : cases.get(0); } @@ -1275,7 +1402,7 @@ abstract class AbstractTypeGenerator { * */ private Type resolveLeafSchemaNodeAsMethod(final GeneratedTypeBuilder typeBuilder, final LeafSchemaNode leaf, - final ModuleContext context) { + final ModuleContext context, final boolean inGrouping) { if (leaf == null || typeBuilder == null || leaf.isAddedByUses()) { return null; } @@ -1283,16 +1410,11 @@ abstract class AbstractTypeGenerator { final Module parentModule = findParentModule(schemaContext, leaf); Type returnType = null; - final TypeDefinition typeDef = CompatUtils.compatLeafType(leaf); + final TypeDefinition typeDef = CompatUtils.compatType(leaf); if (isInnerType(leaf, typeDef)) { if (typeDef instanceof EnumTypeDefinition) { - returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, leaf); final EnumTypeDefinition enumTypeDef = (EnumTypeDefinition) typeDef; - final EnumBuilder enumBuilder = resolveInnerEnumFromTypeDefinition(enumTypeDef, leaf.getQName(), - typeBuilder, context); - if (enumBuilder != null) { - returnType = enumBuilder.toInstance(typeBuilder); - } + returnType = resolveInnerEnumFromTypeDefinition(enumTypeDef, leaf.getQName(), typeBuilder, context); typeProvider.putReferencedType(leaf.getPath(), returnType); } else if (typeDef instanceof UnionTypeDefinition) { final UnionTypeDefinition unionDef = (UnionTypeDefinition)typeDef; @@ -1312,12 +1434,12 @@ abstract class AbstractTypeGenerator { // and apply restrictions from leaf type final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(typeDef); returnType = typeProvider.javaTypeForSchemaDefinitionType(getBaseOrDeclaredType(typeDef), leaf, - restrictions); + restrictions, inGrouping); addPatternConstant(typeBuilder, leaf.getQName().getLocalName(), restrictions.getPatternConstraints()); } } else { final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(typeDef); - returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, leaf, restrictions); + returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, leaf, restrictions, inGrouping); addPatternConstant(typeBuilder, leaf.getQName().getLocalName(), restrictions.getPatternConstraints()); } @@ -1380,7 +1502,8 @@ abstract class AbstractTypeGenerator { } } - private static IdentitySchemaNode findIdentityByName(final Set identities, final String name) { + private static IdentitySchemaNode findIdentityByName(final Collection identities, + final String name) { for (final IdentitySchemaNode id : identities) { if (id.getQName().getLocalName().equals(name)) { return id; @@ -1389,7 +1512,7 @@ abstract class AbstractTypeGenerator { return null; } - private Module findModuleFromImports(final Set imports, final String prefix) { + private Module findModuleFromImports(final Collection imports, final String prefix) { for (final ModuleImport imp : imports) { if (imp.getPrefix().equals(prefix)) { return schemaContext.findModule(imp.getModuleName(), imp.getRevision()).orElse(null); @@ -1402,7 +1525,7 @@ abstract class AbstractTypeGenerator { final boolean isReadOnly) { if (leaf != null && toBuilder != null) { Type returnType; - final TypeDefinition typeDef = CompatUtils.compatLeafType(leaf); + final TypeDefinition typeDef = CompatUtils.compatType(leaf); if (typeDef instanceof UnionTypeDefinition) { // GeneratedType for this type definition should have be already created final ModuleContext mc = moduleContext(typeDef.getQName().getModule()); @@ -1469,7 +1592,7 @@ abstract class AbstractTypeGenerator { * */ private boolean resolveLeafListSchemaNode(final GeneratedTypeBuilder typeBuilder, final LeafListSchemaNode node, - final ModuleContext context) { + final ModuleContext context, final boolean inGrouping) { if (node == null || typeBuilder == null || node.isAddedByUses()) { return false; } @@ -1482,11 +1605,8 @@ abstract class AbstractTypeGenerator { Type returnType = null; if (typeDef.getBaseType() == null) { if (typeDef instanceof EnumTypeDefinition) { - returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, node); final EnumTypeDefinition enumTypeDef = (EnumTypeDefinition) typeDef; - final EnumBuilder enumBuilder = resolveInnerEnumFromTypeDefinition(enumTypeDef, nodeName, - typeBuilder, context); - returnType = new ReferencedTypeImpl(enumBuilder.getIdentifier()); + returnType = resolveInnerEnumFromTypeDefinition(enumTypeDef, nodeName, typeBuilder, context); typeProvider.putReferencedType(node.getPath(), returnType); } else if (typeDef instanceof UnionTypeDefinition) { final UnionTypeDefinition unionDef = (UnionTypeDefinition)typeDef; @@ -1497,12 +1617,12 @@ abstract class AbstractTypeGenerator { returnType = genTOBuilder.build(); } else { final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(typeDef); - returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, node, restrictions); + returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, node, restrictions, inGrouping); addPatternConstant(typeBuilder, node.getQName().getLocalName(), restrictions.getPatternConstraints()); } } else { final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(typeDef); - returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, node, restrictions); + returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, node, restrictions, inGrouping); addPatternConstant(typeBuilder, node.getQName().getLocalName(), restrictions.getPatternConstraints()); } @@ -1538,7 +1658,7 @@ abstract class AbstractTypeGenerator { final MethodSignatureBuilder method = unionBuilder.addMethod("getDefaultInstance"); method.setReturnType(returnType); - method.addParameter(Types.STRING, "defaultValue"); + method.addParameter(STRING, "defaultValue"); method.setAccessModifier(AccessModifier.PUBLIC); method.setStatic(true); @@ -1578,8 +1698,7 @@ abstract class AbstractTypeGenerator { name = JavaTypeName.create(packageName, BindingMapping.getClassName(schemaNode.getQName())); } - final GeneratedTypeBuilder it = addRawInterfaceDefinition(name, schemaNode); - + final GeneratedTypeBuilder it = addRawInterfaceDefinition(context, name, schemaNode); it.addImplementsType(baseInterface); if (!(schemaNode instanceof GroupingDefinition)) { it.addImplementsType(augmentable(it)); @@ -1610,7 +1729,8 @@ abstract class AbstractTypeGenerator { *
  • if schemaNode name is null
    • * */ - private GeneratedTypeBuilder addRawInterfaceDefinition(final JavaTypeName identifier, final SchemaNode schemaNode) { + private GeneratedTypeBuilder addRawInterfaceDefinition(final ModuleContext context, final JavaTypeName identifier, + final SchemaNode schemaNode) { checkArgument(schemaNode != null, "Data Schema Node cannot be NULL."); checkArgument(schemaNode.getQName() != null, "QName for Data Schema Node cannot be NULL."); final String schemaNodeName = schemaNode.getQName().getLocalName(); @@ -1618,10 +1738,9 @@ abstract class AbstractTypeGenerator { // FIXME: Validation of name conflict final GeneratedTypeBuilder newType = typeProvider.newGeneratedTypeBuilder(identifier); - final Module module = findParentModule(schemaContext, schemaNode); - qnameConstant(newType, JavaTypeName.create(BindingMapping.getRootPackageName(module.getQNameModule()), - BindingMapping.MODULE_INFO_CLASS_NAME), schemaNode.getQName().getLocalName()); + qnameConstant(newType, context.moduleInfoType(), schemaNode.getQName().getLocalName()); + final Module module = context.module(); addCodegenInformation(newType, module, schemaNode); newType.setSchemaPath(schemaNode.getPath()); newType.setModuleName(module.getName()); @@ -1670,7 +1789,7 @@ abstract class AbstractTypeGenerator { getterMethodName(node.getQName().getLocalName(), returnType)); getMethod.setReturnType(returnType); - annotateDeprecatedIfNecessary(node.getStatus(), getMethod); + annotateDeprecatedIfNecessary(node, getMethod); addComment(getMethod, node); return getMethod; @@ -1681,7 +1800,7 @@ abstract class AbstractTypeGenerator { final MethodSignatureBuilder getMethod = interfaceBuilder.addMethod( BindingMapping.getNonnullMethodName(node.getQName().getLocalName())); getMethod.setReturnType(returnType).setDefault(true); - annotateDeprecatedIfNecessary(node.getStatus(), getMethod); + annotateDeprecatedIfNecessary(node, getMethod); } /** @@ -1703,14 +1822,14 @@ abstract class AbstractTypeGenerator { */ private void addSchemaNodeToListBuilders(final ModuleContext context, final DataSchemaNode schemaNode, final GeneratedTypeBuilder typeBuilder, final GeneratedTOBuilder genTOBuilder, - final List listKeys) { + final List listKeys, final boolean inGrouping) { checkArgument(schemaNode != null, "Data Schema Node cannot be NULL."); checkArgument(typeBuilder != null, "Generated Type Builder cannot be NULL."); if (schemaNode instanceof LeafSchemaNode) { final LeafSchemaNode leaf = (LeafSchemaNode) schemaNode; final String leafName = leaf.getQName().getLocalName(); - Type type = resolveLeafSchemaNodeAsMethod(typeBuilder, leaf, context); + Type type = resolveLeafSchemaNodeAsMethod(typeBuilder, leaf, context, inGrouping); if (listKeys.contains(leafName)) { if (type == null) { resolveLeafSchemaNodeAsProperty(genTOBuilder, leaf, true); @@ -1720,14 +1839,16 @@ abstract class AbstractTypeGenerator { } } else if (!schemaNode.isAddedByUses()) { if (schemaNode instanceof LeafListSchemaNode) { - resolveLeafListSchemaNode(typeBuilder, (LeafListSchemaNode) schemaNode, context); + resolveLeafListSchemaNode(typeBuilder, (LeafListSchemaNode) schemaNode, context, inGrouping); } else if (schemaNode instanceof ContainerSchemaNode) { containerToGenType(context, typeBuilder, childOf(typeBuilder), - (ContainerSchemaNode) schemaNode); + (ContainerSchemaNode) schemaNode, inGrouping); } else if (schemaNode instanceof ChoiceSchemaNode) { - choiceToGeneratedType(context, typeBuilder, (ChoiceSchemaNode) schemaNode); + choiceToGeneratedType(context, typeBuilder, (ChoiceSchemaNode) schemaNode, inGrouping); } else if (schemaNode instanceof ListSchemaNode) { - listToGenType(context, typeBuilder, childOf(typeBuilder), (ListSchemaNode) schemaNode); + listToGenType(context, typeBuilder, childOf(typeBuilder), (ListSchemaNode) schemaNode, inGrouping); + } else if (schemaNode instanceof AnyxmlSchemaNode || schemaNode instanceof AnydataSchemaNode) { + opaqueToGeneratedType(context, typeBuilder, schemaNode); } } } @@ -1753,32 +1874,19 @@ abstract class AbstractTypeGenerator { * an empty list is returned. */ private static List listKeys(final ListSchemaNode list) { - final List listKeys = new ArrayList<>(); - final List keyDefinition = list.getKeyDefinition(); - if (keyDefinition != null) { - for (final QName keyDef : keyDefinition) { - listKeys.add(keyDef.getLocalName()); - } - } - return listKeys; - } - - /** - * Generates for the list which contains any list keys special generated TO builder. - * - * @param packageName string with package name to which the list belongs - * @param list list schema node which is source of data about the list name - * @return generated TO builder which represents the keys of the list or null if list is - * null or list of key definitions is null or empty. - */ - private GeneratedTOBuilder resolveListKeyTOBuilder(final ModuleContext context, final ListSchemaNode list) { - if (list.getKeyDefinition() != null && !list.getKeyDefinition().isEmpty()) { - return typeProvider.newGeneratedTOBuilder(JavaTypeName.create( - packageNameForGeneratedType(context.modulePackageName(), list.getPath()), - BindingMapping.getClassName(list.getQName().getLocalName() + "Key"))); + switch (keyDefinition.size()) { + case 0: + return Collections.emptyList(); + case 1: + return Collections.singletonList(keyDefinition.get(0).getLocalName()); + default: + final List listKeys = new ArrayList<>(keyDefinition.size()); + for (final QName keyDef : keyDefinition) { + listKeys.add(keyDef.getLocalName()); + } + return listKeys; } - return null; } /** @@ -1795,8 +1903,7 @@ abstract class AbstractTypeGenerator { private Type addTOToTypeBuilder(final UnionTypeDefinition typeDef, final GeneratedTypeBuilder typeBuilder, final DataSchemaNode leaf, final Module parentModule) { final List types = typeProvider.provideGeneratedTOBuildersForUnionTypeDef( - typeBuilder.getIdentifier().createEnclosed(BindingMapping.getClassName(leaf.getQName())), - typeDef, leaf); + allocateNestedType(typeBuilder.getIdentifier(), leaf.getQName()), typeDef, leaf); checkState(!types.isEmpty(), "No GeneratedTOBuilder objects generated from union %s", typeDef); final List genTOBuilders = new ArrayList<>(types); @@ -1829,11 +1936,9 @@ abstract class AbstractTypeGenerator { private GeneratedTOBuilder addTOToTypeBuilder(final BitsTypeDefinition typeDef, final GeneratedTypeBuilder typeBuilder, final DataSchemaNode leaf, final Module parentModule) { final GeneratedTOBuilder genTOBuilder = typeProvider.provideGeneratedTOBuilderForBitsTypeDefinition( - typeBuilder.getIdentifier().createEnclosed(BindingMapping.getClassName(leaf.getQName())), - typeDef, parentModule.getName()); + allocateNestedType(typeBuilder.getIdentifier(), leaf.getQName()), typeDef, parentModule.getName()); typeBuilder.addEnclosingTransferObject(genTOBuilder); return genTOBuilder; - } /** @@ -1849,17 +1954,27 @@ abstract class AbstractTypeGenerator { private GeneratedTypeBuilder addImplementedInterfaceFromUses(final DataNodeContainer dataNodeContainer, final GeneratedTypeBuilder builder) { for (final UsesNode usesNode : dataNodeContainer.getUses()) { - final GeneratedType genType = findGroupingByPath(usesNode.getGroupingPath()).build(); + final GeneratedTypeBuilder genType = findGrouping(usesNode.getSourceGrouping()); if (genType == null) { - throw new IllegalStateException("Grouping " + usesNode.getGroupingPath() + "is not resolved for " - + builder.getName()); + throw new IllegalStateException("Grouping " + usesNode.getSourceGrouping().getQName() + + " is not resolved for " + builder.getFullyQualifiedName()); } - builder.addImplementsType(genType); + builder.addImplementsType(genType.build()); } return builder; } + private JavaTypeName findAliasByPath(final SchemaPath path) { + for (final ModuleContext ctx : genCtx.values()) { + final JavaTypeName result = ctx.getAlias(path); + if (result != null) { + return result; + } + } + return null; + } + private GeneratedTypeBuilder findChildNodeByPath(final SchemaPath path) { for (final ModuleContext ctx : genCtx.values()) { final GeneratedTypeBuilder result = ctx.getChildNode(path); @@ -1870,6 +1985,16 @@ abstract class AbstractTypeGenerator { return null; } + private GeneratedTypeBuilder findGrouping(final GroupingDefinition grouping) { + for (final ModuleContext ctx : genCtx.values()) { + final GeneratedTypeBuilder result = ctx.getGrouping(grouping.getPath()); + if (result != null) { + return result; + } + } + return null; + } + private GeneratedTypeBuilder findGroupingByPath(final SchemaPath path) { for (final ModuleContext ctx : genCtx.values()) { final GeneratedTypeBuilder result = ctx.getGrouping(path); @@ -1890,9 +2015,43 @@ abstract class AbstractTypeGenerator { return null; } - private static void annotateDeprecatedIfNecessary(final Status status, final AnnotableTypeBuilder builder) { - if (status == Status.DEPRECATED) { - builder.addAnnotation(DEPRECATED_ANNOTATION); + private static JavaTypeName allocateNestedType(final JavaTypeName parent, final QName child) { + // Single '$' suffix cannot come from user, this mirrors AbstractGeneratedTypeBuilder.addEnumeration() + return parent.createEnclosed(BindingMapping.getClassName(child), "$"); + } + + private static void annotateDeprecatedIfNecessary(final WithStatus node, final AnnotableTypeBuilder builder) { + switch (node.getStatus()) { + case DEPRECATED: + // FIXME: we really want to use a pre-made annotation + builder.addAnnotation(DEPRECATED_ANNOTATION); + break; + case OBSOLETE: + builder.addAnnotation(DEPRECATED_ANNOTATION).addParameter("forRemoval", "true"); + break; + case CURRENT: + // No-op + break; + default: + throw new IllegalStateException("Unhandled status in " + node); } } + + private static void narrowImplementedInterface(final GeneratedTypeBuilder typeBuilder) { + defineImplementedInterfaceMethod(typeBuilder, wildcardTypeFor(typeBuilder.getIdentifier())); + } + + private static void defaultImplementedInterace(final GeneratedTypeBuilder typeBuilder) { + defineImplementedInterfaceMethod(typeBuilder, DefaultType.of(typeBuilder)).setDefault(true); + } + + private static MethodSignatureBuilder defineImplementedInterfaceMethod(final GeneratedTypeBuilder typeBuilder, + final Type classType) { + final MethodSignatureBuilder ret = typeBuilder + .addMethod(BindingMapping.DATA_CONTAINER_IMPLEMENTED_INTERFACE_NAME) + .setAccessModifier(AccessModifier.PUBLIC) + .setReturnType(classType(classType)); + ret.addAnnotation(OVERRIDE_ANNOTATION); + return ret; + } }