import static org.opendaylight.controller.yang.model.util.SchemaContextUtil.findDataSchemaNode;
import static org.opendaylight.controller.yang.model.util.SchemaContextUtil.findParentModule;
-import java.util.*;
import java.util.concurrent.Future;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
import org.opendaylight.controller.binding.generator.util.ReferencedTypeImpl;
import org.opendaylight.controller.binding.generator.util.Types;
import org.opendaylight.controller.binding.generator.util.generated.type.builder.GeneratedTOBuilderImpl;
import org.opendaylight.controller.sal.binding.model.api.GeneratedTransferObject;
import org.opendaylight.controller.sal.binding.model.api.GeneratedType;
import org.opendaylight.controller.sal.binding.model.api.Type;
-import org.opendaylight.controller.sal.binding.model.api.type.builder.*;
+import org.opendaylight.controller.sal.binding.model.api.type.builder.EnumBuilder;
+import org.opendaylight.controller.sal.binding.model.api.type.builder.GeneratedPropertyBuilder;
+import org.opendaylight.controller.sal.binding.model.api.type.builder.GeneratedTOBuilder;
+import org.opendaylight.controller.sal.binding.model.api.type.builder.GeneratedTypeBuilder;
+import org.opendaylight.controller.sal.binding.model.api.type.builder.MethodSignatureBuilder;
import org.opendaylight.controller.sal.binding.yang.types.TypeProviderImpl;
import org.opendaylight.controller.yang.binding.Notification;
import org.opendaylight.controller.yang.common.QName;
import org.opendaylight.controller.yang.common.RpcResult;
-import org.opendaylight.controller.yang.model.api.*;
+import org.opendaylight.controller.yang.model.api.AugmentationSchema;
+import org.opendaylight.controller.yang.model.api.ChoiceCaseNode;
+import org.opendaylight.controller.yang.model.api.ChoiceNode;
+import org.opendaylight.controller.yang.model.api.ContainerSchemaNode;
+import org.opendaylight.controller.yang.model.api.DataNodeContainer;
+import org.opendaylight.controller.yang.model.api.DataSchemaNode;
+import org.opendaylight.controller.yang.model.api.GroupingDefinition;
+import org.opendaylight.controller.yang.model.api.IdentitySchemaNode;
+import org.opendaylight.controller.yang.model.api.LeafListSchemaNode;
+import org.opendaylight.controller.yang.model.api.LeafSchemaNode;
+import org.opendaylight.controller.yang.model.api.ListSchemaNode;
+import org.opendaylight.controller.yang.model.api.Module;
+import org.opendaylight.controller.yang.model.api.NotificationDefinition;
+import org.opendaylight.controller.yang.model.api.RpcDefinition;
+import org.opendaylight.controller.yang.model.api.SchemaContext;
+import org.opendaylight.controller.yang.model.api.SchemaNode;
+import org.opendaylight.controller.yang.model.api.SchemaPath;
+import org.opendaylight.controller.yang.model.api.TypeDefinition;
+import org.opendaylight.controller.yang.model.api.type.BitsTypeDefinition;
import org.opendaylight.controller.yang.model.api.type.EnumTypeDefinition;
import org.opendaylight.controller.yang.model.api.type.EnumTypeDefinition.EnumPair;
import org.opendaylight.controller.yang.model.util.DataNodeIterator;
import org.opendaylight.controller.yang.model.util.ExtendedType;
import org.opendaylight.controller.yang.model.util.SchemaContextUtil;
+import org.opendaylight.controller.yang.model.util.UnionType;
public final class BindingGeneratorImpl implements BindingGenerator {
if (rpc != null) {
String rpcName = parseToClassName(rpc.getQName().getLocalName());
- MethodSignatureBuilder method = interfaceBuilder.addMethod(rpcName);
+ String rpcMethodName = parseToValidParamName(rpcName);
+ MethodSignatureBuilder method = interfaceBuilder.addMethod(rpcMethodName);
final List<DataNodeIterator> rpcInOut = new ArrayList<>();
if ((targetSchemaNode != null) && (targetSchemaNode.getQName() != null)
&& (targetSchemaNode.getQName().getLocalName() != null)) {
final Module targetModule = findParentModule(schemaContext, targetSchemaNode);
-
final String targetBasePackage = moduleNamespaceToPackageName(targetModule);
final String targetPackageName = packageNameForGeneratedType(targetBasePackage, targetSchemaNode.getPath());
-
final String targetSchemaNodeName = targetSchemaNode.getQName().getLocalName();
final Set<DataSchemaNode> augChildNodes = augSchema.getChildNodes();
- final GeneratedTypeBuilder augTypeBuilder = addRawAugmentGenTypeDefinition(augmentPackageName,
- targetPackageName, targetSchemaNodeName, augSchema);
- if (augTypeBuilder != null) {
- genTypes.add(augTypeBuilder.toInstance());
+
+ if (!(targetSchemaNode instanceof ChoiceNode)) {
+ final GeneratedTypeBuilder augTypeBuilder = addRawAugmentGenTypeDefinition(augmentPackageName,
+ targetPackageName, targetSchemaNodeName, augSchema);
+ final GeneratedType augType = augTypeBuilder.toInstance();
+ genTypes.add(augType);
+ } else {
+ final Type refChoiceType = new ReferencedTypeImpl(targetPackageName,
+ parseToClassName(targetSchemaNodeName));
+ final ChoiceNode choiceTarget = (ChoiceNode) targetSchemaNode;
+ final Set<ChoiceCaseNode> choiceCaseNodes = choiceTarget.getCases();
+ genTypes.addAll(augmentCasesToGenTypes(augmentPackageName, refChoiceType, choiceCaseNodes));
}
genTypes.addAll(augmentationBodyToGenTypes(augmentPackageName, augChildNodes));
+ }
+ return genTypes;
+ }
+ private List<GeneratedType> augmentCasesToGenTypes(final String augmentPackageName, final Type refChoiceType,
+ final Set<ChoiceCaseNode> choiceCaseNodes) {
+ if (augmentPackageName == null) {
+ throw new IllegalArgumentException("Augment Package Name string cannot be NULL!");
+ }
+ if (choiceCaseNodes == null) {
+ throw new IllegalArgumentException("Set of Choice Case Nodes cannot be NULL!");
}
+ final List<GeneratedType> genTypes = generateTypesFromAugmentedChoiceCases(augmentPackageName, refChoiceType,
+ choiceCaseNodes);
return genTypes;
}
} else if (childNode instanceof ListSchemaNode) {
genTypes.addAll(listToGenType(augBasePackageName, (ListSchemaNode) childNode));
}
+ } else if (childNode instanceof ChoiceNode) {
+ final ChoiceNode choice = (ChoiceNode) childNode;
+ for (final ChoiceCaseNode caseNode : choice.getCases()) {
+ augSchemaIts.add(new DataNodeIterator(caseNode));
+ }
+ genTypes.addAll(choiceToGeneratedType(augBasePackageName, (ChoiceNode) childNode));
}
}
for (final DataNodeIterator it : augSchemaIts) {
final List<ContainerSchemaNode> augContainers = it.allContainers();
final List<ListSchemaNode> augLists = it.allLists();
+ final List<ChoiceNode> augChoices = it.allChoices();
- if ((augContainers != null) && !augContainers.isEmpty()) {
+ if (augContainers != null) {
for (final ContainerSchemaNode container : augContainers) {
genTypes.add(containerToGenType(augBasePackageName, container));
}
}
- if ((augLists != null) && !augLists.isEmpty()) {
+ if (augLists != null) {
for (final ListSchemaNode list : augLists) {
genTypes.addAll(listToGenType(augBasePackageName, list));
}
}
+ if (augChoices != null) {
+ for (final ChoiceNode choice : augChoices) {
+ genTypes.addAll(choiceToGeneratedType(augBasePackageName, choice));
+ }
+ }
}
return genTypes;
}
final List<GeneratedType> generatedTypes = new ArrayList<>();
for (final ChoiceCaseNode caseNode : caseNodes) {
- if (caseNode != null) {
+ if (caseNode != null && !caseNode.isAddedByUses()) {
+ final String packageName = packageNameForGeneratedType(basePackageName, caseNode.getPath());
+ final GeneratedTypeBuilder caseTypeBuilder = addDefaultInterfaceDefinition(packageName, caseNode);
+ caseTypeBuilder.addImplementsType(refChoiceType);
+
+ final Set<DataSchemaNode> childNodes = caseNode.getChildNodes();
+ if (childNodes != null) {
+ resolveDataSchemaNodes(basePackageName, caseTypeBuilder, childNodes);
+ }
+ generatedTypes.add(caseTypeBuilder.toInstance());
+ }
+ }
+
+ return generatedTypes;
+ }
+
+ private List<GeneratedType> generateTypesFromAugmentedChoiceCases(final String basePackageName,
+ final Type refChoiceType, final Set<ChoiceCaseNode> caseNodes) {
+ if (basePackageName == null) {
+ throw new IllegalArgumentException("Base Package Name cannot be NULL!");
+ }
+ if (refChoiceType == null) {
+ throw new IllegalArgumentException("Referenced Choice Type cannot be NULL!");
+ }
+ if (caseNodes == null) {
+ throw new IllegalArgumentException("Set of Choice Case Nodes cannot be NULL!");
+ }
+
+ final List<GeneratedType> generatedTypes = new ArrayList<>();
+ for (final ChoiceCaseNode caseNode : caseNodes) {
+ if (caseNode != null && caseNode.isAugmenting()) {
final String packageName = packageNameForGeneratedType(basePackageName, caseNode.getPath());
final GeneratedTypeBuilder caseTypeBuilder = addDefaultInterfaceDefinition(packageName, caseNode);
caseTypeBuilder.addImplementsType(refChoiceType);
final TypeDefinition<?> typeDef = leaf.getType();
Type returnType = null;
- if (!(typeDef instanceof EnumTypeDefinition)) {
+ if (typeDef instanceof EnumTypeDefinition) {
returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef);
- } else {
final EnumTypeDefinition enumTypeDef = enumTypeDefFromExtendedType(typeDef);
final EnumBuilder enumBuilder = resolveInnerEnumFromTypeDefinition(enumTypeDef, leafName,
typeBuilder);
returnType = new ReferencedTypeImpl(enumBuilder.getPackageName(), enumBuilder.getName());
}
((TypeProviderImpl) typeProvider).putReferencedType(leaf.getPath(), returnType);
+ } else if (typeDef instanceof UnionType) {
+ GeneratedTOBuilder genTOBuilder = addEnclosedTOToTypeBuilder(typeDef, typeBuilder, leafName);
+ if (genTOBuilder != null) {
+ returnType = new ReferencedTypeImpl(genTOBuilder.getPackageName(), genTOBuilder.getName());
+ }
+ } else if (typeDef instanceof BitsTypeDefinition) {
+ GeneratedTOBuilder genTOBuilder = addEnclosedTOToTypeBuilder(typeDef, typeBuilder, leafName);
+ if (genTOBuilder != null) {
+ returnType = new ReferencedTypeImpl(genTOBuilder.getPackageName(), genTOBuilder.getName());
+ }
+ } else {
+ returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef);
}
if (returnType != null) {
constructGetter(typeBuilder, leafName, leafDesc, returnType);
- if (!leaf.isConfiguration()) {
- constructSetter(typeBuilder, leafName, leafDesc, returnType);
- }
return true;
}
}
final Type listType = Types.listTypeFor(typeProvider.javaTypeForSchemaDefinitionType(type));
constructGetter(typeBuilder, nodeName, nodeDesc, listType);
- if (!node.isConfiguration()) {
- constructSetter(typeBuilder, nodeName, nodeDesc, listType);
- }
return true;
}
}
final String packageName = packageNameForGeneratedType(basePackageName, schemaNode.getPath());
final GeneratedTypeBuilder rawGenType = addDefaultInterfaceDefinition(packageName, schemaNode);
constructGetter(typeBuilder, listName, schemaNode.getDescription(), Types.listTypeFor(rawGenType));
- if (!schemaNode.isConfiguration()) {
- constructSetter(typeBuilder, listName, schemaNode.getDescription(), Types.listTypeFor(rawGenType));
- }
return true;
}
}
}
/**
- * Method instantiates new Generated Type Builder and sets the implements definitions of Data Object and
- * Augmentable.
- *
- * @param packageName Generated Type Package Name
- * @param schemaNode Schema Node definition
+ * Method instantiates new Generated Type Builder and sets the implements
+ * definitions of Data Object and Augmentable.
+ *
+ * @param packageName
+ * Generated Type Package Name
+ * @param schemaNode
+ * Schema Node definition
* @return Generated Type Builder instance for Schema Node definition
*/
private GeneratedTypeBuilder addDefaultInterfaceDefinition(final String packageName, final SchemaNode schemaNode) {
}
/**
- *
+ *
* @param packageName
* @param schemaNode
* @return
}
return genTOBuilder;
}
+
+ private GeneratedTOBuilder addEnclosedTOToTypeBuilder(TypeDefinition<?> typeDef, GeneratedTypeBuilder typeBuilder,
+ String leafName) {
+ String className = parseToClassName(leafName);
+ GeneratedTOBuilder genTOBuilder = null;
+ if (typeDef instanceof UnionType) {
+ genTOBuilder = ((TypeProviderImpl) typeProvider).addUnionGeneratedTypeDefinition(
+ typeBuilder.getPackageName(), typeDef, className);
+ } else if (typeDef instanceof BitsTypeDefinition) {
+ genTOBuilder = ((TypeProviderImpl) typeProvider).bitsTypedefToTransferObject(typeBuilder.getPackageName(),
+ typeDef, className);
+ }
+ if (genTOBuilder != null) {
+ typeBuilder.addEnclosingTransferObject(genTOBuilder);
+ return genTOBuilder;
+ }
+ return null;
+
+ }
+
}
Code Review / controller.git / blobdiff