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;
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;
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;
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;
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;
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;
* Comparator based on augment target path.
*/
private static final Comparator<AugmentationSchemaNode> AUGMENT_COMP = (o1, o2) -> {
- final Iterator<QName> thisIt = o1.getTargetPath().getPathFromRoot().iterator();
- final Iterator<QName> otherIt = o2.getTargetPath().getPathFromRoot().iterator();
+ final Iterator<QName> thisIt = o1.getTargetPath().getNodeIdentifiers().iterator();
+ final Iterator<QName> otherIt = o2.getTargetPath().getNodeIdentifiers().iterator();
while (thisIt.hasNext()) {
if (!otherIt.hasNext()) {
/**
* 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<SchemaNode, JavaTypeName> renames;
- AbstractTypeGenerator(final SchemaContext context, final AbstractTypeProvider typeProvider,
+ AbstractTypeGenerator(final EffectiveModelContext context, final AbstractTypeProvider typeProvider,
final Map<SchemaNode, JavaTypeName> renames) {
this.schemaContext = requireNonNull(context);
this.typeProvider = requireNonNull(typeProvider);
contexts.forEach(this::allAugmentsToGenTypes);
}
+ final @NonNull EffectiveModelContext schemaContext() {
+ return schemaContext;
+ }
+
final Collection<ModuleContext> moduleContexts() {
return genCtx.values();
}
abstract void addCodegenInformation(GeneratedTypeBuilderBase<?> genType, Module module, SchemaNode node);
abstract void addCodegenInformation(GeneratedTypeBuilder interfaceBuilder, Module module, String description,
- Set<? extends SchemaNode> nodes);
+ Collection<? extends SchemaNode> nodes);
abstract void addComment(TypeMemberBuilder<?> genType, DocumentedNode node);
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;
}
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<TypeDefinition<?>> 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) {
}
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());
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<String> 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);
}
}
}
checkArgument(module != null, "Module reference cannot be NULL.");
checkState(module.getAugmentations() != null, "Augmentations Set cannot be NULL.");
- final Set<AugmentationSchemaNode> augmentations = module.getAugmentations();
- final List<AugmentationSchemaNode> sortedAugmentations = new ArrayList<>(augmentations);
+ final List<AugmentationSchemaNode> sortedAugmentations = new ArrayList<>(module.getAugmentations());
sortedAugmentations.sort(AUGMENT_COMP);
return sortedAugmentations;
final Module module = context.module();
addImplementedInterfaceFromUses(module, moduleDataTypeBuilder);
moduleDataTypeBuilder.addImplementsType(DATA_ROOT);
+ // if we have more than 2 top level uses statements we need to define getImplementedInterface() on the
+ // top level DataRoot object
+ if (module.getUses().size() > 1) {
+ narrowImplementedInterface(moduleDataTypeBuilder);
+ }
addCodegenInformation(moduleDataTypeBuilder, module);
return moduleDataTypeBuilder;
}
private <T extends DataNodeContainer & ActionNodeContainer> 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)) {
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));
}
private Optional<ActionDefinition> findOrigAction(final DataNodeContainer parent, final ActionDefinition action) {
+ final QName qname = action.getQName();
for (UsesNode uses : parent.getUses()) {
- final GroupingDefinition grp = findUsedGrouping(uses);
- final Optional<ActionDefinition> 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<ActionDefinition> found = grp.findAction(qname.bindTo(grp.getQName().getModule()));
if (found.isPresent()) {
final ActionDefinition result = found.get();
return result.isAddedByUses() ? findOrigAction(grp, result) : found;
}
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();
}
private void rpcMethodsToGenType(final ModuleContext context) {
final Module module = context.module();
checkArgument(module.getName() != null, "Module name cannot be NULL.");
- final Set<RpcDefinition> rpcDefinitions = module.getRpcs();
+ final Collection<? extends RpcDefinition> rpcDefinitions = module.getRpcs();
checkState(rpcDefinitions != null, "Set of rpcs from module " + module.getName() + " cannot be NULL.");
if (rpcDefinitions.isEmpty()) {
return;
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");
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();
}
private void notificationsToGenType(final ModuleContext context) {
final Module module = context.module();
checkArgument(module.getName() != null, "Module name cannot be NULL.");
- final Set<NotificationDefinition> notifications = module.getNotifications();
+ final Collection<? extends NotificationDefinition> notifications = module.getNotifications();
if (notifications.isEmpty()) {
return;
}
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);
}
}
context.addTopLevelNodeType(listenerInterface);
}
+ private <T extends DataNodeContainer & NotificationNodeContainer> void notificationsToGenType(
+ final ModuleContext context, final Type parent, final T parentSchema, final Type keyType,
+ final boolean inGrouping) {
+ final Collection<? extends NotificationDefinition> 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 <b>identities</b> of the module to the list of
* <code>Type</code> objects.
*
*/
private void allIdentitiesToGenTypes(final ModuleContext context) {
- final Set<IdentitySchemaNode> schemaIdentities = context.module().getIdentities();
+ final Collection<? extends IdentitySchemaNode> schemaIdentities = context.module().getIdentities();
if (schemaIdentities != null && !schemaIdentities.isEmpty()) {
for (final IdentitySchemaNode identity : schemaIdentities) {
}
final GeneratedTypeBuilder newType = typeProvider.newGeneratedTypeBuilder(name);
- final Set<IdentitySchemaNode> baseIdentities = identity.getBaseIdentities();
+ final Collection<? extends IdentitySchemaNode> baseIdentities = identity.getBaseIdentities();
if (!baseIdentities.isEmpty()) {
for (IdentitySchemaNode baseIdentity : baseIdentities) {
JavaTypeName base = renames.get(baseIdentity);
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));
}
* collection of groupings from which types will be generated
*
*/
- private void groupingsToGenTypes(final ModuleContext context, final Collection<GroupingDefinition> groupings) {
+ private void groupingsToGenTypes(final ModuleContext context,
+ final Collection<? extends GroupingDefinition> 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);
}
}
* @param module Module in which type should be generated
* @return enumeration builder which contains data from <code>enumTypeDef</code>
*/
- 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;
}
/**
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);
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);
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.
*
* @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) {
*/
private GeneratedTypeBuilder addRawAugmentGenTypeDefinition(final ModuleContext context,
final String augmentPackageName, final Type targetTypeRef,
- final AugmentationSchemaNode augSchema) {
+ final AugmentationSchemaNode augSchema, final boolean inGrouping) {
Map<String, GeneratedTypeBuilder> augmentBuilders =
genTypeBuilders.computeIfAbsent(augmentPackageName, k -> new HashMap<>());
final String augIdentifier = getAugmentIdentifier(augSchema.getUnknownSchemaNodes());
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<UnknownSchemaNode> unknownSchemaNodes) {
+ private static String getAugmentIdentifier(final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
for (final UnknownSchemaNode unknownSchemaNode : unknownSchemaNodes) {
final QName nodeType = unknownSchemaNode.getNodeType();
if (AUGMENT_IDENTIFIER_NAME.equals(nodeType.getLocalName())
* child nodes) could be added to it.
*/
private GeneratedTypeBuilder resolveDataSchemaNodes(final ModuleContext context, final GeneratedTypeBuilder parent,
- final @Nullable Type childOf, final Iterable<DataSchemaNode> schemaNodes) {
+ final @Nullable Type childOf, final Iterable<? extends DataSchemaNode> 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);
}
}
}
* The getter method could be added to it.
*/
private GeneratedTypeBuilder augSchemaNodeToMethods(final ModuleContext context,
- final GeneratedTypeBuilder typeBuilder, final Iterable<DataSchemaNode> schemaNodes) {
+ final GeneratedTypeBuilder typeBuilder, final Iterable<? extends DataSchemaNode> 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);
}
}
}
* @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());
}
* </ul>
*/
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 <code>caseNodes</code> set to list of corresponding generated types. For every <i>case</i> which is not
* added through augment or <i>uses</i> is created generated type builder. The package names for the builder is
* </ul>
*/
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<DataSchemaNode> caseChildNodes = caseNode.getChildNodes();
+ final Iterable<? extends DataSchemaNode> caseChildNodes = caseNode.getChildNodes();
if (caseChildNodes != null) {
final SchemaPath choiceNodeParentPath = choiceNode.getPath().getParent();
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) {
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);
}
}
// 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<DataSchemaNode> augmentedNodes,
- final DataNodeContainer usesNodeParent) {
+ final Type targetType, final ChoiceSchemaNode targetNode,
+ final Iterable<? extends DataSchemaNode> 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.");
if (caseNode != null) {
final GeneratedTypeBuilder caseTypeBuilder = addDefaultInterfaceDefinition(context, caseNode);
caseTypeBuilder.addImplementsType(targetType);
+ defaultImplementedInterace(caseTypeBuilder);
CaseSchemaNode node = null;
final String caseLocalName = caseNode.getQName().getLocalName();
} else {
node = findNamedCase(targetNode, caseLocalName);
}
- final Iterable<DataSchemaNode> childNodes = node.getChildNodes();
+ final Iterable<? extends DataSchemaNode> 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);
}
private static CaseSchemaNode findNamedCase(final ChoiceSchemaNode choice, final String caseName) {
- final List<CaseSchemaNode> cases = choice.findCaseNodes(caseName);
+ final List<? extends CaseSchemaNode> cases = choice.findCaseNodes(caseName);
return cases.isEmpty() ? null : cases.get(0);
}
* </ul>
*/
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;
}
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;
// 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());
}
}
}
- private static IdentitySchemaNode findIdentityByName(final Set<IdentitySchemaNode> identities, final String name) {
+ private static IdentitySchemaNode findIdentityByName(final Collection<? extends IdentitySchemaNode> identities,
+ final String name) {
for (final IdentitySchemaNode id : identities) {
if (id.getQName().getLocalName().equals(name)) {
return id;
return null;
}
- private Module findModuleFromImports(final Set<ModuleImport> imports, final String prefix) {
+ private Module findModuleFromImports(final Collection<? extends ModuleImport> imports, final String prefix) {
for (final ModuleImport imp : imports) {
if (imp.getPrefix().equals(prefix)) {
return schemaContext.findModule(imp.getModuleName(), imp.getRevision()).orElse(null);
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());
* </ul>
*/
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;
}
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;
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());
}
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);
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));
* <li>if schemaNode name is null</li>
* </ul>
*/
- 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();
// 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());
getterMethodName(node.getQName().getLocalName(), returnType));
getMethod.setReturnType(returnType);
- annotateDeprecatedIfNecessary(node.getStatus(), getMethod);
+ annotateDeprecatedIfNecessary(node, getMethod);
addComment(getMethod, node);
return getMethod;
final MethodSignatureBuilder getMethod = interfaceBuilder.addMethod(
BindingMapping.getNonnullMethodName(node.getQName().getLocalName()));
getMethod.setReturnType(returnType).setDefault(true);
- annotateDeprecatedIfNecessary(node.getStatus(), getMethod);
+ annotateDeprecatedIfNecessary(node, getMethod);
}
/**
*/
private void addSchemaNodeToListBuilders(final ModuleContext context, final DataSchemaNode schemaNode,
final GeneratedTypeBuilder typeBuilder, final GeneratedTOBuilder genTOBuilder,
- final List<String> listKeys) {
+ final List<String> 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);
}
} 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);
}
}
}
* an empty list is returned.
*/
private static List<String> listKeys(final ListSchemaNode list) {
- final List<String> listKeys = new ArrayList<>();
-
final List<QName> keyDefinition = list.getKeyDefinition();
- if (keyDefinition != null) {
- for (final QName keyDef : keyDefinition) {
- listKeys.add(keyDef.getLocalName());
- }
- }
- return listKeys;
- }
-
- /**
- * Generates for the <code>list</code> 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 <code>list</code> or null if <code>list</code> 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<String> listKeys = new ArrayList<>(keyDefinition.size());
+ for (final QName keyDef : keyDefinition) {
+ listKeys.add(keyDef.getLocalName());
+ }
+ return listKeys;
}
- return null;
}
/**
private Type addTOToTypeBuilder(final UnionTypeDefinition typeDef,
final GeneratedTypeBuilder typeBuilder, final DataSchemaNode leaf, final Module parentModule) {
final List<GeneratedTOBuilder> 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<GeneratedTOBuilder> genTOBuilders = new ArrayList<>(types);
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;
-
}
/**
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);
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);
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;
+ }
}
Code Review / mdsal.git / blobdiff