Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* Copyright 2017-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.yang.runtime.impl;
import org.onosproject.yang.compiler.datamodel.RpcNotificationContainer;
import org.onosproject.yang.compiler.datamodel.YangAugment;
import org.onosproject.yang.compiler.datamodel.YangAugmentableNode;
import org.onosproject.yang.compiler.datamodel.YangCase;
import org.onosproject.yang.compiler.datamodel.YangChoice;
import org.onosproject.yang.compiler.datamodel.YangInput;
import org.onosproject.yang.compiler.datamodel.YangLeaf;
import org.onosproject.yang.compiler.datamodel.YangLeafList;
import org.onosproject.yang.compiler.datamodel.YangLeavesHolder;
import org.onosproject.yang.compiler.datamodel.YangList;
import org.onosproject.yang.compiler.datamodel.YangNode;
import org.onosproject.yang.compiler.datamodel.YangOutput;
import org.onosproject.yang.compiler.datamodel.YangRpc;
import org.onosproject.yang.compiler.datamodel.YangSchemaNode;
import org.onosproject.yang.compiler.utils.io.YangPluginConfig;
import org.onosproject.yang.model.DataNode;
import org.onosproject.yang.model.DefaultResourceData;
import org.onosproject.yang.model.DefaultResourceData.Builder;
import org.onosproject.yang.model.InnerNode;
import org.onosproject.yang.model.LeafModelObject;
import org.onosproject.yang.model.LeafNode;
import org.onosproject.yang.model.ModelObject;
import org.onosproject.yang.model.ModelObjectData;
import org.onosproject.yang.model.ModelObjectId;
import org.onosproject.yang.model.ResourceData;
import org.onosproject.yang.model.ResourceId;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import static org.onosproject.yang.compiler.datamodel.YangSchemaNodeType.YANG_NON_DATA_NODE;
import static org.onosproject.yang.compiler.datamodel.utils.DataModelUtils.nonEmpty;
import static org.onosproject.yang.compiler.translator.tojava.YangJavaModelUtils.getAugmentClassName;
import static org.onosproject.yang.compiler.utils.io.impl.YangIoUtils.getCamelCase;
import static org.onosproject.yang.model.DataNode.Type.MULTI_INSTANCE_LEAF_VALUE_NODE;
import static org.onosproject.yang.model.DataNode.Type.MULTI_INSTANCE_NODE;
import static org.onosproject.yang.model.DataNode.Type.SINGLE_INSTANCE_LEAF_VALUE_NODE;
import static org.onosproject.yang.model.DataNode.Type.SINGLE_INSTANCE_NODE;
import static org.onosproject.yang.runtime.RuntimeHelper.DEFAULT_CAPS;
import static org.onosproject.yang.runtime.RuntimeHelper.PERIOD;
import static org.onosproject.yang.runtime.RuntimeHelper.getCapitalCase;
import static org.onosproject.yang.runtime.impl.ModelConverterUtil.TRUE;
import static org.onosproject.yang.runtime.impl.ModelConverterUtil.getAttributeOfObject;
import static org.onosproject.yang.runtime.impl.ModelConverterUtil.getJavaName;
import static org.onosproject.yang.runtime.impl.ModelConverterUtil.getLeafListObject;
import static org.onosproject.yang.runtime.impl.ModelConverterUtil.getLeafObject;
import static org.onosproject.yang.runtime.impl.ModelConverterUtil.isTypeEmpty;
/**
* Representation of data tree builder which generates YANG data tree from the
* class objects which are provided from the applications and return it to the
* protocol(s).
*/
class DefaultDataTreeBuilder {
/*
*
* ModelObjectId | List | ResourceId | List
* ---------------|-------------------|----------------------|---------
* Null | Null | Form module | null
* Class | Null | Form module to node | null
* Class +Leaf | Null | From module to leaf | null
* Leaf | Null | From module to leaf | null
* Null | Class | Form module | class
* Class | Class | From module to node | class
* Class+leaf | Object | INVALID case | -----
*/
/**
* Default YANG Model registry for getting the schema node with respect
* to class packages.
*/
private final DefaultYangModelRegistry reg;
/**
* Creates and instance of data tree builder.
*
* @param registry model registry
*/
DefaultDataTreeBuilder(DefaultYangModelRegistry registry) {
reg = registry;
}
/**
* Returns resource data for given model object data. resource data
* contains resource identifier for given model object identifier and
* list of data nodes for given model objects.
*
* @param modelData model object data
* @return resource data
*/
ResourceData getResourceData(ModelObjectData modelData) {
List modelObjects = modelData.modelObjects();
ModelObjectId id = modelData.identifier();
Builder rscData = DefaultResourceData.builder();
//Create resource identifier.
ModIdToRscIdConverter converter = new ModIdToRscIdConverter(reg);
rscData.resourceId(converter.fetchResourceId(id));
YangSchemaNode lastIndexNode = converter.getLastIndexNode();
//If module object list is empty or null then we just need to
// create resource identifier.
if (!nonEmpty(modelObjects)) {
return rscData.build();
}
if (converter.isMoIdWithLeaf() && nonEmpty(modelObjects)) {
throw new ModelConvertorException(
"invalid module object data when model object identifier" +
" contains leaf node, no object should be added to" +
" model object list." + modelData);
}
if (id == null || !nonEmpty(id.atomicPaths())) {
lastIndexNode = fetchModNode(modelObjects.get(0), converter);
}
//Create data nodes.
DataTreeBuilderHelper helper = new DataTreeBuilderHelper(reg);
YangSchemaNode curNode;
for (ModelObject modObj : modelObjects) {
//Do processing of data node conversion from model objects.
if (modObj instanceof LeafModelObject) {
//Process leaf object.
processLeafObj(lastIndexNode, rscData, (LeafModelObject) modObj);
} else {
if (converter.isInputOrOutput()) {
curNode = handleRpcChild(modObj, (YangNode)
lastIndexNode, rscData);
} else {
curNode = fetchCurNode(modObj, (YangNode) lastIndexNode);
}
if (curNode != null) {
processDataNodeConversion((YangNode) curNode, helper,
rscData, modObj);
} else {
throw new ModelConvertorException(
"failed to convert model object in data node" +
modObj);
}
}
}
return rscData.build();
}
/**
* Process model object to data node conversion.
*
* @param curNode current root node
* @param helper data tree builder helper
* @param rscData resource data builder
* @param curObj current root object
*/
private void processDataNodeConversion(
YangNode curNode, DataTreeBuilderHelper helper,
Builder rscData, Object curObj) {
if (curNode == null) {
return;
}
DataTreeNodeInfo info = new DataTreeNodeInfo();
//Set object in parent node info.
setObjInParent(curNode, curObj, info);
info.type(SINGLE_INSTANCE_NODE);
switch (curNode.getYangSchemaNodeType()) {
case YANG_SINGLE_INSTANCE_NODE:
case YANG_MULTI_INSTANCE_NODE:
processNodeObj(helper, curObj, rscData, curNode);
break;
case YANG_AUGMENT_NODE:
processModelObjects(helper, curNode, rscData, curObj);
break;
case YANG_CHOICE_NODE:
handleChoiceNode(curNode, info, helper, rscData);
break;
case YANG_NON_DATA_NODE:
if (curNode instanceof YangCase) {
handleCaseNode(curNode, info, helper, rscData);
}
break;
default:
throw new ModelConvertorException(
"Non processable schema node has arrived for adding " +
"it in data tree");
}
}
/**
* Returns input/output nodes.
*
* @param obj model object for input/output nodes
* @param parent module node
* @param rscData resource data builder
* @return input/output node
*/
private YangSchemaNode handleRpcChild(
Object obj, YangNode parent, Builder rscData) {
if (obj != null && parent != null) {
//process all the node which are in data model tree.
String name = obj.getClass().getName();
YangNode child = parent.getChild();
while (child != null && !(child instanceof YangRpc)) {
child = child.getNextSibling();
}
while (child != null && child instanceof YangRpc &&
!name.contains(child.getJavaPackage() + "."
+ child.getJavaClassNameOrBuiltInType().toLowerCase())) {
child = child.getNextSibling();
}
if (child != null) {
//Rpc should be part of resource identifier for input/output
// nodes.
ResourceId id = ResourceId.builder()
.addBranchPointSchema("/", null)
.addBranchPointSchema(child.getName(), child
.getNameSpace().getModuleNamespace()).build();
rscData.resourceId(id);
child = child.getChild();
return getNode(child, name);
}
}
// this could also be possible that we have received this module node
// when model object is a node at third level of root node. for
// example if we have a model object id which is null and model
// object is an object of choice instance then this will be called
// because choice object will be instance of case class which is an
// third level node.
return fetchCurNode(obj, parent);
}
/**
* In last index node we will be having parent node of the current object
* so we need to get the current node and start processing it for
* conversion.
*
* @param obj current object
* @param parent parent node
* @return current node
*/
private YangSchemaNode fetchCurNode(Object obj, YangNode parent) {
YangSchemaNode output;
if (obj != null && parent != null) {
//process all the node which are in data model tree.
String name = obj.getClass().getName();
YangNode child = parent.getChild();
while (child != null) {
if (child.getYangSchemaNodeType() == YANG_NON_DATA_NODE) {
child = child.getNextSibling();
continue;
}
//search if parent node has choice as child node.
if (child instanceof YangChoice) {
output = findFromChoiceNode(name, parent);
//search if parent node has a case child node
} else if (child instanceof YangCase) {
output = findFromCaseNode(name, parent);
//no need to process non data nodes.
} else {
//search for normal nodes.
output = getNode(child, name);
}
if (output != null) {
return output;
}
child = child.getNextSibling();
}
return findIfAugmentable(name, parent);
}
return null;
}
/**
* Find the node in augment. if current object is a object of augment
* node or if object is a object of child node of augment node.
*
* @param name class qualified name
* @param parent parent node
* @return current node for object
*/
private YangSchemaNode findIfAugmentable(String name, YangNode parent) {
List augments = ((YangAugmentableNode) parent)
.getAugmentedInfoList();
YangNode child;
YangSchemaNode output;
if (nonEmpty(augments)) {
//this is if we are having an augment class object.
for (YangAugment augment : augments) {
output = getNode(augment, name);
if (output != null) {
return output;
}
}
//this is if we have a child class object which is a
// child node of augment node.
for (YangAugment augment : augments) {
child = augment.getChild();
output = getNode(child, name);
if (output != null) {
return output;
}
}
}
return null;
}
/**
* Find in choice node if current object is an object of choice/case node.
*
* @param qName qualified name
* @param parent choice's paren node
* @return choice node
*/
private YangSchemaNode findFromChoiceNode(String qName, YangSchemaNode parent) {
YangNode child = ((YangNode) parent).getChild();
YangSchemaNode output;
while (child != null) {
if (child instanceof YangChoice) {
output = findFromCaseNode(qName, child);
if (output != null) {
return output;
}
}
child = child.getNextSibling();
}
return null;
}
/**
* Find in case if given object is an object of case node.
*
* @param qName qualified name
* @param parent case's parent node
* @return case node
*/
private YangSchemaNode findFromCaseNode(String qName, YangSchemaNode parent) {
YangNode caseNode = ((YangNode) parent).getChild();
String javaName;
while (caseNode != null) {
javaName = caseNode.getJavaPackage() + PERIOD +
DEFAULT_CAPS + getCapitalCase(getCamelCase(
caseNode.getName(), null));
if (javaName.equals(qName)) {
return caseNode;
}
caseNode = caseNode.getNextSibling();
}
return findIfAugmentable(qName, (YangNode) parent);
}
/**
* Returns the node which has the same java package as the object's package.
*
* @param child child node
* @param pkg java package
* @return child node
*/
private YangSchemaNode getNode(YangNode child, String pkg) {
String javaName;
while (child != null) {
if (child instanceof YangAugment) {
javaName = child.getJavaPackage() + PERIOD + DEFAULT_CAPS +
getAugmentClassName((YangAugment) child,
new YangPluginConfig());
} else if (child instanceof YangInput ||
child instanceof YangOutput) {
javaName = child.getJavaPackage() + PERIOD + DEFAULT_CAPS +
getCapitalCase(child.getJavaClassNameOrBuiltInType());
} else {
javaName = child.getJavaPackage() + PERIOD + DEFAULT_CAPS +
getCapitalCase(getCamelCase(child.getName(), null));
}
if (javaName.equals(pkg)) {
return child;
}
child = child.getNextSibling();
}
return null;
}
/**
* Returns module node when model object identifier is null. model object
* will be used here to get the module node.
*
* @param object module object
* @param converter identifier converter
* @return module node
*/
private YangSchemaNode fetchModNode(ModelObject object,
ModIdToRscIdConverter converter) {
if (object instanceof LeafModelObject) {
LeafModelObject obj = (LeafModelObject) object;
return converter.fetchModNodeFromLeaf(obj.leafIdentifier()
.getClass().getName());
}
return converter.fetchModuleNode(object.getClass().getName());
}
/**
* Process leaf and leaf list information.
*
* @param holder holder node
* @param rscData resource data
* @param lObj leaf model object
*/
private void processLeafObj(YangSchemaNode holder, Builder rscData,
LeafModelObject lObj) {
//handle leaf nodes.
YangLeavesHolder lHolder = (YangLeavesHolder) holder;
if (lObj.leafIdentifier() != null) {
String name = lObj.leafIdentifier().toString().toLowerCase();
List