diff --git a/plugin/src/main/java/org/onosproject/yangutils/translator/tojava/javamodel/AttributesJavaDataType.java b/plugin/src/main/java/org/onosproject/yangutils/translator/tojava/javamodel/AttributesJavaDataType.java
new file mode 100644
index 0000000..a0840eb
--- /dev/null
+++ b/plugin/src/main/java/org/onosproject/yangutils/translator/tojava/javamodel/AttributesJavaDataType.java
@@ -0,0 +1,447 @@
+/*
+ * Copyright 2016-present Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onosproject.yangutils.translator.tojava.javamodel;
+
+import java.util.Stack;
+import org.onosproject.yangutils.datamodel.YangDataTypes;
+import org.onosproject.yangutils.datamodel.YangDerivedInfo;
+import org.onosproject.yangutils.datamodel.YangEnumeration;
+import org.onosproject.yangutils.datamodel.YangNode;
+import org.onosproject.yangutils.datamodel.YangType;
+import org.onosproject.yangutils.datamodel.YangTypeDef;
+import org.onosproject.yangutils.datamodel.YangUnion;
+import org.onosproject.yangutils.translator.exception.TranslatorException;
+import org.onosproject.yangutils.translator.tojava.JavaCodeGeneratorInfo;
+import org.onosproject.yangutils.translator.tojava.JavaFileInfo;
+import org.onosproject.yangutils.translator.tojava.JavaFileInfoContainer;
+import org.onosproject.yangutils.utils.io.impl.YangToJavaNamingConflictUtil;
+
+import static org.onosproject.yangutils.translator.tojava.javamodel.YangJavaModelUtils.getCurNodePackage;
+import static org.onosproject.yangutils.translator.tojava.utils.JavaIdentifierSyntax.getRootPackage;
+import static org.onosproject.yangutils.utils.UtilConstants.BIG_INTEGER;
+import static org.onosproject.yangutils.utils.UtilConstants.BOOLEAN_DATA_TYPE;
+import static org.onosproject.yangutils.utils.UtilConstants.BOOLEAN_WRAPPER;
+import static org.onosproject.yangutils.utils.UtilConstants.BYTE;
+import static org.onosproject.yangutils.utils.UtilConstants.BYTE_WRAPPER;
+import static org.onosproject.yangutils.utils.UtilConstants.INT;
+import static org.onosproject.yangutils.utils.UtilConstants.INTEGER_WRAPPER;
+import static org.onosproject.yangutils.utils.UtilConstants.JAVA_LANG;
+import static org.onosproject.yangutils.utils.UtilConstants.JAVA_MATH;
+import static org.onosproject.yangutils.utils.UtilConstants.LONG;
+import static org.onosproject.yangutils.utils.UtilConstants.LONG_WRAPPER;
+import static org.onosproject.yangutils.utils.UtilConstants.PERIOD;
+import static org.onosproject.yangutils.utils.UtilConstants.SHORT;
+import static org.onosproject.yangutils.utils.UtilConstants.SHORT_WRAPPER;
+import static org.onosproject.yangutils.utils.UtilConstants.STRING_DATA_TYPE;
+import static org.onosproject.yangutils.utils.UtilConstants.YANG_BINARY_CLASS;
+import static org.onosproject.yangutils.utils.UtilConstants.YANG_BITS_CLASS;
+import static org.onosproject.yangutils.utils.UtilConstants.YANG_DECIMAL64_CLASS;
+import static org.onosproject.yangutils.utils.UtilConstants.YANG_TYPES_PKG;
+import static org.onosproject.yangutils.utils.io.impl.YangIoUtils.getCamelCase;
+import static org.onosproject.yangutils.utils.io.impl.YangIoUtils.getCapitalCase;
+import static org.onosproject.yangutils.utils.io.impl.YangIoUtils.getPackageDirPathFromJavaJPackage;
+
+/**
+ * Represents java data types info corresponding to YANG type.
+ */
+public final class AttributesJavaDataType {
+
+    /**
+     * Creates an instance of attribute java data type.
+     */
+    private AttributesJavaDataType() {
+    }
+
+    /**
+     * Returns java type.
+     *
+     * @param yangType YANG type
+     * @return java type
+     */
+    public static String getJavaDataType(YangType<?> yangType) {
+
+        YangDataTypes type = yangType.getDataType();
+
+        switch (type) {
+            case INT8:
+                return BYTE;
+            case INT16:
+                return SHORT;
+            case INT32:
+                return INT;
+            case INT64:
+                return LONG;
+            case UINT8:
+                return SHORT;
+            case UINT16:
+                return INT;
+            case UINT32:
+                return LONG;
+            case UINT64:
+                return BIG_INTEGER;
+            case BINARY:
+                return YANG_BINARY_CLASS;
+            case DECIMAL64:
+                return YANG_DECIMAL64_CLASS;
+            case STRING:
+                return STRING_DATA_TYPE;
+            case BOOLEAN:
+                return BOOLEAN_DATA_TYPE;
+            default:
+                throw new TranslatorException("given data type is not supported.");
+        }
+    }
+
+    /**
+     * Returns java import class.
+     *
+     * @param yangType     YANG type
+     * @param isListAttr   if the attribute need to be a list
+     * @param pluginConfig plugin configurations
+     * @return java import class
+     */
+    public static String getJavaImportClass(YangType<?> yangType, boolean isListAttr,
+                                            YangToJavaNamingConflictUtil pluginConfig) {
+
+        YangDataTypes type = yangType.getDataType();
+
+        if (isListAttr) {
+            switch (type) {
+                case INT8:
+                    return BYTE_WRAPPER;
+                case INT16:
+                    return SHORT_WRAPPER;
+                case INT32:
+                    return INTEGER_WRAPPER;
+                case INT64:
+                    return LONG_WRAPPER;
+                case UINT8:
+                    return SHORT_WRAPPER;
+                case UINT16:
+                    return INTEGER_WRAPPER;
+                case UINT32:
+                    return LONG_WRAPPER;
+                case UINT64:
+                    return BIG_INTEGER;
+                case DECIMAL64:
+                    return YANG_DECIMAL64_CLASS;
+                case STRING:
+                    return STRING_DATA_TYPE;
+                case BOOLEAN:
+                    return BOOLEAN_WRAPPER;
+                case ENUMERATION:
+                    return getCapitalCase(
+                            getCamelCase(((YangJavaEnumeration) yangType.getDataTypeExtendedInfo()).getName(),
+                                    pluginConfig));
+                case BITS:
+                    return YANG_BITS_CLASS;
+                case BINARY:
+                    return YANG_BINARY_CLASS;
+                case LEAFREF:
+                    //TODO:LEAFREF
+                    break;
+                case IDENTITYREF:
+                    //TODO:IDENTITYREF
+                    break;
+                case EMPTY:
+                    return BOOLEAN_WRAPPER;
+                case UNION:
+                    return getCapitalCase(getCamelCase(((YangJavaUnion) yangType.getDataTypeExtendedInfo()).getName(),
+                            pluginConfig));
+                case INSTANCE_IDENTIFIER:
+                    //TODO:INSTANCE_IDENTIFIER
+                    break;
+                case DERIVED:
+                    return getCapitalCase(
+                            getCamelCase(yangType.getDataTypeName(), pluginConfig));
+                default:
+                    throw new TranslatorException("given data type is not supported.");
+            }
+        } else {
+            switch (type) {
+                case UINT64:
+                    return BIG_INTEGER;
+                case DECIMAL64:
+                    return YANG_DECIMAL64_CLASS;
+                case STRING:
+                    return STRING_DATA_TYPE;
+                case ENUMERATION:
+                    return getCapitalCase(
+                            getCamelCase(((YangJavaEnumeration) yangType.getDataTypeExtendedInfo()).getName(),
+                                    pluginConfig));
+                case BITS:
+                    return YANG_BITS_CLASS;
+                case BINARY:
+                    return YANG_BINARY_CLASS;
+                case LEAFREF:
+                    //TODO:LEAFREF
+                    break;
+                case IDENTITYREF:
+                    //TODO:IDENTITYREF
+                    break;
+                case EMPTY:
+                    return BOOLEAN_DATA_TYPE;
+                case UNION:
+                    return getCapitalCase(getCamelCase(((YangJavaUnion) yangType.getDataTypeExtendedInfo()).getName(),
+                            pluginConfig));
+                case INSTANCE_IDENTIFIER:
+                    //TODO:INSTANCE_IDENTIFIER
+                    break;
+                case DERIVED:
+                    return getCapitalCase(
+                            getCamelCase(yangType.getDataTypeName(), pluginConfig));
+                default:
+                    return null;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Returns java import package.
+     *
+     * @param yangType         YANG type
+     * @param isListAttr       if the attribute is of list type
+     * @param conflictResolver object of YANG to java naming conflict util
+     * @return java import package
+     */
+    public static String getJavaImportPackage(YangType<?> yangType, boolean isListAttr,
+                                              YangToJavaNamingConflictUtil conflictResolver) {
+
+        YangDataTypes type = yangType.getDataType();
+
+        if (isListAttr) {
+            switch (type) {
+                case INT8:
+                case INT16:
+                case INT32:
+                case INT64:
+                case UINT8:
+                case UINT16:
+                case UINT32:
+                case STRING:
+                case BOOLEAN:
+                case EMPTY:
+                    return JAVA_LANG;
+                case UINT64:
+                    return JAVA_MATH;
+                case ENUMERATION:
+                    return getEnumsPackage(yangType, conflictResolver);
+                case DECIMAL64:
+                case BITS:
+                case BINARY:
+                    return YANG_TYPES_PKG;
+                case LEAFREF:
+                    //TODO:LEAFREF
+                    break;
+                case IDENTITYREF:
+                    //TODO:IDENTITYREF
+                    break;
+                case UNION:
+                    return getUnionPackage(yangType, conflictResolver);
+                case INSTANCE_IDENTIFIER:
+                    //TODO:INSTANCE_IDENTIFIER
+                    break;
+                case DERIVED:
+                    return getTypDefsPackage(yangType, conflictResolver);
+                default:
+                    throw new TranslatorException("given data type is not supported.");
+            }
+        } else {
+            switch (type) {
+                case UINT64:
+                    return JAVA_MATH;
+                case STRING:
+                    return JAVA_LANG;
+                case ENUMERATION:
+                    return getEnumsPackage(yangType, conflictResolver);
+                case DECIMAL64:
+                case BITS:
+                case BINARY:
+                    return YANG_TYPES_PKG;
+                case LEAFREF:
+                    //TODO:LEAFREF
+                    break;
+                case IDENTITYREF:
+                    //TODO:IDENTITYREF
+                    break;
+                case EMPTY:
+                    return JAVA_LANG;
+                case UNION:
+                    return getUnionPackage(yangType, conflictResolver);
+                case INSTANCE_IDENTIFIER:
+                    //TODO:INSTANCE_IDENTIFIER
+                    break;
+                case DERIVED:
+                    return getTypDefsPackage(yangType, conflictResolver);
+                default:
+                    return null;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Returns java package for typedef node.
+     *
+     * @param type             YANG type
+     * @param conflictResolver object of YANG to java naming conflict util
+     * @return java package for typedef node
+     */
+    private static String getTypDefsPackage(YangType<?> type, YangToJavaNamingConflictUtil conflictResolver) {
+        Object var = type.getDataTypeExtendedInfo();
+        if (!(var instanceof YangDerivedInfo)) {
+            throw new TranslatorException("type should have been derived.");
+        }
+
+        if (!(((YangDerivedInfo<?>) var).getReferredTypeDef() instanceof YangTypeDef)) {
+            throw new TranslatorException("derived info is not an instance of typedef.");
+        }
+
+        YangJavaTypeDef typedef = (YangJavaTypeDef) ((YangDerivedInfo<?>) var).getReferredTypeDef();
+        if (typedef.getJavaFileInfo().getPackage() == null) {
+            return getPackageFromParent(typedef.getParent(), conflictResolver);
+        }
+        return typedef.getJavaFileInfo().getPackage();
+    }
+
+    /**
+     * Returns java package for union node.
+     *
+     * @param type             YANG type
+     * @param conflictResolver object of YANG to java naming conflict util
+     * @return java package for union node
+     */
+    private static String getUnionPackage(YangType<?> type, YangToJavaNamingConflictUtil conflictResolver) {
+
+        if (!(type.getDataTypeExtendedInfo() instanceof YangUnion)) {
+            throw new TranslatorException("type should have been union.");
+        }
+
+        YangJavaUnion union = (YangJavaUnion) type.getDataTypeExtendedInfo();
+        if (union.getJavaFileInfo().getPackage() == null) {
+            return getPackageFromParent(union.getParent(), conflictResolver);
+        }
+        return union.getJavaFileInfo().getPackage();
+    }
+
+    /**
+     * Returns YANG enumeration's java package.
+     *
+     * @param type             YANG type
+     * @param conflictResolver object of YANG to java naming conflict util
+     * @return YANG enumeration's java package
+     */
+    private static String getEnumsPackage(YangType<?> type, YangToJavaNamingConflictUtil conflictResolver) {
+
+        if (!(type.getDataTypeExtendedInfo() instanceof YangEnumeration)) {
+            throw new TranslatorException("type should have been enumeration.");
+        }
+        YangJavaEnumeration enumeration = (YangJavaEnumeration) type.getDataTypeExtendedInfo();
+        if (enumeration.getJavaFileInfo().getPackage() == null) {
+            return getPackageFromParent(enumeration.getParent(), conflictResolver);
+        }
+        return enumeration.getJavaFileInfo().getPackage();
+    }
+
+    /**
+     * Returns package from parent node.
+     *
+     * @param parent           parent YANG node
+     * @param conflictResolver object of YANG to java naming conflict util
+     * @return java package from parent node
+     */
+    private static String getPackageFromParent(YangNode parent,
+                                               YangToJavaNamingConflictUtil conflictResolver) {
+        if (!(parent instanceof JavaFileInfoContainer)) {
+            throw new TranslatorException("invalid child node is being processed.");
+        }
+        JavaFileInfo parentInfo = ((JavaFileInfoContainer) parent).getJavaFileInfo();
+        if (parentInfo.getPackage() == null) {
+            updateJavaFileInfo(parent, conflictResolver);
+        }
+        return parentInfo.getPackage() + PERIOD + parentInfo.getJavaName().toLowerCase();
+    }
+
+    /**
+     * Update the referred data model nodes java file info, this will be called,
+     * when the linked node is yet to translate. Then resolve until the parent hierarchy.
+     *
+     * @param yangNode         node whose java info needs to be updated
+     * @param conflictResolver yang plugin config
+     */
+    public static void updateJavaFileInfo(YangNode yangNode,
+                                          YangToJavaNamingConflictUtil conflictResolver) {
+        Stack<YangNode> nodesToUpdatePackage = new Stack<YangNode>();
+
+        /*
+         * Add the nodes to be updated for package info in a stack.
+         */
+        while (yangNode != null
+                && ((JavaFileInfoContainer) yangNode)
+                .getJavaFileInfo().getPackage() == null) {
+            nodesToUpdatePackage.push(yangNode);
+            yangNode = yangNode.getParent();
+        }
+
+        /*
+         * If the package is not updated till root node, then root package needs to
+         * be updated.
+         */
+        if (yangNode == null) {
+            yangNode = nodesToUpdatePackage.pop();
+            String pkg;
+            if (yangNode instanceof YangJavaModule) {
+                YangJavaModule module = (YangJavaModule) yangNode;
+                pkg = getRootPackage(module.getVersion(), module.getNameSpace().getUri(), module
+                        .getRevision().getRevDate(), conflictResolver);
+            } else if (yangNode instanceof YangJavaSubModule) {
+                YangJavaSubModule submodule = (YangJavaSubModule) yangNode;
+                pkg = getRootPackage(submodule.getVersion(),
+                        submodule.getNameSpaceFromModule(submodule.getBelongsTo()),
+                        submodule.getRevision().getRevDate(), conflictResolver);
+            } else {
+                throw new TranslatorException("Invalid root node of data model tree");
+            }
+
+            ((JavaCodeGeneratorInfo) yangNode).getJavaFileInfo()
+                    .setJavaName(getCamelCase(yangNode.getName(), conflictResolver));
+            ((JavaCodeGeneratorInfo) yangNode).getJavaFileInfo()
+                    .setPackage(pkg);
+            ((JavaCodeGeneratorInfo) yangNode).getJavaFileInfo()
+                    .setPackageFilePath(getPackageDirPathFromJavaJPackage(
+                            ((JavaCodeGeneratorInfo) yangNode).getJavaFileInfo()
+                                    .getPackage()));
+        }
+
+        /**
+         * Parent of the node in stack is updated with java info,
+         * all the nodes can be popped and updated
+         */
+        while (nodesToUpdatePackage.size() != 0) {
+            yangNode = nodesToUpdatePackage.pop();
+            ((JavaCodeGeneratorInfo) yangNode).getJavaFileInfo()
+                    .setJavaName(getCamelCase(yangNode.getName(), conflictResolver));
+            ((JavaCodeGeneratorInfo) yangNode).getJavaFileInfo()
+                    .setPackage(getCurNodePackage(yangNode));
+            ((JavaCodeGeneratorInfo) yangNode).getJavaFileInfo()
+                    .setPackageFilePath(getPackageDirPathFromJavaJPackage(
+                            ((JavaCodeGeneratorInfo) yangNode).getJavaFileInfo()
+                                    .getPackage()));
+        }
+    }
+}