+ private EnumBuilder resolveInnerEnumFromTypeDefinition(
+ final EnumTypeDefinition enumTypeDef, final String enumName,
+ final GeneratedTypeBuilder typeBuilder) {
+ if ((enumTypeDef != null) && (typeBuilder != null)
+ && (enumTypeDef.getQName() != null)
+ && (enumTypeDef.getQName().getLocalName() != null)) {
+
+ final String enumerationName = parseToClassName(enumName);
+ final EnumBuilder enumBuilder = typeBuilder
+ .addEnumeration(enumerationName);
+
+ if (enumBuilder != null) {
+ final List<EnumPair> enums = enumTypeDef.getValues();
+ if (enums != null) {
+ int listIndex = 0;
+ for (final EnumPair enumPair : enums) {
+ if (enumPair != null) {
+ final String enumPairName = parseToClassName(enumPair
+ .getName());
+ Integer enumPairValue = enumPair.getValue();
+
+ if (enumPairValue == null) {
+ enumPairValue = listIndex;
+ }
+ enumBuilder.addValue(enumPairName, enumPairValue);
+ listIndex++;
+ }
+ }
+ }
+ return enumBuilder;
+ }
+ }
+ return null;
+ }
+
+ 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).");
+ }
+
+ 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();
+ final GeneratedTypeBuilder augTypeBuilder = addRawAugmentGenTypeDefinition(
+ augmentPackageName, targetPackageName,
+ targetSchemaNodeName, augSchema);
+ if (augTypeBuilder != null) {
+ genTypes.add(augTypeBuilder.toInstance());
+ }
+ genTypes.addAll(augmentationBodyToGenTypes(augmentPackageName,
+ augChildNodes));
+
+ }
+ 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);
+ }
+
+ 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));
+ }
+ }
+ }
+
+ for (final DataNodeIterator it : augSchemaIts) {
+ final List<ContainerSchemaNode> augContainers = it.allContainers();
+ final List<ListSchemaNode> augLists = it.allLists();
+
+ if ((augContainers != null) && !augContainers.isEmpty()) {
+ for (final ContainerSchemaNode container : augContainers) {
+ genTypes.add(containerToGenType(augBasePackageName,
+ container));
+ }
+ }
+ if ((augLists != null) && !augLists.isEmpty()) {
+ for (final ListSchemaNode list : augLists) {
+ genTypes.addAll(listToGenType(augBasePackageName, list));
+ }
+ }
+ }
+ return genTypes;
+ }
+
+ 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) {