*/
package org.opendaylight.controller.sal.binding.generator.impl;
-import java.net.URI;
+import static org.opendaylight.controller.binding.generator.util.BindingGeneratorUtil.*;
+import static org.opendaylight.controller.yang.model.util.SchemaContextUtil.findDataSchemaNode;
+import static org.opendaylight.controller.yang.model.util.SchemaContextUtil.findParentModule;
+
+import java.util.concurrent.Future;
+
import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Calendar;
-import java.util.GregorianCalendar;
+import java.util.Collections;
+import java.util.Comparator;
import java.util.HashMap;
-import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
-import org.opendaylight.controller.binding.generator.util.BindingGeneratorUtil;
+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.binding.generator.util.generated.type.builder.GeneratedTypeBuilderImpl;
import org.opendaylight.controller.sal.binding.generator.api.BindingGenerator;
import org.opendaylight.controller.sal.binding.generator.spi.TypeProvider;
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.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.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 class BindingGeneratorImpl implements BindingGenerator {
-
- private static final String[] SET_VALUES = new String[] { "abstract",
- "assert", "boolean", "break", "byte", "case", "catch", "char",
- "class", "const", "continue", "default", "double", "do", "else",
- "enum", "extends", "false", "final", "finally", "float", "for",
- "goto", "if", "implements", "import", "instanceof", "int",
- "interface", "long", "native", "new", "null", "package", "private",
- "protected", "public", "return", "short", "static", "strictfp",
- "super", "switch", "synchronized", "this", "throw", "throws",
- "transient", "true", "try", "void", "volatile", "while" };
+public final class BindingGeneratorImpl implements BindingGenerator {
- public static final Set<String> JAVA_RESERVED_WORDS = new HashSet<String>(
- Arrays.asList(SET_VALUES));
-
- private static Calendar calendar = new GregorianCalendar();
private Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders;
private TypeProvider typeProvider;
- private String basePackageName;
+ private SchemaContext schemaContext;
public BindingGeneratorImpl() {
super();
}
- private static String validatePackage(final String packageName) {
- if (packageName != null) {
- final String[] packNameParts = packageName.split("\\.");
- if (packNameParts != null) {
- final StringBuilder builder = new StringBuilder();
- for (int i = 0; i < packNameParts.length; ++i) {
- if (JAVA_RESERVED_WORDS.contains(packNameParts[i])) {
- packNameParts[i] = "_" + packNameParts[i];
- }
- if (i > 0) {
- builder.append(".");
- }
- builder.append(packNameParts[i]);
+ @Override
+ public List<Type> generateTypes(final SchemaContext context) {
+ if (context == null) {
+ throw new IllegalArgumentException("Schema Context reference cannot be NULL!");
+ }
+ if (context.getModules() == null) {
+ throw new IllegalStateException("Schema Context does not contain defined modules!");
+ }
+
+ final List<Type> generatedTypes = new ArrayList<>();
+ schemaContext = context;
+ typeProvider = new TypeProviderImpl(context);
+ final Set<Module> modules = context.getModules();
+ genTypeBuilders = new HashMap<>();
+ for (final Module module : modules) {
+ generatedTypes.add(moduleToDataType(module));
+ generatedTypes.addAll(allTypeDefinitionsToGenTypes(module));
+ generatedTypes.addAll(allContainersToGenTypes(module));
+ generatedTypes.addAll(allListsToGenTypes(module));
+ generatedTypes.addAll(allChoicesToGenTypes(module));
+ generatedTypes.addAll(allAugmentsToGenTypes(module));
+ generatedTypes.addAll(allRPCMethodsToGenType(module));
+ generatedTypes.addAll(allNotificationsToGenType(module));
+ generatedTypes.addAll(allIdentitiesToGenTypes(module, context));
+ generatedTypes.addAll(allGroupingsToGenTypes(module));
+ }
+ return generatedTypes;
+ }
+
+ @Override
+ public List<Type> generateTypes(final SchemaContext context, final Set<Module> modules) {
+ if (context == null) {
+ throw new IllegalArgumentException("Schema Context reference cannot be NULL!");
+ }
+ if (context.getModules() == null) {
+ throw new IllegalStateException("Schema Context does not contain defined modules!");
+ }
+ if (modules == null) {
+ throw new IllegalArgumentException("Sef of Modules cannot be NULL!");
+ }
+
+ final List<Type> filteredGenTypes = new ArrayList<>();
+ schemaContext = context;
+ typeProvider = new TypeProviderImpl(context);
+ final Set<Module> contextModules = context.getModules();
+ genTypeBuilders = new HashMap<>();
+ for (final Module contextModule : contextModules) {
+ final List<Type> generatedTypes = new ArrayList<>();
+
+ generatedTypes.add(moduleToDataType(contextModule));
+ generatedTypes.addAll(allTypeDefinitionsToGenTypes(contextModule));
+ generatedTypes.addAll(allContainersToGenTypes(contextModule));
+ generatedTypes.addAll(allListsToGenTypes(contextModule));
+ generatedTypes.addAll(allChoicesToGenTypes(contextModule));
+ generatedTypes.addAll(allAugmentsToGenTypes(contextModule));
+ generatedTypes.addAll(allRPCMethodsToGenType(contextModule));
+ generatedTypes.addAll(allNotificationsToGenType(contextModule));
+ generatedTypes.addAll(allIdentitiesToGenTypes(contextModule, context));
+ generatedTypes.addAll(allGroupingsToGenTypes(contextModule));
+
+ if (modules.contains(contextModule)) {
+ filteredGenTypes.addAll(generatedTypes);
+ }
+ }
+ return filteredGenTypes;
+ }
+
+ private List<Type> allTypeDefinitionsToGenTypes(final Module module) {
+ if (module == null) {
+ throw new IllegalArgumentException("Module reference cannot be NULL!");
+ }
+ if (module.getName() == null) {
+ throw new IllegalArgumentException("Module name cannot be NULL!");
+ }
+ if (module.getTypeDefinitions() == null) {
+ throw new IllegalArgumentException("Type Definitions for module " + module.getName() + " cannot be NULL!");
+ }
+
+ final Set<TypeDefinition<?>> typeDefinitions = module.getTypeDefinitions();
+ final List<Type> generatedTypes = new ArrayList<>();
+ for (final TypeDefinition<?> typedef : typeDefinitions) {
+ if (typedef != null) {
+ final Type type = ((TypeProviderImpl) typeProvider).generatedTypeForExtendedDefinitionType(typedef);
+ if ((type != null) && !generatedTypes.contains(type)) {
+ generatedTypes.add(type);
}
- return builder.toString();
}
}
- return packageName;
+ return generatedTypes;
}
- @Override
- public List<Type> generateTypes(final SchemaContext context) {
- final List<Type> genTypes = new ArrayList<Type>();
-
- if (context != null) {
- typeProvider = new TypeProviderImpl(context);
- final Set<Module> modules = context.getModules();
-
- if (modules != null) {
- for (final Module module : modules) {
- final DataNodeIterator moduleIterator = new DataNodeIterator(
- module);
-
- genTypeBuilders = new HashMap<String, Map<String, GeneratedTypeBuilder>>();
- final List<ContainerSchemaNode> schemaContainers = moduleIterator
- .allContainers();
- final List<ListSchemaNode> schemaLists = moduleIterator
- .allLists();
-
- basePackageName = BindingGeneratorUtil
- .moduleNamespaceToPackageName(
- module.getNamespace(),
- module.getYangVersion());
-
- if (schemaContainers.size() > 0) {
- for (final ContainerSchemaNode container : schemaContainers) {
- genTypes.add(containerToGenType(container));
+ private List<Type> allContainersToGenTypes(final Module module) {
+ if (module == null) {
+ throw new IllegalArgumentException("Module reference cannot be NULL!");
+ }
+
+ if (module.getName() == null) {
+ throw new IllegalArgumentException("Module name cannot be NULL!");
+ }
+
+ if (module.getChildNodes() == null) {
+ throw new IllegalArgumentException("Reference to Set of Child Nodes in module " + module.getName()
+ + " cannot be NULL!");
+ }
+
+ final List<Type> generatedTypes = new ArrayList<>();
+ final DataNodeIterator it = new DataNodeIterator(module);
+ final List<ContainerSchemaNode> schemaContainers = it.allContainers();
+ final String basePackageName = moduleNamespaceToPackageName(module);
+ for (final ContainerSchemaNode container : schemaContainers) {
+ generatedTypes.add(containerToGenType(basePackageName, container));
+ }
+ return generatedTypes;
+ }
+
+ private List<Type> allListsToGenTypes(final Module module) {
+ if (module == null) {
+ throw new IllegalArgumentException("Module reference cannot be NULL!");
+ }
+
+ if (module.getName() == null) {
+ throw new IllegalArgumentException("Module name cannot be NULL!");
+ }
+
+ if (module.getChildNodes() == null) {
+ throw new IllegalArgumentException("Reference to Set of Child Nodes in module " + module.getName()
+ + " cannot be NULL!");
+ }
+
+ final List<Type> generatedTypes = new ArrayList<>();
+ final DataNodeIterator it = new DataNodeIterator(module);
+ final List<ListSchemaNode> schemaLists = it.allLists();
+ final String basePackageName = moduleNamespaceToPackageName(module);
+ if (schemaLists != null) {
+ for (final ListSchemaNode list : schemaLists) {
+ generatedTypes.addAll(listToGenType(basePackageName, list));
+ }
+ }
+ return generatedTypes;
+ }
+
+ private List<GeneratedType> allChoicesToGenTypes(final Module module) {
+ if (module == null) {
+ throw new IllegalArgumentException("Module reference cannot be NULL!");
+ }
+ if (module.getName() == null) {
+ throw new IllegalArgumentException("Module name cannot be NULL!");
+ }
+
+ final DataNodeIterator it = new DataNodeIterator(module);
+ final List<ChoiceNode> choiceNodes = it.allChoices();
+ final String basePackageName = moduleNamespaceToPackageName(module);
+
+ final List<GeneratedType> generatedTypes = new ArrayList<>();
+ for (final ChoiceNode choice : choiceNodes) {
+ if (choice != null) {
+ generatedTypes.addAll(choiceToGeneratedType(basePackageName, choice));
+ }
+ }
+ return generatedTypes;
+ }
+
+ private List<Type> allAugmentsToGenTypes(final Module module) {
+ if (module == null) {
+ throw new IllegalArgumentException("Module reference cannot be NULL!");
+ }
+ if (module.getName() == null) {
+ throw new IllegalArgumentException("Module name cannot be NULL!");
+ }
+ if (module.getChildNodes() == null) {
+ throw new IllegalArgumentException("Reference to Set of Augmentation Definitions in module "
+ + module.getName() + " cannot be NULL!");
+ }
+
+ final List<Type> generatedTypes = new ArrayList<>();
+ final String basePackageName = moduleNamespaceToPackageName(module);
+ final List<AugmentationSchema> augmentations = resolveAugmentations(module);
+ for (final AugmentationSchema augment : augmentations) {
+ generatedTypes.addAll(augmentationToGenTypes(basePackageName, augment));
+ }
+ return generatedTypes;
+ }
+
+ private List<AugmentationSchema> resolveAugmentations(final Module module) {
+ if (module == null) {
+ throw new IllegalArgumentException("Module reference cannot be NULL!");
+ }
+ if (module.getAugmentations() == null) {
+ throw new IllegalStateException("Augmentations Set cannot be NULL!");
+ }
+
+ final Set<AugmentationSchema> augmentations = module.getAugmentations();
+ final List<AugmentationSchema> sortedAugmentations = new ArrayList<>(augmentations);
+ Collections.sort(sortedAugmentations, new Comparator<AugmentationSchema>() {
+
+ @Override
+ public int compare(AugmentationSchema augSchema1, AugmentationSchema augSchema2) {
+
+ if (augSchema1.getTargetPath().getPath().size() > augSchema2.getTargetPath().getPath().size()) {
+ return 1;
+ } else if (augSchema1.getTargetPath().getPath().size() < augSchema2.getTargetPath().getPath().size()) {
+ return -1;
+ }
+ return 0;
+
+ }
+ });
+
+ return sortedAugmentations;
+ }
+
+ private GeneratedType moduleToDataType(final Module module) {
+ if (module == null) {
+ throw new IllegalArgumentException("Module reference cannot be NULL!");
+ }
+
+ final GeneratedTypeBuilder moduleDataTypeBuilder = moduleTypeBuilder(module, "Data");
+
+ final String basePackageName = moduleNamespaceToPackageName(module);
+ if (moduleDataTypeBuilder != null) {
+ final Set<DataSchemaNode> dataNodes = module.getChildNodes();
+ resolveDataSchemaNodes(basePackageName, moduleDataTypeBuilder, dataNodes);
+ }
+ return moduleDataTypeBuilder.toInstance();
+ }
+
+ private List<Type> allRPCMethodsToGenType(final Module module) {
+ if (module == null) {
+ throw new IllegalArgumentException("Module reference cannot be NULL!");
+ }
+
+ if (module.getName() == null) {
+ throw new IllegalArgumentException("Module name cannot be NULL!");
+ }
+
+ if (module.getChildNodes() == null) {
+ throw new IllegalArgumentException("Reference to Set of RPC Method Definitions in module "
+ + module.getName() + " cannot be NULL!");
+ }
+
+ final String basePackageName = moduleNamespaceToPackageName(module);
+ final Set<RpcDefinition> rpcDefinitions = module.getRpcs();
+ final List<Type> genRPCTypes = new ArrayList<>();
+ final GeneratedTypeBuilder interfaceBuilder = moduleTypeBuilder(module, "Service");
+ final Type future = Types.typeForClass(Future.class);
+ for (final RpcDefinition rpc : rpcDefinitions) {
+ if (rpc != null) {
+
+ String rpcName = parseToClassName(rpc.getQName().getLocalName());
+ String rpcMethodName = parseToValidParamName(rpcName);
+ MethodSignatureBuilder method = interfaceBuilder.addMethod(rpcMethodName);
+
+ final List<DataNodeIterator> rpcInOut = new ArrayList<>();
+
+ ContainerSchemaNode input = rpc.getInput();
+ ContainerSchemaNode output = rpc.getOutput();
+
+ if (input != null) {
+ rpcInOut.add(new DataNodeIterator(input));
+ GeneratedTypeBuilder inType = addRawInterfaceDefinition(basePackageName, input, rpcName);
+ resolveDataSchemaNodes(basePackageName, inType, input.getChildNodes());
+ Type inTypeInstance = inType.toInstance();
+ genRPCTypes.add(inTypeInstance);
+ method.addParameter(inTypeInstance, "input");
+ }
+
+ Type outTypeInstance = Types.typeForClass(Void.class);
+ if (output != null) {
+ rpcInOut.add(new DataNodeIterator(output));
+
+ GeneratedTypeBuilder outType = addRawInterfaceDefinition(basePackageName, output, rpcName);
+ resolveDataSchemaNodes(basePackageName, outType, output.getChildNodes());
+ outTypeInstance = outType.toInstance();
+ genRPCTypes.add(outTypeInstance);
+
+ }
+
+ final Type rpcRes = Types.parameterizedTypeFor(Types.typeForClass(RpcResult.class), outTypeInstance);
+ method.setReturnType(Types.parameterizedTypeFor(future, rpcRes));
+ for (DataNodeIterator it : rpcInOut) {
+ List<ContainerSchemaNode> nContainers = it.allContainers();
+ if ((nContainers != null) && !nContainers.isEmpty()) {
+ for (final ContainerSchemaNode container : nContainers) {
+ genRPCTypes.add(containerToGenType(basePackageName, container));
}
}
- if (schemaLists.size() > 0) {
- for (final ListSchemaNode list : schemaLists) {
- genTypes.addAll(listToGenType(list));
+ List<ListSchemaNode> nLists = it.allLists();
+ if ((nLists != null) && !nLists.isEmpty()) {
+ for (final ListSchemaNode list : nLists) {
+ genRPCTypes.addAll(listToGenType(basePackageName, list));
}
}
+ }
+ }
+ }
+ genRPCTypes.add(interfaceBuilder.toInstance());
+ return genRPCTypes;
+ }
- final GeneratedType genDataType = moduleToDataType(module);
- final GeneratedType genRpcType = rpcMethodsToGenType(module);
- final GeneratedType genNotifyType = notifycationsToGenType(module);
+ private List<Type> allNotificationsToGenType(final Module module) {
+ if (module == null) {
+ throw new IllegalArgumentException("Module reference cannot be NULL!");
+ }
- if (genDataType != null) {
- genTypes.add(genDataType);
- }
- if (genRpcType != null) {
- genTypes.add(genRpcType);
- }
- if (genNotifyType != null) {
- genTypes.add(genNotifyType);
- }
+ if (module.getName() == null) {
+ throw new IllegalArgumentException("Module name cannot be NULL!");
+ }
+
+ if (module.getChildNodes() == null) {
+ throw new IllegalArgumentException("Reference to Set of Notification Definitions in module "
+ + module.getName() + " cannot be NULL!");
+ }
+
+ final String basePackageName = moduleNamespaceToPackageName(module);
+ final List<Type> genNotifyTypes = new ArrayList<>();
+ final Set<NotificationDefinition> notifications = module.getNotifications();
+
+ for (final NotificationDefinition notification : notifications) {
+ if (notification != null) {
+ DataNodeIterator it = new DataNodeIterator(notification);
+
+ // Containers
+ for (ContainerSchemaNode node : it.allContainers()) {
+ genNotifyTypes.add(containerToGenType(basePackageName, node));
}
-
- //FIXME this is quick add of typedefs to generated types from type provider
- genTypes.addAll(((TypeProviderImpl)typeProvider).getGeneratedTypeDefs());
+ // Lists
+ for (ListSchemaNode node : it.allLists()) {
+ genNotifyTypes.addAll(listToGenType(basePackageName, node));
+ }
+ final GeneratedTypeBuilder notificationTypeBuilder = addDefaultInterfaceDefinition(basePackageName,
+ notification);
+ notificationTypeBuilder.addImplementsType(Types.typeForClass(Notification.class));
+ // Notification object
+ resolveDataSchemaNodes(basePackageName, notificationTypeBuilder, notification.getChildNodes());
+ genNotifyTypes.add(notificationTypeBuilder.toInstance());
}
}
- return genTypes;
+ return genNotifyTypes;
}
- private GeneratedType moduleToDataType(final Module module) {
- if (module != null) {
- final Set<TypeDefinition<?>> typeDefinitions = module
- .getTypeDefinitions();
- final GeneratedTypeBuilder moduleDataTypeBuilder = moduleTypeBuilder(
- module, "Data");
-
- if (moduleDataTypeBuilder != null) {
- if (typeDefinitions != null) {
- for (final TypeDefinition<?> typedef : typeDefinitions) {
- if (isDerivedFromEnumerationType(typedef)) {
- final EnumTypeDefinition enumBaseType = enumTypeDefFromExtendedType(typedef);
- resolveEnumFromTypeDefinition(enumBaseType, typedef
- .getQName().getLocalName(),
- moduleDataTypeBuilder);
- }
- }
- }
+ private List<Type> allIdentitiesToGenTypes(final Module module, final SchemaContext context) {
+ List<Type> genTypes = new ArrayList<>();
+
+ final Set<IdentitySchemaNode> schemaIdentities = module.getIdentities();
- final Set<DataSchemaNode> dataNodes = module.getChildNodes();
- resolveTypesFromDataSchemaNode(moduleDataTypeBuilder, dataNodes);
- return moduleDataTypeBuilder.toInstance();
+ final String basePackageName = moduleNamespaceToPackageName(module);
+
+ if (schemaIdentities != null && !schemaIdentities.isEmpty()) {
+ for (final IdentitySchemaNode identity : schemaIdentities) {
+ genTypes.add(identityToGenType(basePackageName, identity, context));
}
}
- return null;
+ return genTypes;
}
- private boolean isDerivedFromEnumerationType(
- final TypeDefinition<?> typeDefinition) {
- if (typeDefinition != null) {
- if (typeDefinition.getBaseType() instanceof EnumTypeDefinition) {
- return true;
- } else if (typeDefinition.getBaseType() instanceof ExtendedType) {
- return isDerivedFromEnumerationType(typeDefinition
- .getBaseType());
+ private GeneratedType identityToGenType(final String basePackageName, final IdentitySchemaNode identity,
+ final SchemaContext context) {
+ if (identity == null) {
+ return null;
+ }
+
+ final String packageName = packageNameForGeneratedType(basePackageName, identity.getPath());
+ final String genTypeName = parseToClassName(identity.getQName().getLocalName());
+ final GeneratedTOBuilderImpl newType = new GeneratedTOBuilderImpl(packageName, genTypeName);
+
+ IdentitySchemaNode baseIdentity = identity.getBaseIdentity();
+ if (baseIdentity != null) {
+ Module baseIdentityParentModule = SchemaContextUtil.findParentModule(context, baseIdentity);
+
+ final String returnTypePkgName = moduleNamespaceToPackageName(baseIdentityParentModule);
+ final String returnTypeName = parseToClassName(baseIdentity.getQName().getLocalName());
+
+ GeneratedTransferObject gto = new GeneratedTOBuilderImpl(returnTypePkgName, returnTypeName).toInstance();
+ newType.setExtendsType(gto);
+ } else {
+ newType.setExtendsType(Types.getBaseIdentityTO());
+ }
+ newType.setAbstract(true);
+ return newType.toInstance();
+ }
+
+ private List<Type> allGroupingsToGenTypes(final Module module) {
+ final List<Type> genTypes = new ArrayList<>();
+ final String basePackageName = moduleNamespaceToPackageName(module);
+ final Set<GroupingDefinition> groupings = module.getGroupings();
+ if (groupings != null && !groupings.isEmpty()) {
+ for (final GroupingDefinition grouping : groupings) {
+ genTypes.add(groupingToGenType(basePackageName, grouping));
}
}
- return false;
+ return genTypes;
}
- private EnumTypeDefinition enumTypeDefFromExtendedType(
- final TypeDefinition<?> typeDefinition) {
+ private GeneratedType groupingToGenType(final String basePackageName, GroupingDefinition grouping) {
+ if (grouping == null) {
+ return null;
+ }
+
+ final String packageName = packageNameForGeneratedType(basePackageName, grouping.getPath());
+ final Set<DataSchemaNode> schemaNodes = grouping.getChildNodes();
+ final GeneratedTypeBuilder typeBuilder = addDefaultInterfaceDefinition(packageName, grouping);
+
+ resolveDataSchemaNodes(basePackageName, typeBuilder, schemaNodes);
+ return typeBuilder.toInstance();
+ }
+
+ private EnumTypeDefinition enumTypeDefFromExtendedType(final TypeDefinition<?> typeDefinition) {
if (typeDefinition != null) {
if (typeDefinition.getBaseType() instanceof EnumTypeDefinition) {
return (EnumTypeDefinition) typeDefinition.getBaseType();
return null;
}
- private EnumBuilder resolveEnumFromTypeDefinition(
- final EnumTypeDefinition enumTypeDef, final String enumName,
+ private EnumBuilder resolveInnerEnumFromTypeDefinition(final EnumTypeDefinition enumTypeDef, final String enumName,
final GeneratedTypeBuilder typeBuilder) {
- if ((enumTypeDef != null) && (typeBuilder != null)
- && (enumTypeDef.getQName() != null)
+ if ((enumTypeDef != null) && (typeBuilder != null) && (enumTypeDef.getQName() != null)
&& (enumTypeDef.getQName().getLocalName() != null)) {
- final String enumerationName = BindingGeneratorUtil
- .parseToClassName(enumName);
- final EnumBuilder enumBuilder = typeBuilder
- .addEnumeration(enumerationName);
+ final String enumerationName = parseToClassName(enumName);
+ final EnumBuilder enumBuilder = typeBuilder.addEnumeration(enumerationName);
if (enumBuilder != null) {
final List<EnumPair> enums = enumTypeDef.getValues();
int listIndex = 0;
for (final EnumPair enumPair : enums) {
if (enumPair != null) {
- final String enumPairName = BindingGeneratorUtil
- .parseToClassName(enumPair.getName());
+ final String enumPairName = parseToClassName(enumPair.getName());
Integer enumPairValue = enumPair.getValue();
if (enumPairValue == null) {
return null;
}
- private GeneratedTypeBuilder moduleTypeBuilder(final Module module,
- final String postfix) {
- if (module != null) {
- String packageName = resolveBasePackageName(module.getNamespace(),
- module.getYangVersion());
- final String moduleName = BindingGeneratorUtil
- .parseToClassName(module.getName()) + postfix;
+ private GeneratedTypeBuilder moduleTypeBuilder(final Module module, final String postfix) {
+ if (module == null) {
+ throw new IllegalArgumentException("Module reference cannot be NULL!");
+ }
+ String packageName = moduleNamespaceToPackageName(module);
+ final String moduleName = parseToClassName(module.getName()) + postfix;
+
+ return new GeneratedTypeBuilderImpl(packageName, moduleName);
+
+ }
+
+ private List<Type> augmentationToGenTypes(final String augmentPackageName, final AugmentationSchema augSchema) {
+ if (augmentPackageName == null) {
+ throw new IllegalArgumentException("Package Name cannot be NULL!");
+ }
+ if (augSchema == null) {
+ throw new IllegalArgumentException("Augmentation Schema cannot be NULL!");
+ }
+ if (augSchema.getTargetPath() == null) {
+ throw new IllegalStateException("Augmentation Schema does not contain Target Path (Target Path is NULL).");
+ }
- if (packageName != null) {
- packageName = validatePackage(packageName);
- return new GeneratedTypeBuilderImpl(packageName, moduleName);
+ final List<Type> genTypes = new ArrayList<>();
+
+ // EVERY augmented interface will extends Augmentation<T> interface
+ // and DataObject interface!!!
+ final SchemaPath targetPath = augSchema.getTargetPath();
+ final DataSchemaNode targetSchemaNode = findDataSchemaNode(schemaContext, targetPath);
+ 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();
+
+ 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 null;
+ return genTypes;
}
- private GeneratedType rpcMethodsToGenType(final Module module) {
- if (module != null) {
- final Set<RpcDefinition> rpcDefinitions = module.getRpcs();
- //TODO: add implementation
- if ((rpcDefinitions != null) && !rpcDefinitions.isEmpty()) {
- final GeneratedTypeBuilder rpcTypeBuilder = moduleTypeBuilder(
- module, "Rpc");
+ 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;
+ }
+
+ private GeneratedTypeBuilder addRawAugmentGenTypeDefinition(final String augmentPackageName,
+ final String targetPackageName, final String targetSchemaNodeName, final AugmentationSchema augSchema) {
+ final String targetTypeName = parseToClassName(targetSchemaNodeName);
+ Map<String, GeneratedTypeBuilder> augmentBuilders = genTypeBuilders.get(augmentPackageName);
+ if (augmentBuilders == null) {
+ augmentBuilders = new HashMap<>();
+ genTypeBuilders.put(augmentPackageName, augmentBuilders);
+ }
- for (final RpcDefinition rpc : rpcDefinitions) {
- if (rpc != null) {
+ final String augTypeName = augGenTypeName(augmentBuilders, targetTypeName);
+ final Type targetTypeRef = new ReferencedTypeImpl(targetPackageName, targetTypeName);
+ final Set<DataSchemaNode> augChildNodes = augSchema.getChildNodes();
- }
+ final GeneratedTypeBuilder augTypeBuilder = new GeneratedTypeBuilderImpl(augmentPackageName, augTypeName);
+
+ augTypeBuilder.addImplementsType(Types.DATA_OBJECT);
+ augTypeBuilder.addImplementsType(Types.augmentationTypeFor(targetTypeRef));
+
+ augSchemaNodeToMethods(augmentPackageName, augTypeBuilder, augChildNodes);
+ augmentBuilders.put(augTypeName, augTypeBuilder);
+ return augTypeBuilder;
+ }
+
+ private List<Type> augmentationBodyToGenTypes(final String augBasePackageName,
+ final Set<DataSchemaNode> augChildNodes) {
+ final List<Type> genTypes = new ArrayList<>();
+ final List<DataNodeIterator> augSchemaIts = new ArrayList<>();
+ for (final DataSchemaNode childNode : augChildNodes) {
+ if (childNode instanceof DataNodeContainer) {
+ augSchemaIts.add(new DataNodeIterator((DataNodeContainer) childNode));
+
+ if (childNode instanceof ContainerSchemaNode) {
+ genTypes.add(containerToGenType(augBasePackageName, (ContainerSchemaNode) childNode));
+ } 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));
}
}
- return null;
- }
-
- private GeneratedType notifycationsToGenType(final Module module) {
- if (module != null) {
- final Set<NotificationDefinition> notifications = module
- .getNotifications();
- //TODO: add implementation
- if ((notifications != null) && !notifications.isEmpty()) {
- final GeneratedTypeBuilder notifyTypeBuilder = moduleTypeBuilder(
- module, "Notification");
- for (final NotificationDefinition notification : notifications) {
- if (notification != null) {
+ 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) {
+ for (final ContainerSchemaNode container : augContainers) {
+ genTypes.add(containerToGenType(augBasePackageName, container));
+ }
+ }
+ 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 null;
+ return genTypes;
}
-
- private List<GeneratedType> augmentationToGenTypes(final Module module) {
- final List<GeneratedType> augmentGenTypes = new ArrayList<GeneratedType>();
-
- //TODO: add implementation
-
- return augmentGenTypes;
- }
-
- private GeneratedType containerToGenType(ContainerSchemaNode container) {
- if (container == null) {
+
+ private String augGenTypeName(final Map<String, GeneratedTypeBuilder> builders, final String genTypeName) {
+ String augTypeName = genTypeName;
+
+ int index = 1;
+ while ((builders != null) && builders.containsKey(genTypeName + index)) {
+ index++;
+ }
+ augTypeName += index;
+ return augTypeName;
+ }
+
+ private GeneratedType containerToGenType(final String basePackageName, ContainerSchemaNode containerNode) {
+ if (containerNode == null) {
return null;
}
- final Set<DataSchemaNode> schemaNodes = container.getChildNodes();
- final GeneratedTypeBuilder typeBuilder = addRawInterfaceDefinition(container);
- resolveTypesFromDataSchemaNode(typeBuilder, schemaNodes);
+ final String packageName = packageNameForGeneratedType(basePackageName, containerNode.getPath());
+ final Set<DataSchemaNode> schemaNodes = containerNode.getChildNodes();
+ final GeneratedTypeBuilder typeBuilder = addDefaultInterfaceDefinition(packageName, containerNode);
+
+ resolveDataSchemaNodes(basePackageName, typeBuilder, schemaNodes);
return typeBuilder.toInstance();
}
- private GeneratedTypeBuilder resolveTypesFromDataSchemaNode(
- final GeneratedTypeBuilder typeBuilder,
- final Set<DataSchemaNode> schemaNodes) {
+ private GeneratedTypeBuilder resolveDataSchemaNodes(final String basePackageName,
+ final GeneratedTypeBuilder typeBuilder, final Set<DataSchemaNode> schemaNodes) {
+ if ((schemaNodes != null) && (typeBuilder != null)) {
+ for (final DataSchemaNode schemaNode : schemaNodes) {
+ if (schemaNode.isAugmenting()) {
+ continue;
+ }
+ addSchemaNodeToBuilderAsMethod(basePackageName, schemaNode, typeBuilder);
+ }
+ }
+ return typeBuilder;
+ }
+ private GeneratedTypeBuilder augSchemaNodeToMethods(final String basePackageName,
+ final GeneratedTypeBuilder typeBuilder, final Set<DataSchemaNode> schemaNodes) {
if ((schemaNodes != null) && (typeBuilder != null)) {
- for (final DataSchemaNode node : schemaNodes) {
- if (node instanceof LeafSchemaNode) {
- resolveLeafSchemaNodeAsMethod(typeBuilder,
- (LeafSchemaNode) node);
- } else if (node instanceof LeafListSchemaNode) {
- resolveLeafListSchemaNode(typeBuilder,
- (LeafListSchemaNode) node);
-
- } else if (node instanceof ContainerSchemaNode) {
- resolveContainerSchemaNode(typeBuilder,
- (ContainerSchemaNode) node);
- } else if (node instanceof ListSchemaNode) {
- resolveListSchemaNode(typeBuilder, (ListSchemaNode) node);
+ for (final DataSchemaNode schemaNode : schemaNodes) {
+ if (schemaNode.isAugmenting()) {
+ addSchemaNodeToBuilderAsMethod(basePackageName, schemaNode, typeBuilder);
}
}
}
return typeBuilder;
}
- private boolean resolveLeafSchemaNodeAsMethod(
- final GeneratedTypeBuilder typeBuilder, final LeafSchemaNode leaf) {
- if ((leaf != null) && (typeBuilder != null)) {
- final String leafName = leaf.getQName().getLocalName();
- String leafDesc = leaf.getDescription();
- if (leafDesc == null) {
- leafDesc = "";
+ private void addSchemaNodeToBuilderAsMethod(final String basePackageName, final DataSchemaNode schemaNode,
+ final GeneratedTypeBuilder typeBuilder) {
+ if (schemaNode != null && typeBuilder != null) {
+ if (schemaNode instanceof LeafSchemaNode) {
+ resolveLeafSchemaNodeAsMethod(typeBuilder, (LeafSchemaNode) schemaNode);
+ } else if (schemaNode instanceof LeafListSchemaNode) {
+ resolveLeafListSchemaNode(typeBuilder, (LeafListSchemaNode) schemaNode);
+ } else if (schemaNode instanceof ContainerSchemaNode) {
+ resolveContainerSchemaNode(basePackageName, typeBuilder, (ContainerSchemaNode) schemaNode);
+ } else if (schemaNode instanceof ListSchemaNode) {
+ resolveListSchemaNode(basePackageName, typeBuilder, (ListSchemaNode) schemaNode);
+ } else if (schemaNode instanceof ChoiceNode) {
+ resolveChoiceSchemaNode(basePackageName, typeBuilder, (ChoiceNode) schemaNode);
}
+ }
+ }
- if (leafName != null) {
- final TypeDefinition<?> typeDef = leaf.getType();
+ private void resolveChoiceSchemaNode(final String basePackageName, final GeneratedTypeBuilder typeBuilder,
+ final ChoiceNode choiceNode) {
+ if (basePackageName == null) {
+ throw new IllegalArgumentException("Base Package Name cannot be NULL!");
+ }
+ if (typeBuilder == null) {
+ throw new IllegalArgumentException("Generated Type Builder cannot be NULL!");
+ }
+ if (choiceNode == null) {
+ throw new IllegalArgumentException("Choice Schema Node cannot be NULL!");
+ }
- Type type = null;
- if (!(typeDef instanceof EnumTypeDefinition)
- && !isDerivedFromEnumerationType(typeDef)) {
- type = typeProvider
- .javaTypeForSchemaDefinitionType(typeDef);
- } else {
- if (isImported(leaf.getPath(), typeDef.getPath())) {
- // TODO: resolving of imported enums as references to
- // GeneratedTypeData interface
- } else {
- final EnumTypeDefinition enumTypeDef = enumTypeDefFromExtendedType(typeDef);
- final EnumBuilder enumBuilder = resolveEnumFromTypeDefinition(
- enumTypeDef, leafName, typeBuilder);
-
- if (enumBuilder != null) {
- type = new ReferencedTypeImpl(
- enumBuilder.getPackageName(),
- enumBuilder.getName());
- }
- }
+ final String choiceName = choiceNode.getQName().getLocalName();
+ if (choiceName != null) {
+ final String packageName = packageNameForGeneratedType(basePackageName, choiceNode.getPath());
+ final GeneratedTypeBuilder choiceType = addDefaultInterfaceDefinition(packageName, choiceNode);
+ constructGetter(typeBuilder, choiceName, choiceNode.getDescription(), choiceType);
+ }
+ }
+
+ private List<GeneratedType> choiceToGeneratedType(final String basePackageName, final ChoiceNode choiceNode) {
+ if (basePackageName == null) {
+ throw new IllegalArgumentException("Base Package Name cannot be NULL!");
+ }
+ if (choiceNode == null) {
+ throw new IllegalArgumentException("Choice Schema Node cannot be NULL!");
+ }
+
+ final List<GeneratedType> generatedTypes = new ArrayList<>();
+ final String packageName = packageNameForGeneratedType(basePackageName, choiceNode.getPath());
+ final GeneratedTypeBuilder choiceTypeBuilder = addRawInterfaceDefinition(packageName, choiceNode);
+ choiceTypeBuilder.addImplementsType(Types.DATA_OBJECT);
+ final GeneratedType choiceType = choiceTypeBuilder.toInstance();
+
+ generatedTypes.add(choiceType);
+ final Set<ChoiceCaseNode> caseNodes = choiceNode.getCases();
+ if ((caseNodes != null) && !caseNodes.isEmpty()) {
+ generatedTypes.addAll(generateTypesFromChoiceCases(basePackageName, choiceType, caseNodes));
+ }
+ return generatedTypes;
+ }
+
+ private List<GeneratedType> generateTypesFromChoiceCases(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.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());
+ }
+ }
- constructGetter(typeBuilder, leafName, leafDesc, type);
- if (!leaf.isConfiguration()) {
- constructSetter(typeBuilder, leafName, leafDesc, type);
+ 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 Set<DataSchemaNode> childNodes = caseNode.getChildNodes();
+ if (childNodes != null) {
+ resolveDataSchemaNodes(basePackageName, caseTypeBuilder, childNodes);
}
- return true;
+ generatedTypes.add(caseTypeBuilder.toInstance());
}
}
- return false;
+
+ return generatedTypes;
}
- private boolean isImported(final SchemaPath leafPath,
- final SchemaPath typeDefPath) {
- if ((leafPath != null) && (leafPath.getPath() != null)
- && (typeDefPath != null) && (typeDefPath.getPath() != null)) {
+ private boolean resolveLeafSchemaNodeAsMethod(final GeneratedTypeBuilder typeBuilder, final LeafSchemaNode leaf) {
+ if ((leaf != null) && (typeBuilder != null)) {
+ final String leafName = leaf.getQName().getLocalName();
+ String leafDesc = leaf.getDescription();
+ if (leafDesc == null) {
+ leafDesc = "";
+ }
- final QName leafPathQName = leafPath.getPath().get(0);
- final QName typePathQName = typeDefPath.getPath().get(0);
+ if (leafName != null) {
+ final TypeDefinition<?> typeDef = leaf.getType();
- if ((leafPathQName != null)
- && (leafPathQName.getNamespace() != null)
- && (typePathQName != null)
- && (typePathQName.getNamespace() != null)) {
+ Type returnType = null;
+ if (typeDef instanceof EnumTypeDefinition) {
+ returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef);
+ final EnumTypeDefinition enumTypeDef = enumTypeDefFromExtendedType(typeDef);
+ final EnumBuilder enumBuilder = resolveInnerEnumFromTypeDefinition(enumTypeDef, leafName,
+ typeBuilder);
- return !leafPathQName.getNamespace().equals(
- typePathQName.getNamespace());
+ if (enumBuilder != null) {
+ 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);
+ return true;
+ }
}
}
return false;
}
- private boolean resolveLeafSchemaNodeAsProperty(
- final GeneratedTOBuilder toBuilder, final LeafSchemaNode leaf,
+ private boolean resolveLeafSchemaNodeAsProperty(final GeneratedTOBuilder toBuilder, final LeafSchemaNode leaf,
boolean isReadOnly) {
if ((leaf != null) && (toBuilder != null)) {
final String leafName = leaf.getQName().getLocalName();
final TypeDefinition<?> typeDef = leaf.getType();
// TODO: properly resolve enum types
- final Type javaType = typeProvider
- .javaTypeForSchemaDefinitionType(typeDef);
+ final Type returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef);
- final GeneratedPropertyBuilder propBuilder = toBuilder
- .addProperty(BindingGeneratorUtil
- .parseToClassName(leafName));
+ if (returnType != null) {
+ final GeneratedPropertyBuilder propBuilder = toBuilder.addProperty(parseToClassName(leafName));
- propBuilder.setReadOnly(isReadOnly);
- propBuilder.addReturnType(javaType);
- propBuilder.addComment(leafDesc);
+ propBuilder.setReadOnly(isReadOnly);
+ propBuilder.setReturnType(returnType);
+ propBuilder.setComment(leafDesc);
- toBuilder.addEqualsIdentity(propBuilder);
- toBuilder.addHashIdentity(propBuilder);
- toBuilder.addToStringProperty(propBuilder);
+ toBuilder.addEqualsIdentity(propBuilder);
+ toBuilder.addHashIdentity(propBuilder);
+ toBuilder.addToStringProperty(propBuilder);
- return true;
+ return true;
+ }
}
}
return false;
}
- private boolean resolveLeafListSchemaNode(
- final GeneratedTypeBuilder typeBuilder,
- final LeafListSchemaNode node) {
+ private boolean resolveLeafListSchemaNode(final GeneratedTypeBuilder typeBuilder, final LeafListSchemaNode node) {
if ((node != null) && (typeBuilder != null)) {
final String nodeName = node.getQName().getLocalName();
String nodeDesc = node.getDescription();
if (nodeName != null) {
final TypeDefinition<?> type = node.getType();
- final Type listType = Types.listTypeFor(typeProvider
- .javaTypeForSchemaDefinitionType(type));
+ final Type listType = Types.listTypeFor(typeProvider.javaTypeForSchemaDefinitionType(type));
constructGetter(typeBuilder, nodeName, nodeDesc, listType);
- if (!node.isConfiguration()) {
- constructSetter(typeBuilder, nodeName, nodeDesc, listType);
- }
return true;
}
}
return false;
}
- private boolean resolveContainerSchemaNode(
- final GeneratedTypeBuilder typeBuilder,
- final ContainerSchemaNode node) {
- if ((node != null) && (typeBuilder != null)) {
- final String nodeName = node.getQName().getLocalName();
+ private boolean resolveContainerSchemaNode(final String basePackageName, final GeneratedTypeBuilder typeBuilder,
+ final ContainerSchemaNode containerNode) {
+ if ((containerNode != null) && (typeBuilder != null)) {
+ final String nodeName = containerNode.getQName().getLocalName();
if (nodeName != null) {
- final GeneratedTypeBuilder rawGenType = addRawInterfaceDefinition(node);
- constructGetter(typeBuilder, nodeName, "", rawGenType);
+ final String packageName = packageNameForGeneratedType(basePackageName, containerNode.getPath());
+
+ final GeneratedTypeBuilder rawGenType = addDefaultInterfaceDefinition(packageName, containerNode);
+ constructGetter(typeBuilder, nodeName, containerNode.getDescription(), rawGenType);
return true;
}
return false;
}
- private boolean resolveListSchemaNode(
- final GeneratedTypeBuilder typeBuilder, final ListSchemaNode node) {
- if ((node != null) && (typeBuilder != null)) {
- final String nodeName = node.getQName().getLocalName();
+ private boolean resolveListSchemaNode(final String basePackageName, final GeneratedTypeBuilder typeBuilder,
+ final ListSchemaNode schemaNode) {
+ if ((schemaNode != null) && (typeBuilder != null)) {
+ final String listName = schemaNode.getQName().getLocalName();
- if (nodeName != null) {
- final GeneratedTypeBuilder rawGenType = addRawInterfaceDefinition(node);
- constructGetter(typeBuilder, nodeName, "",
- Types.listTypeFor(rawGenType));
- if (!node.isConfiguration()) {
- constructSetter(typeBuilder, nodeName, "",
- Types.listTypeFor(rawGenType));
- }
+ if (listName != null) {
+ final String packageName = packageNameForGeneratedType(basePackageName, schemaNode.getPath());
+ final GeneratedTypeBuilder rawGenType = addDefaultInterfaceDefinition(packageName, schemaNode);
+ constructGetter(typeBuilder, listName, schemaNode.getDescription(), Types.listTypeFor(rawGenType));
return true;
}
}
return false;
}
- private GeneratedTypeBuilder addRawInterfaceDefinition(
- final DataSchemaNode schemaNode) {
+ /**
+ * 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) {
+ final GeneratedTypeBuilder builder = addRawInterfaceDefinition(packageName, schemaNode, "");
+ builder.addImplementsType(Types.DATA_OBJECT);
+ builder.addImplementsType(Types.augmentableTypeFor(builder));
+ return builder;
+ }
+
+ /**
+ *
+ * @param packageName
+ * @param schemaNode
+ * @return
+ */
+ private GeneratedTypeBuilder addRawInterfaceDefinition(final String packageName, final SchemaNode schemaNode) {
+ return addRawInterfaceDefinition(packageName, schemaNode, "");
+ }
+
+ private GeneratedTypeBuilder addRawInterfaceDefinition(final String packageName, final SchemaNode schemaNode,
+ final String prefix) {
if (schemaNode == null) {
- return null;
+ throw new IllegalArgumentException("Data Schema Node cannot be NULL!");
+ }
+ if (packageName == null) {
+ throw new IllegalArgumentException("Package Name for Generated Type cannot be NULL!");
+ }
+ if (schemaNode.getQName() == null) {
+ throw new IllegalArgumentException("QName for Data Schema Node cannot be NULL!");
}
-
- final String packageName = BindingGeneratorUtil
- .packageNameForGeneratedType(basePackageName,
- schemaNode.getPath());
final String schemaNodeName = schemaNode.getQName().getLocalName();
+ if (schemaNodeName == null) {
+ throw new IllegalArgumentException("Local Name of QName for Data Schema Node cannot be NULL!");
+ }
- if ((packageName != null) && (schemaNode != null)
- && (schemaNodeName != null)) {
- final String genTypeName = BindingGeneratorUtil
- .parseToClassName(schemaNodeName);
- final GeneratedTypeBuilder newType = new GeneratedTypeBuilderImpl(
- packageName, genTypeName);
+ final String genTypeName;
+ if (prefix == null) {
+ genTypeName = parseToClassName(schemaNodeName);
+ } else {
+ genTypeName = prefix + parseToClassName(schemaNodeName);
+ }
- if (!genTypeBuilders.containsKey(packageName)) {
- final Map<String, GeneratedTypeBuilder> builders = new HashMap<String, GeneratedTypeBuilder>();
+ final GeneratedTypeBuilder newType = new GeneratedTypeBuilderImpl(packageName, genTypeName);
+ if (!genTypeBuilders.containsKey(packageName)) {
+ final Map<String, GeneratedTypeBuilder> builders = new HashMap<>();
+ builders.put(genTypeName, newType);
+ genTypeBuilders.put(packageName, builders);
+ } else {
+ final Map<String, GeneratedTypeBuilder> builders = genTypeBuilders.get(packageName);
+ if (!builders.containsKey(genTypeName)) {
builders.put(genTypeName, newType);
- genTypeBuilders.put(packageName, builders);
- } else {
- final Map<String, GeneratedTypeBuilder> builders = genTypeBuilders
- .get(packageName);
- if (!builders.containsKey(genTypeName)) {
- builders.put(genTypeName, newType);
- }
}
- return newType;
}
- return null;
+ return newType;
}
private String getterMethodName(final String methodName) {
final StringBuilder method = new StringBuilder();
method.append("get");
- method.append(BindingGeneratorUtil.parseToClassName(methodName));
+ method.append(parseToClassName(methodName));
return method.toString();
}
private String setterMethodName(final String methodName) {
final StringBuilder method = new StringBuilder();
method.append("set");
- method.append(BindingGeneratorUtil.parseToClassName(methodName));
+ method.append(parseToClassName(methodName));
return method.toString();
}
- private MethodSignatureBuilder constructGetter(
- final GeneratedTypeBuilder interfaceBuilder,
- final String schemaNodeName, final String comment,
- final Type returnType) {
- final MethodSignatureBuilder getMethod = interfaceBuilder
- .addMethod(getterMethodName(schemaNodeName));
+ private MethodSignatureBuilder constructGetter(final GeneratedTypeBuilder interfaceBuilder,
+ final String schemaNodeName, final String comment, final Type returnType) {
+ final MethodSignatureBuilder getMethod = interfaceBuilder.addMethod(getterMethodName(schemaNodeName));
- getMethod.addComment(comment);
- getMethod.addReturnType(returnType);
+ getMethod.setComment(comment);
+ getMethod.setReturnType(returnType);
return getMethod;
}
- private MethodSignatureBuilder constructSetter(
- final GeneratedTypeBuilder interfaceBuilder,
- final String schemaNodeName, final String comment,
- final Type parameterType) {
- final MethodSignatureBuilder setMethod = interfaceBuilder
- .addMethod(setterMethodName(schemaNodeName));
+ private MethodSignatureBuilder constructSetter(final GeneratedTypeBuilder interfaceBuilder,
+ final String schemaNodeName, final String comment, final Type parameterType) {
+ final MethodSignatureBuilder setMethod = interfaceBuilder.addMethod(setterMethodName(schemaNodeName));
- setMethod.addComment(comment);
- setMethod.addParameter(parameterType,
- BindingGeneratorUtil.parseToValidParamName(schemaNodeName));
- setMethod.addReturnType(Types.voidType());
+ setMethod.setComment(comment);
+ setMethod.addParameter(parameterType, parseToValidParamName(schemaNodeName));
+ setMethod.setReturnType(Types.voidType());
return setMethod;
}
- private String resolveBasePackageName(final URI moduleNamespace,
- final String yangVersion) {
- final StringBuilder packageNameBuilder = new StringBuilder();
-
- packageNameBuilder.append("org.opendaylight.yang.gen.v");
- packageNameBuilder.append(yangVersion);
- packageNameBuilder.append(".rev");
- packageNameBuilder.append(calendar.get(Calendar.YEAR));
- packageNameBuilder.append((calendar.get(Calendar.MONTH) + 1));
- packageNameBuilder.append(calendar.get(Calendar.DAY_OF_MONTH));
- packageNameBuilder.append(".");
+ private List<Type> listToGenType(final String basePackageName, final ListSchemaNode list) {
+ if (basePackageName == null) {
+ throw new IllegalArgumentException("Package Name for Generated Type cannot be NULL!");
+ }
+ if (list == null) {
+ throw new IllegalArgumentException("List Schema Node cannot be NULL!");
+ }
- String namespace = moduleNamespace.toString();
- namespace = namespace.replace(":", ".");
- namespace = namespace.replace("-", ".");
+ final String packageName = packageNameForGeneratedType(basePackageName, list.getPath());
+ final GeneratedTypeBuilder typeBuilder = resolveListTypeBuilder(packageName, list);
+ final List<String> listKeys = listKeys(list);
+ GeneratedTOBuilder genTOBuilder = resolveListKeyTOBuilder(packageName, list, listKeys);
- packageNameBuilder.append(namespace);
+ final Set<DataSchemaNode> schemaNodes = list.getChildNodes();
- return packageNameBuilder.toString();
+ for (final DataSchemaNode schemaNode : schemaNodes) {
+ if (schemaNode.isAugmenting()) {
+ continue;
+ }
+ addSchemaNodeToListBuilders(basePackageName, schemaNode, typeBuilder, genTOBuilder, listKeys);
+ }
+ return typeBuildersToGenTypes(typeBuilder, genTOBuilder);
}
- private List<Type> listToGenType(final ListSchemaNode list) {
- if (list == null) {
- return null;
- }
- final GeneratedTypeBuilder typeBuilder = resolveListTypeBuilder(list);
- final List<String> listKeys = listKeys(list);
- GeneratedTOBuilder genTOBuilder = null;
- if (listKeys.size() > 0) {
- genTOBuilder = resolveListKey(list);
+ private void addSchemaNodeToListBuilders(final String basePackageName, final DataSchemaNode schemaNode,
+ final GeneratedTypeBuilder typeBuilder, final GeneratedTOBuilder genTOBuilder, final List<String> listKeys) {
+ if (schemaNode == null) {
+ throw new IllegalArgumentException("Data Schema Node cannot be NULL!");
}
- final Set<DataSchemaNode> schemaNodes = list.getChildNodes();
- for (final DataSchemaNode node : schemaNodes) {
+ if (typeBuilder == null) {
+ throw new IllegalArgumentException("Generated Type Builder cannot be NULL!");
+ }
- if (node instanceof LeafSchemaNode) {
- final LeafSchemaNode leaf = (LeafSchemaNode) node;
- if (!isPartOfListKey(leaf, listKeys)) {
- resolveLeafSchemaNodeAsMethod(typeBuilder, leaf);
- } else {
- resolveLeafSchemaNodeAsProperty(genTOBuilder, leaf, true);
- }
- } else if (node instanceof LeafListSchemaNode) {
- resolveLeafListSchemaNode(typeBuilder,
- (LeafListSchemaNode) node);
- } else if (node instanceof ContainerSchemaNode) {
- resolveContainerSchemaNode(typeBuilder,
- (ContainerSchemaNode) node);
- } else if (node instanceof ListSchemaNode) {
- resolveListSchemaNode(typeBuilder, (ListSchemaNode) node);
+ if (schemaNode instanceof LeafSchemaNode) {
+ final LeafSchemaNode leaf = (LeafSchemaNode) schemaNode;
+ if (!isPartOfListKey(leaf, listKeys)) {
+ resolveLeafSchemaNodeAsMethod(typeBuilder, leaf);
+ } else {
+ resolveLeafSchemaNodeAsProperty(genTOBuilder, leaf, true);
}
+ } else if (schemaNode instanceof LeafListSchemaNode) {
+ resolveLeafListSchemaNode(typeBuilder, (LeafListSchemaNode) schemaNode);
+ } else if (schemaNode instanceof ContainerSchemaNode) {
+ resolveContainerSchemaNode(basePackageName, typeBuilder, (ContainerSchemaNode) schemaNode);
+ } else if (schemaNode instanceof ListSchemaNode) {
+ resolveListSchemaNode(basePackageName, typeBuilder, (ListSchemaNode) schemaNode);
+ }
+ }
+
+ private List<Type> typeBuildersToGenTypes(final GeneratedTypeBuilder typeBuilder, GeneratedTOBuilder genTOBuilder) {
+ final List<Type> genTypes = new ArrayList<>();
+ if (typeBuilder == null) {
+ throw new IllegalArgumentException("Generated Type Builder cannot be NULL!");
}
- final List<Type> genTypes = new ArrayList<Type>();
if (genTOBuilder != null) {
final GeneratedTransferObject genTO = genTOBuilder.toInstance();
- constructGetter(typeBuilder, genTO.getName(),
- "Returns Primary Key of Yang List Type", genTO);
+ constructGetter(typeBuilder, genTO.getName(), "Returns Primary Key of Yang List Type", genTO);
genTypes.add(genTO);
}
genTypes.add(typeBuilder.toInstance());
* @param list
* @return
*/
- private GeneratedTOBuilder resolveListKey(final ListSchemaNode list) {
- final String packageName = BindingGeneratorUtil
- .packageNameForGeneratedType(basePackageName, list.getPath());
+ private GeneratedTOBuilder resolveListKey(final String packageName, final ListSchemaNode list) {
final String listName = list.getQName().getLocalName() + "Key";
-
- return BindingGeneratorUtil.schemaNodeToTransferObjectBuilder(
- packageName, list, listName);
+ return schemaNodeToTransferObjectBuilder(packageName, list, listName);
}
- private boolean isPartOfListKey(final LeafSchemaNode leaf,
- final List<String> keys) {
+ private boolean isPartOfListKey(final LeafSchemaNode leaf, final List<String> keys) {
if ((leaf != null) && (keys != null) && (leaf.getQName() != null)) {
final String leafName = leaf.getQName().getLocalName();
if (keys.contains(leafName)) {
}
private List<String> listKeys(final ListSchemaNode list) {
- final List<String> listKeys = new ArrayList<String>();
+ final List<String> listKeys = new ArrayList<>();
if (list.getKeyDefinition() != null) {
final List<QName> keyDefinitions = list.getKeyDefinition();
return listKeys;
}
- private GeneratedTypeBuilder resolveListTypeBuilder(
- final ListSchemaNode list) {
- final String packageName = BindingGeneratorUtil
- .packageNameForGeneratedType(basePackageName,
- list.getPath());
+ private GeneratedTypeBuilder resolveListTypeBuilder(final String packageName, final ListSchemaNode list) {
+ if (packageName == null) {
+ throw new IllegalArgumentException("Package Name for Generated Type cannot be NULL!");
+ }
+ if (list == null) {
+ throw new IllegalArgumentException("List Schema Node cannot be NULL!");
+ }
+
final String schemaNodeName = list.getQName().getLocalName();
- final String genTypeName = BindingGeneratorUtil
- .parseToClassName(schemaNodeName);
+ final String genTypeName = parseToClassName(schemaNodeName);
GeneratedTypeBuilder typeBuilder = null;
- if (genTypeBuilders.containsKey(packageName)) {
- final Map<String, GeneratedTypeBuilder> builders = new HashMap<String, GeneratedTypeBuilder>();
+ final Map<String, GeneratedTypeBuilder> builders = genTypeBuilders.get(packageName);
+ if (builders != null) {
typeBuilder = builders.get(genTypeName);
-
- if (null == typeBuilder) {
- typeBuilder = addRawInterfaceDefinition(list);
- }
+ }
+ if (typeBuilder == null) {
+ typeBuilder = addDefaultInterfaceDefinition(packageName, list);
}
return typeBuilder;
}
+
+ private GeneratedTOBuilder resolveListKeyTOBuilder(final String packageName, final ListSchemaNode list,
+ final List<String> listKeys) {
+ GeneratedTOBuilder genTOBuilder = null;
+ if (listKeys.size() > 0) {
+ genTOBuilder = resolveListKey(packageName, list);
+ }
+ 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