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.augmentationTypeFor;
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.mapTypeFor;
import static org.opendaylight.mdsal.binding.model.util.Types.primitiveVoidType;
-import static org.opendaylight.mdsal.binding.model.util.Types.typeForClass;
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 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 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.AnyXmlSchemaNode;
+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.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;
}
final GeneratedTypeBuilder genType = addDefaultInterfaceDefinition(context, node, baseInterface);
defaultImplementedInterace(genType);
- annotateDeprecatedIfNecessary(node.getStatus(), genType);
+ annotateDeprecatedIfNecessary(node, genType);
final Module module = context.module();
genType.setModuleName(module.getName());
constructGetter(parent, genType, node);
resolveDataSchemaNodes(context, genType, genType, node.getChildNodes(), inGrouping);
actionsToGenType(context, genType, node, null, inGrouping);
+ notificationsToGenType(context, genType, node, null, inGrouping);
}
}
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, inGrouping);
+
+ constructGetter(parent, listType, node);
+ 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, inGrouping);
+ 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 <T extends DataNodeContainer & ActionNodeContainer> void actionsToGenType(final ModuleContext context,
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()) {
qnameConstant(builder, JavaTypeName.create(context.modulePackageName(),
BindingMapping.MODULE_INFO_CLASS_NAME), 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) {
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 Optional<ActionDefinition> found = grp.findAction(action.getQName());
if (found.isPresent()) {
final ActionDefinition result = found.get();
return result.isAddedByUses() ? findOrigAction(grp, result) : found;
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
outType.addImplementsType(type);
outType.addImplementsType(augmentable(outType));
defaultImplementedInterace(outType);
- annotateDeprecatedIfNecessary(rpc.getStatus(), outType);
+ annotateDeprecatedIfNecessary(rpc, outType);
resolveDataSchemaNodes(context, outType, outType, schema.getChildNodes(), false);
context.addChildNodeType(schema, outType);
return outType.build();
final GeneratedTypeBuilder notificationInterface = addDefaultInterfaceDefinition(
context.modulePackageName(), notification, DATA_OBJECT, context);
defaultImplementedInterace(notificationInterface);
- annotateDeprecatedIfNecessary(notification.getStatus(), notificationInterface);
+ annotateDeprecatedIfNecessary(notification, notificationInterface);
notificationInterface.addImplementsType(NOTIFICATION);
context.addChildNodeType(notification, notificationInterface);
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 Set<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 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));
}
// node of grouping is resolved to the method.
final GeneratedTypeBuilder genType = addDefaultInterfaceDefinition(context, grouping);
narrowImplementedInterface(genType);
- annotateDeprecatedIfNecessary(grouping.getStatus(), genType);
+ annotateDeprecatedIfNecessary(grouping, genType);
context.addGroupingType(grouping, genType);
resolveDataSchemaNodes(context, genType, genType, grouping.getChildNodes(), true);
groupingsToGenTypes(context, grouping.getGroupings());
processUsesAugments(grouping, context, true);
actionsToGenType(context, genType, grouping, null, true);
+ notificationsToGenType(context, genType, grouping, null, true);
}
}
augTypeBuilder.addImplementsType(DATA_OBJECT);
defaultImplementedInterace(augTypeBuilder);
- augTypeBuilder.addImplementsType(augmentationTypeFor(targetTypeRef));
- annotateDeprecatedIfNecessary(augSchema.getStatus(), augTypeBuilder);
+ augTypeBuilder.addImplementsType(augmentation(targetTypeRef));
+ annotateDeprecatedIfNecessary(augSchema, augTypeBuilder);
addImplementedInterfaceFromUses(augSchema, augTypeBuilder);
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;
}
listToGenType(context, typeBuilder, baseInterface, (ListSchemaNode) node, inGrouping);
} else if (node instanceof ChoiceSchemaNode) {
choiceToGeneratedType(context, typeBuilder, (ChoiceSchemaNode) node, inGrouping);
- } else if (node instanceof AnyXmlSchemaNode) {
- // FIXME: MDSAL-438: also cover AnyDataSchemaNode
- opaqueToGeneratedType(context, typeBuilder, (AnyXmlSchemaNode) node);
+ } else if (node instanceof AnyxmlSchemaNode || node instanceof AnydataSchemaNode) {
+ opaqueToGeneratedType(context, typeBuilder, node);
} else {
LOG.debug("Unable to add schema node {} as method in {}: unsupported type of node.", node.getClass(),
typeBuilder.getFullyQualifiedName());
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();
}
private void opaqueToGeneratedType(final ModuleContext context, final GeneratedTypeBuilder parent,
- final AnyXmlSchemaNode anyxmlNode) {
- if (!anyxmlNode.isAddedByUses()) {
+ final DataSchemaNode anyNode) {
+ if (!anyNode.isAddedByUses()) {
final GeneratedTypeBuilder anyxmlTypeBuilder = addRawInterfaceDefinition(
- JavaTypeName.create(packageNameForGeneratedType(context.modulePackageName(), anyxmlNode.getPath()),
- BindingMapping.getClassName(anyxmlNode.getQName())), anyxmlNode);
+ JavaTypeName.create(packageNameForGeneratedType(context.modulePackageName(), anyNode.getPath()),
+ BindingMapping.getClassName(anyNode.getQName())), anyNode);
anyxmlTypeBuilder.addImplementsType(opaqueObject(anyxmlTypeBuilder)).addImplementsType(childOf(parent));
defaultImplementedInterace(anyxmlTypeBuilder);
- annotateDeprecatedIfNecessary(anyxmlNode.getStatus(), anyxmlTypeBuilder);
- context.addChildNodeType(anyxmlNode, anyxmlTypeBuilder);
+ annotateDeprecatedIfNecessary(anyNode, anyxmlTypeBuilder);
+ context.addChildNodeType(anyNode, anyxmlTypeBuilder);
- constructGetter(parent, anyxmlTypeBuilder.build(), anyxmlNode);
+ constructGetter(parent, anyxmlTypeBuilder.build(), anyNode);
}
}
final GeneratedTypeBuilder caseTypeBuilder = addDefaultInterfaceDefinition(context, caseNode);
caseTypeBuilder.addImplementsType(refChoiceType);
defaultImplementedInterace(caseTypeBuilder);
- annotateDeprecatedIfNecessary(caseNode.getStatus(), caseTypeBuilder);
+ annotateDeprecatedIfNecessary(caseNode, caseTypeBuilder);
context.addCaseType(caseNode.getPath(), caseTypeBuilder);
context.addChoiceToCaseMapping(refChoiceType, caseTypeBuilder, caseNode);
final Iterable<DataSchemaNode> caseChildNodes = caseNode.getChildNodes();
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);
}
/**
* 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 = findGroupingByPath(usesNode.getGroupingPath());
if (genType == null) {
throw new IllegalStateException("Grouping " + usesNode.getGroupingPath() + "is not resolved for "
+ builder.getName());
}
- builder.addImplementsType(genType);
+ builder.addImplementsType(genType.build());
}
return builder;
}
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);
}
}