generator/src/main/java/org/onosproject/yangutils/translator/tojava/utils/SubtreeFilteringMethodsGenerator.java

/*
 * 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.utils;

import org.onosproject.yangutils.datamodel.RpcNotificationContainer;
import org.onosproject.yangutils.datamodel.YangAugment;
import org.onosproject.yangutils.datamodel.YangCase;
import org.onosproject.yangutils.datamodel.YangChoice;
import org.onosproject.yangutils.datamodel.YangDataStructure;
import org.onosproject.yangutils.datamodel.YangLeafRef;
import org.onosproject.yangutils.datamodel.YangLeavesHolder;
import org.onosproject.yangutils.datamodel.YangNode;
import org.onosproject.yangutils.datamodel.YangType;
import org.onosproject.yangutils.translator.exception.TranslatorException;
import org.onosproject.yangutils.translator.tojava.JavaAttributeInfo;
import org.onosproject.yangutils.translator.tojava.JavaCodeGeneratorInfo;
import org.onosproject.yangutils.translator.tojava.JavaFileInfoContainer;
import org.onosproject.yangutils.translator.tojava.JavaFileInfoTranslator;

import java.io.IOException;
import java.util.LinkedHashMap;
import java.util.Map;

import static org.onosproject.yangutils.datamodel.utils.builtindatatype.YangDataTypes.IDENTITYREF;
import static org.onosproject.yangutils.datamodel.utils.builtindatatype.YangDataTypes.LEAFREF;
import static org.onosproject.yangutils.translator.tojava.GeneratedTempFileType.FILTER_CONTENT_MATCH_FOR_LEAF_LIST_MASK;
import static org.onosproject.yangutils.translator.tojava.GeneratedTempFileType.FILTER_CONTENT_MATCH_FOR_LEAF_MASK;
import static org.onosproject.yangutils.translator.tojava.GeneratedTempFileType.FILTER_CONTENT_MATCH_FOR_NODES_MASK;
import static org.onosproject.yangutils.translator.tojava.utils.IndentationType.EIGHT_SPACE;
import static org.onosproject.yangutils.translator.tojava.utils.IndentationType.FOUR_SPACE;
import static org.onosproject.yangutils.translator.tojava.utils.IndentationType.SIXTEEN_SPACE;
import static org.onosproject.yangutils.translator.tojava.utils.IndentationType.TWELVE_SPACE;
import static org.onosproject.yangutils.translator.tojava.utils.IndentationType.TWENTY_EIGHT_SPACE;
import static org.onosproject.yangutils.translator.tojava.utils.IndentationType.TWENTY_FOUR_SPACE;
import static org.onosproject.yangutils.translator.tojava.utils.IndentationType.TWENTY_SPACE;
import static org.onosproject.yangutils.translator.tojava.utils.JavaFileGeneratorUtils.getDataFromTempFileHandle;
import static org.onosproject.yangutils.translator.tojava.utils.MethodClassTypes.CLASS_TYPE;
import static org.onosproject.yangutils.translator.tojava.utils.MethodsGenerator.getYangDataStructure;
import static org.onosproject.yangutils.translator.tojava.utils.StringGenerator.getAppInstanceAttrString;
import static org.onosproject.yangutils.translator.tojava.utils.StringGenerator.getElseIfConditionBegin;
import static org.onosproject.yangutils.translator.tojava.utils.StringGenerator.getEqualEqualString;
import static org.onosproject.yangutils.translator.tojava.utils.StringGenerator.getForLoopString;
import static org.onosproject.yangutils.translator.tojava.utils.StringGenerator.getIfConditionBegin;
import static org.onosproject.yangutils.translator.tojava.utils.StringGenerator.getLeafFlagSetString;
import static org.onosproject.yangutils.translator.tojava.utils.StringGenerator.getNewInstance;
import static org.onosproject.yangutils.translator.tojava.utils.StringGenerator.getOpenCloseParaWithValue;
import static org.onosproject.yangutils.translator.tojava.utils.StringGenerator.getReturnString;
import static org.onosproject.yangutils.translator.tojava.utils.StringGenerator.getTwoParaEqualsString;
import static org.onosproject.yangutils.translator.tojava.utils.StringGenerator.methodClose;
import static org.onosproject.yangutils.translator.tojava.utils.StringGenerator.multiAttrMethodSignature;
import static org.onosproject.yangutils.translator.tojava.utils.StringGenerator.signatureClose;
import static org.onosproject.yangutils.translator.tojava.utils.TranslatorUtils.getBeanFiles;
import static org.onosproject.yangutils.utils.UtilConstants.ADD_STRING;
import static org.onosproject.yangutils.utils.UtilConstants.AND_OPERATION;
import static org.onosproject.yangutils.utils.UtilConstants.APP_INSTANCE;
import static org.onosproject.yangutils.utils.UtilConstants.BIT_SET;
import static org.onosproject.yangutils.utils.UtilConstants.BOOLEAN_DATA_TYPE;
import static org.onosproject.yangutils.utils.UtilConstants.BREAK;
import static org.onosproject.yangutils.utils.UtilConstants.BUILDER;
import static org.onosproject.yangutils.utils.UtilConstants.BUILDER_LOWER_CASE;
import static org.onosproject.yangutils.utils.UtilConstants.BUILD_FOR_FILTER;
import static org.onosproject.yangutils.utils.UtilConstants.CLASS_STRING;
import static org.onosproject.yangutils.utils.UtilConstants.CLOSE_CURLY_BRACKET;
import static org.onosproject.yangutils.utils.UtilConstants.CLOSE_PARENTHESIS;
import static org.onosproject.yangutils.utils.UtilConstants.COMMA;
import static org.onosproject.yangutils.utils.UtilConstants.DEFAULT;
import static org.onosproject.yangutils.utils.UtilConstants.DEFAULT_CAPS;
import static org.onosproject.yangutils.utils.UtilConstants.DIAMOND_CLOSE_BRACKET;
import static org.onosproject.yangutils.utils.UtilConstants.DIAMOND_OPEN_BRACKET;
import static org.onosproject.yangutils.utils.UtilConstants.EIGHT_SPACE_INDENTATION;
import static org.onosproject.yangutils.utils.UtilConstants.ELSE;
import static org.onosproject.yangutils.utils.UtilConstants.EMPTY_STRING;
import static org.onosproject.yangutils.utils.UtilConstants.ENTRY;
import static org.onosproject.yangutils.utils.UtilConstants.ENTRY_SET;
import static org.onosproject.yangutils.utils.UtilConstants.EQUAL;
import static org.onosproject.yangutils.utils.UtilConstants.EQUALS_STRING;
import static org.onosproject.yangutils.utils.UtilConstants.EXTEND;
import static org.onosproject.yangutils.utils.UtilConstants.FALSE;
import static org.onosproject.yangutils.utils.UtilConstants.FLAG;
import static org.onosproject.yangutils.utils.UtilConstants.GET;
import static org.onosproject.yangutils.utils.UtilConstants.GET_KEY;
import static org.onosproject.yangutils.utils.UtilConstants.GET_VALUE;
import static org.onosproject.yangutils.utils.UtilConstants.INSTANCE;
import static org.onosproject.yangutils.utils.UtilConstants.IS_ANY_SELECT_OR_CONTAINMENT_NODE_FLAG;
import static org.onosproject.yangutils.utils.UtilConstants.IS_EMPTY;
import static org.onosproject.yangutils.utils.UtilConstants.IS_SELECT_ALL_SCHEMA_CHILD_FLAG;
import static org.onosproject.yangutils.utils.UtilConstants.KEYS;
import static org.onosproject.yangutils.utils.UtilConstants.LEAF_IDENTIFIER;
import static org.onosproject.yangutils.utils.UtilConstants.MAP;
import static org.onosproject.yangutils.utils.UtilConstants.NEW_LINE;
import static org.onosproject.yangutils.utils.UtilConstants.NOT;
import static org.onosproject.yangutils.utils.UtilConstants.NULL;
import static org.onosproject.yangutils.utils.UtilConstants.OPEN_CLOSE_BRACKET_STRING;
import static org.onosproject.yangutils.utils.UtilConstants.OPEN_CURLY_BRACKET;
import static org.onosproject.yangutils.utils.UtilConstants.OPEN_PARENTHESIS;
import static org.onosproject.yangutils.utils.UtilConstants.OP_PARAM;
import static org.onosproject.yangutils.utils.UtilConstants.OR_OPERATION;
import static org.onosproject.yangutils.utils.UtilConstants.PERIOD;
import static org.onosproject.yangutils.utils.UtilConstants.PRIVATE;
import static org.onosproject.yangutils.utils.UtilConstants.PROCESS_CHILD_NODE_STF_PARAM;
import static org.onosproject.yangutils.utils.UtilConstants.PROCESS_LEAF_LIST_STF_PARAM;
import static org.onosproject.yangutils.utils.UtilConstants.PROCESS_LEAF_STF_PARAM;
import static org.onosproject.yangutils.utils.UtilConstants.PROCESS_SUBTREE_FILTERING;
import static org.onosproject.yangutils.utils.UtilConstants.PUBLIC;
import static org.onosproject.yangutils.utils.UtilConstants.QUESTION_MARK;
import static org.onosproject.yangutils.utils.UtilConstants.RESULT;
import static org.onosproject.yangutils.utils.UtilConstants.SELECT_ALL_CHILD;
import static org.onosproject.yangutils.utils.UtilConstants.SELECT_ALL_CHILD_SCHEMA_PARAM;
import static org.onosproject.yangutils.utils.UtilConstants.SELECT_LEAF;
import static org.onosproject.yangutils.utils.UtilConstants.SELECT_OR_CONTAINMENT_NODE_PARAM;
import static org.onosproject.yangutils.utils.UtilConstants.SEMI_COLON;
import static org.onosproject.yangutils.utils.UtilConstants.SET_METHOD_PREFIX;
import static org.onosproject.yangutils.utils.UtilConstants.SIXTEEN_SPACE_INDENTATION;
import static org.onosproject.yangutils.utils.UtilConstants.SPACE;
import static org.onosproject.yangutils.utils.UtilConstants.STF_BUILDER_PARAM;
import static org.onosproject.yangutils.utils.UtilConstants.SUBTREE_FILTERED;
import static org.onosproject.yangutils.utils.UtilConstants.SUBTREE_FILTERING_RESULT_BUILDER;
import static org.onosproject.yangutils.utils.UtilConstants.THIRTY_TWO_SPACE_INDENTATION;
import static org.onosproject.yangutils.utils.UtilConstants.TO;
import static org.onosproject.yangutils.utils.UtilConstants.TRUE;
import static org.onosproject.yangutils.utils.UtilConstants.TWELVE_SPACE_INDENTATION;
import static org.onosproject.yangutils.utils.UtilConstants.TWENTY_EIGHT_SPACE_INDENTATION;
import static org.onosproject.yangutils.utils.UtilConstants.TWENTY_FOUR_SPACE_INDENTATION;
import static org.onosproject.yangutils.utils.UtilConstants.TWENTY_SPACE_INDENTATION;
import static org.onosproject.yangutils.utils.UtilConstants.TWO;
import static org.onosproject.yangutils.utils.UtilConstants.VALUE_LEAF;
import static org.onosproject.yangutils.utils.UtilConstants.VALUE_LEAF_SET;
import static org.onosproject.yangutils.utils.UtilConstants.ZERO;
import static org.onosproject.yangutils.utils.io.impl.YangIoUtils.getCamelCase;
import static org.onosproject.yangutils.utils.io.impl.YangIoUtils.getCapitalCase;

/**
 * Represents generator for subtree filtering methods of generated files
 * based on the file type.
 */
public final class SubtreeFilteringMethodsGenerator {

    /**
     * private to make it a util.
     */
    private SubtreeFilteringMethodsGenerator() {
    }

    /**
     * Returns process sub tree for choice interface class.
     *
     * @param node choice node
     * @return process sub tree for choice interface class
     */
    static String getProcessSubTreeForChoiceInterface(YangNode node) {
        if (!(node instanceof YangChoice)) {
            throw new TranslatorException("process sub tree for interface is " +
                                                  "only allowed in choice " +
                                                  "node.");
        }
        JavaFileInfoTranslator info = ((JavaCodeGeneratorInfo) node)
                .getJavaFileInfo();

        String name = info.getJavaName();
        String returnType = getCapitalCase(name);

        String javadoc = "\n   /**\n" +
                "     * Applications need not to implement process subtree " +
                "of " + name + "\n     * it will be overridden by " +
                "corresponding case class.\n" +
                "     *\n" +
                "     * @param " + APP_INSTANCE + SPACE +
                APP_INSTANCE + SPACE + "being passed to check" +
                " for" +
                " content match\n" +
                "     * @param isSelectAllSchemaChild is select all schema child\n" +
                "     * @return match result\n" +
                "     */\n";
        StringBuilder builder = new StringBuilder(javadoc);
        Map<String, String> param = new LinkedHashMap<>();
        param.put(APP_INSTANCE, returnType);
        param.put(SELECT_ALL_CHILD_SCHEMA_PARAM, BOOLEAN_DATA_TYPE);
        builder.append(multiAttrMethodSignature(PROCESS_SUBTREE_FILTERING, null,
                                                DEFAULT, returnType, param,
                                                CLASS_TYPE))
                .append(getReturnString(NULL, EIGHT_SPACE_INDENTATION))
                .append(signatureClose()).append(methodClose(FOUR_SPACE));
        return builder.toString();
    }

    /**
     * Returns is filter content match for leaf.
     *
     * @param javaAttributeInfo java attribute
     * @param type              data type
     * @return is filter content match for leaf
     */
    public static String getSubtreeFilteringForLeaf(
            JavaAttributeInfo javaAttributeInfo, YangType<?> type) {
        String attrQualifiedType;
        String attributeName = javaAttributeInfo.getAttributeName();
        attrQualifiedType = getIfFilterContentMatchMethodImpl(attributeName,
                                                              type);
        /* if (valueLeafFlags.get(LeafIdentifier.LEAF.getLeafIndex())) {
         * if (appInstance.leaf() != leaf()) {
         * return false;
         * } else {
         * subTreeFilteringResultBuilder.leaf(appInstance.leaf());
         * }
         * } else if (selectLeafFlags.get(LeafIdentifier.LEAF.getLeafIndex()) ||
         * isSelectAllSchemaChild) {
         * isAnySelectOrContainmentNode = true;
         * subTreeFilteringResultBuilder.leaf(appInstance.leaf());
         * }*/

/*        if (isSubTreeFiltered && !appInstance.isLeafValueSet(
                LeafIdentifier.LEAF2)) {
            subTreeFilteringResultBuilder.leaf2(leaf2());
        } else {
            return false;
        }*/
        String condition = SUBTREE_FILTERED + SPACE + AND_OPERATION + SPACE + NOT +
                APP_INSTANCE + PERIOD + VALUE_LEAF_SET +
                getOpenCloseParaWithValue(
                        LEAF_IDENTIFIER + PERIOD + attributeName.toUpperCase());
        return getIfConditionBegin(EIGHT_SPACE_INDENTATION, getLeafFlagSetString(
                attributeName, VALUE_LEAF, EMPTY_STRING, GET)) +
                getIfConditionBegin(TWELVE_SPACE_INDENTATION, attrQualifiedType) +
                getIfConditionBegin(SIXTEEN_SPACE_INDENTATION, condition) +
                TWENTY_SPACE_INDENTATION + SUBTREE_FILTERING_RESULT_BUILDER +
                PERIOD + attributeName + getOpenCloseParaWithValue(
                attributeName + OPEN_CLOSE_BRACKET_STRING) + signatureClose() +
                SIXTEEN_SPACE_INDENTATION + CLOSE_CURLY_BRACKET + ELSE +
                OPEN_CURLY_BRACKET + NEW_LINE + getReturnString(
                FALSE, TWENTY_SPACE_INDENTATION) + signatureClose() +
                SIXTEEN_SPACE_INDENTATION + CLOSE_CURLY_BRACKET + NEW_LINE +
                TWELVE_SPACE_INDENTATION + CLOSE_CURLY_BRACKET + ELSE +
                OPEN_CURLY_BRACKET + NEW_LINE +
                getSubTreeBuilderCallString(SIXTEEN_SPACE_INDENTATION, attributeName,
                                            TWELVE_SPACE) +
                getElseIfConditionBegin(EIGHT_SPACE_INDENTATION, getLeafFlagSetString(
                        attributeName, SELECT_LEAF, EMPTY_STRING, GET) + SPACE +
                        OR_OPERATION + SPACE + IS_SELECT_ALL_SCHEMA_CHILD_FLAG) +
                getSelectOrContainmentAssignString() +
                getSubTreeBuilderCallString(TWELVE_SPACE_INDENTATION, attributeName,
                                            EIGHT_SPACE);
    }

    private static String getSubTreeBuilderCallString(String indent, String
            name, IndentationType type) {
        return indent + SUBTREE_FILTERING_RESULT_BUILDER + PERIOD + name +
                getOpenCloseParaWithValue(APP_INSTANCE + PERIOD + name +
                                                  OPEN_CLOSE_BRACKET_STRING) +
                signatureClose() + methodClose(type);
    }

    private static String getAttrTypeForFcmWhenPrimitiveDataType(
            String attributeName) {
        return/* TODO: Need to check if we can expose the value leaf flag in
         interface.
                NOT + APP_INSTANCE + PERIOD + GET_VALUE_LEAF_FLAGS +
                OPEN_PARENTHESIS + CLOSE_PARENTHESIS +
                GET_METHOD_PREFIX + OPEN_PARENTHESIS + LEAF_IDENTIFIER +
                PERIOD + attributeName.toUpperCase() + PERIOD
                + GET_LEAF_INDEX + OR_OPERATION +*/
                APP_INSTANCE + PERIOD + attributeName + OPEN_PARENTHESIS +
                        CLOSE_PARENTHESIS + SPACE + NOT + EQUAL + SPACE +
                        attributeName + OPEN_PARENTHESIS +
                        CLOSE_PARENTHESIS;
    }

    private static String attrTypeForFcmWhenNonPrimitiveDataTypes(String name) {
        /*
         * appInstance.name() == null || name().equals(appInstance.name())
         */
        return getEqualEqualString(StringGenerator.getAppInstanceAttrString(name), NULL) +
                SPACE + OR_OPERATION + SPACE + NOT + OPEN_PARENTHESIS +
                getTwoParaEqualsString(name + OPEN_CLOSE_BRACKET_STRING,
                                       StringGenerator.getAppInstanceAttrString(name))
                + CLOSE_PARENTHESIS;
    }

    private static String getIfFilterContentMatchMethodImpl(
            String name, YangType dataType) {
        String attrQualifiedType;
        if (dataType.getDataType().isPrimitiveDataType()) {
            attrQualifiedType = getAttrTypeForFcmWhenPrimitiveDataType(name);
        } else if (dataType.getDataType() == LEAFREF) {

            // When leafref in grouping.
            if (((YangLeafRef) dataType.getDataTypeExtendedInfo())
                    .isInGrouping()) {
                attrQualifiedType = attrTypeForFcmWhenNonPrimitiveDataTypes(name);
            } else {
                YangType type = ((YangLeafRef) dataType.getDataTypeExtendedInfo())
                        .getEffectiveDataType();
                if (type.getDataType().isPrimitiveDataType()) {
                    attrQualifiedType = getAttrTypeForFcmWhenPrimitiveDataType(name);
                } else {
                    attrQualifiedType = attrTypeForFcmWhenNonPrimitiveDataTypes(
                            name);
                }
            }
        } else {
            attrQualifiedType = attrTypeForFcmWhenNonPrimitiveDataTypes(name);
        }
        return attrQualifiedType;
    }

    /**
     * Returns is filter content match for leaf.
     *
     * @param javaAttributeInfo java attribute
     * @return is filter content match for leaf
     */
    public static String getSubtreeFilteringForLeafList(
            JavaAttributeInfo javaAttributeInfo) {
        return getSubtreeFilteringForList(javaAttributeInfo, true, null);
    }

    /**
     * Returns is filter content match for child node.
     *
     * @param curNode current node
     * @param path    path of temp file
     * @return is filter content match for child node
     */
    static String getProcessChildNodeSubtreeFiltering(YangNode curNode, String path)
            throws IOException {
       /* Generate code will look like this.
        private boolean processChildNodesSubTreeFiltering(Link
 appInstance, LinkBuilder subTreeFilteringResultBuilder,
                Boolean isAnySelectOrContainmentNode, boolean isSelectAllSchemaChild) {
            if (isSelectAllSchemaChild) {
                for (Areas areas : appInstance.areas()) {
                    subTreeFilteringResultBuilder.addToAreas(areas);
                }
            } else if (areas() != null) {
                isAnySelectOrContainmentNode = true;
                if (!areas().isEmpty()) {
                    if (appInstance.areas() != null && !appInstance.areas().isEmpty()) {
                        for (Areas areas : areas()) {
                            for (Areas areas2 : appInstance.areas()) {
                                Areas result = areas.processSubtreeFiltering(areas2, false);
                                if (result != null) {
                                    subTreeFilteringResultBuilder.addToAreas(result);
                                }
                            }
                        }
                    }
                } else {
                    if (appInstance.areas() != null && !appInstance.areas().isEmpty()) {
                        for (Areas areas : appInstance.areas()) {
                            subTreeFilteringResultBuilder.addToAreas(areas);
                        }
                    }
                }
            }

            return true;
        }*/
        return getProcessStfMethods(PROCESS_CHILD_NODE_STF_PARAM, curNode,
                                    path,
                                    FILTER_CONTENT_MATCH_FOR_NODES_MASK);
    }

    /**
     * Returns is filter content match for leaf list.
     *
     * @param curNode current node
     * @param path    path of temp file
     * @return is filter content match for leaf list
     */
    static String getProcessLeafListSubtreeFiltering(YangNode curNode, String path)
            throws IOException {
       /* Generate code will look like this.
        private boolean processLeafListSubTreeFiltering(Link appInstance, LinkBuilder subTreeFilteringResultBuilder,
                Boolean isAnySelectOrContainmentNode, boolean isSelectAllSchemaChild) {
            if (isSelectAllSchemaChild) {
                for (String portId : appInstance.portId()) {
                    subTreeFilteringResultBuilder.addToPortId(portId);
                }
            } else if (portId() != null) {
                if (!portId().isEmpty()) {
                    if (appInstance.portId() == null || appInstance.portId().isEmpty()) {
                        return false;
                    }
                    for (String portId : portId()) {
                        boolean flag = false;
                        for (String portId2 : appInstance.portId()) {
                            if (portId.equals(portId2)) {
                                flag = true;
                                subTreeFilteringResultBuilder.addToPortId(portId2);
                                break;
                            }
                        }
                        if (!flag) {
                            return false;
                        }
                    }
                } else {
                    isAnySelectOrContainmentNode = true;
                    if (appInstance.portId() != null && !appInstance.portId().isEmpty()) {
                        for (String portId : appInstance.portId()) {
                            subTreeFilteringResultBuilder.addToPortId(portId);
                        }
                    }
                }
            }

            return true;
        }*/
        return getProcessStfMethods(PROCESS_LEAF_LIST_STF_PARAM, curNode, path,
                                    FILTER_CONTENT_MATCH_FOR_LEAF_LIST_MASK);
    }

    /**
     * Returns is filter content match for leaf.
     *
     * @param curNode current node
     * @param path    path of temp file
     * @return is filter content match for leaf
     */
    static String getProcessLeafSubtreeFiltering(YangNode curNode, String path)
            throws IOException {
     /* Generate code will look like this.
      private boolean processLeafSubtreeFiltering(Link appInstance, LinkBuilder subTreeFilteringResultBuilder,
                Boolean isAnySelectOrContainmentNode, boolean isSelectAllSchemaChild) {
            if (valueLeafFlags.get(LeafIdentifier.PORT.getLeafIndex())) {
                if (appInstance.port() != port()) {
                    return false;
                } else {
                    subTreeFilteringResultBuilder.port(appInstance.port());
                }
            } else if (selectLeafFlags.get(LeafIdentifier.PORT.getLeafIndex()) || isSelectAllSchemaChild) {
                isAnySelectOrContainmentNode = true;
                subTreeFilteringResultBuilder.port(appInstance.port());
            }

            return true;
        }*/
        return getProcessStfMethods(PROCESS_LEAF_STF_PARAM, curNode, path,
                                    FILTER_CONTENT_MATCH_FOR_LEAF_MASK);
    }

    /**
     * Returns is filter content match for leaf.
     *
     * @param curNode current node
     * @return is filter content match for leaf
     */
    static String getProcessSubtreeFilteringStart(YangNode curNode) {

       /* Generate code will look like this.
       public Link processSubtreeFiltering(Link appInstance, boolean isSelectAllSchemaChild) {
            LinkBuilder subTreeFilteringResultBuilder = new LinkBuilder();
            Boolean isAnySelectOrContainmentNode = false;
        */
        StringBuilder builder = new StringBuilder();
        JavaFileInfoTranslator javaFileInfo =
                ((JavaFileInfoContainer) curNode).getJavaFileInfo();
        String instance = APP_INSTANCE;
        String name = getCapitalCase(javaFileInfo.getJavaName());
        String builderNamePrefix = getCapitalCase(javaFileInfo.getJavaName());
        String caseName = getNameOfClassForIfCase(curNode);
        String returnType;
        if (curNode instanceof RpcNotificationContainer) {
            returnType = name + OP_PARAM;
        } else {
            returnType = DEFAULT_CAPS + name;
        }
        if (caseName != null) {
            instance = INSTANCE;
            name = caseName;
        }

        String javadoc = "\n    /**\n" +
                "     * Checks if the passed " + name + " maps the content " +
                "match query condition.\n" +
                "     *\n" +
                "     * @param " + instance + SPACE + instance + SPACE +
                "being passed to check for content match\n" +
                "     * @param isSelectAllSchemaChild is select all schema " +
                "child\n" +
                "     * @return match result\n" +
                "     */\n";
        Map<String, String> param = new LinkedHashMap<>();
        param.put(instance, name);
        param.put(SELECT_ALL_CHILD_SCHEMA_PARAM, BOOLEAN_DATA_TYPE);
        builder.append(javadoc)
                .append(multiAttrMethodSignature(PROCESS_SUBTREE_FILTERING, null,
                                                 PUBLIC, returnType, param,
                                                 CLASS_TYPE));

        builder.append(getNewInstance(builderNamePrefix + BUILDER,
                                      SUBTREE_FILTERING_RESULT_BUILDER,
                                      EIGHT_SPACE_INDENTATION, EMPTY_STRING));
        builder.append(getNewInstance(BIT_SET,
                                      IS_ANY_SELECT_OR_CONTAINMENT_NODE_FLAG,
                                      EIGHT_SPACE_INDENTATION, EMPTY_STRING));
        if (caseName != null) {
            builder.append(getCaseCastString(javaFileInfo, instance, curNode));
        }

        return builder.toString();
    }

    /**
     * Returns all process sub tree method implementations.
     *
     * @param methodName method name
     * @param curNode    current node
     * @param path       path for temporary file
     * @param file       temp file
     * @return method implementations
     * @throws IOException when fails to fetch data from temp files
     */
    private static String getProcessStfMethods(
            String methodName, YangNode curNode, String path, int file)
            throws IOException {
        StringBuilder builder = new StringBuilder(EMPTY_STRING);
        JavaFileInfoTranslator javaFileInfo =
                ((JavaFileInfoContainer) curNode).getJavaFileInfo();
        String instance = APP_INSTANCE;
        String name = getCapitalCase(javaFileInfo.getJavaName());
        String builderNamePrefix = getCapitalCase(javaFileInfo.getJavaName());
        String caseName = getNameOfClassForIfCase(curNode);
        if (caseName != null) {
            instance = INSTANCE;
            name = caseName;
        }

        Map<String, String> param = new LinkedHashMap<>();
        param.put(instance, name);
        param.put(STF_BUILDER_PARAM, builderNamePrefix + BUILDER);
        param.put(SELECT_OR_CONTAINMENT_NODE_PARAM, BIT_SET);
        param.put(SELECT_ALL_CHILD_SCHEMA_PARAM, BOOLEAN_DATA_TYPE);

        builder.append(multiAttrMethodSignature(methodName, null,
                                                PRIVATE, BOOLEAN_DATA_TYPE, param, CLASS_TYPE));

        if (caseName != null) {
            builder.append(getCaseCastString(javaFileInfo, instance, curNode));
        }
        builder.append(getDataFromTempFileHandle(file,
                                                 getBeanFiles(curNode), path))
                .append(getReturnString(TRUE, EIGHT_SPACE_INDENTATION)).append(
                signatureClose()).append(methodClose(FOUR_SPACE))
                .append(NEW_LINE);
        return builder.toString();
    }

    /**
     * Returns the body for process subtree filtering.
     *
     * @param curNode node for which the code is being generated
     * @return body of subtree filtering
     */
    static String getProcessSubtreeFunctionBody(YangNode curNode) {
        StringBuilder builder = new StringBuilder();

       /* if (!processLeafSubtreeFiltering(appInstance, subTreeFilteringResultBuilder,
                                         isAnySelectOrContainmentNode, isSelectAllSchemaChild)) {
            return null;
        }
        if (!processLeafListSubTreeFiltering(appInstance, subTreeFilteringResultBuilder,
                                             isAnySelectOrContainmentNode, isSelectAllSchemaChild)) {
            return null;
        }
        if (!processChildNodesSubTreeFiltering(appInstance, subTreeFilteringResultBuilder,
                                               isAnySelectOrContainmentNode, isSelectAllSchemaChild)) {
            return null;
        }
      */
        if (curNode instanceof YangLeavesHolder) {
            YangLeavesHolder holder = (YangLeavesHolder) curNode;
            if (!holder.getListOfLeaf().isEmpty()) {
                builder.append(getInnerStfMethodClass(PROCESS_LEAF_STF_PARAM));
            }
            if (!holder.getListOfLeafList().isEmpty()) {
                builder.append(getInnerStfMethodClass(PROCESS_LEAF_LIST_STF_PARAM));
            }
        }
        if (curNode.getChild() != null) {
            builder.append(getInnerStfMethodClass(PROCESS_CHILD_NODE_STF_PARAM));
        }

        return builder.toString();
    }

    //Method calls for process subtree filtering method.
    private static String getInnerStfMethodClass(String name) {
        StringBuilder builder = new StringBuilder()
                .append(getIfConditionBegin(EIGHT_SPACE_INDENTATION,
                                            getMethodCallsConditionsForStfMethods(name)))
                .append(getReturnString(NULL, TWELVE_SPACE_INDENTATION)).append(
                        signatureClose()).append(methodClose(EIGHT_SPACE));
        return builder.toString();
    }

    // Condition for if check in process sub tree method.
    private static String getMethodCallsConditionsForStfMethods(String name) {
        return NOT + name + getOpenCloseParaWithValue(getConditionString());
    }

    //variable call for conditional method call
    private static String getConditionString() {
        return APP_INSTANCE + COMMA + SPACE + SUBTREE_FILTERING_RESULT_BUILDER +
                COMMA + SPACE + SELECT_OR_CONTAINMENT_NODE_PARAM + COMMA + SPACE +
                SELECT_ALL_CHILD;
    }

    /**
     * Returns is filter content match for node.
     *
     * @param attr attribute info
     * @param node YANG node
     * @return is filter content match for node
     */
    public static String getSubtreeFilteringForNode(JavaAttributeInfo attr, YangNode node) {
        boolean isList = attr.isListAttr();
        if (isList) {
            return getSubtreeFilteringForList(attr, false, node);
        } else {
            return getSubtreeFilteringForChildNode(attr, node);
        }
    }

    /**
     * Returns is filter content match close.
     *
     * @param name name of class
     * @return is filter content match close
     */
    static String getProcessSubTreeFilteringEnd(String name) {
        /* generate code will look like this.
        if (!isSelectAllSchemaChild && !isAnySelectOrContainmentNode) {
            return processSubtreeFiltering(appInstance, true);
        }
        return subTreeFilteringResultBuilder.build();
        */

        StringBuilder builder = new StringBuilder();
        String cond1 = NOT + IS_SELECT_ALL_SCHEMA_CHILD_FLAG + SPACE + AND_OPERATION +
                SPACE + NOT + IS_ANY_SELECT_OR_CONTAINMENT_NODE_FLAG +
                PERIOD + GET + getOpenCloseParaWithValue(ZERO);
        String call = PROCESS_SUBTREE_FILTERING + getOpenCloseParaWithValue(
                APP_INSTANCE + COMMA + SPACE + TRUE);
        builder.append(getIfConditionBegin(EIGHT_SPACE_INDENTATION, cond1))
                .append(getReturnString(call, TWELVE_SPACE_INDENTATION))
                .append(signatureClose()).append(methodClose(EIGHT_SPACE));

        call = getOpenCloseParaWithValue(name) + SPACE +
                SUBTREE_FILTERING_RESULT_BUILDER + PERIOD + BUILD_FOR_FILTER +
                OPEN_CLOSE_BRACKET_STRING;
        builder.append(getReturnString(call, EIGHT_SPACE_INDENTATION))
                .append(signatureClose()).append(methodClose(FOUR_SPACE))
                .append(NEW_LINE);
        return builder.toString();
    }

    /**
     * Returns filter content match for child nodes.
     *
     * @param attr attribute to be added
     * @param node YANG node
     * @return filter content match for child nodes
     */
    private static String getSubtreeFilteringForChildNode(JavaAttributeInfo attr,
                                                          YangNode node) {
        StringBuilder builder = new StringBuilder();
        String name = attr.getAttributeName();
        String clsInfo = attr.getImportInfo()
                .getClassInfo();
        String type = DEFAULT_CAPS + attr.getImportInfo()
                .getClassInfo();
        if (attr.isQualifiedName()) {
            type = attr.getImportInfo().getPkgInfo() + PERIOD +
                    type;
            clsInfo = attr.getImportInfo().getPkgInfo() + PERIOD +
                    clsInfo;
        }
        String classCast = getOpenCloseParaWithValue(type) + SPACE;
        String cast = getOpenCloseParaWithValue(classCast + name);
        if (node != null && node instanceof YangChoice) {
            cast = name;
        }

        String resultString = cast + NEW_LINE + TWENTY_EIGHT_SPACE_INDENTATION +
                PERIOD + PROCESS_SUBTREE_FILTERING + OPEN_PARENTHESIS
                + APP_INSTANCE + PERIOD + name + OPEN_CLOSE_BRACKET_STRING
                + COMMA + SPACE + FALSE + CLOSE_PARENTHESIS + SEMI_COLON +
                NEW_LINE;

        String cond1 = name + OPEN_CLOSE_BRACKET_STRING + SPACE + NOT + EQUAL +
                SPACE + NULL + SPACE + OR_OPERATION + SPACE + SELECT_ALL_CHILD;
        builder.append(getIfConditionBegin(EIGHT_SPACE_INDENTATION, cond1))
                .append(getSelectOrContainmentAssignString());

        builder.append(getIfConditionBegin(TWELVE_SPACE_INDENTATION,
                                           getAppInstanceCondition(name, NOT)));

        String assignment = SIXTEEN_SPACE_INDENTATION + clsInfo + SPACE + RESULT +
                SPACE + EQUAL + SPACE + NULL + signatureClose();

        builder.append(assignment)
                .append(getIfConditionBegin(SIXTEEN_SPACE_INDENTATION,
                                            SELECT_ALL_CHILD));
/*
        result = ((DefaultInterfaces)(DefaultInterfaces.builder()
                .build())).processSubtreeFiltering(appInstance.interfaces(),
                                                   true);*/

        assignment = getDummyObjectCreation(node, name, clsInfo, type,
                                            classCast, false, false);
        builder.append(assignment).append(SIXTEEN_SPACE_INDENTATION).append(
                CLOSE_CURLY_BRACKET).append(ELSE).append(OPEN_CURLY_BRACKET)
                .append(NEW_LINE);

        assignment = TWENTY_SPACE_INDENTATION + RESULT + SPACE + EQUAL + SPACE
                + resultString;
        cond1 = RESULT + SPACE + NOT + EQUAL + SPACE + NULL;

        builder.append(assignment).append(methodClose(SIXTEEN_SPACE))
                .append(getIfConditionBegin(SIXTEEN_SPACE_INDENTATION, cond1));

        assignment = TWENTY_SPACE_INDENTATION + SUBTREE_FILTERING_RESULT_BUILDER +
                PERIOD + name + getOpenCloseParaWithValue(RESULT) +
                signatureClose();
        builder.append(assignment).append(methodClose(SIXTEEN_SPACE)).append(
                TWELVE_SPACE_INDENTATION).append(CLOSE_CURLY_BRACKET)
                .append(getSubTreeFilteredCondition(name)).append(methodClose(EIGHT_SPACE));
        return builder.toString();
    }

    private static String getAppInstanceCondition(String name, String condition) {
        return APP_INSTANCE + PERIOD + name + OPEN_CLOSE_BRACKET_STRING + SPACE +
                condition + EQUAL + SPACE + NULL;
    }

    private static String getSelectOrContainmentAssignString() {
        return TWELVE_SPACE_INDENTATION + IS_ANY_SELECT_OR_CONTAINMENT_NODE_FLAG +
                PERIOD + SET_METHOD_PREFIX + getOpenCloseParaWithValue(ZERO) +
                signatureClose();
    }

    /**
     * Returns filter content match for list types.
     *
     * @param javaAttributeInfo attribute information
     * @param isLeafList        if for leaf list
     * @param node              YANG node
     * @return filter content match for list types
     */
    private static String getSubtreeFilteringForList(
            JavaAttributeInfo javaAttributeInfo, boolean isLeafList,
            YangNode node) {
        StringBuilder builder = new StringBuilder();
        String caps = getCapitalCase(javaAttributeInfo.getAttributeName());
        String name = javaAttributeInfo.getAttributeName();
        String type = javaAttributeInfo.getImportInfo().getClassInfo();
        if (javaAttributeInfo.getAttributeType() != null && javaAttributeInfo
                .getAttributeType().getDataType() == IDENTITYREF) {
            type = CLASS_STRING + DIAMOND_OPEN_BRACKET +
                    QUESTION_MARK + SPACE + EXTEND + SPACE +
                    type + DIAMOND_CLOSE_BRACKET;
        }

        YangDataStructure struct = getYangDataStructure
                (javaAttributeInfo.getCompilerAnnotation());

        boolean isMap = false;
        if (struct != null && struct == YangDataStructure.MAP) {
            isMap = true;
        }

        String clsInfo = DEFAULT_CAPS + type;
        if (javaAttributeInfo.isQualifiedName()) {
            if (javaAttributeInfo.getAttributeType() != null && javaAttributeInfo
                    .getAttributeType().getDataType() == IDENTITYREF) {
                type = CLASS_STRING + DIAMOND_OPEN_BRACKET +
                        QUESTION_MARK + SPACE + EXTEND + SPACE +
                        javaAttributeInfo.getImportInfo().getPkgInfo() + PERIOD +
                        type + DIAMOND_CLOSE_BRACKET;
            } else {
                type = javaAttributeInfo.getImportInfo().getPkgInfo() + PERIOD +
                        type;
            }
            clsInfo = javaAttributeInfo.getImportInfo().getPkgInfo() + PERIOD +
                    clsInfo;
        }

        String classCast = getOpenCloseParaWithValue(clsInfo) + SPACE;
        String cast = getOpenCloseParaWithValue(classCast + name);

        if (node != null && node instanceof YangChoice) {
            cast = name;
        }
        String validPass;
        //If map is in DS then need to pass name.getValue() to processSubTree.
        if (isMap) {
            validPass = name + TWO + PERIOD + GET_VALUE;
        } else {
            validPass = name + TWO;
        }
        String resultString = cast + NEW_LINE + TWENTY_EIGHT_SPACE_INDENTATION +
                PERIOD + PROCESS_SUBTREE_FILTERING + OPEN_PARENTHESIS +
                validPass + COMMA + SPACE + FALSE + CLOSE_PARENTHESIS + SEMI_COLON +
                NEW_LINE;
        /*
         * If select all schema child
         */
        String forCondition;
        String mapEntry;
        String para;
        //If map is there in DS the for loop should run for map entry.
        if (!isMap) {
            forCondition = getForLoopString(SIXTEEN_SPACE_INDENTATION, type, name,
                                            getAppInstanceAttrString(name));
        } else {
            mapEntry = MAP + PERIOD + ENTRY + DIAMOND_OPEN_BRACKET + type +
                    KEYS + COMMA + SPACE + type + DIAMOND_CLOSE_BRACKET + SPACE;
            para = getAppInstanceAttrString(name) + PERIOD + ENTRY_SET;
            forCondition = getForLoopString(SIXTEEN_SPACE_INDENTATION,
                                            mapEntry, name, para);
        }
        builder.append(getIfConditionBegin(EIGHT_SPACE_INDENTATION,
                                           IS_SELECT_ALL_SCHEMA_CHILD_FLAG))
                .append(getIfConditionBegin(TWELVE_SPACE_INDENTATION,
                                            getAppInstanceCondition(name, NOT)))
                .append(forCondition);
        String assignment;
        String result;
        //If map is added then while creating dummy object need to used name
        // .getValue() and to add the result in subTreeBuilder need to pass
        // using key and value, key will be name.getKey() and value will be
        // result.
        if (isMap) {
            result = getOpenCloseParaWithValue(name + PERIOD + GET_KEY + COMMA +
                                                       SPACE + RESULT);
        } else {
            result = getOpenCloseParaWithValue(RESULT);
        }
        if (!isLeafList) {
            builder.append(TWENTY_SPACE_INDENTATION).append(type).append(SPACE)
                    .append(RESULT).append(signatureClose());
            assignment = getDummyObjectCreation(node, name, type, clsInfo,
                                                classCast, true, isMap);
            builder.append(assignment);
            assignment = TWENTY_SPACE_INDENTATION +
                    SUBTREE_FILTERING_RESULT_BUILDER + PERIOD + ADD_STRING +
                    getCapitalCase(TO) + caps + result +
                    signatureClose();
            builder.append(assignment);
        } else {
            assignment = TWENTY_SPACE_INDENTATION +
                    SUBTREE_FILTERING_RESULT_BUILDER + PERIOD + ADD_STRING +
                    getCapitalCase(TO) + caps + getOpenCloseParaWithValue(name) +
                    signatureClose();
            builder.append(assignment);
        }
        builder.append(methodClose(SIXTEEN_SPACE))
                .append(TWELVE_SPACE_INDENTATION).append(CLOSE_CURLY_BRACKET);

/*    } else {
        if (isSubTreeFiltered && leafList2() != null) {
            subTreeFilteringResultBuilder.addToLeafList2(leafList2());
        }
    }*/
        builder.append(getSubTreeFilteredCondition(name));

        String cond = name + OPEN_CLOSE_BRACKET_STRING + SPACE + NOT + EQUAL +
                SPACE + NULL;

        //If need to explicitly participate in query
        builder.append(getElseIfConditionBegin(EIGHT_SPACE_INDENTATION, cond));

        if (!isLeafList) {
            builder.append(getSelectOrContainmentAssignString());
        }

        //If there is any parameter in the query condition
        cond = NOT + name + OPEN_CLOSE_BRACKET_STRING + PERIOD + IS_EMPTY;
        builder.append(getIfConditionBegin(TWELVE_SPACE_INDENTATION, cond));

        if (isLeafList) {
            cond = getAppInstanceCondition(name, EQUAL) + SPACE + OR_OPERATION +
                    SPACE + APP_INSTANCE + PERIOD + name +
                    OPEN_CLOSE_BRACKET_STRING + PERIOD + IS_EMPTY;
            /*
             * If there is no app instance to perform content match
             */
            builder.append(getIfConditionBegin(SIXTEEN_SPACE_INDENTATION, cond))
                    .append(getReturnString(FALSE, TWENTY_SPACE_INDENTATION))
                    .append(signatureClose())
                    .append(methodClose(SIXTEEN_SPACE))
                    // for instance iterator
                    .append(getForLoopString(SIXTEEN_SPACE_INDENTATION, type, name,
                                             name + OPEN_CLOSE_BRACKET_STRING));

            assignment = TWENTY_SPACE_INDENTATION + BOOLEAN_DATA_TYPE + SPACE +
                    FLAG + SPACE + EQUAL + SPACE + FALSE + signatureClose();
            builder.append(assignment)
                    // for app instance iterator
                    .append(getForLoopString(TWENTY_SPACE_INDENTATION, type,
                                             name + TWO,
                                             getAppInstanceAttrString(name)));

            cond = name + PERIOD + EQUALS_STRING
                    + OPEN_PARENTHESIS + name + TWO + CLOSE_PARENTHESIS;
            //the content match leaf list attribute value matches
            builder.append(getIfConditionBegin(TWENTY_FOUR_SPACE_INDENTATION,
                                               cond));

            assignment = TWENTY_EIGHT_SPACE_INDENTATION + FLAG + SPACE + EQUAL +
                    SPACE + TRUE + SEMI_COLON + NEW_LINE;
            builder.append(assignment);
            assignment = TWENTY_EIGHT_SPACE_INDENTATION +
                    SUBTREE_FILTERING_RESULT_BUILDER + PERIOD + ADD_STRING +
                    getCapitalCase(TO) + caps + getOpenCloseParaWithValue(name + TWO) +
                    signatureClose();
            builder.append(assignment).append(TWENTY_EIGHT_SPACE_INDENTATION)
                    .append(BREAK).append(signatureClose())
                    //the content match leaf list attribute value matches
                    .append(methodClose(TWENTY_FOUR_SPACE))
                    // for app instance iterator
                    .append(methodClose(TWENTY_SPACE))
                    //if the content match failed
                    .append(getIfConditionBegin(TWENTY_SPACE_INDENTATION, NOT +
                            FLAG))
                    .append(getReturnString(FALSE, TWENTY_FOUR_SPACE_INDENTATION))
                    .append(signatureClose()).append(methodClose(TWENTY_SPACE))// if flag == false
                    .append(methodClose(SIXTEEN_SPACE)); // for instance iterator

        } else {
            cond = getAppInstanceCondition(name, NOT) + SPACE + AND_OPERATION +
                    SPACE + NOT + getAppInstanceAttrString(name) +
                    PERIOD + IS_EMPTY;
            //Same here for loop for map entry.
            if (!isMap) {
                forCondition = getForLoopString(TWENTY_SPACE_INDENTATION, type,
                                                name + TWO,
                                                getAppInstanceAttrString(name));
            } else {
                mapEntry = MAP + PERIOD + ENTRY + DIAMOND_OPEN_BRACKET + type +
                        KEYS + COMMA + SPACE + type + DIAMOND_CLOSE_BRACKET + SPACE;
                para = getAppInstanceAttrString(name) + PERIOD + ENTRY_SET;
                forCondition = getForLoopString(TWENTY_SPACE_INDENTATION,
                                                mapEntry, name + TWO, para);
            }
            String forCondition2;
            //Same here for loop for map entry.
            if (!isMap) {
                forCondition2 = getForLoopString(SIXTEEN_SPACE_INDENTATION, type, name,
                                                 name + OPEN_CLOSE_BRACKET_STRING);
            } else {
                mapEntry = MAP + PERIOD + ENTRY + DIAMOND_OPEN_BRACKET + type +
                        KEYS + COMMA + SPACE + type + DIAMOND_CLOSE_BRACKET + SPACE;
                para = name + OPEN_CLOSE_BRACKET_STRING + PERIOD + ENTRY_SET;
                forCondition2 = getForLoopString(SIXTEEN_SPACE_INDENTATION,
                                                 mapEntry, name, para);
            }
            /*if there is any app instance entry*/
            builder.append(getIfConditionBegin(SIXTEEN_SPACE_INDENTATION,
                                               cond))
                    //loop all the app instance(s)
                    .append(forCondition2)
                    .append(forCondition);


            assignment = TWENTY_EIGHT_SPACE_INDENTATION + type + SPACE +
                    RESULT + SPACE + EQUAL + SPACE + resultString;
            builder.append(assignment);
            cond = RESULT + SPACE + NOT + EQUAL + SPACE + NULL;
            builder.append(getIfConditionBegin(TWENTY_EIGHT_SPACE_INDENTATION, cond));

            //If map is added then while creating dummy object need to used name
            // .getValue() and to add the result in subTreeBuilder need to pass
            // using key and value, key will be name.getKey() and value will be
            // result.
            if (isMap) {
                result = getOpenCloseParaWithValue(name + TWO + PERIOD + GET_KEY +
                                                           COMMA +
                                                           SPACE + RESULT);
            } else {
                result = getOpenCloseParaWithValue(RESULT);
            }
            assignment = THIRTY_TWO_SPACE_INDENTATION +
                    SUBTREE_FILTERING_RESULT_BUILDER + PERIOD + ADD_STRING +
                    getCapitalCase(TO) + caps + result + signatureClose();
            builder.append(assignment).append(methodClose(TWENTY_EIGHT_SPACE))
                    //loop all the app instance(s)
                    .append(methodClose(TWENTY_FOUR_SPACE))
                    //loop all the query condition instance(s)
                    .append(methodClose(TWENTY_SPACE))
                    .append(SIXTEEN_SPACE_INDENTATION).append(CLOSE_CURLY_BRACKET)
                    .append(getSubTreeFilteredCondition(name));
            //if there is any app instance entry
        }

        cond = TWELVE_SPACE_INDENTATION + CLOSE_CURLY_BRACKET
                + ELSE + OPEN_CURLY_BRACKET + NEW_LINE;
        builder.append(cond);

        if (isLeafList) {
            builder.append(getSelectOrContainmentAssignString());
        }

        //need to pass name.getKey() and name.getValue() while adding to
        // subtree builder.
        if (!isMap) {
            forCondition = getForLoopString(SIXTEEN_SPACE_INDENTATION, type,
                                            name, getAppInstanceAttrString(name));
        } else {
            mapEntry = MAP + PERIOD + ENTRY + DIAMOND_OPEN_BRACKET + type +
                    KEYS + COMMA + SPACE + type + DIAMOND_CLOSE_BRACKET + SPACE;
            para = getAppInstanceAttrString(name) + PERIOD + ENTRY_SET;
            forCondition = getForLoopString(SIXTEEN_SPACE_INDENTATION,
                                            mapEntry, name, para);
        }
        cond = getAppInstanceCondition(name, NOT) + SPACE + AND_OPERATION +
                SPACE + NOT + getAppInstanceAttrString(name) + PERIOD + IS_EMPTY;
        builder.append(getIfConditionBegin(SIXTEEN_SPACE_INDENTATION, cond))
                .append(forCondition);
        if (isMap) {
            result = getOpenCloseParaWithValue(name + PERIOD + GET_KEY + COMMA +
                                                       SPACE + name + PERIOD +
                                                       GET_VALUE);
        } else {
            result = getOpenCloseParaWithValue(name);
        }
        assignment = TWENTY_FOUR_SPACE_INDENTATION +
                SUBTREE_FILTERING_RESULT_BUILDER + PERIOD + ADD_STRING +
                getCapitalCase(TO) + caps + result + signatureClose();
        builder.append(assignment).append(methodClose(TWENTY_SPACE))// Close collection Iteration loop
                // close  if condition
                .append(methodClose(SIXTEEN_SPACE))
                .append(methodClose(TWELVE_SPACE))// close  else condition
                .append(methodClose(EIGHT_SPACE));// close else if condition

        return builder.toString();
    }

    public static String getAugmentableSubTreeFiltering() {
        return "        if (yangAugmentedInfoMap.isEmpty()) {\n" +
                "            java.util.Set<Map.Entry<Class<?>, Object>> " +
                "augment =" +
                " appInstance.yangAugmentedInfoMap().entrySet();\n" +
                "            if (augment != null && !augment.isEmpty()) {\n" +
                "                java.util.Iterator<Map.Entry<Class<?>, " +
                "Object>> augItr =" +
                " augment.iterator();\n" +
                "                while (augItr.hasNext()) {\n" +
                "                    Map.Entry<Class<?>, Object> aug =" +
                " augItr.next();\n" +
                "                    Class<?> augClass = aug.getKey();\n" +
                "                    String augClassName = augClass.getName();\n" +
                "                    int index = augClassName.lastIndexOf('.');\n" +
                "                    String classPackage = augClassName.substring(0, index) +\n" +
                "                            \".\" + \"Default\" + augClass.getSimpleName() + \"$\"\n" +
                "                            + augClass.getSimpleName() + \"Builder\";\n" +
                "                    ClassLoader classLoader = augClass.getClassLoader();\n" +
                "                    try {\n" +
                "                        Class<?> builderClass;\n" +
                "                        builderClass = classLoader.loadClass(classPackage);\n" +
                "                        Object builderObj = builderClass.newInstance();\n" +
                "                        java.lang.reflect.Method method = " +
                "builderClass.getMethod(\"build\");\n" +
                "                        Object defaultObj = method.invoke(builderObj);\n" +
                "                        Class<?> defaultClass = defaultObj.getClass();\n" +
                "                        method = defaultClass.getMethod(" +
                "\"processSubtreeFiltering\", augClass, boolean.class);\n" +
                "                        Object result = method.invoke(" +
                "defaultObj, aug.getValue(), true);\n" +
                "                        subTreeFilteringResultBuilder." +
                "addYangAugmentedInfo(result, augClass);\n" +
                "                    } catch (ClassNotFoundException | InstantiationException\n" +
                "                            | NoSuchMethodException |\n" +
                "                            InvocationTargetException | IllegalAccessException e) {\n" +
                "                    }\n" +
                "                }\n" +
                "            }\n" +
                "        } else {\n" +
                "            java.util.Set<Map.Entry<Class<?>, Object>> augment = yangAugmentedInfoMap\n" +
                "                    .entrySet();\n" +
                "            java.util.Iterator<Map.Entry<Class<?>, Object>> augItr = augment.iterator();\n" +
                "            while (augItr.hasNext()) {\n" +
                "                Map.Entry<Class<?>, Object> aug = augItr.next();\n" +
                "                Class<?> augClass = aug.getKey();\n" +
                "                Object appInstanceInfo = appInstance." +
                "yangAugmentedInfo(augClass);\n" +
                "                if (appInstanceInfo == null) {\n" +
                "                    subTreeFilteringResultBuilder." +
                "addYangAugmentedInfo(aug.getValue(), aug.getKey());\n" +
                "                } else {\n" +
                "                    Object processSubtreeFiltering;\n" +
                "                    try {\n" +
                "                        processSubtreeFiltering = " +
                "aug.getValue().getClass()\n" +
                "                                .getMethod(\"processSubtreeFiltering\"," +
                " aug.getKey(), boolean.class)\n" +
                "                                .invoke(aug.getValue(), appInstanceInfo, true);\n" +
                "                        if (processSubtreeFiltering != null) {\n" +
                "                            subTreeFilteringResultBuilder\n" +
                "                                    .addYangAugmentedInfo(" +
                "processSubtreeFiltering, aug.getKey());\n" +
                "                        }\n" +
                "                    } catch (NoSuchMethodException | InvocationTargetException |\n" +
                "                            IllegalAccessException e) {\n" +
                "                    }\n" +
                "                }\n" +
                "            }\n" +
                "        }\n";
    }

    private static String getSubTreeFilteredCondition(String name) {
        StringBuilder builder = new StringBuilder();
        String cond = SUBTREE_FILTERED + SPACE + AND_OPERATION + SPACE + name +
                OPEN_CLOSE_BRACKET_STRING + SPACE + NOT + EQUAL + SPACE + NULL;

        builder.append(ELSE).append(OPEN_CURLY_BRACKET).append(NEW_LINE)
                .append(getIfConditionBegin(SIXTEEN_SPACE_INDENTATION, cond))
                .append(TWENTY_SPACE_INDENTATION)
                .append(SUBTREE_FILTERING_RESULT_BUILDER).append(PERIOD)
                .append(name).append(getOpenCloseParaWithValue(name)).append(
                signatureClose()).append(SIXTEEN_SPACE_INDENTATION).append(
                CLOSE_CURLY_BRACKET).append(NEW_LINE).append(TWELVE_SPACE_INDENTATION)
                .append(CLOSE_CURLY_BRACKET).append(NEW_LINE);
        return builder.toString();
    }

    private static String getNameOfClassForIfCase(YangNode curNode) {
        String name = null;
        JavaFileInfoTranslator parentInfo;
        if (curNode instanceof YangCase) {
            YangNode parent = curNode.getParent();
            if (parent instanceof YangChoice) {
                parentInfo = ((JavaFileInfoContainer) parent).getJavaFileInfo();
                name = getCapitalCase(parentInfo.getJavaName());
            } else if (parent instanceof YangAugment) {
                parentInfo = ((JavaFileInfoContainer) ((YangAugment) parent)
                        .getAugmentedNode()).getJavaFileInfo();
                if (parentInfo != null) {
                    name = getCapitalCase(parentInfo.getJavaName());
                } else {
                    name = getCapitalCase(getCamelCase(
                            ((YangAugment) parent).getAugmentedNode().getName(),
                            null));
                }
            }
        }
        return name;
    }

    private static String getCaseCastString(
            JavaFileInfoTranslator javaFileInfo, String instance, YangNode curNode) {
        if (curNode instanceof YangCase) {
            String caseName = DEFAULT_CAPS + getCapitalCase(
                    javaFileInfo.getJavaName());
            return EIGHT_SPACE_INDENTATION + caseName + SPACE + APP_INSTANCE + SPACE +
                    EQUAL + SPACE + OPEN_PARENTHESIS + caseName +
                    CLOSE_PARENTHESIS + SPACE + instance + signatureClose();
        }
        return null;
    }

    private static String getDummyObjectCreation(YangNode node, String name,
                                                 String clsInfo, String type,
                                                 String classCast, boolean isList,
                                                 boolean isMap) {
        String para = getAppInstanceAttrString(name);
        if (isList) {
            if (isMap) {
                para = name + PERIOD + GET_VALUE;
            } else {
                para = name;
            }
        }
        if (node != null && node instanceof YangChoice) {
            return getChoiceReflectionResult(name, clsInfo);
        }
        return TWENTY_SPACE_INDENTATION + RESULT + SPACE + EQUAL + SPACE +
                getOpenCloseParaWithValue(
                        classCast + type + PERIOD + BUILDER_LOWER_CASE +
                                OPEN_CLOSE_BRACKET_STRING + NEW_LINE +
                                TWENTY_EIGHT_SPACE_INDENTATION + PERIOD +
                                BUILD_FOR_FILTER + OPEN_CLOSE_BRACKET_STRING) +
                PERIOD + PROCESS_SUBTREE_FILTERING + getOpenCloseParaWithValue(
                para + COMMA + SPACE + TRUE) + signatureClose();

    }

    private static String getChoiceReflectionResult(String name, String returnType) {
        String call = "appInstance." + name + "()";
        return "                    Class<?>[] classArray = " + call + "" +
                ".getClass()" +
                ".getInterfaces();\n" +
                "                    Class<?> caseClass = classArray[0];\n" +
                "                    try {\n" +
                "                        Object obj1 = caseClass.newInstance();\n" +
                "                        java.lang.reflect.Method method =" +
                " caseClass.getMethod(\"builder\", caseClass);\n" +
                "                        Object obj = method.invoke(obj1," +
                " (Object) null);\n" +
                "                        method = caseClass.getMethod(\"build\", caseClass);\n" +
                "                        Object obj2 = method.invoke(obj, " +
                "(Object) null);\n" +
                "                        method = caseClass.getMethod(\"processSubtreeFiltering\", caseClass);\n" +
                "                        result = (" + returnType + ") method.invoke" +
                "(obj2, " + call + ", true);\n" +
                "                    } catch (NoSuchMethodException | InstantiationException |\n" +
                "                            IllegalAccessException | InvocationTargetException e) {\n" +
                "                        e.printStackTrace();\n" +
                "                    }\n";
    }
}