import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.mdsal.binding.generator.util.BaseYangTypes;
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.TypeConstants;
import org.opendaylight.mdsal.binding.model.util.generated.type.builder.GeneratedPropertyBuilderImpl;
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.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.TypeDefinition;
/**
* Holds reference to schema context to resolve data of augmented element when creating augmentation builder.
*/
- private final @NonNull 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 SchemaContext schemaContext() {
+ final @NonNull EffectiveModelContext schemaContext() {
return schemaContext;
}
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(), false);
}
+
+ // Resolve RPCs and notifications only after we have created instantiated tree
+ rpcMethodsToGenType(context);
+ notificationsToGenType(context);
return context;
}
listType = listTypeFor(genType);
}
- constructGetter(parent, listType, node);
+ constructGetter(parent, listType, node).setMechanics(ValueMechanics.NULLIFY_EMPTY);
constructNonnull(parent, listType, node);
actionsToGenType(context, genType, node, keyTypeBuilder, inGrouping);
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;
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(), inGrouping);
output = actionContainer(context, RPC_OUTPUT, action.getOutput(), inGrouping);
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, builder);
builder.addImplementsType(keyType != null ? keyedListAction(parent, keyType, 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 = uses.getSourceGrouping();
- final Optional<ActionDefinition> found = grp.findAction(action.getQName());
+ // 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 Type createRpcContainer(final ModuleContext context, final String rpcName, final RpcDefinition rpc,
final ContainerSchemaNode schema, final Type type) {
processUsesAugments(schema, context, false);
- final GeneratedTypeBuilder outType = addRawInterfaceDefinition(
+ final GeneratedTypeBuilder outType = addRawInterfaceDefinition(context,
JavaTypeName.create(context.modulePackageName(), rpcName + BindingMapping.getClassName(schema.getQName())),
schema);
addImplementedInterfaceFromUses(schema, outType);
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);
}
* @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;
}
/**
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)) {
- addRawAugmentGenTypeDefinition(context, DefaultType.of(targetTypeBuilder), augSchema, false);
-
+ 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, false);
+ 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 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.bindTo(result.getQName().getModule());
- result = ((DataNodeContainer) result).getDataChildByName(resultNode);
+
+ 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) {
final GeneratedTypeBuilder augTypeBuilder = typeProvider.newGeneratedTypeBuilder(
JavaTypeName.create(augmentPackageName, augTypeName));
- augTypeBuilder.addImplementsType(DATA_OBJECT);
+ augTypeBuilder.addImplementsType(augmentation(targetTypeRef));
defaultImplementedInterace(augTypeBuilder);
- augTypeBuilder.addImplementsType(augmentation(targetTypeRef));
annotateDeprecatedIfNecessary(augSchema, augTypeBuilder);
addImplementedInterfaceFromUses(augSchema, augTypeBuilder);
private void choiceToGeneratedType(final ModuleContext context, final GeneratedTypeBuilder parent,
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));
private void opaqueToGeneratedType(final ModuleContext context, final GeneratedTypeBuilder parent,
final DataSchemaNode anyNode) {
if (!anyNode.isAddedByUses()) {
- final GeneratedTypeBuilder anyxmlTypeBuilder = addRawInterfaceDefinition(
+ final GeneratedTypeBuilder anyxmlTypeBuilder = addRawInterfaceDefinition(context,
JavaTypeName.create(packageNameForGeneratedType(context.modulePackageName(), anyNode.getPath()),
BindingMapping.getClassName(anyNode.getQName())), anyNode);
anyxmlTypeBuilder.addImplementsType(opaqueObject(anyxmlTypeBuilder)).addImplementsType(childOf(parent));
final TypeDefinition<?> typeDef = CompatUtils.compatType(leaf);
if (isInnerType(leaf, typeDef)) {
if (typeDef instanceof EnumTypeDefinition) {
- returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, leaf, inGrouping);
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;
Type returnType = null;
if (typeDef.getBaseType() == null) {
if (typeDef instanceof EnumTypeDefinition) {
- returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, node, inGrouping);
final EnumTypeDefinition enumTypeDef = (EnumTypeDefinition) typeDef;
- final EnumBuilder enumBuilder = resolveInnerEnumFromTypeDefinition(enumTypeDef, nodeName,
- typeBuilder, context);
- returnType = DefaultType.of(enumBuilder);
+ returnType = resolveInnerEnumFromTypeDefinition(enumTypeDef, nodeName, typeBuilder, context);
typeProvider.putReferencedType(node.getPath(), returnType);
} else if (typeDef instanceof UnionTypeDefinition) {
final UnionTypeDefinition unionDef = (UnionTypeDefinition)typeDef;
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());
final GeneratedTypeBuilder genType = findGrouping(usesNode.getSourceGrouping());
if (genType == null) {
throw new IllegalStateException("Grouping " + usesNode.getSourceGrouping().getQName()
- + " is not resolved for " + builder.getName());
+ + " is not resolved for " + builder.getFullyQualifiedName());
}
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);
Code Review / mdsal.git / blobdiff