X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=opendaylight%2Fsal%2Fyang-prototype%2Fcode-generator%2Fbinding-generator-impl%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fsal%2Fbinding%2Fyang%2Ftypes%2FTypeProviderImpl.java;h=f650004ba22e92d9bb419305edcd4e1d16c81540;hb=2f14a41bbd09010114116aef1499641f7251bf83;hp=bb5e80a5257e0153d9ccc24384f319381744eb50;hpb=2a42a9c68c2149801f3c26d0f4c46cc857cffb00;p=controller.git

diff --git a/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/main/java/org/opendaylight/controller/sal/binding/yang/types/TypeProviderImpl.java b/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/main/java/org/opendaylight/controller/sal/binding/yang/types/TypeProviderImpl.java
index bb5e80a525..f650004ba2 100644
--- a/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/main/java/org/opendaylight/controller/sal/binding/yang/types/TypeProviderImpl.java
+++ b/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/main/java/org/opendaylight/controller/sal/binding/yang/types/TypeProviderImpl.java
@@ -7,38 +7,66 @@
  */
 package org.opendaylight.controller.sal.binding.yang.types;
 
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Queue;
-import java.util.Set;
-
+import org.apache.commons.lang.StringEscapeUtils;
+import org.opendaylight.controller.binding.generator.util.ReferencedTypeImpl;
+import org.opendaylight.controller.binding.generator.util.TypeConstants;
 import org.opendaylight.controller.binding.generator.util.Types;
+import org.opendaylight.controller.binding.generator.util.generated.type.builder.EnumerationBuilderImpl;
+import org.opendaylight.controller.binding.generator.util.generated.type.builder.GeneratedTOBuilderImpl;
 import org.opendaylight.controller.sal.binding.generator.spi.TypeProvider;
+import org.opendaylight.controller.sal.binding.model.api.Enumeration;
+import org.opendaylight.controller.sal.binding.model.api.GeneratedTransferObject;
 import org.opendaylight.controller.sal.binding.model.api.Type;
+import org.opendaylight.controller.sal.binding.model.api.type.builder.EnumBuilder;
+import org.opendaylight.controller.sal.binding.model.api.type.builder.GeneratedPropertyBuilder;
+import org.opendaylight.controller.sal.binding.model.api.type.builder.GeneratedTOBuilder;
+import org.opendaylight.controller.sal.binding.model.api.type.builder.GeneratedTypeBuilder;
 import org.opendaylight.controller.yang.common.QName;
-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.LeafListSchemaNode;
-import org.opendaylight.controller.yang.model.api.LeafSchemaNode;
-import org.opendaylight.controller.yang.model.api.ListSchemaNode;
-import org.opendaylight.controller.yang.model.api.Module;
-import org.opendaylight.controller.yang.model.api.ModuleImport;
-import org.opendaylight.controller.yang.model.api.RevisionAwareXPath;
-import org.opendaylight.controller.yang.model.api.SchemaContext;
-import org.opendaylight.controller.yang.model.api.SchemaPath;
-import org.opendaylight.controller.yang.model.api.TypeDefinition;
-import org.opendaylight.controller.yang.model.api.type.IdentityrefTypeDefinition;
-import org.opendaylight.controller.yang.model.api.type.LeafrefTypeDefinition;
+import org.opendaylight.controller.yang.model.api.*;
+import org.opendaylight.controller.yang.model.api.type.*;
+import org.opendaylight.controller.yang.model.api.type.BitsTypeDefinition.Bit;
+import org.opendaylight.controller.yang.model.api.type.EnumTypeDefinition.EnumPair;
 import org.opendaylight.controller.yang.model.util.ExtendedType;
-import org.opendaylight.controller.yang.model.util.Leafref;
 
-public class TypeProviderImpl implements TypeProvider {
+import org.opendaylight.controller.yang.model.util.StringType;
+import org.opendaylight.controller.yang.model.util.UnionType;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+
+import static org.opendaylight.controller.binding.generator.util.BindingGeneratorUtil.*;
+import static org.opendaylight.controller.yang.model.util.SchemaContextUtil.*;
 
-    private SchemaContext schemaContext;
+public final class TypeProviderImpl implements TypeProvider {
+
+    private final SchemaContext schemaContext;
+    private Map<String, Map<String, Type>> genTypeDefsContextMap;
+    private final Map<SchemaPath, Type> referencedTypes;
+
+    public TypeProviderImpl(final SchemaContext schemaContext) {
+        if (schemaContext == null) {
+            throw new IllegalArgumentException("Schema Context cannot be null!");
+        }
 
-    public TypeProviderImpl(SchemaContext schemaContext) {
         this.schemaContext = schemaContext;
+        this.genTypeDefsContextMap = new HashMap<>();
+        this.referencedTypes = new HashMap<>();
+        resolveTypeDefsFromContext();
+    }
+
+    public void putReferencedType(final SchemaPath refTypePath, final Type refType) {
+        if (refTypePath == null) {
+            throw new IllegalArgumentException("Path reference of " + "Enumeration Type Definition cannot be NULL!");
+        }
+
+        if (refType == null) {
+            throw new IllegalArgumentException("Reference to Enumeration " + "Type cannot be NULL!");
+        }
+        referencedTypes.put(refTypePath, refType);
     }
 
     /*
@@ -49,73 +77,168 @@ public class TypeProviderImpl implements TypeProvider {
      */
     @Override
     public Type javaTypeForYangType(String type) {
-        Type t = BaseYangTypes.BASE_YANG_TYPES_PROVIDER
-                .javaTypeForYangType(type);
+        Type t = BaseYangTypes.BASE_YANG_TYPES_PROVIDER.javaTypeForYangType(type);
         return t;
     }
 
     @Override
     public Type javaTypeForSchemaDefinitionType(final TypeDefinition<?> typeDefinition) {
         Type returnType = null;
-        if (typeDefinition != null) {
-            if (typeDefinition instanceof Leafref) {
+        if (typeDefinition == null) {
+            throw new IllegalArgumentException("Type Definition cannot be NULL!");
+        }
+        if (typeDefinition.getQName() == null) {
+            throw new IllegalArgumentException(
+                    "Type Definition cannot have non specified QName (QName cannot be NULL!)");
+        }
+        if (typeDefinition.getQName().getLocalName() == null) {
+            throw new IllegalArgumentException("Type Definitions Local Name cannot be NULL!");
+        }
+        final String typedefName = typeDefinition.getQName().getLocalName();
+        if (typeDefinition instanceof ExtendedType) {
+            final TypeDefinition<?> baseTypeDef = baseTypeDefForExtendedType(typeDefinition);
+
+            if (baseTypeDef instanceof LeafrefTypeDefinition) {
+                final LeafrefTypeDefinition leafref = (LeafrefTypeDefinition) baseTypeDef;
+                returnType = provideTypeForLeafref(leafref);
+            } else if (baseTypeDef instanceof IdentityrefTypeDefinition) {
+                final IdentityrefTypeDefinition idref = (IdentityrefTypeDefinition) baseTypeDef;
+                returnType = returnTypeForIdentityref(idref);
+            } else if (baseTypeDef instanceof EnumTypeDefinition) {
+                final EnumTypeDefinition enumTypeDef = (EnumTypeDefinition) baseTypeDef;
+                returnType = resolveEnumFromTypeDefinition(enumTypeDef, typedefName);
+            } else {
+                final Module module = findParentModuleForTypeDefinition(schemaContext, typeDefinition);
+                if (module != null) {
+                    final Map<String, Type> genTOs = genTypeDefsContextMap.get(module.getName());
+                    if (genTOs != null) {
+                        returnType = genTOs.get(typedefName);
+                    }
+                    if (returnType == null) {
+                        returnType = BaseYangTypes.BASE_YANG_TYPES_PROVIDER
+                                .javaTypeForSchemaDefinitionType(baseTypeDef);
+                    }
+                }
+            }
+        } else {
+            if (typeDefinition instanceof LeafrefTypeDefinition) {
                 final LeafrefTypeDefinition leafref = (LeafrefTypeDefinition) typeDefinition;
                 returnType = provideTypeForLeafref(leafref);
             } else if (typeDefinition instanceof IdentityrefTypeDefinition) {
-
-            } else if (typeDefinition instanceof ExtendedType) {
-                final TypeDefinition<?> baseType = typeDefinition.getBaseType(); 
-                return javaTypeForSchemaDefinitionType(baseType);
+                final IdentityrefTypeDefinition idref = (IdentityrefTypeDefinition) typeDefinition;
+                returnType = returnTypeForIdentityref(idref);
+            } else {
+                returnType = BaseYangTypes.BASE_YANG_TYPES_PROVIDER.javaTypeForSchemaDefinitionType(typeDefinition);
             }
-            else {
-                returnType = baseTypeForExtendedType(typeDefinition);
+        }
+        // TODO: add throw exception when we will be able to resolve ALL yang
+        // types!
+        // if (returnType == null) {
+        // throw new IllegalArgumentException("Type Provider can't resolve " +
+        // "type for specified Type Definition " + typedefName);
+        // }
+        return returnType;
+    }
+
+    private Type returnTypeForIdentityref(IdentityrefTypeDefinition idref) {
+        QName baseIdQName = idref.getIdentity();
+        Module module = schemaContext.findModuleByNamespace(baseIdQName.getNamespace());
+        IdentitySchemaNode identity = null;
+        for (IdentitySchemaNode id : module.getIdentities()) {
+            if (id.getQName().equals(baseIdQName)) {
+                identity = id;
             }
         }
+        if (identity == null) {
+            throw new IllegalArgumentException("Target identity '" + baseIdQName + "' do not exists");
+        }
+
+        final String basePackageName = moduleNamespaceToPackageName(module);
+        final String packageName = packageNameForGeneratedType(basePackageName, identity.getPath());
+        final String genTypeName = parseToClassName(identity.getQName().getLocalName());
+
+        Type baseType = Types.typeForClass(Class.class);
+        Type paramType = Types.wildcardTypeFor(packageName, genTypeName);
+        Type returnType = Types.parameterizedTypeFor(baseType, paramType);
         return returnType;
     }
-    
-    public Type baseTypeForExtendedType(final TypeDefinition<?> typeDefinition) {
+
+    public Type generatedTypeForExtendedDefinitionType(final TypeDefinition<?> typeDefinition) {
         Type returnType = null;
-        if (typeDefinition != null) {
-            if (typeDefinition instanceof ExtendedType) {
-                final TypeDefinition<?> extType = typeDefinition.getBaseType(); 
-                return baseTypeForExtendedType(extType);
-            } else {
-                returnType = BaseYangTypes.BASE_YANG_TYPES_PROVIDER
-                        .javaTypeForSchemaDefinitionType(typeDefinition);
+        if (typeDefinition == null) {
+            throw new IllegalArgumentException("Type Definition cannot be NULL!");
+        }
+        if (typeDefinition.getQName() == null) {
+            throw new IllegalArgumentException(
+                    "Type Definition cannot have non specified QName (QName cannot be NULL!)");
+        }
+        if (typeDefinition.getQName() == null) {
+            throw new IllegalArgumentException("Type Definitions Local Name cannot be NULL!");
+        }
+
+        final String typedefName = typeDefinition.getQName().getLocalName();
+        if (typeDefinition instanceof ExtendedType) {
+            final TypeDefinition<?> baseTypeDef = baseTypeDefForExtendedType(typeDefinition);
+
+            if (!(baseTypeDef instanceof LeafrefTypeDefinition) && !(baseTypeDef instanceof IdentityrefTypeDefinition)) {
+                final Module module = findParentModuleForTypeDefinition(schemaContext, typeDefinition);
+
+                if (module != null) {
+                    final Map<String, Type> genTOs = genTypeDefsContextMap.get(module.getName());
+                    if (genTOs != null) {
+                        returnType = genTOs.get(typedefName);
+                    }
+                }
             }
         }
         return returnType;
     }
-    
+
+    private TypeDefinition<?> baseTypeDefForExtendedType(final TypeDefinition<?> extendTypeDef) {
+        if (extendTypeDef == null) {
+            throw new IllegalArgumentException("Type Definiition reference cannot be NULL!");
+        }
+        final TypeDefinition<?> baseTypeDef = extendTypeDef.getBaseType();
+        if (baseTypeDef instanceof ExtendedType) {
+            return baseTypeDefForExtendedType(baseTypeDef);
+        } else {
+            return baseTypeDef;
+        }
+
+    }
+
     public Type provideTypeForLeafref(final LeafrefTypeDefinition leafrefType) {
         Type returnType = null;
-        if ((leafrefType != null) && (leafrefType.getPathStatement() != null)
-                && (leafrefType.getPath() != null)) {
+        if (leafrefType == null) {
+            throw new IllegalArgumentException("Leafref Type Definition reference cannot be NULL!");
+        }
 
-            final RevisionAwareXPath xpath = leafrefType.getPathStatement();
-            final String strXPath = xpath.toString();
+        if (leafrefType.getPathStatement() == null) {
+            throw new IllegalArgumentException("The Path Statement for Leafref Type Definition cannot be NULL!");
+        }
 
-            if (strXPath != null) {
-                if (strXPath.matches(".*//[.* | .*//].*")) {
-                    returnType = Types.typeForClass(Object.class);
-                } else {
-                    final Module module = resolveModuleFromSchemaPath(leafrefType
-                            .getPath());
-                    if (module != null) {
-                        Queue<String> leafrefPath;
-                        if (!xpath.isAbsolute()) {
-                            leafrefPath = resolveRelativeXPath(xpath,
-                                    leafrefType.getPath());
-                        } else {
-                            leafrefPath = xpathToPrefixedPath(strXPath,
-                                    module.getName());
-                        }
-                        if (leafrefPath != null) {
-                            final DataSchemaNode dataNode = findSchemaNodeForGivenPath(
-                                    module, leafrefPath);
-                            returnType = resolveTypeFromDataSchemaNode(dataNode);
-                        }
+        final RevisionAwareXPath xpath = leafrefType.getPathStatement();
+        final String strXPath = xpath.toString();
+
+        if (strXPath != null) {
+            if (strXPath.contains("[")) {
+                returnType = Types.typeForClass(Object.class);
+            } else {
+                final Module module = findParentModuleForTypeDefinition(schemaContext, leafrefType);
+                if (module != null) {
+                    final DataSchemaNode dataNode;
+                    if (xpath.isAbsolute()) {
+                        dataNode = findDataSchemaNode(schemaContext, module, xpath);
+                    } else {
+                        dataNode = findDataSchemaNodeForRelativeXPath(schemaContext, module, leafrefType, xpath);
+                    }
+
+                    if (leafContainsEnumDefinition(dataNode)) {
+                        returnType = referencedTypes.get(dataNode.getPath());
+                    } else if (leafListContainsEnumDefinition(dataNode)) {
+                        returnType = Types.listTypeFor(referencedTypes.get(dataNode.getPath()));
+                    } else {
+                        returnType = resolveTypeFromDataSchemaNode(dataNode);
                     }
                 }
             }
@@ -123,6 +246,97 @@ public class TypeProviderImpl implements TypeProvider {
         return returnType;
     }
 
+    private boolean leafContainsEnumDefinition(final DataSchemaNode dataNode) {
+        if (dataNode instanceof LeafSchemaNode) {
+            final LeafSchemaNode leaf = (LeafSchemaNode) dataNode;
+            if (leaf.getType() instanceof EnumTypeDefinition) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private boolean leafListContainsEnumDefinition(final DataSchemaNode dataNode) {
+        if (dataNode instanceof LeafListSchemaNode) {
+            final LeafListSchemaNode leafList = (LeafListSchemaNode) dataNode;
+            if (leafList.getType() instanceof EnumTypeDefinition) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private Enumeration resolveEnumFromTypeDefinition(final EnumTypeDefinition enumTypeDef, final String enumName) {
+        if (enumTypeDef == null) {
+            throw new IllegalArgumentException("EnumTypeDefinition reference cannot be NULL!");
+        }
+        if (enumTypeDef.getValues() == null) {
+            throw new IllegalArgumentException("EnumTypeDefinition MUST contain at least ONE value definition!");
+        }
+        if (enumTypeDef.getQName() == null) {
+            throw new IllegalArgumentException("EnumTypeDefinition MUST contain NON-NULL QName!");
+        }
+        if (enumTypeDef.getQName().getLocalName() == null) {
+            throw new IllegalArgumentException("Local Name in EnumTypeDefinition QName cannot be NULL!");
+        }
+
+        final String enumerationName = parseToClassName(enumName);
+
+        Module module = findParentModuleForTypeDefinition(schemaContext, enumTypeDef);
+        final String basePackageName = moduleNamespaceToPackageName(module);
+
+        final EnumBuilder enumBuilder = new EnumerationBuilderImpl(basePackageName, enumerationName);
+        updateEnumPairsFromEnumTypeDef(enumTypeDef, enumBuilder);
+        return enumBuilder.toInstance(null);
+    }
+
+    private EnumBuilder resolveInnerEnumFromTypeDefinition(final EnumTypeDefinition enumTypeDef, final String enumName,
+            final GeneratedTypeBuilder typeBuilder) {
+        if (enumTypeDef == null) {
+            throw new IllegalArgumentException("EnumTypeDefinition reference cannot be NULL!");
+        }
+        if (enumTypeDef.getValues() == null) {
+            throw new IllegalArgumentException("EnumTypeDefinition MUST contain at least ONE value definition!");
+        }
+        if (enumTypeDef.getQName() == null) {
+            throw new IllegalArgumentException("EnumTypeDefinition MUST contain NON-NULL QName!");
+        }
+        if (enumTypeDef.getQName().getLocalName() == null) {
+            throw new IllegalArgumentException("Local Name in EnumTypeDefinition QName cannot be NULL!");
+        }
+        if (typeBuilder == null) {
+            throw new IllegalArgumentException("Generated Type Builder reference cannot be NULL!");
+        }
+
+        final String enumerationName = parseToClassName(enumName);
+        final EnumBuilder enumBuilder = typeBuilder.addEnumeration(enumerationName);
+
+        updateEnumPairsFromEnumTypeDef(enumTypeDef, enumBuilder);
+
+        return enumBuilder;
+    }
+
+    private void updateEnumPairsFromEnumTypeDef(final EnumTypeDefinition enumTypeDef, final EnumBuilder enumBuilder) {
+        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++;
+                    }
+                }
+            }
+        }
+    }
+
     private Type resolveTypeFromDataSchemaNode(final DataSchemaNode dataNode) {
         Type returnType = null;
         if (dataNode != null) {
@@ -137,149 +351,381 @@ public class TypeProviderImpl implements TypeProvider {
         return returnType;
     }
 
-    /**
-     * Search which starts from root of Module.
-     * 
-     * @param module
-     * @param prefixedPath
-     * @return
-     */
-    private DataSchemaNode findSchemaNodeForGivenPath(final Module module,
-            final Queue<String> prefixedPath) {
-        if ((module != null) && (prefixedPath != null)) {
-            DataNodeContainer nextContainer = module;
-            final String modulePrefix = module.getPrefix();
-            
-            String childNodeName = null;
-            DataSchemaNode schemaNode = null;
-            while ((nextContainer != null) && (prefixedPath.size() > 0)) {
-                childNodeName = prefixedPath.poll();
-                if (childNodeName.contains(":")) {
-                    final String[] prefixedChildNode = childNodeName.split(":");
-                    if ((modulePrefix != null)
-                            && modulePrefix.equals(prefixedChildNode[0])) {
-
-                        childNodeName = prefixedChildNode[1];
-                    } else {
-                        final Module nextModule = resolveModuleForPrefix(
-                                prefixedChildNode[0], module);
-                        final Queue<String> nextModulePrefixedPath = new LinkedList<String>();
-                        nextModulePrefixedPath.add(childNodeName);
-                        nextModulePrefixedPath.addAll(prefixedPath);
-                        prefixedPath.clear();
+    private void resolveTypeDefsFromContext() {
+        final Set<Module> modules = schemaContext.getModules();
+        if (modules == null) {
+            throw new IllegalArgumentException("Sef of Modules cannot be NULL!");
+        }
+        for (final Module module : modules) {
+            if (module == null) {
+                continue;
+            }
+            final String moduleName = module.getName();
+            final String basePackageName = moduleNamespaceToPackageName(module);
 
-                        schemaNode = findSchemaNodeForGivenPath(nextModule,
-                                nextModulePrefixedPath);
+            final Set<TypeDefinition<?>> typeDefinitions = module.getTypeDefinitions();
+            final List<TypeDefinition<?>> listTypeDefinitions = sortTypeDefinitionAccordingDepth(typeDefinitions);
 
-                        return schemaNode;
-                    }
+            final Map<String, Type> typeMap = new HashMap<>();
+            genTypeDefsContextMap.put(moduleName, typeMap);
+
+            if ((listTypeDefinitions != null) && (basePackageName != null)) {
+                for (final TypeDefinition<?> typedef : listTypeDefinitions) {
+                    typedefToGeneratedType(basePackageName, moduleName, typedef);
                 }
+            }
+        }
+    }
+
+    private Type typedefToGeneratedType(final String basePackageName, final String moduleName,
+            final TypeDefinition<?> typedef) {
+        if ((basePackageName != null) && (moduleName != null) && (typedef != null) && (typedef.getQName() != null)) {
+
+            final String typedefName = typedef.getQName().getLocalName();
+            final TypeDefinition<?> innerTypeDefinition = typedef.getBaseType();
+            if (!(innerTypeDefinition instanceof LeafrefTypeDefinition)
+                    && !(innerTypeDefinition instanceof IdentityrefTypeDefinition)) {
+                Type returnType = null;
+                if (innerTypeDefinition instanceof ExtendedType) {
+                    ExtendedType extendedTypeDef = (ExtendedType) innerTypeDefinition;
+                    returnType = resolveExtendedTypeFromTypeDef(extendedTypeDef, basePackageName, typedefName,
+                            moduleName);
+                } else if (innerTypeDefinition instanceof UnionTypeDefinition) {
+                    final GeneratedTOBuilder genTOBuilder = addUnionGeneratedTypeDefinition(basePackageName, typedef,
+                            typedefName);
+                    returnType = genTOBuilder.toInstance();
+                } else if (innerTypeDefinition instanceof EnumTypeDefinition) {
+                    final EnumTypeDefinition enumTypeDef = (EnumTypeDefinition) innerTypeDefinition;
+                    returnType = resolveEnumFromTypeDefinition(enumTypeDef, typedefName);
+
+                } else if (innerTypeDefinition instanceof BitsTypeDefinition) {
+                    final BitsTypeDefinition bitsTypeDefinition = (BitsTypeDefinition) innerTypeDefinition;
+                    final GeneratedTOBuilder genTOBuilder = bitsTypedefToTransferObject(basePackageName,
+                            bitsTypeDefinition, typedefName);
+                    returnType = genTOBuilder.toInstance();
 
-                schemaNode = nextContainer.getDataChildByName(childNodeName);
-                if (schemaNode instanceof ContainerSchemaNode) {
-                    nextContainer = (ContainerSchemaNode) schemaNode;
-                } else if (schemaNode instanceof ListSchemaNode) {
-                    nextContainer = (ListSchemaNode) schemaNode;
                 } else {
-                    return schemaNode;
+                    final Type javaType = BaseYangTypes.BASE_YANG_TYPES_PROVIDER
+                            .javaTypeForSchemaDefinitionType(innerTypeDefinition);
+
+                    returnType = wrapJavaTypeIntoTO(basePackageName, typedef, javaType);
+                }
+                if (returnType != null) {
+                    final Map<String, Type> typeMap = genTypeDefsContextMap.get(moduleName);
+                    if (typeMap != null) {
+                        typeMap.put(typedefName, returnType);
+                    }
+                    return returnType;
                 }
             }
         }
-
         return null;
     }
 
-    private Module resolveModuleFromSchemaPath(final SchemaPath schemaPath) {
-        if ((schemaPath != null) && (schemaPath.getPath() != null)) {
-            final QName qname = schemaPath.getPath().get(0);
+    private GeneratedTransferObject wrapJavaTypeIntoTO(final String basePackageName, final TypeDefinition<?> typedef,
+            final Type javaType) {
+        if (javaType != null) {
+            final String typedefName = typedef.getQName().getLocalName();
+            final String propertyName = parseToValidParamName(typedefName);
+
+            final GeneratedTOBuilder genTOBuilder = typedefToTransferObject(basePackageName, typedef);
 
-            if ((qname != null) && (qname.getNamespace() != null)) {
-                return schemaContext
-                        .findModuleByNamespace(qname.getNamespace());
+            final GeneratedPropertyBuilder genPropBuilder = genTOBuilder.addProperty(propertyName);
+
+            genPropBuilder.setReturnType(javaType);
+            genTOBuilder.addEqualsIdentity(genPropBuilder);
+            genTOBuilder.addHashIdentity(genPropBuilder);
+            genTOBuilder.addToStringProperty(genPropBuilder);
+            if (javaType == BaseYangTypes.STRING_TYPE) {
+                if (typedef instanceof ExtendedType) {
+                    final List<String> regExps = resolveRegExpressionsFromTypedef((ExtendedType) typedef);
+                    addStringRegExAsConstant(genTOBuilder, regExps);
+                }
             }
+            return genTOBuilder.toInstance();
         }
         return null;
     }
 
-    private Queue<String> xpathToPrefixedPath(final String xpath,
-            final String moduleName) {
-        final Queue<String> retQueue = new LinkedList<String>();
-        if ((xpath != null) && (moduleName != null)) {
-            final String[] prefixedPath = xpath.split("/");
+    public GeneratedTOBuilder addUnionGeneratedTypeDefinition(final String basePackageName,
+            final TypeDefinition<?> typedef, String typeDefName) {
+        if (basePackageName == null) {
+            throw new IllegalArgumentException("Base Package Name cannot be NULL!");
+        }
+        if (typedef == null) {
+            throw new IllegalArgumentException("Type Definition cannot be NULL!");
+        }
+        if (typedef.getQName() == null) {
+            throw new IllegalArgumentException(
+                    "Type Definition cannot have non specified QName (QName cannot be NULL!)");
+        }
+
+        final TypeDefinition<?> baseTypeDefinition = typedef.getBaseType();
+        if ((baseTypeDefinition != null) && (baseTypeDefinition instanceof UnionTypeDefinition)) {
+            final Module parentModule = findParentModuleForTypeDefinition(schemaContext, typedef);
+            final UnionTypeDefinition unionTypeDef = (UnionTypeDefinition) baseTypeDefinition;
+            final List<TypeDefinition<?>> unionTypes = unionTypeDef.getTypes();
 
-            if (prefixedPath != null) {
-                for (int i = 0; i < prefixedPath.length; ++i) {
-                    if (!prefixedPath[i].isEmpty()) {
-                        retQueue.add(prefixedPath[i]);
+            Map<String, Type> genTOsMap = null;
+            if (parentModule != null && parentModule.getName() != null) {
+                genTOsMap = genTypeDefsContextMap.get(parentModule.getName());
+            }
+
+            final GeneratedTOBuilder unionGenTransObject;
+            if (typeDefName != null && !typeDefName.isEmpty()) {
+                final String typeName = parseToClassName(typeDefName);
+                unionGenTransObject = new GeneratedTOBuilderImpl(basePackageName, typeName);
+            } else {
+                unionGenTransObject = typedefToTransferObject(basePackageName, typedef);
+            }
+            unionGenTransObject.setIsUnion(true);
+
+            final List<String> regularExpressions = new ArrayList<String>();
+            for (final TypeDefinition<?> unionType : unionTypes) {
+                final String typeName = unionType.getQName().getLocalName();
+                if (unionType instanceof ExtendedType) {
+                    final Module unionTypeModule = findParentModuleForTypeDefinition(schemaContext, unionType);
+                    if (unionTypeModule != null && unionTypeModule.getName() != null) {
+                        final Map<String, Type> innerGenTOs = genTypeDefsContextMap.get(unionTypeModule.getName());
+                        Type genTransferObject = null;
+                        if (innerGenTOs != null) {
+                            genTransferObject = innerGenTOs.get(typeName);
+                        }
+                        if (genTransferObject != null) {
+                            updateUnionTypeAsProperty(unionGenTransObject, genTransferObject,
+                                    genTransferObject.getName());
+                        } else {
+                            final TypeDefinition<?> baseType = baseTypeDefForExtendedType(unionType);
+                            if (typeName.equals(baseType.getQName().getLocalName())) {
+                                final Type javaType = BaseYangTypes.BASE_YANG_TYPES_PROVIDER
+                                        .javaTypeForSchemaDefinitionType(baseType);
+                                if (javaType != null) {
+                                    updateUnionTypeAsProperty(unionGenTransObject, javaType, typeName);
+                                }
+                            }
+                            if (baseType instanceof StringType) {
+                                regularExpressions.addAll(resolveRegExpressionsFromTypedef((ExtendedType) unionType));
+                            }
+                        }
+                    }
+                } else if (unionType instanceof EnumTypeDefinition) {
+                    final EnumBuilder enumBuilder = resolveInnerEnumFromTypeDefinition((EnumTypeDefinition) unionType,
+                            typeName, unionGenTransObject);
+                    final Type enumRefType = new ReferencedTypeImpl(enumBuilder.getPackageName(), enumBuilder.getName());
+                    updateUnionTypeAsProperty(unionGenTransObject, enumRefType, typeName);
+                } else {
+                    final Type javaType = BaseYangTypes.BASE_YANG_TYPES_PROVIDER
+                            .javaTypeForSchemaDefinitionType(unionType);
+                    if (javaType != null) {
+                        updateUnionTypeAsProperty(unionGenTransObject, javaType, typeName);
                     }
                 }
             }
+            if (!regularExpressions.isEmpty()) {
+                addStringRegExAsConstant(unionGenTransObject, regularExpressions);
+            }
+
+            genTOsMap.put(typedef.getQName().getLocalName(), unionGenTransObject.toInstance());
+            return unionGenTransObject;
         }
-        return retQueue;
+        return null;
     }
 
-    private Module resolveModuleForPrefix(final String prefix,
-            final Module parent) {
-        if ((prefix != null) && (parent != null)) {
-            final Set<ModuleImport> imports = parent.getImports();
-
-            if (imports != null) {
-                for (final ModuleImport impModule : imports) {
-                    final String impModPrefix = impModule.getPrefix();
-                    if ((impModPrefix != null) && prefix.equals(impModPrefix)) {
-                        return resolveModuleFromContext(prefix,
-                                impModule.getModuleName());
-                    }
+    private void updateUnionTypeAsProperty(final GeneratedTOBuilder unionGenTransObject, final Type type,
+            final String propertyName) {
+        if (unionGenTransObject != null && type != null) {
+            if (!unionGenTransObject.containsProperty(propertyName)) {
+                final GeneratedPropertyBuilder propBuilder = unionGenTransObject
+                        .addProperty(parseToValidParamName(propertyName));
+                propBuilder.setReturnType(type);
+
+                if (!(type instanceof Enumeration)) {
+                    unionGenTransObject.addEqualsIdentity(propBuilder);
+                    unionGenTransObject.addHashIdentity(propBuilder);
+                    unionGenTransObject.addToStringProperty(propBuilder);
                 }
             }
         }
+    }
+
+    private GeneratedTOBuilder typedefToTransferObject(final String basePackageName, final TypeDefinition<?> typedef) {
+
+        final String packageName = packageNameForGeneratedType(basePackageName, typedef.getPath());
+        final String typeDefTOName = typedef.getQName().getLocalName();
+
+        if ((packageName != null) && (typedef != null) && (typeDefTOName != null)) {
+            final String genTOName = parseToClassName(typeDefTOName);
+            final GeneratedTOBuilder newType = new GeneratedTOBuilderImpl(packageName, genTOName);
+
+            return newType;
+        }
         return null;
     }
 
-    private Module resolveModuleFromContext(final String prefix,
-            final String moduleName) {
-        final Set<Module> modules = schemaContext.getModules();
+    public GeneratedTOBuilder bitsTypedefToTransferObject(final String basePackageName,
+            final TypeDefinition<?> typeDef, String typeDefName) {
 
-        if ((prefix != null) && (moduleName != null) && (modules != null)) {
-            for (Module module : modules) {
-                if ((module != null) && prefix.equals(module.getPrefix())
-                        && moduleName.equals(module.getName())) {
-                    return module;
-                }
+        if (typeDef == null) {
+            throw new IllegalArgumentException("typeDef cannot be NULL!");
+        }
+        if (basePackageName == null) {
+            throw new IllegalArgumentException("Base Package Name cannot be NULL!");
+        }
+
+        if (typeDef instanceof BitsTypeDefinition) {
+            BitsTypeDefinition bitsTypeDefinition = (BitsTypeDefinition) typeDef;
+
+            final String typeName = parseToClassName(typeDefName);
+            final GeneratedTOBuilder genTOBuilder = new GeneratedTOBuilderImpl(basePackageName, typeName);
+
+            final List<Bit> bitList = bitsTypeDefinition.getBits();
+            GeneratedPropertyBuilder genPropertyBuilder;
+            for (final Bit bit : bitList) {
+                String name = bit.getName();
+                genPropertyBuilder = genTOBuilder.addProperty(parseToValidParamName(name));
+                genPropertyBuilder.setReadOnly(false);
+                genPropertyBuilder.setReturnType(BaseYangTypes.BOOLEAN_TYPE);
+
+                genTOBuilder.addEqualsIdentity(genPropertyBuilder);
+                genTOBuilder.addHashIdentity(genPropertyBuilder);
+                genTOBuilder.addToStringProperty(genPropertyBuilder);
             }
+
+            return genTOBuilder;
         }
         return null;
     }
 
-    private Queue<String> resolveRelativeXPath(
-            final RevisionAwareXPath relativeXPath,
-            final SchemaPath leafrefSchemaPath) {
-        final Queue<String> absolutePath = new LinkedList<String>();
-
-        if ((relativeXPath != null) && !relativeXPath.isAbsolute()
-                && (leafrefSchemaPath != null)) {
-            final String strXPath = relativeXPath.toString();
-            if (strXPath != null) {
-                final String[] xpaths = strXPath.split("/");
-
-                if (xpaths != null) {
-                    int colCount = 0;
-                    while (xpaths[colCount].contains("..")) {
-                        ++colCount;
-                    }
-                    final List<QName> path = leafrefSchemaPath.getPath();
-                    if (path != null) {
-                        int lenght = path.size() - colCount;
-                        for (int i = 0; i < lenght; ++i) {
-                            absolutePath.add(path.get(i).getLocalName());
-                        }
-                        for (int i = colCount; i < xpaths.length; ++i) {
-                            absolutePath.add(xpaths[i]);
-                        }
-                    }
+    private List<String> resolveRegExpressionsFromTypedef(ExtendedType typedef) {
+        final List<String> regExps = new ArrayList<String>();
+        if (typedef == null) {
+            throw new IllegalArgumentException("typedef can't be null");
+        }
+        final TypeDefinition<?> strTypeDef = baseTypeDefForExtendedType(typedef);
+        if (strTypeDef instanceof StringType) {
+            final List<PatternConstraint> patternConstraints = typedef.getPatterns();
+            if (!patternConstraints.isEmpty()) {
+                String regEx;
+                String modifiedRegEx;
+                for (PatternConstraint patternConstraint : patternConstraints) {
+                    regEx = patternConstraint.getRegularExpression();
+                    modifiedRegEx = StringEscapeUtils.escapeJava(regEx);
+                    regExps.add(modifiedRegEx);
+                }
+            }
+        }
+        return regExps;
+    }
+
+    private void addStringRegExAsConstant(GeneratedTOBuilder genTOBuilder, List<String> regularExpressions) {
+        if (genTOBuilder == null)
+            throw new IllegalArgumentException("genTOBuilder can't be null");
+        if (regularExpressions == null)
+            throw new IllegalArgumentException("regularExpressions can't be null");
+
+        if (!regularExpressions.isEmpty()) {
+            genTOBuilder.addConstant(Types.listTypeFor(BaseYangTypes.STRING_TYPE), TypeConstants.PATTERN_CONSTANT_NAME,
+                    regularExpressions);
+        }
+    }
+
+    private GeneratedTransferObject resolveExtendedTypeFromTypeDef(final ExtendedType extendedType,
+            final String basePackageName, final String typedefName, final String moduleName) {
+
+        if (extendedType == null) {
+            throw new IllegalArgumentException("Extended type cannot be NULL!");
+        }
+        if (basePackageName == null) {
+            throw new IllegalArgumentException("String with base package name cannot be NULL!");
+        }
+        if (typedefName == null) {
+            throw new IllegalArgumentException("String with type definition name cannot be NULL!");
+        }
+
+        final String typeDefName = parseToClassName(typedefName);
+        final String lowTypeDef = extendedType.getQName().getLocalName();
+        final GeneratedTOBuilder genTOBuilder = new GeneratedTOBuilderImpl(basePackageName, typeDefName);
+
+        final Map<String, Type> typeMap = genTypeDefsContextMap.get(moduleName);
+        if (typeMap != null) {
+            Type type = typeMap.get(lowTypeDef);
+            if (type instanceof GeneratedTransferObject) {
+                genTOBuilder.setExtendsType((GeneratedTransferObject) type);
+            }
+        }
+
+        return genTOBuilder.toInstance();
+    }
+
+    /**
+     * The method find out for each type definition how many immersion (depth)
+     * is necessary to get to the base type. Every type definition is inserted
+     * to the map which key is depth and value is list of type definitions with
+     * equal depth. In next step are lists from this map concatenated to one
+     * list in ascending order according to their depth. All type definitions
+     * are in the list behind all type definitions on which depends.
+     * 
+     * @param unsortedTypeDefinitions
+     *            represents list of type definitions
+     * @return list of type definitions sorted according their each other
+     *         dependencies (type definitions which are depend on other type
+     *         definitions are in list behind them).
+     */
+    private List<TypeDefinition<?>> sortTypeDefinitionAccordingDepth(
+            final Set<TypeDefinition<?>> unsortedTypeDefinitions) {
+        List<TypeDefinition<?>> sortedTypeDefinition = new ArrayList<>();
+
+        Map<Integer, List<TypeDefinition<?>>> typeDefinitionsDepths = new TreeMap<>();
+        for (TypeDefinition<?> unsortedTypeDefinition : unsortedTypeDefinitions) {
+            final int depth = getTypeDefinitionDepth(unsortedTypeDefinition);
+            List<TypeDefinition<?>> typeDefinitionsConcreteDepth = typeDefinitionsDepths.get(depth);
+            if (typeDefinitionsConcreteDepth == null) {
+                typeDefinitionsConcreteDepth = new ArrayList<TypeDefinition<?>>();
+                typeDefinitionsDepths.put(depth, typeDefinitionsConcreteDepth);
+            }
+            typeDefinitionsConcreteDepth.add(unsortedTypeDefinition);
+        }
+
+        Set<Integer> depths = typeDefinitionsDepths.keySet(); // keys are in
+                                                              // ascending order
+        for (Integer depth : depths) {
+            sortedTypeDefinition.addAll(typeDefinitionsDepths.get(depth));
+        }
+
+        return sortedTypeDefinition;
+    }
+
+    /**
+     * The method return how many immersion is necessary to get from type
+     * definition to base type.
+     * 
+     * @param typeDefinition
+     *            is type definition for which is depth looked for.
+     * @return how many immersion is necessary to get from type definition to
+     *         base type
+     */
+    private int getTypeDefinitionDepth(final TypeDefinition<?> typeDefinition) {
+        if (typeDefinition == null) {
+            throw new IllegalArgumentException("Type definition can't be null");
+        }
+        int depth = 1;
+        TypeDefinition<?> baseType = typeDefinition.getBaseType();
+
+        if (baseType instanceof ExtendedType) {
+            depth = depth + getTypeDefinitionDepth(typeDefinition.getBaseType());
+        } else if (baseType instanceof UnionType) {
+            List<TypeDefinition<?>> childTypeDefinitions = ((UnionType) baseType).getTypes();
+            int maxChildDepth = 0;
+            int childDepth = 1;
+            for (TypeDefinition<?> childTypeDefinition : childTypeDefinitions) {
+                childDepth = childDepth + getTypeDefinitionDepth(childTypeDefinition.getBaseType());
+                if (childDepth > maxChildDepth) {
+                    maxChildDepth = childDepth;
                 }
             }
+            return maxChildDepth;
         }
-        return absolutePath;
+        return depth;
     }
+
 }