import static org.opendaylight.mdsal.binding.model.util.BindingGeneratorUtil.computeDefaultSUID;
import static org.opendaylight.mdsal.binding.model.util.BindingGeneratorUtil.packageNameForAugmentedGeneratedType;
import static org.opendaylight.mdsal.binding.model.util.BindingGeneratorUtil.packageNameForGeneratedType;
+import static org.opendaylight.mdsal.binding.model.util.BindingTypes.BASE_IDENTITY;
import static org.opendaylight.mdsal.binding.model.util.BindingTypes.DATA_OBJECT;
import static org.opendaylight.mdsal.binding.model.util.BindingTypes.DATA_ROOT;
-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.NOTIFICATION;
+import static org.opendaylight.mdsal.binding.model.util.BindingTypes.NOTIFICATION_LISTENER;
+import static org.opendaylight.mdsal.binding.model.util.BindingTypes.ROUTING_CONTEXT;
+import static org.opendaylight.mdsal.binding.model.util.BindingTypes.RPC_SERVICE;
import static org.opendaylight.mdsal.binding.model.util.BindingTypes.augmentable;
+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.rpcResult;
import static org.opendaylight.mdsal.binding.model.util.Types.BOOLEAN;
import static org.opendaylight.mdsal.binding.model.util.Types.FUTURE;
import static org.opendaylight.mdsal.binding.model.util.Types.typeForClass;
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.AnnotableTypeBuilder;
import org.opendaylight.mdsal.binding.model.api.type.builder.AnnotationTypeBuilder;
import org.opendaylight.mdsal.binding.model.api.type.builder.EnumBuilder;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedPropertyBuilder;
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.BindingGeneratorUtil;
-import org.opendaylight.mdsal.binding.model.util.BindingTypes;
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.yang.types.AbstractTypeProvider;
import org.opendaylight.mdsal.binding.yang.types.BaseYangTypes;
import org.opendaylight.mdsal.binding.yang.types.GroupingDefinitionDependencySort;
-import org.opendaylight.yangtools.yang.binding.BaseIdentity;
import org.opendaylight.yangtools.yang.binding.BindingMapping;
-import org.opendaylight.yangtools.yang.binding.DataContainer;
-import org.opendaylight.yangtools.yang.binding.RpcService;
-import org.opendaylight.yangtools.yang.binding.annotations.RoutingContext;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
-import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
abstract class AbstractTypeGenerator {
private static final Logger LOG = LoggerFactory.getLogger(BindingGeneratorImpl.class);
private static final Splitter COLON_SPLITTER = Splitter.on(':');
+ private static final JavaTypeName DEPRECATED_ANNOTATION = JavaTypeName.create(Deprecated.class);
+ private static final JavaTypeName OVERRIDE_ANNOTATION = JavaTypeName.create(Override.class);
/**
* Comparator based on augment target path.
final List<String> listKeys = listKeys(node);
final GeneratedTOBuilder genTOBuilder = resolveListKeyTOBuilder(context, node);
if (genTOBuilder != null) {
- final Type identifierMarker = Types.parameterizedTypeFor(IDENTIFIER, genType);
- final Type identifiableMarker = Types.parameterizedTypeFor(IDENTIFIABLE, genTOBuilder);
+ final Type identifierMarker = identifier(genType);
+ final Type identifiableMarker = identifiable(genTOBuilder);
genTOBuilder.addImplementsType(identifierMarker);
genType.addImplementsType(identifiableMarker);
}
}
final GeneratedTypeBuilder interfaceBuilder = moduleTypeBuilder(context, "Service");
- interfaceBuilder.addImplementsType(Types.typeForClass(RpcService.class));
+ interfaceBuilder.addImplementsType(RPC_SERVICE);
addCodegenInformation(interfaceBuilder, module, "RPCs", rpcDefinitions);
method.addParameter(
createRpcContainer(context, rpcName, rpc, verifyNotNull(rpc.getInput())), "input");
method.setReturnType(Types.parameterizedTypeFor(FUTURE,
- Types.parameterizedTypeFor(Types.typeForClass(RpcResult.class),
- createRpcContainer(context, rpcName, rpc, verifyNotNull(rpc.getOutput())))));
+ rpcResult(createRpcContainer(context, rpcName, rpc, verifyNotNull(rpc.getOutput())))));
}
}
}
final GeneratedTypeBuilder listenerInterface = moduleTypeBuilder(context, "Listener");
- listenerInterface.addImplementsType(BindingTypes.NOTIFICATION_LISTENER);
+ listenerInterface.addImplementsType(NOTIFICATION_LISTENER);
for (final NotificationDefinition notification : notifications) {
if (notification != null) {
packageNameForGeneratedType(context.modulePackageName(), identity.getPath()),
BindingMapping.getClassName(identity.getQName())));
final Set<IdentitySchemaNode> baseIdentities = identity.getBaseIdentities();
- if (baseIdentities.isEmpty()) {
- final GeneratedTOBuilder gto = typeProvider.newGeneratedTOBuilder(JavaTypeName.create(BaseIdentity.class));
- newType.addImplementsType(gto.build());
- } else {
+ if (!baseIdentities.isEmpty()) {
for (IdentitySchemaNode baseIdentity : baseIdentities) {
final QName qname = baseIdentity.getQName();
final GeneratedTransferObject gto = typeProvider.newGeneratedTOBuilder(JavaTypeName.create(
BindingMapping.getRootPackageName(qname.getModule()), BindingMapping.getClassName(qname))).build();
newType.addImplementsType(gto);
}
+ } else {
+ newType.addImplementsType(BASE_IDENTITY);
}
final Module module = context.module();
final GeneratedTypeBuilder choiceTypeBuilder = addRawInterfaceDefinition(
JavaTypeName.create(packageNameForGeneratedType(context.modulePackageName(), choiceNode.getPath()),
BindingMapping.getClassName(choiceNode.getQName())), choiceNode);
- constructGetter(parent, choiceTypeBuilder, choiceNode);
- choiceTypeBuilder.addImplementsType(typeForClass(DataContainer.class));
+ choiceTypeBuilder.addImplementsType(choiceIn(parent));
annotateDeprecatedIfNecessary(choiceNode.getStatus(), choiceTypeBuilder);
context.addChildNodeType(choiceNode, choiceTypeBuilder);
- generateTypesFromChoiceCases(context, choiceTypeBuilder.build(), choiceNode);
+
+ final GeneratedType choiceType = choiceTypeBuilder.build();
+ generateTypesFromChoiceCases(context, choiceType, choiceNode);
+
+ constructGetter(parent, choiceType, choiceNode);
}
}
final GeneratedTypeBuilder caseTypeBuilder = addDefaultInterfaceDefinition(context, caseNode);
caseTypeBuilder.addImplementsType(targetType);
- SchemaNode parent;
- final SchemaPath nodeSp = targetNode.getPath();
- parent = findDataSchemaNode(schemaContext, nodeSp.getParent());
-
- GeneratedTypeBuilder childOfType = null;
- if (parent instanceof Module) {
- childOfType = moduleContext(((Module) parent).getQNameModule()).getModuleNode();
- } else if (parent instanceof CaseSchemaNode) {
- childOfType = findCaseByPath(parent.getPath());
- } else if (parent instanceof DataSchemaNode || parent instanceof NotificationDefinition) {
- childOfType = findChildNodeByPath(parent.getPath());
- } else if (parent instanceof GroupingDefinition) {
- childOfType = findGroupingByPath(parent.getPath());
- }
-
- if (childOfType == null) {
- throw new IllegalArgumentException("Failed to find parent type of choice " + targetNode);
- }
-
+ GeneratedTypeBuilder childOfType = findChildOfType(targetNode);
CaseSchemaNode node = null;
final String caseLocalName = caseNode.getQName().getLocalName();
if (caseNode instanceof CaseSchemaNode) {
}
}
+ private GeneratedTypeBuilder findChildOfType(final ChoiceSchemaNode targetNode) {
+ final SchemaPath nodePath = targetNode.getPath();
+ final SchemaPath parentSp = nodePath.getParent();
+ if (parentSp.getParent() == null) {
+ return moduleContext(nodePath.getLastComponent().getModule()).getModuleNode();
+ }
+
+ final SchemaNode parent = findDataSchemaNode(schemaContext, parentSp);
+ GeneratedTypeBuilder childOfType = null;
+ if (parent instanceof CaseSchemaNode) {
+ childOfType = findCaseByPath(parent.getPath());
+ } else if (parent instanceof DataSchemaNode || parent instanceof NotificationDefinition) {
+ childOfType = findChildNodeByPath(parent.getPath());
+ } else if (parent instanceof GroupingDefinition) {
+ childOfType = findGroupingByPath(parent.getPath());
+ }
+
+ if (childOfType == null) {
+ throw new IllegalArgumentException("Failed to find parent type of choice " + targetNode);
+ }
+
+ return childOfType;
+ }
+
private static CaseSchemaNode findNamedCase(final ChoiceSchemaNode choice, final String caseName) {
final List<CaseSchemaNode> cases = choice.findCaseNodes(caseName);
return cases.isEmpty() ? null : cases.get(0);
+ nodeParam);
}
- final AnnotationTypeBuilder rc = getter.addAnnotation(JavaTypeName.create(RoutingContext.class));
+ final AnnotationTypeBuilder rc = getter.addAnnotation(ROUTING_CONTEXT);
final String packageName = packageNameForGeneratedType(basePackageName, identity.getPath());
final String genTypeName = BindingMapping.getClassName(identity.getQName().getLocalName());
rc.addParameter("value", packageName + "." + genTypeName + ".class");
final Type parent, final ModuleContext context) {
final GeneratedTypeBuilder it = addRawInterfaceDefinition(
JavaTypeName.create(packageName, BindingMapping.getClassName(schemaNode.getQName())), schemaNode);
- if (parent == null) {
- it.addImplementsType(DATA_OBJECT);
- } else {
- it.addImplementsType(BindingTypes.childOf(parent));
- }
+
+ it.addImplementsType(parent == null ? DATA_OBJECT : childOf(parent));
if (!(schemaNode instanceof GroupingDefinition)) {
it.addImplementsType(augmentable(it));
}
-
if (schemaNode instanceof DataNodeContainer) {
- groupingsToGenTypes(context, ((DataNodeContainer) schemaNode).getGroupings());
- addImplementedInterfaceFromUses((DataNodeContainer) schemaNode, it);
+ final DataNodeContainer containerSchema = (DataNodeContainer) schemaNode;
+ groupingsToGenTypes(context, containerSchema.getGroupings());
+ addImplementedInterfaceFromUses(containerSchema, it);
}
return it;
getterMethodName(node.getQName().getLocalName(), returnType));
getMethod.setReturnType(returnType);
- if (node.getStatus() == Status.DEPRECATED) {
- getMethod.addAnnotation("java.lang", "Deprecated");
- }
+ annotateDeprecatedIfNecessary(node.getStatus(), getMethod);
if (!returnType.getPackageName().isEmpty()) {
// The return type has a package, so it's not a primitive type
getMethod.addAnnotation("javax.annotation", "Nullable");
if (genTOBuilder != null) {
final GeneratedTransferObject genTO = genTOBuilder.build();
-
- // Fake the 'getKey()' for items, this is equivalent to constructGetter()
- final MethodSignatureBuilder getMethod = typeBuilder.addMethod(getterMethodName("key", genTO));
- getMethod.setReturnType(genTO);
- getMethod.setComment("Returns Primary Key of Yang List Type");
+ // Add Identifiable.getKey() for items
+ typeBuilder.addMethod(BindingMapping.IDENTIFIABLE_KEY_NAME).setReturnType(genTO)
+ .addAnnotation(OVERRIDE_ANNOTATION);
context.addGeneratedTOBuilder(genTOBuilder);
}
}
return null;
}
- private static void annotateDeprecatedIfNecessary(final Status status, final GeneratedTypeBuilder builder) {
+ private static void annotateDeprecatedIfNecessary(final Status status, final AnnotableTypeBuilder builder) {
if (status == Status.DEPRECATED) {
- builder.addAnnotation("java.lang", "Deprecated");
+ builder.addAnnotation(DEPRECATED_ANNOTATION);
}
}
}
Code Review / mdsal.git / blobdiff