| /* |
| * Copyright 2016-present Open Networking Foundation |
| * |
| * 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.yms.app.yob; |
| |
| import org.onosproject.yangutils.datamodel.RpcNotificationContainer; |
| import org.onosproject.yangutils.datamodel.YangDerivedInfo; |
| import org.onosproject.yangutils.datamodel.YangIdentity; |
| import org.onosproject.yangutils.datamodel.YangIdentityRef; |
| import org.onosproject.yangutils.datamodel.YangLeaf; |
| import org.onosproject.yangutils.datamodel.YangLeafList; |
| import org.onosproject.yangutils.datamodel.YangLeafRef; |
| import org.onosproject.yangutils.datamodel.YangNode; |
| import org.onosproject.yangutils.datamodel.YangSchemaNode; |
| import org.onosproject.yangutils.datamodel.YangSchemaNodeContextInfo; |
| import org.onosproject.yangutils.datamodel.YangType; |
| import org.onosproject.yangutils.datamodel.utils.builtindatatype.YangDataTypes; |
| import org.onosproject.yms.app.ydt.YdtExtendedContext; |
| import org.onosproject.yms.app.yob.exception.YobException; |
| import org.onosproject.yms.app.ysr.YangSchemaRegistry; |
| import org.slf4j.Logger; |
| import org.slf4j.LoggerFactory; |
| |
| import java.lang.reflect.Constructor; |
| import java.lang.reflect.Field; |
| import java.lang.reflect.InvocationTargetException; |
| import java.lang.reflect.Method; |
| import java.math.BigDecimal; |
| import java.math.BigInteger; |
| import java.util.Base64; |
| |
| import static org.onosproject.yangutils.datamodel.YangSchemaNodeType.YANG_AUGMENT_NODE; |
| import static org.onosproject.yangutils.translator.tojava.utils.JavaIdentifierSyntax.getEnumJavaAttribute; |
| import static org.onosproject.yms.app.ydt.AppType.YOB; |
| import static org.onosproject.yms.app.yob.YobConstants.DEFAULT; |
| import static org.onosproject.yms.app.yob.YobConstants.EVENT; |
| import static org.onosproject.yms.app.yob.YobConstants.EVENT_SUBJECT; |
| import static org.onosproject.yms.app.yob.YobConstants.E_DATA_TYPE_NOT_SUPPORT; |
| import static org.onosproject.yms.app.yob.YobConstants.E_FAIL_TO_CREATE_OBJ; |
| import static org.onosproject.yms.app.yob.YobConstants.E_FAIL_TO_GET_FIELD; |
| import static org.onosproject.yms.app.yob.YobConstants.E_FAIL_TO_GET_METHOD; |
| import static org.onosproject.yms.app.yob.YobConstants.E_FAIL_TO_INVOKE_METHOD; |
| import static org.onosproject.yms.app.yob.YobConstants.E_FAIL_TO_LOAD_CLASS; |
| import static org.onosproject.yms.app.yob.YobConstants.E_FAIL_TO_LOAD_CONSTRUCTOR; |
| import static org.onosproject.yms.app.yob.YobConstants.E_INVALID_DATA_TREE; |
| import static org.onosproject.yms.app.yob.YobConstants.E_INVALID_EMPTY_DATA; |
| import static org.onosproject.yms.app.yob.YobConstants.FROM_STRING; |
| import static org.onosproject.yms.app.yob.YobConstants.LEAF_IDENTIFIER; |
| import static org.onosproject.yms.app.yob.YobConstants.L_FAIL_TO_GET_FIELD; |
| import static org.onosproject.yms.app.yob.YobConstants.L_FAIL_TO_GET_METHOD; |
| import static org.onosproject.yms.app.yob.YobConstants.L_FAIL_TO_INVOKE_METHOD; |
| import static org.onosproject.yms.app.yob.YobConstants.L_FAIL_TO_LOAD_CLASS; |
| import static org.onosproject.yms.app.yob.YobConstants.OF; |
| import static org.onosproject.yms.app.yob.YobConstants.OP_PARAM; |
| import static org.onosproject.yms.app.yob.YobConstants.PERIOD; |
| import static org.onosproject.yms.app.yob.YobConstants.SELECT_LEAF; |
| import static org.onosproject.yms.app.yob.YobConstants.TYPE; |
| import static org.onosproject.yms.app.yob.YobConstants.VALUE_OF; |
| |
| /** |
| * Utils to support object creation. |
| */ |
| public final class YobUtils { |
| |
| private static final Logger log = LoggerFactory.getLogger(YobUtils.class); |
| |
| // no instantiation |
| private YobUtils() { |
| } |
| |
| /** |
| * Sets data from string value in parent method. |
| * |
| * @param type refers to YANG type |
| * @param leafValue leafValue argument is used to set the value |
| * in method |
| * @param parentSetterMethod Invokes the underlying method represented |
| * by this parentSetterMethod |
| * @param parentBuilderObject the parentBuilderObject is to invoke the |
| * underlying method |
| * @param ydtExtendedContext ydtExtendedContext is used to get |
| * application related |
| * information maintained in YDT |
| * @throws InvocationTargetException if failed to invoke method |
| * @throws IllegalAccessException if member cannot be accessed |
| * @throws NoSuchMethodException if method is not found |
| */ |
| static void setDataFromStringValue(YangDataTypes type, String leafValue, |
| Method parentSetterMethod, |
| Object parentBuilderObject, |
| YdtExtendedContext ydtExtendedContext) |
| throws InvocationTargetException, IllegalAccessException, |
| NoSuchMethodException { |
| switch (type) { |
| case INT8: |
| parentSetterMethod.invoke(parentBuilderObject, |
| Byte.parseByte(leafValue)); |
| break; |
| |
| case UINT8: |
| case INT16: |
| parentSetterMethod.invoke(parentBuilderObject, |
| Short.parseShort(leafValue)); |
| break; |
| |
| case UINT16: |
| case INT32: |
| parentSetterMethod.invoke(parentBuilderObject, |
| Integer.parseInt(leafValue)); |
| break; |
| |
| case UINT32: |
| case INT64: |
| parentSetterMethod.invoke(parentBuilderObject, |
| Long.parseLong(leafValue)); |
| break; |
| |
| case UINT64: |
| parentSetterMethod.invoke(parentBuilderObject, |
| new BigInteger(leafValue)); |
| break; |
| |
| case EMPTY: |
| if (leafValue == null || "".equals(leafValue)) { |
| parentSetterMethod.invoke(parentBuilderObject, true); |
| } else { |
| log.info(E_INVALID_EMPTY_DATA); |
| } |
| break; |
| |
| case BOOLEAN: |
| parentSetterMethod.invoke(parentBuilderObject, |
| Boolean.parseBoolean(leafValue)); |
| break; |
| |
| case STRING: |
| parentSetterMethod.invoke(parentBuilderObject, leafValue); |
| break; |
| |
| case BINARY: |
| byte[] value = Base64.getDecoder().decode(leafValue); |
| parentSetterMethod.invoke(parentBuilderObject, value); |
| break; |
| |
| case BITS: |
| parseBitSetTypeInfo(ydtExtendedContext, parentSetterMethod, |
| parentBuilderObject, leafValue); |
| break; |
| |
| case DECIMAL64: |
| parentSetterMethod.invoke(parentBuilderObject, |
| new BigDecimal(leafValue)); |
| break; |
| |
| case DERIVED: |
| parseDerivedTypeInfo(ydtExtendedContext, parentSetterMethod, |
| parentBuilderObject, leafValue, false); |
| break; |
| |
| case IDENTITYREF: |
| parseIdentityRefInfo(ydtExtendedContext, parentSetterMethod, |
| parentBuilderObject, leafValue); |
| break; |
| |
| case UNION: |
| parseDerivedTypeInfo(ydtExtendedContext, parentSetterMethod, |
| parentBuilderObject, leafValue, false); |
| break; |
| |
| case LEAFREF: |
| parseLeafRefTypeInfo(ydtExtendedContext, parentSetterMethod, |
| parentBuilderObject, leafValue); |
| break; |
| |
| case ENUMERATION: |
| parseDerivedTypeInfo(ydtExtendedContext, parentSetterMethod, |
| parentBuilderObject, leafValue, true); |
| break; |
| |
| default: |
| log.error(E_DATA_TYPE_NOT_SUPPORT); |
| } |
| } |
| |
| /** |
| * Sets the select leaf flag for leaf. |
| * |
| * @param builderClass builder in which the select leaf flag needs to be |
| * set |
| * @param leafNode YANG data tree leaf node |
| * @param schemaRegistry YANG schema registry |
| * @param builderObject the parent build object on which to invoke |
| * the method |
| * @throws InvocationTargetException if method could not be invoked |
| * @throws IllegalAccessException if method could not be accessed |
| * @throws NoSuchMethodException if method does not exist |
| */ |
| static void setSelectLeaf(Class builderClass, |
| YdtExtendedContext leafNode, |
| YangSchemaRegistry schemaRegistry, |
| Object builderObject) throws NoSuchMethodException, |
| InvocationTargetException, IllegalAccessException { |
| |
| YangSchemaNode parentSchema = ((YdtExtendedContext) leafNode |
| .getParent()).getYangSchemaNode(); |
| while (parentSchema.getReferredSchema() != null) { |
| parentSchema = parentSchema.getReferredSchema(); |
| } |
| |
| while (((YangNode) parentSchema).getParent() != null) { |
| parentSchema = ((YangNode) parentSchema).getParent(); |
| } |
| |
| String qualName = getQualifiedinterface(parentSchema); |
| Class<?> regClass = schemaRegistry.getRegisteredClass(parentSchema); |
| if (regClass == null) { |
| throw new YobException(E_FAIL_TO_LOAD_CLASS + qualName); |
| } |
| |
| Class<?> interfaceClass = null; |
| try { |
| interfaceClass = regClass.getClassLoader().loadClass(qualName); |
| } catch (ClassNotFoundException e) { |
| log.info(E_FAIL_TO_LOAD_CLASS, qualName); |
| return; |
| } |
| |
| Class<?>[] innerClasses = interfaceClass.getClasses(); |
| for (Class<?> innerEnumClass : innerClasses) { |
| if (innerEnumClass.getSimpleName().equals(LEAF_IDENTIFIER)) { |
| Method valueOfMethod = innerEnumClass |
| .getDeclaredMethod(VALUE_OF, String.class); |
| String leafName = leafNode.getYangSchemaNode() |
| .getJavaAttributeName().toUpperCase(); |
| Object obj = valueOfMethod.invoke(null, leafName); |
| Method selectLeafMethod = builderClass |
| .getDeclaredMethod(SELECT_LEAF, innerEnumClass); |
| selectLeafMethod.invoke(builderObject, obj); |
| break; |
| } |
| } |
| } |
| |
| /** |
| * To set data into parent setter method from string value for derived type. |
| * |
| * @param leafValue value to be set in method |
| * @param parentSetterMethod the parent setter method to be invoked |
| * @param parentBuilderObject the parent build object on which to invoke the |
| * method |
| * @param ydtExtendedContext application context |
| * @param isEnum flag to check whether type is enum or derived |
| * @throws InvocationTargetException if failed to invoke method |
| * @throws IllegalAccessException if member cannot be accessed |
| * @throws NoSuchMethodException if the required method is not found |
| */ |
| private static void parseDerivedTypeInfo(YdtExtendedContext ydtExtendedContext, |
| Method parentSetterMethod, |
| Object parentBuilderObject, |
| String leafValue, boolean isEnum) |
| throws InvocationTargetException, IllegalAccessException, |
| NoSuchMethodException { |
| Class<?> childSetClass = null; |
| Constructor<?> childConstructor = null; |
| Object childValue = null; |
| Object childObject = null; |
| Method childMethod = null; |
| |
| YangSchemaNode yangJavaModule = ydtExtendedContext.getYangSchemaNode(); |
| while (yangJavaModule.getReferredSchema() != null) { |
| yangJavaModule = yangJavaModule.getReferredSchema(); |
| } |
| |
| String qualifiedClassName = yangJavaModule.getJavaPackage() + PERIOD + |
| getCapitalCase(yangJavaModule.getJavaClassNameOrBuiltInType()); |
| ClassLoader classLoader = getClassLoader(null, qualifiedClassName, |
| ydtExtendedContext, null); |
| try { |
| childSetClass = classLoader.loadClass(qualifiedClassName); |
| } catch (ClassNotFoundException e) { |
| log.error(L_FAIL_TO_LOAD_CLASS, qualifiedClassName); |
| } |
| |
| if (!isEnum) { |
| if (childSetClass != null) { |
| childConstructor = childSetClass.getDeclaredConstructor(); |
| } |
| |
| if (childConstructor != null) { |
| childConstructor.setAccessible(true); |
| } |
| |
| try { |
| if (childConstructor != null) { |
| childObject = childConstructor.newInstance(); |
| } |
| } catch (InstantiationException e) { |
| log.error(E_FAIL_TO_LOAD_CONSTRUCTOR, qualifiedClassName); |
| } |
| if (childSetClass != null) { |
| childMethod = childSetClass |
| .getDeclaredMethod(FROM_STRING, String.class); |
| } |
| } else { |
| if (childSetClass != null) { |
| childMethod = childSetClass.getDeclaredMethod(OF, String.class); |
| } |
| } |
| if (childMethod != null) { |
| childValue = childMethod.invoke(childObject, leafValue); |
| } |
| |
| parentSetterMethod.invoke(parentBuilderObject, childValue); |
| } |
| |
| /** |
| * To set data into parent setter method from string value for bits type. |
| * |
| * @param leafValue value to be set in method |
| * @param parentSetterMethod the parent setter method to be invoked |
| * @param parentBuilderObject the parent build object on which to invoke the |
| * method |
| * @param ydtExtendedContext application context |
| * @throws InvocationTargetException if failed to invoke method |
| * @throws IllegalAccessException if member cannot be accessed |
| * @throws NoSuchMethodException if the required method is not found |
| */ |
| private static void parseBitSetTypeInfo(YdtExtendedContext ydtExtendedContext, |
| Method parentSetterMethod, |
| Object parentBuilderObject, |
| String leafValue) |
| throws InvocationTargetException, IllegalAccessException, |
| NoSuchMethodException { |
| Class<?> childSetClass = null; |
| Object childValue = null; |
| Object childObject = null; |
| Method childMethod = null; |
| |
| YangSchemaNode schemaNode = ydtExtendedContext.getYangSchemaNode(); |
| while (schemaNode.getReferredSchema() != null) { |
| schemaNode = schemaNode.getReferredSchema(); |
| } |
| |
| YangSchemaNode parentSchema = ((YdtExtendedContext) ydtExtendedContext |
| .getParent()).getYangSchemaNode(); |
| String qualifiedClassName = parentSchema.getJavaPackage() + PERIOD + |
| parentSchema.getJavaAttributeName().toLowerCase() + |
| PERIOD + getCapitalCase(schemaNode.getJavaAttributeName()); |
| |
| ClassLoader classLoader = getClassLoader(null, qualifiedClassName, |
| ydtExtendedContext, null); |
| |
| try { |
| childSetClass = classLoader.loadClass(qualifiedClassName); |
| } catch (ClassNotFoundException e) { |
| log.error(L_FAIL_TO_LOAD_CLASS, qualifiedClassName); |
| } |
| |
| if (childSetClass != null) { |
| childMethod = childSetClass.getDeclaredMethod(FROM_STRING, String.class); |
| } |
| if (childMethod != null) { |
| childValue = childMethod.invoke(childObject, leafValue); |
| } |
| |
| parentSetterMethod.invoke(parentBuilderObject, childValue); |
| } |
| |
| /** |
| * To set data into parent setter method from string value for leafref type. |
| * |
| * @param leafValue leaf value to be set |
| * @param parentSetterMethod the parent setter method to be invoked |
| * @param parentBuilderObject the parent build object on which to invoke |
| * the method |
| * @param ydtExtendedContext application context |
| * @throws InvocationTargetException if method could not be invoked |
| * @throws IllegalAccessException if method could not be accessed |
| * @throws NoSuchMethodException if method does not exist |
| */ |
| private static void parseLeafRefTypeInfo(YdtExtendedContext ydtExtendedContext, |
| Method parentSetterMethod, |
| Object parentBuilderObject, |
| String leafValue) |
| throws InvocationTargetException, IllegalAccessException, |
| NoSuchMethodException { |
| |
| YangSchemaNode schemaNode = ydtExtendedContext.getYangSchemaNode(); |
| while (schemaNode.getReferredSchema() != null) { |
| schemaNode = schemaNode.getReferredSchema(); |
| } |
| |
| YangLeafRef leafRef; |
| if (schemaNode instanceof YangLeaf) { |
| leafRef = (YangLeafRef) ((YangLeaf) schemaNode) |
| .getDataType().getDataTypeExtendedInfo(); |
| } else { |
| leafRef = (YangLeafRef) ((YangLeafList) schemaNode) |
| .getDataType().getDataTypeExtendedInfo(); |
| } |
| |
| YangType type = leafRef.getEffectiveDataType(); |
| if (type.getDataType() == YangDataTypes.DERIVED && |
| schemaNode.getJavaPackage().equals(YobConstants.JAVA_LANG)) { |
| /* |
| * If leaf is inside grouping, then its return type will be of type |
| * Object and if its actual type is derived type then get the |
| * effective built-in type and set the value. |
| */ |
| YangDerivedInfo derivedInfo = (YangDerivedInfo) leafRef |
| .getEffectiveDataType() |
| .getDataTypeExtendedInfo(); |
| YobUtils.setDataFromStringValue(derivedInfo.getEffectiveBuiltInType(), |
| leafValue, parentSetterMethod, |
| parentBuilderObject, |
| ydtExtendedContext); |
| } else { |
| YobUtils.setDataFromStringValue(type.getDataType(), |
| leafValue, parentSetterMethod, |
| parentBuilderObject, |
| ydtExtendedContext); |
| } |
| } |
| |
| /** |
| * Updates class loader for all the classes. |
| * |
| * @param registry YANG schema registry |
| * @param qualifiedClassName qualified class name |
| * @param curNode YDT context |
| * @param rootNode application root node |
| * @return current class loader |
| */ |
| static ClassLoader getClassLoader(YangSchemaRegistry registry, |
| String qualifiedClassName, |
| YdtExtendedContext curNode, |
| YdtExtendedContext rootNode) { |
| |
| if (rootNode != null && curNode == rootNode) { |
| YangSchemaNode curSchemaNode = curNode.getYangSchemaNode(); |
| while (!(curSchemaNode instanceof RpcNotificationContainer)) { |
| curNode = (YdtExtendedContext) curNode.getParent(); |
| if (curNode == null) { |
| throw new YobException(E_INVALID_DATA_TREE); |
| } |
| curSchemaNode = curNode.getYangSchemaNode(); |
| } |
| |
| Class<?> regClass = registry.getRegisteredClass(curSchemaNode); |
| return regClass.getClassLoader(); |
| } |
| |
| YdtExtendedContext parent = (YdtExtendedContext) curNode.getParent(); |
| YobWorkBench parentBuilderContainer = (YobWorkBench) parent.getAppInfo(YOB); |
| Object parentObj = parentBuilderContainer.getParentBuilder(curNode, |
| registry); |
| return parentObj.getClass().getClassLoader(); |
| } |
| |
| /** |
| * Returns the class loader to be used for the switched context schema node. |
| * |
| * @param curLoader current context class loader |
| * @param context switched context |
| * @param registry schema registry |
| * @return class loader to be used for the switched context schema node |
| */ |
| static ClassLoader getTargetClassLoader(ClassLoader curLoader, |
| YangSchemaNodeContextInfo context, |
| YangSchemaRegistry registry) { |
| YangSchemaNode augmentSchemaNode = context.getContextSwitchedNode(); |
| if (augmentSchemaNode.getYangSchemaNodeType() == YANG_AUGMENT_NODE) { |
| YangSchemaNode moduleNode = ((YangNode) augmentSchemaNode).getParent(); |
| |
| Class<?> moduleClass = registry.getRegisteredClass(moduleNode); |
| if (moduleClass == null) { |
| throw new YobException(E_FAIL_TO_LOAD_CLASS + moduleNode |
| .getJavaClassNameOrBuiltInType()); |
| } |
| return moduleClass.getClassLoader(); |
| } |
| return curLoader; |
| } |
| |
| /** |
| * Returns the schema node's module interface. |
| * |
| * @param schemaNode YANG schema node |
| * @param schemaRegistry YANG schema registry |
| * @return schema node's module interface |
| */ |
| public static Class<?> getModuleInterface(YangSchemaNode schemaNode, |
| YangSchemaRegistry schemaRegistry) { |
| |
| YangNode yangNode = (YangNode) schemaNode; |
| while (yangNode.getReferredSchema() != null) { |
| yangNode = (YangNode) yangNode.getReferredSchema(); |
| } |
| |
| while (yangNode.getParent() != null) { |
| yangNode = yangNode.getParent(); |
| } |
| |
| String qualName = getQualifiedinterface(yangNode); |
| Class<?> regClass = schemaRegistry.getRegisteredClass(yangNode); |
| if (regClass == null) { |
| throw new YobException(E_FAIL_TO_LOAD_CLASS + qualName); |
| } |
| |
| try { |
| return regClass.getClassLoader().loadClass(qualName); |
| } catch (ClassNotFoundException e) { |
| log.error(L_FAIL_TO_LOAD_CLASS, qualName); |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Returns the qualified default / op param class. |
| * |
| * @param schemaNode schema node of the required class |
| * @return qualified default / op param class name |
| */ |
| static String getQualifiedDefaultClass(YangSchemaNode schemaNode) { |
| String packageName = schemaNode.getJavaPackage(); |
| String className = getCapitalCase( |
| schemaNode.getJavaClassNameOrBuiltInType()); |
| |
| if (schemaNode instanceof RpcNotificationContainer) { |
| return packageName + PERIOD + className + OP_PARAM; |
| } |
| |
| return packageName + PERIOD + DEFAULT + className; |
| } |
| |
| /** |
| * Returns the qualified interface name. |
| * |
| * @param schemaNode schema node of the required class |
| * @return qualified interface name |
| */ |
| static String getQualifiedinterface(YangSchemaNode schemaNode) { |
| String packageName = schemaNode.getJavaPackage(); |
| String className = getCapitalCase( |
| schemaNode.getJavaClassNameOrBuiltInType()); |
| |
| return packageName + PERIOD + className; |
| } |
| |
| /** |
| * Returns the capital cased first letter of the given string. |
| * |
| * @param name string to be capital cased |
| * @return capital cased string |
| */ |
| public static String getCapitalCase(String name) { |
| // TODO: It will be removed if common util is committed. |
| return name.substring(0, 1).toUpperCase() + |
| name.substring(1); |
| } |
| |
| /** |
| * To set data into parent setter method from string value for identity ref. |
| * |
| * @param leafValue leaf value to be set |
| * @param parentSetterMethod the parent setter method to be invoked |
| * @param parentBuilderObject the parent build object on which to invoke |
| * the method |
| * @param ydtExtendedContext application context |
| * @throws InvocationTargetException if method could not be invoked |
| * @throws IllegalAccessException if method could not be accessed |
| * @throws NoSuchMethodException if method does not exist |
| */ |
| private static void parseIdentityRefInfo(YdtExtendedContext |
| ydtExtendedContext, |
| Method parentSetterMethod, |
| Object parentBuilderObject, |
| String leafValue) |
| throws InvocationTargetException, IllegalAccessException, |
| NoSuchMethodException { |
| Class<?> childSetClass = null; |
| Object childValue = null; |
| Method childMethod = null; |
| |
| YangSchemaNode yangJavaModule = ydtExtendedContext.getYangSchemaNode(); |
| while (yangJavaModule.getReferredSchema() != null) { |
| yangJavaModule = yangJavaModule.getReferredSchema(); |
| } |
| |
| String qualifiedClassName = null; |
| YangType type; |
| if (yangJavaModule instanceof YangLeaf) { |
| type = ((YangLeaf) yangJavaModule).getDataType(); |
| } else { |
| type = ((YangLeafList) yangJavaModule).getDataType(); |
| } |
| |
| if (type.getDataType() == YangDataTypes.LEAFREF && yangJavaModule |
| .getJavaPackage().equals(YobConstants.JAVA_LANG)) { |
| YangLeafRef leafref = ((YangLeafRef) type.getDataTypeExtendedInfo()); |
| YangType effectiveType = leafref.getEffectiveDataType(); |
| if (effectiveType.getDataType() == YangDataTypes.IDENTITYREF) { |
| YangIdentityRef identityref = ((YangIdentityRef) effectiveType |
| .getDataTypeExtendedInfo()); |
| YangIdentity identity = identityref.getReferredIdentity(); |
| qualifiedClassName = identity.getJavaPackage() + PERIOD + |
| getCapitalCase(identity.getJavaClassNameOrBuiltInType()); |
| } |
| } else { |
| qualifiedClassName = yangJavaModule.getJavaPackage() + PERIOD + |
| getCapitalCase(yangJavaModule.getJavaClassNameOrBuiltInType()); |
| } |
| |
| ClassLoader classLoader = getClassLoader(null, qualifiedClassName, |
| ydtExtendedContext, null); |
| try { |
| childSetClass = classLoader.loadClass(qualifiedClassName); |
| } catch (ClassNotFoundException e) { |
| log.error(L_FAIL_TO_LOAD_CLASS, qualifiedClassName); |
| } |
| |
| if (childSetClass != null) { |
| childMethod = childSetClass |
| .getDeclaredMethod(FROM_STRING, String.class); |
| } |
| |
| if (childMethod != null) { |
| childValue = childMethod.invoke(null, leafValue); |
| } |
| |
| parentSetterMethod.invoke(parentBuilderObject, childValue); |
| } |
| |
| /** |
| * Creates and sets default notification object in event subject object. |
| * |
| * @param defaultObj default notification object |
| * @param curNode application context |
| * @param registry YANG schema registry |
| * @return notification event subject object |
| */ |
| public static Object createAndSetInEventSubjectInstance(Object defaultObj, |
| YdtExtendedContext curNode, |
| YangSchemaRegistry registry) { |
| YangSchemaNode childSchema = ((YdtExtendedContext) curNode |
| .getFirstChild()).getYangSchemaNode(); |
| String packageName = childSchema.getJavaPackage(); |
| String className = getCapitalCase(curNode.getYangSchemaNode() |
| .getJavaClassNameOrBuiltInType()); |
| String qualName = packageName + PERIOD + className + EVENT_SUBJECT; |
| |
| ClassLoader classLoader = YobUtils.getClassLoader(registry, qualName, |
| curNode, curNode); |
| |
| Object eventSubObj; |
| Class<?> eventSubjectClass = null; |
| try { |
| eventSubjectClass = classLoader.loadClass(qualName); |
| eventSubObj = eventSubjectClass.newInstance(); |
| } catch (ClassNotFoundException e) { |
| log.error(E_FAIL_TO_LOAD_CLASS, className); |
| throw new YobException(E_FAIL_TO_LOAD_CLASS + |
| qualName); |
| } catch (InstantiationException e) { |
| log.error(E_FAIL_TO_CREATE_OBJ, className); |
| throw new YobException(E_FAIL_TO_CREATE_OBJ + |
| eventSubjectClass.getName()); |
| } catch (IllegalAccessException e) { |
| log.error(L_FAIL_TO_INVOKE_METHOD, className); |
| throw new YobException(E_FAIL_TO_INVOKE_METHOD + |
| eventSubjectClass.getName()); |
| } |
| |
| setInEventSubject(((YdtExtendedContext) curNode.getFirstChild()), |
| eventSubObj, defaultObj); |
| return eventSubObj; |
| } |
| |
| /** |
| * Sets the default notification object in event subject class. |
| * |
| * @param ydtNode application context |
| * @param eventSubObj notification event subject instance |
| * @param defaultObj default notification instance |
| */ |
| public static void setInEventSubject(YdtExtendedContext ydtNode, |
| Object eventSubObj, |
| Object defaultObj) { |
| |
| Class<?> eventSubjectClass = eventSubObj.getClass(); |
| String className = eventSubjectClass.getName(); |
| String setter = ydtNode.getYangSchemaNode().getJavaAttributeName(); |
| |
| try { |
| Class<?> type = null; |
| Field fieldName = eventSubjectClass.getDeclaredField(setter); |
| if (fieldName != null) { |
| type = fieldName.getType(); |
| } |
| |
| Method method; |
| method = eventSubjectClass.getDeclaredMethod(setter, type); |
| method.invoke(eventSubObj, defaultObj); |
| } catch (NoSuchFieldException e) { |
| log.error(L_FAIL_TO_GET_FIELD, className); |
| throw new YobException(E_FAIL_TO_GET_FIELD + className); |
| } catch (NoSuchMethodException e) { |
| log.error(L_FAIL_TO_GET_METHOD, className); |
| throw new YobException(E_FAIL_TO_GET_METHOD + className); |
| } catch (InvocationTargetException | IllegalAccessException e) { |
| log.error(L_FAIL_TO_INVOKE_METHOD, className); |
| throw new YobException(E_FAIL_TO_INVOKE_METHOD + className); |
| } |
| } |
| |
| /** |
| * Creates an object of notification event class and sets event subject |
| * in event class. |
| * |
| * @param eventSubObj instance of event subject class |
| * @param curNode current YDT node |
| * @param registry YANG schema registry |
| * @return notification event object |
| */ |
| public static Object createAndSetInEventInstance(Object eventSubObj, |
| YdtExtendedContext curNode, |
| YangSchemaRegistry registry) { |
| YangSchemaNode childSchema = ((YdtExtendedContext) curNode |
| .getFirstChild()).getYangSchemaNode(); |
| String packageName = childSchema.getJavaPackage(); |
| String className = getCapitalCase(curNode.getYangSchemaNode() |
| .getJavaClassNameOrBuiltInType()); |
| String qualName = packageName + PERIOD + className + EVENT; |
| |
| try { |
| ClassLoader classLoader = YobUtils.getClassLoader(registry, qualName, |
| curNode, curNode); |
| Class<?> eventClass = classLoader.loadClass(qualName); |
| Class<?>[] innerClasses = eventClass.getClasses(); |
| Object typeObj = null; |
| for (Class<?> innerEnumClass : innerClasses) { |
| if (innerEnumClass.getSimpleName().equals(TYPE)) { |
| Method valueOfMethod = innerEnumClass |
| .getDeclaredMethod(VALUE_OF, String.class); |
| String eventType = getEnumJavaAttribute(childSchema.getName()) |
| .toUpperCase(); |
| typeObj = valueOfMethod.invoke(null, eventType); |
| break; |
| } |
| } |
| |
| Constructor constructor = eventClass |
| .getDeclaredConstructor(typeObj.getClass(), |
| eventSubObj.getClass()); |
| constructor.setAccessible(true); |
| return constructor.newInstance(typeObj, eventSubObj); |
| } catch (ClassNotFoundException e) { |
| log.error(L_FAIL_TO_INVOKE_METHOD, className); |
| throw new YobException(E_FAIL_TO_INVOKE_METHOD + className); |
| } catch (InstantiationException e) { |
| log.error(E_FAIL_TO_CREATE_OBJ, className); |
| throw new YobException(E_FAIL_TO_CREATE_OBJ + className); |
| } catch (NoSuchMethodException e) { |
| log.error(L_FAIL_TO_GET_METHOD, className); |
| throw new YobException(E_FAIL_TO_GET_METHOD + className); |
| } catch (InvocationTargetException | IllegalAccessException e) { |
| log.error(L_FAIL_TO_INVOKE_METHOD, className); |
| throw new YobException(E_FAIL_TO_INVOKE_METHOD + className); |
| } |
| } |
| } |