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.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.*;
import org.opendaylight.controller.sal.binding.model.api.type.builder.*;
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.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 java.util.*;
+import java.util.concurrent.Future;
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;
-public class BindingGeneratorImpl implements BindingGenerator {
+public final class BindingGeneratorImpl implements BindingGenerator {
private Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders;
private TypeProvider typeProvider;
@Override
public List<Type> generateTypes(final SchemaContext context) {
if (context == null) {
- throw new IllegalArgumentException("Schema Context reference cannot be NULL");
+ throw new IllegalArgumentException("Schema Context reference "
+ + "cannot be NULL!");
}
if (context.getModules() == null) {
- throw new IllegalStateException("Schema Context does not contain defined modules!");
+ throw new IllegalStateException("Schema Context does not contain "
+ + "defined modules!");
}
- final List<Type> genTypes = new ArrayList<>();
+ 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) {
- final DataNodeIterator moduleIterator = new DataNodeIterator(
- module);
-
- final List<AugmentationSchema> sortedAugmentations = provideSortedAugmentations(module);
- final List<ContainerSchemaNode> schemaContainers = moduleIterator
- .allContainers();
- final List<ListSchemaNode> schemaLists = moduleIterator
- .allLists();
-
- final String basePackageName = moduleNamespaceToPackageName(module);
- if ((schemaContainers != null)
- && !schemaContainers.isEmpty()) {
- for (final ContainerSchemaNode container : schemaContainers) {
- genTypes.add(containerToGenType(basePackageName,
- container));
- }
- }
- if ((schemaLists != null) && !schemaLists.isEmpty()) {
- for (final ListSchemaNode list : schemaLists) {
- genTypes.addAll(listToGenType(basePackageName, list));
- }
+ generatedTypes.add(moduleToDataType(module));
+ generatedTypes.addAll(allTypeDefinitionsToGenTypes(module));
+ generatedTypes.addAll(allContainersToGenTypes(module));
+ generatedTypes.addAll(allListsToGenTypes(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(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;
+ }
- if ((sortedAugmentations != null)
- && !sortedAugmentations.isEmpty()) {
- for (final AugmentationSchema augment : sortedAugmentations) {
- genTypes.addAll(augmentationToGenTypes(basePackageName, augment));
+ 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 generatedTypes;
+ }
+
+ private List<Type> allContainersToGenTypes(final Module module) {
+ if (module == null) {
+ throw new IllegalArgumentException(
+ "Module reference cannot be NULL!");
+ }
- final GeneratedType genDataType = moduleToDataType(basePackageName, module);
- final List<GeneratedType> genRpcType = rpcMethodsToGenType(basePackageName, module);
- final List<Type> genNotifyType = notifycationsToGenType(basePackageName, module);
+ if (module.getName() == null) {
+ throw new IllegalArgumentException("Module name cannot be NULL!");
+ }
- if (genDataType != null) {
- genTypes.add(genDataType);
- }
- if (genRpcType != null) {
- genTypes.addAll(genRpcType);
- }
- if (genNotifyType != null) {
- genTypes.addAll(genNotifyType);
+ 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));
}
}
- genTypes.addAll(((TypeProviderImpl) typeProvider)
- .getGeneratedTypeDefs());
+ return generatedTypes;
+ }
+
+ private List<Type> allAugmentsToGenTypes(final Module module) {
+ if (module == null) {
+ throw new IllegalArgumentException(
+ "Module reference cannot be NULL!");
+ }
- return genTypes;
+ 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> provideSortedAugmentations(final Module module) {
+ private List<AugmentationSchema> resolveAugmentations(final Module module) {
if (module == null) {
- throw new IllegalArgumentException("Module reference cannot be 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 Set<AugmentationSchema> augmentations = module.getAugmentations();
final List<AugmentationSchema> sortedAugmentations = new ArrayList<>(
augmentations);
Collections.sort(sortedAugmentations,
new Comparator<AugmentationSchema>() {
@Override
- public int compare(
- AugmentationSchema augSchema1,
+ public int compare(AugmentationSchema augSchema1,
AugmentationSchema augSchema2) {
- if (augSchema1.getTargetPath().getPath()
- .size() > augSchema2
+ if (augSchema1.getTargetPath().getPath().size() > augSchema2
.getTargetPath().getPath().size()) {
return 1;
- } else if (augSchema1.getTargetPath()
- .getPath().size() < augSchema2
+ } else if (augSchema1.getTargetPath().getPath().size() < augSchema2
.getTargetPath().getPath().size()) {
return -1;
}
return sortedAugmentations;
}
- private GeneratedType moduleToDataType(final String basePackageName, final Module module) {
+ private GeneratedType moduleToDataType(final Module module) {
if (module == null) {
- throw new IllegalArgumentException("Module reference cannot be 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);
+ resolveDataSchemaNodes(basePackageName, moduleDataTypeBuilder,
+ dataNodes);
}
return moduleDataTypeBuilder.toInstance();
}
- 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 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());
+ MethodSignatureBuilder method = interfaceBuilder
+ .addMethod(rpcName);
+
+ 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.addReturnType(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));
+ }
+ }
+ List<ListSchemaNode> nLists = it.allLists();
+ if ((nLists != null) && !nLists.isEmpty()) {
+ for (final ListSchemaNode list : nLists) {
+ genRPCTypes.addAll(listToGenType(basePackageName,
+ list));
+ }
+ }
+ }
}
}
- return false;
+ genRPCTypes.add(interfaceBuilder.toInstance());
+ return genRPCTypes;
+ }
+
+ private List<Type> allNotificationsToGenType(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 "
+ + "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));
+ }
+ // Lists
+ for (ListSchemaNode node : it.allLists()) {
+ genNotifyTypes.addAll(listToGenType(basePackageName, node));
+ }
+ final GeneratedTypeBuilder notificationTypeBuilder = addRawInterfaceDefinition(
+ basePackageName, notification);
+ notificationTypeBuilder.addImplementsType(Types
+ .typeForClass(Notification.class));
+ // Notification object
+ resolveDataSchemaNodes(basePackageName,
+ notificationTypeBuilder, notification.getChildNodes());
+ genNotifyTypes.add(notificationTypeBuilder.toInstance());
+ }
+ }
+ return genNotifyTypes;
+ }
+
+ private List<Type> allIdentitiesToGenTypes(final Module module,
+ final SchemaContext context) {
+ List<Type> genTypes = new ArrayList<Type>();
+
+ final Set<IdentitySchemaNode> schemaIdentities = module.getIdentities();
+
+ final String basePackageName = moduleNamespaceToPackageName(module);
+
+ if (schemaIdentities != null && !schemaIdentities.isEmpty()) {
+ for (final IdentitySchemaNode identity : schemaIdentities) {
+ genTypes.add(identityToGenType(basePackageName, identity,
+ context));
+ }
+ }
+ return genTypes;
+ }
+
+ private GeneratedType identityToGenType(final String basePackageName,
+ IdentitySchemaNode identity, 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.addExtendsType(gto);
+ } else {
+ newType.addExtendsType(Types.getBaseIdentityTO());
+ }
+
+ return newType.toIdentityInstance();
+ }
+
+ private List<Type> allGroupingsToGenTypes(Module module) {
+ final List<Type> genTypes = new ArrayList<Type>();
+ final String basePackageName = moduleNamespaceToPackageName(module);
+ Set<GroupingDefinition> groupings = module.getGroupings();
+ if (groupings != null && !groupings.isEmpty()) {
+ for (final GroupingDefinition grouping : groupings) {
+ genTypes.add(groupingToGenType(basePackageName, grouping));
+ }
+ }
+ return genTypes;
+ }
+
+ 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 = addRawInterfaceDefinition(
+ packageName, grouping);
+
+ resolveDataSchemaNodes(basePackageName, typeBuilder, schemaNodes);
+ return typeBuilder.toInstance();
}
private EnumTypeDefinition enumTypeDefFromExtendedType(
return null;
}
- private EnumBuilder resolveEnumFromTypeDefinition(
+ private EnumBuilder resolveInnerEnumFromTypeDefinition(
final EnumTypeDefinition enumTypeDef, final String enumName,
final GeneratedTypeBuilder typeBuilder) {
if ((enumTypeDef != null) && (typeBuilder != null)
}
private GeneratedTypeBuilder moduleTypeBuilder(final Module module,
- final String postfix) {
+ final String postfix) {
if (module == null) {
- throw new IllegalArgumentException("Module reference cannot be NULL!");
+ throw new IllegalArgumentException(
+ "Module reference cannot be NULL!");
}
String packageName = moduleNamespaceToPackageName(module);
- final String moduleName = parseToClassName(module.getName())
- + postfix;
+ final String moduleName = parseToClassName(module.getName()) + postfix;
return new GeneratedTypeBuilderImpl(packageName, moduleName);
}
- private List<GeneratedType> rpcMethodsToGenType(final String basePackageName, final Module module) {
- if (module == null) {
- throw new IllegalArgumentException("Module reference cannot be NULL!");
- }
-
- final Set<RpcDefinition> rpcDefinitions = module.getRpcs();
- final List<GeneratedType> rpcTypes = new ArrayList<>();
-
- if ((rpcDefinitions != null) && !rpcDefinitions.isEmpty()) {
- for (final RpcDefinition rpc : rpcDefinitions) {
- if (rpc != null) {
- final List<DataNodeIterator> rpcInOut = new ArrayList<>();
- rpcInOut.add(new DataNodeIterator(rpc.getInput()));
- rpcInOut.add(new DataNodeIterator(rpc.getOutput()));
-
- for (DataNodeIterator it : rpcInOut) {
- List<ContainerSchemaNode> nContainers = it.allContainers();
- if ((nContainers != null) && !nContainers.isEmpty()) {
- for (final ContainerSchemaNode container : nContainers) {
- rpcTypes.add(containerToGenType(basePackageName, container));
- }
- }
- }
- }
- }
- }
- return rpcTypes;
- }
-
- private List<Type> notifycationsToGenType(final String basePackageName, final Module module) {
- if (module == null) {
- throw new IllegalArgumentException("Module reference cannot be NULL!");
- }
- final List<Type> notificationTypes = new ArrayList<>();
- final Set<NotificationDefinition> notifications = module
- .getNotifications();
-
- if ((notifications != null) && !notifications.isEmpty()) {
- for (final NotificationDefinition notification : notifications) {
- if (notification != null) {
- final List<DataNodeIterator> notifyChildren = new ArrayList<>();
-
- for (DataSchemaNode childNode : notification.getChildNodes()) {
- if (childNode instanceof DataNodeContainer) {
- notifyChildren.add(new DataNodeIterator((DataNodeContainer) childNode));
- }
- }
-
- for (DataNodeIterator it : notifyChildren) {
- List<ContainerSchemaNode> nContainers = it.allContainers();
- List<ListSchemaNode> nLists = it.allLists();
- if ((nContainers != null) && !nContainers.isEmpty()) {
- for (final ContainerSchemaNode container : nContainers) {
- notificationTypes.add(containerToGenType(basePackageName, container));
- }
- }
- if ((nLists != null) && !nLists.isEmpty()) {
- for (final ListSchemaNode list : nLists) {
-
- notificationTypes.addAll(listToGenType(basePackageName, list));
- }
- }
- }
- }
- }
- }
- return notificationTypes;
- }
-
private List<Type> augmentationToGenTypes(final String augmentPackageName,
- final AugmentationSchema augSchema) {
+ final AugmentationSchema augSchema) {
if (augmentPackageName == null) {
throw new IllegalArgumentException("Package Name cannot be NULL!");
}
// 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 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 targetPackageName = packageNameForGeneratedType(
+ targetBasePackage, targetSchemaNode.getPath());
- final String targetSchemaNodeName = targetSchemaNode.getQName().getLocalName();
- final Set<DataSchemaNode> augChildNodes = augSchema
- .getChildNodes();
+ final String targetSchemaNodeName = targetSchemaNode.getQName()
+ .getLocalName();
+ final Set<DataSchemaNode> augChildNodes = augSchema.getChildNodes();
final GeneratedTypeBuilder augTypeBuilder = addRawAugmentGenTypeDefinition(
- augmentPackageName, targetPackageName, targetSchemaNodeName, augSchema);
+ augmentPackageName, targetPackageName,
+ targetSchemaNodeName, augSchema);
if (augTypeBuilder != null) {
genTypes.add(augTypeBuilder.toInstance());
}
genTypeBuilders.put(augmentPackageName, augmentBuilders);
}
- final String augTypeName = augGenTypeName(augmentBuilders, targetTypeName);
- final Type targetTypeRef = new ReferencedTypeImpl(targetPackageName, targetTypeName);
- final Set<DataSchemaNode> augChildNodes = augSchema
- .getChildNodes();
+ 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
.augmentationTypeFor(targetTypeRef));
- augSchemaNodeToMethods(augmentPackageName, augTypeBuilder, augChildNodes);
+ augSchemaNodeToMethods(augmentPackageName, augTypeBuilder,
+ augChildNodes);
augmentBuilders.put(augTypeName, augTypeBuilder);
return augTypeBuilder;
}
- private List<Type> augmentationBodyToGenTypes(final String augBasePackageName,
- final Set<DataSchemaNode> augChildNodes) {
+ 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 ((augContainers != null) && !augContainers.isEmpty()) {
for (final ContainerSchemaNode container : augContainers) {
- genTypes.add(containerToGenType(augBasePackageName, container));
+ genTypes.add(containerToGenType(augBasePackageName,
+ container));
}
}
if ((augLists != null) && !augLists.isEmpty()) {
for (final ListSchemaNode list : augLists) {
-// final String listPackageName = packageNameForAugmentedType(
-// augBasePackageName, list.getPath());
genTypes.addAll(listToGenType(augBasePackageName, list));
}
}
}
private GeneratedType containerToGenType(final String basePackageName,
- ContainerSchemaNode containerNode) {
+ ContainerSchemaNode containerNode) {
if (containerNode == null) {
return null;
}
- final String packageName = packageNameForGeneratedType(
- basePackageName, containerNode.getPath());
+ final String packageName = packageNameForGeneratedType(basePackageName,
+ containerNode.getPath());
final Set<DataSchemaNode> schemaNodes = containerNode.getChildNodes();
final GeneratedTypeBuilder typeBuilder = addRawInterfaceDefinition(
packageName, containerNode);
if (schemaNode.isAugmenting()) {
continue;
}
- addSchemaNodeToBuilderAsMethod(basePackageName, schemaNode, typeBuilder);
+ addSchemaNodeToBuilderAsMethod(basePackageName, schemaNode,
+ typeBuilder);
}
}
return typeBuilder;
if ((schemaNodes != null) && (typeBuilder != null)) {
for (final DataSchemaNode schemaNode : schemaNodes) {
if (schemaNode.isAugmenting()) {
- addSchemaNodeToBuilderAsMethod(basePackageName, schemaNode, typeBuilder);
+ addSchemaNodeToBuilderAsMethod(basePackageName, schemaNode,
+ typeBuilder);
}
}
}
return typeBuilder;
}
- private void addSchemaNodeToBuilderAsMethod(
- final String basePackageName,
+ private void addSchemaNodeToBuilderAsMethod(final String basePackageName,
final DataSchemaNode schemaNode,
final GeneratedTypeBuilder typeBuilder) {
if (schemaNode != null && typeBuilder != null) {
final TypeDefinition<?> typeDef = leaf.getType();
Type returnType = null;
- if (!(typeDef instanceof EnumTypeDefinition)
- && !isDerivedFromEnumerationType(typeDef)) {
+ if (!(typeDef instanceof EnumTypeDefinition)) {
returnType = 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) {
- returnType = new ReferencedTypeImpl(
- enumBuilder.getPackageName(),
- enumBuilder.getName());
- }
+ final EnumTypeDefinition enumTypeDef = enumTypeDefFromExtendedType(typeDef);
+ final EnumBuilder enumBuilder = resolveInnerEnumFromTypeDefinition(
+ enumTypeDef, leafName, typeBuilder);
+
+ if (enumBuilder != null) {
+ returnType = new ReferencedTypeImpl(
+ enumBuilder.getPackageName(),
+ enumBuilder.getName());
}
+ ((TypeProviderImpl) typeProvider).putReferencedType(
+ leaf.getPath(), returnType);
}
-
if (returnType != null) {
constructGetter(typeBuilder, leafName, leafDesc, returnType);
if (!leaf.isConfiguration()) {
- constructSetter(typeBuilder, leafName, leafDesc, returnType);
+ constructSetter(typeBuilder, leafName, leafDesc,
+ returnType);
}
return true;
}
return false;
}
- private boolean isImported(final SchemaPath leafPath,
- final SchemaPath typeDefPath) {
- if ((leafPath != null) && (leafPath.getPath() != null)
- && (typeDefPath != null) && (typeDefPath.getPath() != null)) {
-
- final QName leafPathQName = leafPath.getPath().get(0);
- final QName typePathQName = typeDefPath.getPath().get(0);
-
- if ((leafPathQName != null)
- && (leafPathQName.getNamespace() != null)
- && (typePathQName != null)
- && (typePathQName.getNamespace() != null)) {
-
- return !leafPathQName.getNamespace().equals(
- typePathQName.getNamespace());
- }
- }
- return false;
- }
-
private boolean resolveLeafSchemaNodeAsProperty(
final GeneratedTOBuilder toBuilder, final LeafSchemaNode leaf,
boolean isReadOnly) {
}
private boolean resolveContainerSchemaNode(final String basePackageName,
- final GeneratedTypeBuilder typeBuilder,
- final ContainerSchemaNode containerNode) {
+ final GeneratedTypeBuilder typeBuilder,
+ final ContainerSchemaNode containerNode) {
if ((containerNode != null) && (typeBuilder != null)) {
final String nodeName = containerNode.getQName().getLocalName();
}
private boolean resolveListSchemaNode(final String basePackageName,
- final GeneratedTypeBuilder typeBuilder,
- final ListSchemaNode schemaNode) {
+ final GeneratedTypeBuilder typeBuilder,
+ final ListSchemaNode schemaNode) {
if ((schemaNode != null) && (typeBuilder != null)) {
final String listName = schemaNode.getQName().getLocalName();
}
private GeneratedTypeBuilder addRawInterfaceDefinition(
- final String packageName, final DataSchemaNode schemaNode) {
+ 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;
}
final String schemaNodeName = schemaNode.getQName().getLocalName();
if ((packageName != null) && (schemaNodeName != null)) {
- final String genTypeName = parseToClassName(schemaNodeName);
+ final String genTypeName = prefix + parseToClassName(schemaNodeName)
+ ;
final GeneratedTypeBuilder newType = new GeneratedTypeBuilderImpl(
packageName, genTypeName);
return setMethod;
}
-
private List<Type> listToGenType(final String basePackageName,
- final ListSchemaNode list) {
+ final ListSchemaNode list) {
if (basePackageName == null) {
throw new IllegalArgumentException(
"Package Name for Generated Type cannot be NULL!");
"List Schema Node cannot be NULL!");
}
- final String packageName = packageNameForGeneratedType(
- basePackageName, list.getPath());
+ final String packageName = packageNameForGeneratedType(basePackageName,
+ list.getPath());
final GeneratedTypeBuilder typeBuilder = resolveListTypeBuilder(
packageName, list);
final List<String> listKeys = listKeys(list);
if (schemaNode.isAugmenting()) {
continue;
}
- addSchemaNodeToListBuilders(basePackageName, schemaNode, typeBuilder,
- genTOBuilder, listKeys);
- }
-
-// if (list.isAugmenting()) {
-// for (final DataSchemaNode schemaNode : schemaNodes) {
-// if (schemaNode.isAugmenting()) {
-// addSchemaNodeToListBuilders(basePackageName, schemaNode, typeBuilder,
-// genTOBuilder, listKeys);
-// }
-// }
-// } else {
-// for (final DataSchemaNode schemaNode : schemaNodes) {
-// if (schemaNode.isAugmenting()) {
-// continue;
-// }
-// addSchemaNodeToListBuilders(basePackageName, schemaNode, typeBuilder,
-// genTOBuilder, listKeys);
-// }
-// }
+ addSchemaNodeToListBuilders(basePackageName, schemaNode,
+ typeBuilder, genTOBuilder, listKeys);
+ }
return typeBuildersToGenTypes(typeBuilder, genTOBuilder);
}
private void addSchemaNodeToListBuilders(final String basePackageName,
- final DataSchemaNode schemaNode,
- final GeneratedTypeBuilder typeBuilder,
- final GeneratedTOBuilder genTOBuilder,
- final List<String> listKeys) {
+ 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!");
resolveContainerSchemaNode(basePackageName, typeBuilder,
(ContainerSchemaNode) schemaNode);
} else if (schemaNode instanceof ListSchemaNode) {
- resolveListSchemaNode(basePackageName, typeBuilder, (ListSchemaNode) schemaNode);
+ resolveListSchemaNode(basePackageName, typeBuilder,
+ (ListSchemaNode) schemaNode);
}
-
}
private List<Type> typeBuildersToGenTypes(
* @return
*/
private GeneratedTOBuilder resolveListKey(final String packageName,
- final ListSchemaNode list) {
+ final ListSchemaNode list) {
final String listName = list.getQName().getLocalName() + "Key";
return schemaNodeToTransferObjectBuilder(packageName, list, listName);
}
private boolean isPartOfListKey(final LeafSchemaNode leaf,
- final List<String> keys) {
+ final List<String> keys) {
if ((leaf != null) && (keys != null) && (leaf.getQName() != null)) {
final String leafName = leaf.getQName().getLocalName();
if (keys.contains(leafName)) {
final String genTypeName = parseToClassName(schemaNodeName);
GeneratedTypeBuilder typeBuilder = null;
- final Map<String, GeneratedTypeBuilder> builders = genTypeBuilders.get(packageName);
+ final Map<String, GeneratedTypeBuilder> builders = genTypeBuilders
+ .get(packageName);
if (builders != null) {
typeBuilder = builders.get(genTypeName);
}
if (listKeys.size() > 0) {
genTOBuilder = resolveListKey(packageName, list);
}
-
return genTOBuilder;
}
}
Code Review / controller.git / blobdiff