| /* |
| * 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; |
| |
| import org.onosproject.yangutils.datamodel.RpcNotificationContainer; |
| import org.onosproject.yangutils.datamodel.YangAtomicPath; |
| import org.onosproject.yangutils.datamodel.YangAugment; |
| import org.onosproject.yangutils.datamodel.YangCase; |
| import org.onosproject.yangutils.datamodel.YangChoice; |
| import org.onosproject.yangutils.datamodel.YangGrouping; |
| import org.onosproject.yangutils.datamodel.YangLeavesHolder; |
| import org.onosproject.yangutils.datamodel.YangNode; |
| import org.onosproject.yangutils.datamodel.YangNodeIdentifier; |
| import org.onosproject.yangutils.datamodel.YangSchemaNode; |
| import org.onosproject.yangutils.datamodel.YangTranslatorOperatorNode; |
| import org.onosproject.yangutils.datamodel.YangTypeHolder; |
| import org.onosproject.yangutils.datamodel.utils.DataModelUtils; |
| import org.onosproject.yangutils.translator.exception.TranslatorException; |
| import org.onosproject.yangutils.translator.tojava.javamodel.YangJavaAugmentTranslator; |
| import org.onosproject.yangutils.translator.tojava.javamodel.YangJavaEnumerationTranslator; |
| import org.onosproject.yangutils.translator.tojava.javamodel.YangJavaInputTranslator; |
| import org.onosproject.yangutils.translator.tojava.javamodel.YangJavaModuleTranslator; |
| import org.onosproject.yangutils.translator.tojava.javamodel.YangJavaOutputTranslator; |
| import org.onosproject.yangutils.translator.tojava.javamodel.YangJavaSubModuleTranslator; |
| import org.onosproject.yangutils.utils.io.YangPluginConfig; |
| |
| import java.io.File; |
| import java.io.IOException; |
| import java.util.ArrayList; |
| import java.util.List; |
| |
| import static org.onosproject.yangutils.datamodel.utils.DataModelUtils.isRpcChildNodePresent; |
| import static org.onosproject.yangutils.translator.tojava.GeneratedJavaFileType.GENERATE_SERVICE_AND_MANAGER; |
| import static org.onosproject.yangutils.translator.tojava.TempJavaFragmentFiles.addCurNodeInfoInParentTempFile; |
| import static org.onosproject.yangutils.translator.tojava.utils.IndentationType.FOUR_SPACE; |
| import static org.onosproject.yangutils.translator.tojava.utils.JavaFileGenerator.generateInterfaceFile; |
| import static org.onosproject.yangutils.translator.tojava.utils.JavaIdentifierSyntax.getRootPackage; |
| import static org.onosproject.yangutils.translator.tojava.utils.StringGenerator.methodClose; |
| import static org.onosproject.yangutils.translator.tojava.utils.TranslatorErrorType.INVALID_NODE; |
| import static org.onosproject.yangutils.translator.tojava.utils.TranslatorErrorType.INVALID_PARENT_NODE; |
| import static org.onosproject.yangutils.translator.tojava.utils.TranslatorErrorType.INVALID_TRANSLATION_NODE; |
| import static org.onosproject.yangutils.translator.tojava.utils.TranslatorUtils.getBeanFiles; |
| import static org.onosproject.yangutils.translator.tojava.utils.TranslatorUtils.getErrorMsg; |
| import static org.onosproject.yangutils.translator.tojava.utils.TranslatorUtils.getErrorMsgForCodeGenerator; |
| import static org.onosproject.yangutils.utils.UtilConstants.AUGMENTED; |
| import static org.onosproject.yangutils.utils.UtilConstants.EMPTY_STRING; |
| import static org.onosproject.yangutils.utils.UtilConstants.HYPHEN; |
| import static org.onosproject.yangutils.utils.UtilConstants.INPUT_KEYWORD; |
| import static org.onosproject.yangutils.utils.UtilConstants.OUTPUT_KEYWORD; |
| import static org.onosproject.yangutils.utils.UtilConstants.PERIOD; |
| import static org.onosproject.yangutils.utils.io.impl.YangIoUtils.addPackageInfo; |
| 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; |
| import static org.onosproject.yangutils.utils.io.impl.YangIoUtils.insertDataIntoJavaFile; |
| import static org.onosproject.yangutils.utils.io.impl.YangIoUtils.trimAtLast; |
| import static org.onosproject.yangutils.utils.io.impl.YangIoUtils.validateLineLength; |
| |
| /** |
| * Represents utility class for YANG java model. |
| */ |
| public final class YangJavaModelUtils { |
| |
| // No instantiation. |
| private YangJavaModelUtils() { |
| } |
| |
| /** |
| * Updates YANG java file package information. |
| * |
| * @param info YANG java file info node |
| * @param config YANG plugin config |
| */ |
| public static void updatePackageInfo(JavaCodeGeneratorInfo info, |
| YangPluginConfig config) { |
| |
| JavaFileInfoTranslator translator = info.getJavaFileInfo(); |
| |
| if (info instanceof YangJavaAugmentTranslator) { |
| updatePackageForAugmentInfo(info, config); |
| } else { |
| setNodeJavaName(info, config); |
| translator.setJavaAttributeName(info.getJavaFileInfo() |
| .getJavaName()); |
| translator.setPackage(getCurNodePackage((YangNode) info)); |
| } |
| updateCommonPackageInfo(translator, info, config); |
| } |
| |
| /** |
| * The java name for input, output is prefixed with rpc name and other |
| * nodes are set by taking its own name from YANG. |
| * |
| * @param info YANG java file info node |
| * @param config YANG plugin config |
| */ |
| private static void setNodeJavaName(JavaCodeGeneratorInfo info, |
| YangPluginConfig config) { |
| String javaGenName; |
| if (info instanceof YangJavaInputTranslator) { |
| javaGenName = ((YangJavaInputTranslator) info).getParent().getName() + |
| INPUT_KEYWORD; |
| } else if (info instanceof YangJavaOutputTranslator) { |
| javaGenName = ((YangJavaOutputTranslator) info).getParent().getName() + |
| OUTPUT_KEYWORD; |
| } else { |
| javaGenName = ((YangNode) info).getName(); |
| } |
| info.getJavaFileInfo().setJavaName(getCamelCase( |
| javaGenName, config.getConflictResolver())); |
| } |
| |
| /** |
| * Updates YANG java file package information. |
| * |
| * @param info YANG java file info node |
| * @param config YANG plugin config |
| */ |
| private static void updatePackageForAugmentInfo(JavaCodeGeneratorInfo info, |
| YangPluginConfig config) { |
| |
| JavaFileInfoTranslator translator = info.getJavaFileInfo(); |
| |
| translator.setJavaName(getAugmentClassName( |
| (YangJavaAugmentTranslator) info, config)); |
| translator.setPackage(getAugmentsNodePackage((YangNode) info, config)); |
| updateCommonPackageInfo(translator, info, config); |
| } |
| |
| /** |
| * Returns package for augment node. |
| * |
| * @param yangNode augment node |
| * @param config plugin configurations |
| * @return package for augment node |
| */ |
| private static String getAugmentsNodePackage(YangNode yangNode, |
| YangPluginConfig config) { |
| YangAugment augment = (YangAugment) yangNode; |
| StringBuilder augmentPkg = new StringBuilder(); |
| augmentPkg.append(getCurNodePackage(augment)); |
| |
| StringBuilder pkg = new StringBuilder(); |
| pkg.append(PERIOD); |
| for (YangAtomicPath atomicPath : augment.getTargetNode()) { |
| pkg.append(getCamelCase(atomicPath.getNodeIdentifier().getName(), |
| config.getConflictResolver())) |
| .append(PERIOD); |
| } |
| augmentPkg.append(trimAtLast(pkg.toString(), PERIOD).toLowerCase()); |
| return augmentPkg.toString(); |
| } |
| |
| /** |
| * Updates YANG java file package information for specified package. |
| * |
| * @param info YANG java file info node |
| * @param config YANG plugin config |
| */ |
| private static void updatePackageInfo(JavaCodeGeneratorInfo info, |
| YangPluginConfig config, |
| String pkg) { |
| |
| JavaFileInfoTranslator translator = info.getJavaFileInfo(); |
| translator.setJavaName(getCamelCase(((YangNode) info).getName(), |
| config.getConflictResolver())); |
| translator.setPackage(pkg); |
| updateCommonPackageInfo(translator, info, config); |
| } |
| |
| /** |
| * Updates common package information. |
| * |
| * @param translator JAVA file info translator |
| * @param info YANG java file info node |
| * @param config YANG plugin config |
| */ |
| private static void updateCommonPackageInfo(JavaFileInfoTranslator translator, |
| JavaCodeGeneratorInfo info, |
| YangPluginConfig config) { |
| translator.setPackageFilePath(getPackageDirPathFromJavaJPackage( |
| info.getJavaFileInfo().getPackage())); |
| translator.setBaseCodeGenPath(config.getCodeGenDir()); |
| translator.setPluginConfig(config); |
| } |
| |
| /** |
| * Updates temporary java code fragment files. |
| * |
| * @param info YANG java file info node |
| * @throws IOException IO operations fails |
| */ |
| private static void createTempFragmentFile(JavaCodeGeneratorInfo info) |
| throws IOException { |
| info.setTempJavaCodeFragmentFiles( |
| new TempJavaCodeFragmentFiles(info.getJavaFileInfo())); |
| } |
| |
| /** |
| * Updates leaf information in temporary java code fragment files. |
| * |
| * @param info YANG java file info node |
| * @throws IOException IO operations fails |
| */ |
| private static void updateTempFragmentFiles(JavaCodeGeneratorInfo info, |
| YangPluginConfig config) |
| throws IOException { |
| |
| TempJavaCodeFragmentFiles translator = |
| info.getTempJavaCodeFragmentFiles(); |
| |
| if (info instanceof RpcNotificationContainer) { |
| getBeanFiles(info).setRootNode(true); |
| /* |
| * Module / sub module node code generation. |
| */ |
| if (info instanceof YangJavaModuleTranslator) { |
| if (!((YangJavaModuleTranslator) info).getNotificationNodes() |
| .isEmpty()) { |
| updateNotificationNodeInfo(info, config); |
| } |
| } else if (info instanceof YangJavaSubModuleTranslator) { |
| if (!((YangJavaSubModuleTranslator) info).getNotificationNodes() |
| .isEmpty()) { |
| updateNotificationNodeInfo(info, config); |
| } |
| } |
| } |
| if (info instanceof YangLeavesHolder) { |
| YangLeavesHolder holder = (YangLeavesHolder) info; |
| boolean isLeafPresent = holder.getListOfLeaf() != null && !holder |
| .getListOfLeaf().isEmpty(); |
| boolean isLeafListPresent = holder.getListOfLeafList() != null && |
| !holder.getListOfLeafList().isEmpty(); |
| /* |
| * Container |
| * Case |
| * Grouping |
| * Input |
| * List |
| * Notification |
| * Output |
| */ |
| if (isLeafPresent || isLeafListPresent) { |
| getBeanFiles(info).addCurNodeLeavesInfoToTempFiles((YangNode) info, |
| config); |
| } |
| //Add value leaf flag attribute to temp file. |
| if (isLeafPresent) { |
| getBeanFiles(info).addValueLeafFlag(config, (YangNode) info); |
| } |
| if (((YangNode) info).isOpTypeReq()) { |
| // Add operation type as an attribute. |
| getBeanFiles(info).addOperationTypeToTempFiles((YangNode) info, |
| config); |
| if (isLeafPresent) { |
| //Add select leaf flag attribute to temp file. |
| getBeanFiles(info).addSelectLeafFlag(config); |
| } |
| } |
| } else if (info instanceof YangTypeHolder) { |
| /* |
| * Typedef |
| * Union |
| */ |
| translator.addTypeInfoToTempFiles((YangTypeHolder) info, config); |
| } else if (info instanceof YangJavaEnumerationTranslator) { |
| /* |
| * Enumeration |
| */ |
| translator.getEnumTempFiles() |
| .addEnumAttributeToTempFiles((YangNode) info, config); |
| } else if (!(info instanceof YangChoice)) { |
| /*Do nothing, only the interface needs to be generated for choice*/ |
| throw new TranslatorException( |
| getErrorMsgForCodeGenerator(INVALID_TRANSLATION_NODE, |
| info)); |
| } |
| } |
| |
| /** |
| * Process generate code entry of YANG node. |
| * |
| * @param info YANG java file info node |
| * @param config plugin configurations |
| * @throws IOException IO operations fails |
| */ |
| private static void generateTempFiles(JavaCodeGeneratorInfo info, |
| YangPluginConfig config) |
| throws IOException { |
| if (!(info instanceof YangNode)) { |
| throw new TranslatorException( |
| getErrorMsgForCodeGenerator(INVALID_TRANSLATION_NODE, |
| info)); |
| } |
| createTempFragmentFile(info); |
| updateTempFragmentFiles(info, config); |
| } |
| |
| /** |
| * Updates notification node info in service temporary file. |
| * |
| * @param info java code generator info |
| * @param config plugin configurations |
| * @throws IOException when fails to do IO operations |
| */ |
| private static void updateNotificationNodeInfo(JavaCodeGeneratorInfo info, |
| YangPluginConfig config) |
| throws IOException { |
| TempJavaCodeFragmentFiles translator = |
| info.getTempJavaCodeFragmentFiles(); |
| if (info instanceof YangJavaModuleTranslator) { |
| for (YangNode notification : ((YangJavaModuleTranslator) info) |
| .getNotificationNodes()) { |
| translator.getEventFragmentFiles() |
| .addJavaSnippetOfEvent(notification, config); |
| } |
| } |
| if (info instanceof YangJavaSubModuleTranslator) { |
| for (YangNode notification : ((YangJavaSubModuleTranslator) info) |
| .getNotificationNodes()) { |
| translator.getEventFragmentFiles() |
| .addJavaSnippetOfEvent(notification, config); |
| } |
| } |
| } |
| |
| /** |
| * Generates code for the current ata model node and adds itself as an |
| * attribute in the parent. |
| * |
| * @param info YANG java file info node |
| * @param config YANG plugin config |
| * @param isMultiInstance flag to indicate whether it's a list |
| * @throws IOException IO operations fails |
| */ |
| public static void generateCodeAndUpdateInParent(JavaCodeGeneratorInfo info, |
| YangPluginConfig config, |
| boolean isMultiInstance) |
| throws IOException { |
| if (!(info instanceof YangNode)) { |
| throw new TranslatorException( |
| getErrorMsgForCodeGenerator(INVALID_TRANSLATION_NODE, |
| info)); |
| } |
| |
| /* |
| * For second level and below cloned nodes code shouldn't be |
| * generated also they needn't be added in parent, since |
| * generated code will be under grouping, cloned node is only |
| * used for YANG namespace. |
| */ |
| YangNode n = (YangNode) info; |
| if (n.getReferredSchema() != null && |
| !(((YangNode) n.getReferredSchema()).getParent() instanceof |
| YangGrouping)) { |
| return; |
| } |
| /* |
| * If first level cloned node, then it needs to be imported in the |
| * generated code. In case uses under grouping, it would further have |
| * second level uses, hence needn't add in parent grouping. |
| */ |
| YangSchemaNode rn = getRefSchema(info); |
| if (rn != null) { |
| YangNode parent = ((YangNode) info).getParent(); |
| if (!(parent instanceof YangGrouping)) { |
| addCurNodeInfoInParentTempFile((YangNode) rn, isMultiInstance, |
| config, parent); |
| } |
| return; |
| } |
| |
| /* |
| * Generate the Java files corresponding to the current node. |
| */ |
| generateCodeOfAugmentableNode(info, config); |
| |
| /* |
| * Update the current nodes info in its parent nodes generated files. |
| */ |
| addCurNodeInfoInParentTempFile((YangNode) info, isMultiInstance, |
| config); |
| } |
| |
| /** |
| * Returns referred schema node in case of grouping uses. |
| * |
| * @param info YANG java file info node |
| * @return referred schema node |
| */ |
| private static YangSchemaNode getRefSchema(JavaCodeGeneratorInfo info) { |
| |
| YangSchemaNode node = (YangSchemaNode) info; |
| if (node.getReferredSchema() == null) { |
| return null; |
| } |
| |
| /* |
| * Obtain last referred node in case grouping is embedded inside |
| * another grouping. |
| */ |
| while (node.getReferredSchema() != null) { |
| node = node.getReferredSchema(); |
| } |
| return node; |
| } |
| |
| /** |
| * Generates code for the current data model node and adds support for it to |
| * be augmented. |
| * |
| * @param info YANG java file info node |
| * @param config YANG plugin config |
| * @throws IOException IO operations fails |
| */ |
| public static void generateCodeOfAugmentableNode(JavaCodeGeneratorInfo info, |
| YangPluginConfig config) |
| throws IOException { |
| if (!(info instanceof YangNode)) { |
| throw new TranslatorException( |
| getErrorMsgForCodeGenerator(INVALID_TRANSLATION_NODE, |
| info)); |
| } |
| |
| generateCodeOfNode(info, config); |
| TempJavaCodeFragmentFiles tempFiles = |
| info.getTempJavaCodeFragmentFiles(); |
| if (!(info instanceof YangChoice)) { |
| getBeanFiles(info).addYangAugmentedMap(config); |
| } |
| if (info instanceof YangCase) { |
| YangNode parent = ((YangCase) info).getParent(); |
| JavaQualifiedTypeInfoTranslator typeInfo = |
| getQualifierInfoForCasesParent(parent, config); |
| getBeanFiles(info).getJavaExtendsListHolder() |
| .addToExtendsList(typeInfo, (YangNode) info, |
| tempFiles.getBeanTempFiles()); |
| |
| getBeanFiles(info).addParentInfoInCurNodeTempFile((YangNode) info, |
| config); |
| } |
| } |
| |
| /** |
| * Returns cases parent's qualified info. |
| * |
| * @param parent parent node |
| * @param config plugin configuration |
| * @return cases parent's qualified info |
| */ |
| public static JavaQualifiedTypeInfoTranslator |
| getQualifierInfoForCasesParent(YangNode parent, |
| YangPluginConfig config) { |
| String parentName; |
| String parentPkg; |
| JavaFileInfoTranslator parentInfo; |
| if (parent instanceof YangChoice) { |
| parentInfo = ((JavaFileInfoContainer) parent).getJavaFileInfo(); |
| } else { |
| parent = ((YangAugment) parent).getAugmentedNode(); |
| parentInfo = ((JavaFileInfoContainer) parent).getJavaFileInfo(); |
| } |
| if (parentInfo.getPackage() != null) { |
| parentName = getCapitalCase(parentInfo.getJavaName()); |
| parentPkg = parentInfo.getPackage(); |
| } else { |
| parentName = getCapitalCase(getCamelCase(parent.getName(), |
| config.getConflictResolver())); |
| parentPkg = getNodesPackage(parent, config); |
| } |
| JavaQualifiedTypeInfoTranslator qualifiedTypeInfo = |
| new JavaQualifiedTypeInfoTranslator(); |
| qualifiedTypeInfo.setClassInfo(parentName); |
| qualifiedTypeInfo.setPkgInfo(parentPkg); |
| return qualifiedTypeInfo; |
| } |
| |
| /** |
| * Generates code for the current data model node. |
| * |
| * @param info YANG java file info node |
| * @param config YANG plugin config |
| * @throws IOException IO operations fails |
| */ |
| public static void generateCodeOfNode(JavaCodeGeneratorInfo info, |
| YangPluginConfig config) |
| throws IOException { |
| if (!(info instanceof YangNode)) { |
| throw new TranslatorException( |
| getErrorMsgForCodeGenerator(INVALID_TRANSLATION_NODE, |
| info)); |
| } |
| updatePackageInfo(info, config); |
| generateTempFiles(info, config); |
| } |
| |
| /** |
| * Generates code for the root module/sub-module node. |
| * |
| * @param info YANG java file info node |
| * @param config YANG plugin config |
| * @param rootPkg package of the root node |
| * @throws IOException IO operations fails |
| */ |
| public static void generateCodeOfRootNode(JavaCodeGeneratorInfo info, |
| YangPluginConfig config, |
| String rootPkg) |
| throws IOException { |
| if (!(info instanceof YangNode)) { |
| throw new TranslatorException( |
| getErrorMsgForCodeGenerator(INVALID_TRANSLATION_NODE, |
| info)); |
| } |
| updatePackageInfo(info, config, rootPkg); |
| |
| if (isRpcChildNodePresent((YangNode) info)) { |
| info.getJavaFileInfo() |
| .addGeneratedFileTypes(GENERATE_SERVICE_AND_MANAGER); |
| } |
| generateTempFiles(info, config); |
| } |
| |
| /** |
| * Returns the node package string. |
| * |
| * @param curNode current java node whose package string needs to be set |
| * @return returns the root package string |
| */ |
| public static String getCurNodePackage(YangNode curNode) |
| throws TranslatorException { |
| |
| String pkg; |
| if (!(curNode instanceof JavaFileInfoContainer) || |
| curNode.getParent() == null) { |
| throw new TranslatorException(getErrorMsg(INVALID_NODE, curNode)); |
| } |
| |
| YangNode parentNode = DataModelUtils.getParentNodeInGenCode(curNode); |
| if (!(parentNode instanceof JavaFileInfoContainer)) { |
| throw new TranslatorException(getErrorMsg(INVALID_PARENT_NODE, |
| curNode)); |
| } |
| JavaFileInfoTranslator handle = |
| ((JavaFileInfoContainer) parentNode).getJavaFileInfo(); |
| pkg = handle.getPackage() + PERIOD + handle.getJavaName(); |
| return pkg.toLowerCase(); |
| } |
| |
| /** |
| * Returns true if root node contains any data node. |
| * |
| * @param node root YANG node |
| * @return true if root node contains any data node |
| */ |
| public static boolean isRootNodesCodeGenRequired(YangNode node) { |
| return isNodeCodeGenRequired(node, true); |
| } |
| |
| /** |
| * Returns true if get/set method of root node are required. |
| * |
| * @param node root node |
| * @return true if get/set method of root node are required |
| */ |
| public static boolean isGetSetOfRootNodeRequired(YangNode node) { |
| return isNodeCodeGenRequired(node, false); |
| } |
| |
| /** |
| * Returns true if either get/set method of root node are required or root |
| * node contains any data node. This check is done depending on the |
| * boolean parameter indicating whether check to be performed for root |
| * node code generation or get/set method generation. |
| * |
| * @param node root node |
| * @param rootNodeGen flag indicating check type |
| * @return true if check pass, false otherwise |
| */ |
| private static boolean isNodeCodeGenRequired(YangNode node, |
| boolean rootNodeGen) { |
| YangLeavesHolder holder = (YangLeavesHolder) node; |
| |
| if (!holder.getListOfLeaf().isEmpty()) { |
| return true; |
| } |
| if (!holder.getListOfLeafList().isEmpty()) { |
| return true; |
| } |
| node = node.getChild(); |
| if (node == null) { |
| return false; |
| } |
| |
| if (rootNodeGen) { |
| while (node != null) { |
| if (!(node instanceof YangTranslatorOperatorNode)) { |
| return true; |
| } |
| node = node.getNextSibling(); |
| } |
| return false; |
| } |
| while (node != null) { |
| if (!(node instanceof YangAugment)) { |
| return true; |
| } |
| node = node.getNextSibling(); |
| } |
| return false; |
| } |
| |
| /** |
| * Returns nodes package. |
| * |
| * @param node YANG node |
| * @param config plugin config |
| * @return java package |
| */ |
| public static String getNodesPackage(YangNode node, |
| YangPluginConfig config) { |
| |
| List<String> clsInfo = new ArrayList<>(); |
| while (node.getParent() != null) { |
| if (node instanceof YangJavaAugmentTranslator) { |
| clsInfo.add(getAugmentClassName((YangAugment) node, |
| config)); |
| } else { |
| clsInfo.add(getCamelCase(node.getName(), config |
| .getConflictResolver())); |
| } |
| node = node.getParent(); |
| } |
| |
| StringBuilder pkg = new StringBuilder(); |
| if (node instanceof YangJavaModuleTranslator) { |
| YangJavaModuleTranslator module = (YangJavaModuleTranslator) node; |
| pkg.append(getRootPackage(module.getVersion(), |
| module.getModuleNamespace(), |
| module.getRevision(), |
| config.getConflictResolver())); |
| } else if (node instanceof YangJavaSubModuleTranslator) { |
| YangJavaSubModuleTranslator subModule = |
| (YangJavaSubModuleTranslator) node; |
| pkg.append(getRootPackage(subModule.getVersion(), |
| subModule.getNameSpaceFromModule(), |
| subModule.getRevision(), |
| config.getConflictResolver())); |
| } |
| pkg.append(EMPTY_STRING); |
| int size = clsInfo.size(); |
| for (int i = size - 1; i >= 0; i--) { |
| pkg.append(PERIOD).append(clsInfo.get(i)); |
| } |
| return pkg.toString().toLowerCase(); |
| } |
| |
| /** |
| * Returns augment class name. |
| * |
| * @param augment YANG augment |
| * @param config plugin configurations |
| * @return augment class name |
| */ |
| private static String getAugmentClassName(YangAugment augment, |
| YangPluginConfig config) { |
| YangNodeIdentifier identifier = |
| augment.getTargetNode().get(augment.getTargetNode().size() - 1) |
| .getNodeIdentifier(); |
| String name = getCapitalCase(getCamelCase(identifier.getName(), |
| config.getConflictResolver())); |
| if (identifier.getPrefix() != null) { |
| return getCapitalCase(getCamelCase(AUGMENTED + HYPHEN + identifier |
| .getPrefix(), |
| config.getConflictResolver())) + name; |
| } |
| return AUGMENTED + name; |
| } |
| |
| /** |
| * Generated java code during exit. |
| * |
| * @param type generated file type |
| * @param node current YANG node |
| * @throws IOException when fails to generate java files |
| */ |
| public static void generateJava(int type, YangNode node) |
| throws IOException { |
| /* |
| * Call for file generation if node is not under uses. |
| */ |
| if (node.getReferredSchema() == null) { |
| ((TempJavaCodeFragmentFilesContainer) node) |
| .getTempJavaCodeFragmentFiles().generateJavaFile(type, node); |
| } |
| } |
| |
| /** |
| * Generates interface file for those yang file which contains only any |
| * of these grouping, typedef and identity. |
| * |
| * @param rootNode root node |
| * @throws IOException when fails to do IO operations |
| */ |
| public static void generateInterfaceFileForNonDataNodes(YangNode rootNode) throws |
| IOException { |
| JavaCodeGeneratorInfo info = (JavaCodeGeneratorInfo) rootNode; |
| TempJavaCodeFragmentFiles tempFile = info |
| .getTempJavaCodeFragmentFiles(); |
| JavaFileInfoTranslator fileInfo = info.getJavaFileInfo(); |
| File filePath = new File(fileInfo.getBaseCodeGenPath() + fileInfo |
| .getPackageFilePath()); |
| String name = getCapitalCase(fileInfo.getJavaName()); |
| //Add package info file for this. |
| addPackageInfo(filePath, name, fileInfo.getPackage(), false); |
| //Generate file handle for this. |
| File interFace = tempFile.getBeanTempFiles().getJavaFileHandle( |
| name); |
| //generate java code for interface file. |
| validateLineLength(generateInterfaceFile(interFace, null, rootNode, |
| false)); |
| insertDataIntoJavaFile(interFace, methodClose(FOUR_SPACE)); |
| } |
| } |