import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
+import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
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.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.meta.StatementSource;
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.UnionTypeDefinition;
-import org.opendaylight.yangtools.yang.model.util.BaseTypes;
import org.opendaylight.yangtools.yang.model.util.DataNodeIterator;
-import org.opendaylight.yangtools.yang.model.util.ExtendedType;
import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil;
import org.opendaylight.yangtools.yang.model.util.SchemaNodeUtils;
-import org.opendaylight.yangtools.yang.model.util.UnionType;
import org.opendaylight.yangtools.yang.model.util.type.CompatUtils;
-import org.opendaylight.yangtools.yang.parser.builder.util.Comparators;
import org.opendaylight.yangtools.yang.parser.util.ModuleDependencySort;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private static final Splitter BSDOT_SPLITTER = Splitter.on("\\.");
private static final char NEW_LINE = '\n';
+ /**
+ * Comparator based on augment target path.
+ */
+ private static final Comparator<AugmentationSchema> AUGMENT_COMP = (o1, o2) -> {
+ final Iterator<QName> thisIt = o1.getTargetPath().getPathFromRoot().iterator();
+ final Iterator<QName> otherIt = o2.getTargetPath().getPathFromRoot().iterator();
+
+ while (thisIt.hasNext()) {
+ if (!otherIt.hasNext()) {
+ return 1;
+ }
+
+ final int comp = thisIt.next().compareTo(otherIt.next());
+ if (comp != 0) {
+ return comp;
+ }
+ }
+
+ return otherIt.hasNext() ? -1 : 0;
+ };
+
/**
* Constant with the concrete name of identifier.
*/
final GeneratedTypeBuilder parent, final GeneratedTypeBuilder childOf, final ContainerSchemaNode node) {
final GeneratedTypeBuilder genType = processDataSchemaNode(module, basePackageName, childOf, node);
if (genType != null) {
- constructGetter(parent, node.getQName().getLocalName(), node.getDescription(), genType);
+ constructGetter(parent, node.getQName().getLocalName(), node.getDescription(), genType, node.getStatus());
resolveDataSchemaNodes(module, basePackageName, genType, genType, node.getChildNodes());
}
}
final GeneratedTypeBuilder genType = processDataSchemaNode(module, basePackageName, childOf, node);
if (genType != null) {
constructGetter(parent, node.getQName().getLocalName(), node.getDescription(),
- Types.listTypeFor(genType));
+ Types.listTypeFor(genType), node.getStatus());
final List<String> listKeys = listKeys(node);
final String packageName = packageNameForGeneratedType(basePackageName, node.getPath());
final Set<AugmentationSchema> augmentations = module.getAugmentations();
final List<AugmentationSchema> sortedAugmentations = new ArrayList<>(augmentations);
- Collections.sort(sortedAugmentations, Comparators.AUGMENT_COMP);
+ Collections.sort(sortedAugmentations, AUGMENT_COMP);
return sortedAugmentations;
}
final ContainerSchemaNode input = rpc.getInput();
final ContainerSchemaNode output = rpc.getOutput();
- if (input != null) {
+ //in case of implicit RPC input (StatementSource.CONTEXT),
+ // stay compatible (no input argument generated)
+ if (input != null && isExplicitStatement(input)) {
final GeneratedTypeBuilder inType = addRawInterfaceDefinition(basePackageName, input, rpcName);
addImplementedInterfaceFromUses(input, inType);
inType.addImplementsType(DATA_OBJECT);
}
Type outTypeInstance = VOID;
- if (output != null) {
+ //in case of implicit RPC output (StatementSource.CONTEXT),
+ //stay compatible (Future<RpcResult<Void>> return type generated)
+ if (output != null && isExplicitStatement(output)) {
final GeneratedTypeBuilder outType = addRawInterfaceDefinition(basePackageName, output, rpcName);
addImplementedInterfaceFromUses(output, outType);
outType.addImplementsType(DATA_OBJECT);
genCtx.get(module).addTopLevelNodeType(interfaceBuilder);
}
+ private static boolean isExplicitStatement(ContainerSchemaNode node) {
+ return node instanceof EffectiveStatement
+ && ((EffectiveStatement) node).getDeclared().getStatementSource() == StatementSource.DECLARATION;
+ }
+
/**
* Converts all <b>notifications</b> of the module to the list of
* <code>Type</code> objects. In addition are to this list added containers
final GroupingDefinition grouping = (GroupingDefinition) targetGrouping;
SchemaNode result = grouping;
for (final QName node : targetPath.getPathFromRoot()) {
- // finding by local name is valid, grouping cannot contain nodes
- // with same name and different namespace
if (result instanceof DataNodeContainer) {
- result = ((DataNodeContainer) result).getDataChildByName(node.getLocalName());
+ final QName resultNode = QName.create(result.getQName().getModule(), node.getLocalName());
+ result = ((DataNodeContainer) result).getDataChildByName(resultNode);
} else if (result instanceof ChoiceSchemaNode) {
result = ((ChoiceSchemaNode) result).getCaseNodeByName(node.getLocalName());
}
augSchemaNodeToMethods(module, basePackageName, augTypeBuilder, augTypeBuilder, augSchema.getChildNodes());
augmentBuilders.put(augTypeName, augTypeBuilder);
- if(!augSchema.getChildNodes().isEmpty()) {
- genCtx.get(module).addTargetToAugmentation(targetTypeRef, augTypeBuilder);
+ if (!augSchema.getChildNodes().isEmpty()) {
genCtx.get(module).addTypeToAugmentation(augTypeBuilder, augSchema);
}
final String packageName = packageNameForGeneratedType(basePackageName, choiceNode.getPath());
final GeneratedTypeBuilder choiceTypeBuilder = addRawInterfaceDefinition(packageName, choiceNode);
constructGetter(parent, choiceNode.getQName().getLocalName(),
- choiceNode.getDescription(), choiceTypeBuilder);
+ choiceNode.getDescription(), choiceTypeBuilder, choiceNode.getStatus());
choiceTypeBuilder.addImplementsType(typeForClass(DataContainer.class));
annotateDeprecatedIfNecessary(choiceNode.getStatus(), choiceTypeBuilder);
genCtx.get(module).addChildNodeType(choiceNode, choiceTypeBuilder);
}
private static boolean isInnerType(final LeafSchemaNode leaf, final TypeDefinition<?> type) {
- // Deal with old parser, clearing out references to typedefs
- if (type instanceof ExtendedType) {
- return false;
- }
-
// New parser with encapsulated type
if (leaf.getPath().equals(type.getPath())) {
return true;
return true;
}
- // Old parser uses broken Union type, which does not change its schema path
- if (type instanceof UnionType) {
- return true;
- }
-
return false;
}
final EnumTypeDefinition enumTypeDef = (EnumTypeDefinition) typeDef;
final EnumBuilder enumBuilder = resolveInnerEnumFromTypeDefinition(enumTypeDef, leaf.getQName(),
typeBuilder, module);
-
if (enumBuilder != null) {
returnType = enumBuilder.toInstance(typeBuilder);
}
return null;
}
+ if (typeDef instanceof EnumTypeDefinition) {
+ ((TypeProviderImpl) typeProvider).putReferencedType(leaf.getPath(), returnType);
+ }
+
String leafDesc = leaf.getDescription();
if (leafDesc == null) {
leafDesc = "";
}
- final MethodSignatureBuilder getter = constructGetter(typeBuilder, leafName, leafDesc, returnType);
+ final MethodSignatureBuilder getter = constructGetter(typeBuilder, leafName, leafDesc, returnType, leaf.getStatus());
processContextRefExtension(leaf, getter, parentModule);
return returnType;
}
private static TypeDefinition<?> getBaseOrDeclaredType(final TypeDefinition<?> typeDef) {
- if (typeDef instanceof ExtendedType) {
- // Legacy behaviour returning ExtendedType is enough
- return typeDef;
- }
// Returns DerivedType in case of new parser.
final TypeDefinition<?> baseType = typeDef.getBaseType();
return (baseType != null && baseType.getBaseType() != null) ? baseType : typeDef;
qname.getRevision());
final ModuleContext mc = genCtx.get(unionModule);
returnType = mc.getTypedefs().get(typeDef.getPath());
- } else if (typeDef instanceof EnumTypeDefinition && BaseTypes.ENUMERATION_QNAME.equals(typeDef.getQName())) {
+ } else if (typeDef instanceof EnumTypeDefinition && typeDef.getBaseType() == null) {
// Annonymous enumeration (already generated, since it is inherited via uses).
LeafSchemaNode originalLeaf = (LeafSchemaNode) SchemaNodeUtils.getRootOriginalIfPossible(leaf);
QName qname = originalLeaf.getQName();
}
final ParameterizedType listType = Types.listTypeFor(returnType);
- constructGetter(typeBuilder, nodeName.getLocalName(), node.getDescription(), listType);
+ constructGetter(typeBuilder, nodeName.getLocalName(), node.getDescription(), listType, node.getStatus());
return true;
}
* string with comment for the getter method
* @param returnType
* type which represents the return type of the getter method
+ * @param status
+ * status from yang file, for deprecated annotation
* @return method signature builder which represents the getter method of
* <code>interfaceBuilder</code>
*/
private static MethodSignatureBuilder constructGetter(final GeneratedTypeBuilder interfaceBuilder,
- final String schemaNodeName, final String comment, final Type returnType) {
+ final String schemaNodeName, final String comment, final Type returnType, final Status status) {
final MethodSignatureBuilder getMethod = interfaceBuilder
.addMethod(getterMethodName(schemaNodeName, returnType));
+ if (status == Status.DEPRECATED) {
+ getMethod.addAnnotation("", "Deprecated");
+ }
getMethod.setComment(encodeAngleBrackets(comment));
getMethod.setReturnType(returnType);
return getMethod;
if (genTOBuilder != null) {
final GeneratedTransferObject genTO = genTOBuilder.toInstance();
- constructGetter(typeBuilder, "key", "Returns Primary Key of Yang List Type", genTO);
+ constructGetter(typeBuilder, "key", "Returns Primary Key of Yang List Type", genTO, Status.CURRENT);
genCtx.get(module).addGeneratedTOBuilder(genTOBuilder);
}
}
/**
* Builds generated TO builders for <code>typeDef</code> of type
- * {@link org.opendaylight.yangtools.yang.model.util.UnionType UnionType} or
- * {@link org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition
- * BitsTypeDefinition} which are also added to <code>typeBuilder</code> as
- * enclosing transfer object.
+ * {@link UnionTypeDefinition} or {@link BitsTypeDefinition} which are
+ * also added to <code>typeBuilder</code> as enclosing transfer object.
*
* If more then one generated TO builder is created for enclosing then all
* of the generated TO builders are added to <code>typeBuilder</code> as
builder.addAnnotation("", "Deprecated");
}
}
-}
\ No newline at end of file
+}
Code Review / mdsal.git / blobdiff