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 String packageName = packageNameForGeneratedType(basePackageName, node.getPath());
final GeneratedTypeBuilder genType = addDefaultInterfaceDefinition(packageName, node, childOf, module);
genType.addComment(node.getDescription());
+ annotateDeprecatedIfNecessary(node.getStatus(), genType);
genType.setDescription(createDescription(node, genType.getFullyQualifiedName()));
genType.setModuleName(module.getName());
genType.setReference(node.getReference());
addImplementedInterfaceFromUses(input, inType);
inType.addImplementsType(DATA_OBJECT);
inType.addImplementsType(augmentable(inType));
+ annotateDeprecatedIfNecessary(rpc.getStatus(), inType);
resolveDataSchemaNodes(module, basePackageName, inType, inType, input.getChildNodes());
genCtx.get(module).addChildNodeType(input, inType);
final GeneratedType inTypeInstance = inType.toInstance();
addImplementedInterfaceFromUses(output, outType);
outType.addImplementsType(DATA_OBJECT);
outType.addImplementsType(augmentable(outType));
+ annotateDeprecatedIfNecessary(rpc.getStatus(), outType);
resolveDataSchemaNodes(module, basePackageName, outType, outType, output.getChildNodes());
genCtx.get(module).addChildNodeType(output, outType);
outTypeInstance = outType.toInstance();
final GeneratedTypeBuilder notificationInterface = addDefaultInterfaceDefinition(basePackageName,
notification, null, module);
+ annotateDeprecatedIfNecessary(notification.getStatus(), notificationInterface);
notificationInterface.addImplementsType(NOTIFICATION);
genCtx.get(module).addChildNodeType(notification, notificationInterface);
private void groupingToGenType(final String basePackageName, final GroupingDefinition grouping, final Module module) {
final String packageName = packageNameForGeneratedType(basePackageName, grouping.getPath());
final GeneratedTypeBuilder genType = addDefaultInterfaceDefinition(packageName, grouping, module);
+ annotateDeprecatedIfNecessary(grouping.getStatus(), genType);
genCtx.get(module).addGroupingType(grouping.getPath(), genType);
resolveDataSchemaNodes(module, basePackageName, genType, genType, grouping.getChildNodes());
groupingsToGenTypes(module, grouping.getGroupings());
augTypeBuilder.addImplementsType(DATA_OBJECT);
augTypeBuilder.addImplementsType(Types.augmentationTypeFor(targetTypeRef));
+ annotateDeprecatedIfNecessary(augSchema.getStatus(), augTypeBuilder);
addImplementedInterfaceFromUses(augSchema, augTypeBuilder);
augSchemaNodeToMethods(module, basePackageName, augTypeBuilder, augTypeBuilder, augSchema.getChildNodes());
constructGetter(parent, choiceNode.getQName().getLocalName(), choiceNode.getDescription(),
choiceTypeBuilder);
choiceTypeBuilder.addImplementsType(typeForClass(DataContainer.class));
+ annotateDeprecatedIfNecessary(choiceNode.getStatus(), choiceTypeBuilder);
genCtx.get(module).addChildNodeType(choiceNode, choiceTypeBuilder);
generateTypesFromChoiceCases(module, basePackageName, choiceTypeBuilder.toInstance(), choiceNode);
}
final String packageName = packageNameForGeneratedType(basePackageName, caseNode.getPath());
final GeneratedTypeBuilder caseTypeBuilder = addDefaultInterfaceDefinition(packageName, caseNode, module);
caseTypeBuilder.addImplementsType(refChoiceType);
+ annotateDeprecatedIfNecessary(caseNode.getStatus(), caseTypeBuilder);
genCtx.get(module).addCaseType(caseNode.getPath(), caseTypeBuilder);
genCtx.get(module).addChoiceToCaseMapping(refChoiceType, caseTypeBuilder, caseNode);
final Iterable<DataSchemaNode> caseChildNodes = caseNode.getChildNodes();
final String ret = UNICODE_CHAR_PATTERN.matcher(stringBuilder).replaceAll("\\\\\\\\u");
return ret.isEmpty() ? "" : ret;
}
+
+ private void annotateDeprecatedIfNecessary(Status status, GeneratedTypeBuilder builder) {
+ if (status == Status.DEPRECATED) {
+ builder.addAnnotation("", "Deprecated");
+ }
+ }
}
import org.opendaylight.yangtools.yang.model.api.RpcDefinition
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
}
def static writeRPC(RpcDefinition rpc) {
+ var boolean isStatusDeprecated = rpc.status == Status::DEPRECATED
'''
+ «IF isStatusDeprecated»
+ @deprecated - status DEPRECATED
+ «ENDIF»
rpc «rpc.QName.localName» {
«IF !rpc.description.nullOrEmpty»
"«rpc.description»";
reference
"«rpc.reference»";
«ENDIF»
- «IF rpc.status != null»
+ «IF isStatusDeprecated»
status «rpc.status»;
«ENDIF»
}
}
def static writeNotification(NotificationDefinition notification) {
+ var boolean isStatusDeprecated = notification.status == Status::DEPRECATED
'''
+ «IF isStatusDeprecated»
+ @deprecated - status DEPRECATED
+ «ENDIF»
notification «notification.QName.localName» {
«IF !notification.description.nullOrEmpty»
description
reference
"«notification.reference»";
«ENDIF»
- «IF notification.status != null»
+ «IF isStatusDeprecated»
status «notification.status»;
«ENDIF»
}
}
def static writeTypeDefinition(TypeDefinition<?> typeDefinition) {
+ var boolean isStatusDeprecated = typeDefinition.status == Status::DEPRECATED
'''
- type «typeDefinition.QName.localName»;
+ «IF isStatusDeprecated»
+ @deprecated - status DEPRECATED
+ «ENDIF»
+ type «typeDefinition.QName.localName»«IF !isStatusDeprecated»;«ELSE» {
+ status «typeDefinition.status»;
+ }
+ «ENDIF»
'''
}
}
def static writeExtension(ExtensionDefinition extensionDef) {
+ var boolean isStatusDeprecated = extensionDef.status == Status::DEPRECATED
+
'''
+ «IF isStatusDeprecated»
+ @deprecated - status DEPRECATED
+ «ENDIF»
extension «extensionDef.QName.localName» {
«IF !extensionDef.description.nullOrEmpty»
description
}
def static writeGroupingDef(GroupingDefinition groupingDef) {
+ var boolean isStatusDeprecated = groupingDef.status == Status::DEPRECATED
'''
+ «IF isStatusDeprecated»
+ @deprecated - status DEPRECATED
+ «ENDIF»
grouping «groupingDef.QName.localName» {
«IF !groupingDef.groupings.nullOrEmpty»
«writeGroupingDefs(groupingDef.groupings)»
«IF !groupingDef.childNodes.nullOrEmpty»
«writeDataSchemaNodes(groupingDef.childNodes)»
«ENDIF»
+ «IF isStatusDeprecated»
+ status «groupingDef.status»;
+ «ENDIF»
«IF !groupingDef.unknownSchemaNodes.nullOrEmpty»
«writeUnknownSchemaNodes(groupingDef.unknownSchemaNodes)»
«ENDIF»
}
def static writeContSchemaNode(ContainerSchemaNode contSchemaNode) {
+ var boolean isStatusDeprecated = contSchemaNode.status == Status::DEPRECATED
'''
+ «IF isStatusDeprecated»
+ @deprecated - status DEPRECATED
+ «ENDIF»
container «contSchemaNode.getQName.localName» {
«IF !contSchemaNode.childNodes.nullOrEmpty»
«writeDataSchemaNodes(contSchemaNode.childNodes)»
«IF !contSchemaNode.uses.nullOrEmpty»
«writeUsesNodes(contSchemaNode.uses)»
«ENDIF»
+ «IF isStatusDeprecated»
+ status «contSchemaNode.status»;
+ «ENDIF»
«IF !contSchemaNode.unknownSchemaNodes.nullOrEmpty»
«writeUnknownSchemaNodes(contSchemaNode.unknownSchemaNodes)»
«ENDIF»
}
def static writeAnyXmlSchemaNode(AnyXmlSchemaNode anyXmlSchemaNode) {
+ var boolean isStatusDeprecated = anyXmlSchemaNode.status == Status::DEPRECATED
'''
- anyxml «anyXmlSchemaNode.getQName.localName»;
+ «IF isStatusDeprecated»
+ @deprecated - status DEPRECATED
+ «ENDIF»
+ anyxml «anyXmlSchemaNode.getQName.localName»«IF !isStatusDeprecated»;«ELSE» {
+ status «anyXmlSchemaNode.status»;
+ }
+ «ENDIF»
'''
}
def static writeLeafSchemaNode(LeafSchemaNode leafSchemaNode) {
+ var boolean isStatusDeprecated = leafSchemaNode.status == Status::DEPRECATED
'''
+ «IF isStatusDeprecated»
+ @deprecated - status DEPRECATED
+ «ENDIF»
leaf «leafSchemaNode.getQName.localName» {
type «leafSchemaNode.type.getQName.localName»;
+ «IF isStatusDeprecated»
+ status «leafSchemaNode.status»;
+ «ENDIF»
}
'''
}
def static writeLeafListSchemaNode(LeafListSchemaNode leafListSchemaNode) {
+ var boolean isStatusDeprecated = leafListSchemaNode.status == Status::DEPRECATED
'''
+ «IF isStatusDeprecated»
+ @deprecated - status DEPRECATED
+ «ENDIF»
leaf-list «leafListSchemaNode.getQName.localName» {
type «leafListSchemaNode.type.getQName.localName»;
+ «IF isStatusDeprecated»
+ status «leafListSchemaNode.status»;
+ «ENDIF»
}
'''
}
def static writeChoiceCaseNode(ChoiceCaseNode choiceCaseNode) {
+ var boolean isStatusDeprecated = choiceCaseNode.status == Status::DEPRECATED
'''
+ «IF isStatusDeprecated»
+ @deprecated - status DEPRECATED
+ «ENDIF»
case «choiceCaseNode.getQName.localName» {
«FOR childNode : choiceCaseNode.childNodes»
«writeDataSchemaNode(childNode)»
«ENDFOR»
+ «IF isStatusDeprecated»
+ status «choiceCaseNode.status»;
+ «ENDIF»
}
'''
}
def static writeChoiceNode(ChoiceSchemaNode choiceNode) {
+ var boolean isStatusDeprecated = choiceNode.status == Status::DEPRECATED
'''
+ «IF isStatusDeprecated»
+ @deprecated - status DEPRECATED
+ «ENDIF»
choice «choiceNode.getQName.localName» {
«FOR child : choiceNode.cases»
«writeDataSchemaNode(child)»
«ENDFOR»
+ «IF isStatusDeprecated»
+ status «choiceNode.status»;
+ «ENDIF»
}
'''
}
def static writeListSchemaNode(ListSchemaNode listSchemaNode) {
+ var boolean isStatusDeprecated = listSchemaNode.status == Status::DEPRECATED
+
'''
+ «IF isStatusDeprecated»
+ @deprecated - status DEPRECATED
+ «ENDIF»
list «listSchemaNode.getQName.localName» {
key «FOR listKey : listSchemaNode.keyDefinition SEPARATOR " "»"«listKey.localName»"
«ENDFOR»
«IF !listSchemaNode.uses.nullOrEmpty»
«writeUsesNodes(listSchemaNode.uses)»
«ENDIF»
+ «IF isStatusDeprecated»
+ status «listSchemaNode.status»;
+ «ENDIF»
«IF !listSchemaNode.unknownSchemaNodes.nullOrEmpty»
«writeUnknownSchemaNodes(listSchemaNode.unknownSchemaNodes)»
«ENDIF»