Removed getParent() method from DataSchemaNode and DataNodeContainer.
Removed rebuild() method from AugmentationTarget.
Added check of augment target path to parser.
Removed redundant code. Updated tests.
Change-Id: Ie7b5f63e8b655aea91d5137007e85b35f1de6cca
Signed-off-by: Martin Vitez <mvitez@cisco.com>
* and is available at http://www.eclipse.org/legal/epl-v10.html\r
*/
package org.opendaylight.yangtools.sal.binding.generator.impl;
+\r
+import static com.google.common.base.Preconditions.*;\r
+import static extension org.opendaylight.yangtools.binding.generator.util.Types.*;\r
+import static org.opendaylight.yangtools.binding.generator.util.BindingGeneratorUtil.*;\r
+import static org.opendaylight.yangtools.binding.generator.util.BindingTypes.*;\r
+import static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.*;\r
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
-import java.util.Set;
+import java.util.Set;\r
+import java.util.Iterator\r
+import java.util.Collection
import org.opendaylight.yangtools.binding.generator.util.BindingTypes;
import org.opendaylight.yangtools.binding.generator.util.ReferencedTypeImpl;
import org.opendaylight.yangtools.binding.generator.util.Types;
import org.opendaylight.yangtools.yang.model.util.DataNodeIterator;
import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil;
import org.opendaylight.yangtools.yang.model.util.UnionType;
-import static com.google.common.base.Preconditions.*;
-import static extension org.opendaylight.yangtools.binding.generator.util.Types.*;
-import static org.opendaylight.yangtools.binding.generator.util.BindingGeneratorUtil.*;
-import static org.opendaylight.yangtools.binding.generator.util.BindingTypes.*;
-import static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.*;
import org.opendaylight.yangtools.yang.parser.util.ModuleDependencySort
import org.opendaylight.yangtools.yang.model.util.ExtendedType;
import org.opendaylight.yangtools.yang.model.api.UsesNode
import org.opendaylight.yangtools.sal.binding.model.api.type.builder.AnnotationTypeBuilder
import org.opendaylight.yangtools.yang.model.api.ModuleImport
import org.opendaylight.yangtools.yang.binding.DataContainer
-import java.util.Iterator
import org.opendaylight.yangtools.yang.model.api.AugmentationTarget
-import java.util.Collection
-import org.opendaylight.yangtools.yang.model.api.YangNode
import org.opendaylight.yangtools.yang.model.api.NotificationDefinition
import org.opendaylight.yangtools.binding.generator.util.BindingGeneratorUtil
import org.opendaylight.yangtools.sal.binding.model.api.Restrictions
import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedPropertyBuilder
import org.opendaylight.yangtools.binding.generator.util.generated.type.builder.GeneratedPropertyBuilderImpl
-
import org.opendaylight.yangtools.yang.common.QName\rimport org.opendaylight.yangtools.yang.binding.BindingMapping
import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedTypeBuilderBase
-import org.opendaylight.yangtools.yang.common.QName\rimport com.google.common.collect.Sets
-
+import com.google.common.collect.Sets
+import java.net.URI
+import java.util.Date
public class BindingGeneratorImpl implements BindingGenerator {
private final Map<Module, ModuleContext> genCtx = new HashMap()
/**\r
- * Outter key represents the package name. Outter value represents map of\r
+ * Outer key represents the package name. Outer value represents map of\r
* all builders in the same package. Inner key represents the schema node\r
* name (in JAVA class/interface name format). Inner value represents\r
* instance of builder for schema node specified in key part.\r
private var TypeProvider typeProvider;
/**\r
- * Holds reference to schema context to resolve data of augmented elemnt\r
+ * Holds reference to schema context to resolve data of augmented element\r
* when creating augmentation builder\r
*/
private var SchemaContext schemaContext;
/**\r
* Converts all <b>groupings</b> of the module to the list of\r
* <code>Type</code> objects. Firstly are groupings sorted according mutual\r
- * dependencies. At least dependend (indepedent) groupings are in the list\r
+ * dependencies. At least dependent (independent) groupings are in the list\r
* saved at first positions. For every grouping the record is added to map\r
* {@link BindingGeneratorImpl#allGroupings allGroupings}\r
*\r
/**\r
* Tries to find EnumTypeDefinition in <code>typeDefinition</code>. If base\r
* type of <code>typeDefinition</code> is of the type ExtendedType then this\r
- * method is recursivelly called with this base type.\r
+ * method is recursively called with this base type.\r
*\r
* @param typeDefinition\r
* TypeDefinition in which should be EnumTypeDefinition found as\r
* builder\r
* @param typeBuilder\r
* GeneratedTypeBuilder to which will be enum builder assigned\r
- * @return enumeration builder which contais data from\r
+ * @return enumeration builder which contains data from\r
* <code>enumTypeDef</code>\r
*/
private def EnumBuilder resolveInnerEnumFromTypeDefinition(EnumTypeDefinition enumTypeDef, QName enumName,
* string with the name of the package to which the augmentation\r
* belongs\r
* @param augSchema\r
- * AugmentationSchema which is contains data about agumentation\r
+ * AugmentationSchema which is contains data about augmentation\r
* (target path, childs...)\r
* @param module current module\r
* @param parentUsesNode parent uses node of this augment (can be null if this augment is not defined under uses statement)\r
"Augmentation Schema does not contain Target Path (Target Path is NULL).");
processUsesAugments(augSchema, module);
-
- // EVERY augmented interface will extends Augmentation<T> interface\r
- // and DataObject interface\r
+\r
val targetPath = augSchema.targetPath;
- var targetSchemaNode = findDataSchemaNode(schemaContext, targetPath);
+ var targetSchemaNode = findDataSchemaNode(schemaContext, targetPath);\r
if (targetSchemaNode instanceof DataSchemaNode && (targetSchemaNode as DataSchemaNode).isAddedByUses()) {
if (parentUsesNode == null) {
targetSchemaNode = findOriginal(targetSchemaNode as DataSchemaNode);
module.name);
}
}\r
+\r
+ if (targetSchemaNode == null) {\r
+ throw new IllegalArgumentException("augment target not found")\r
+ }\r
if (targetSchemaNode !== null) {
var targetTypeBuilder = findChildNodeByPath(targetSchemaNode.path)
private def DataSchemaNode findCorrectTargetFromAugment(DataSchemaNode node) {
if (!node.augmenting) {
- return null;
+ return null
}
- var String currentName = node.QName.localName;
- var tmpPath = new ArrayList<String>();
- var YangNode parent = node;
+ var String currentName = node.QName.localName\r
+ var Object currentNode = node
+ var Object parent = node;\r
+ val tmpPath = new ArrayList<String>()\r
+ val tmpTree = new ArrayList<SchemaNode>()\r
+
var AugmentationSchema augment = null;
- do {
- parent = (parent as DataSchemaNode).parent;
+ do {\r
+ val SchemaPath sp = (parent as SchemaNode).path\r
+ val List<QName> names = sp.path\r
+ val List<QName> newNames = new ArrayList(names)\r
+ newNames.remove(newNames.size - 1)\r
+ val SchemaPath newSp = new SchemaPath(newNames, sp.absolute)\r
+ parent = findDataSchemaNode(schemaContext, newSp)\r
if (parent instanceof AugmentationTarget) {
- tmpPath.add(currentName);
+ tmpPath.add(currentName);\r
+ tmpTree.add(currentNode as SchemaNode)\r
augment = findNodeInAugment((parent as AugmentationTarget).availableAugmentations, currentName);
if (augment == null) {
- currentName = (parent as DataSchemaNode).QName.localName;
+ currentName = (parent as DataSchemaNode).QName.localName;\r
+ currentNode = parent
}
}
} while ((parent as DataSchemaNode).augmenting && augment == null);
if (augment == null) {
return null;
} else {
- Collections.reverse(tmpPath);
+ Collections.reverse(tmpPath);\r
+ Collections.reverse(tmpTree);
var Object actualParent = augment;
var DataSchemaNode result = null;
for (name : tmpPath) {
}
}
- if (result.addedByUses) {
- result = findCorrectTargetFromGrouping(result);
+ if (result.addedByUses) {\r
+ result = findCorrectTargetFromAugmentGrouping(result, augment, tmpTree);
}
return result;
}
return null;
}
-
- private def DataSchemaNode findCorrectTargetFromGrouping(DataSchemaNode node) {
- if (node.path.path.size == 1) {
-
+\r
+ private def DataSchemaNode findCorrectTargetFromGrouping(DataSchemaNode node) {\r
+ if (node.path.path.size == 1) {\r
// uses is under module statement\r
- val Module m = findParentModule(schemaContext, node);
- var DataSchemaNode result = null;
- for (u : m.uses) {
- var SchemaNode targetGrouping = findNodeInSchemaContext(schemaContext, u.groupingPath.path);
- if (!(targetGrouping instanceof GroupingDefinition)) {
- throw new IllegalArgumentException("Failed to generate code for augment in " + u);
- }
- var gr = targetGrouping as GroupingDefinition;
- result = gr.getDataChildByName(node.QName.localName);
- }
- if (result == null) {
- throw new IllegalArgumentException("Failed to generate code for augment");
- }
- return result;
- } else {
- var DataSchemaNode result = null;
- var String currentName = node.QName.localName;
- var tmpPath = new ArrayList<String>();
- var YangNode parent = node.parent;
- do {
- tmpPath.add(currentName);
- val dataNodeParent = parent as DataNodeContainer;
- for (u : dataNodeParent.uses) {
+ val Module m = findParentModule(schemaContext, node);\r
+ var DataSchemaNode result = null;\r
+ for (u : m.uses) {\r
+ var SchemaNode targetGrouping = findNodeInSchemaContext(schemaContext, u.groupingPath.path);\r
+ if (!(targetGrouping instanceof GroupingDefinition)) {\r
+ throw new IllegalArgumentException("Failed to generate code for augment in " + u);\r
+ }\r
+ var gr = targetGrouping as GroupingDefinition;\r
+ result = gr.getDataChildByName(node.QName.localName);\r
+ }\r
+ if (result == null) {\r
+ throw new IllegalArgumentException("Failed to generate code for augment")\r
+ }\r
+ return result\r
+ } else {\r
+ var DataSchemaNode result = null;\r
+ var String currentName = node.QName.localName\r
+ var tmpPath = new ArrayList<String>()\r
+ var Object parent = null\r
+
+ val SchemaPath sp = node.path
+ val List<QName> names = sp.path
+ val List<QName> newNames = new ArrayList(names)
+ newNames.remove(newNames.size - 1)
+ val SchemaPath newSp = new SchemaPath(newNames, sp.absolute)
+ parent = findDataSchemaNode(schemaContext, newSp)
+\r
+ do {\r
+ tmpPath.add(currentName);\r
+ val dataNodeParent = parent as DataNodeContainer;\r
+ for (u : dataNodeParent.uses) {\r
if (result == null) {\r
- var SchemaNode targetGrouping = findNodeInSchemaContext(schemaContext, u.groupingPath.path);
- if (!(targetGrouping instanceof GroupingDefinition)) {
- throw new IllegalArgumentException("Failed to generate code for augment in " + u);
- }
- var gr = targetGrouping as GroupingDefinition;
- result = gr.getDataChildByName(currentName);\r
- }
- }
+ result = getResultFromUses(u, currentName)\r
+ }\r
+ }\r
if (result == null) {
- currentName = (parent as SchemaNode).QName.localName;
+ currentName = (parent as SchemaNode).QName.localName
if (parent instanceof DataSchemaNode) {
- parent = (parent as DataSchemaNode).parent;
+ val SchemaPath nodeSp = (parent as DataSchemaNode).path
+ val List<QName> nodeNames = nodeSp.path
+ val List<QName> nodeNewNames = new ArrayList(nodeNames)
+ nodeNewNames.remove(nodeNewNames.size - 1)
+ if (nodeNewNames.empty) {
+ parent = getParentModule(parent as SchemaNode)
+ } else {
+ val SchemaPath nodeNewSp = new SchemaPath(nodeNewNames, nodeSp.absolute)
+ parent = findDataSchemaNode(schemaContext, nodeNewSp)
+ }
} else {
- parent = (parent as DataNodeContainer).parent;
+ throw new IllegalArgumentException("Failed to generate code for augment")
}
- }
- } while (result == null && !(parent instanceof Module));
+ }\r
+ } while (result == null && !(parent instanceof Module));\r
+\r
+ if (result != null) {\r
+ result = getTargetNode(tmpPath, result)\r
+ }\r
+ return result;\r
+ }\r
+ }\r
+\r
+ private def DataSchemaNode findCorrectTargetFromAugmentGrouping(DataSchemaNode node, AugmentationSchema parentNode,
+ List<SchemaNode> dataTree) {\r
+\r
+ var DataSchemaNode result = null;
+ var String currentName = node.QName.localName
+ var tmpPath = new ArrayList<String>()\r
+ tmpPath.add(currentName)\r
+ var int i = 1;\r
+ var Object parent = null
+\r
+ do {\r
+ if (dataTree.size < 2 || dataTree.size == i) {
+ parent = parentNode
+ } else {
+ parent = dataTree.get(dataTree.size - (i+1))
+ tmpPath.add((parent as SchemaNode).QName.localName);
+ }\r
- if (result != null) {
- if (tmpPath.size == 1) {\r
- if (result != null && result.addedByUses) {\r
- result = findOriginal(result);\r
- }
- return result;
- } else {
- var DataSchemaNode newParent = result;
- Collections.reverse(tmpPath);
- tmpPath.remove(0);
- for (name : tmpPath) {
- newParent = (newParent as DataNodeContainer).getDataChildByName(name);
- }\r
- if (newParent != null && newParent.addedByUses) {\r
- newParent = findOriginal(newParent);\r
- }
- return newParent;
+ val dataNodeParent = parent as DataNodeContainer;
+ for (u : dataNodeParent.uses) {
+ if (result == null) {\r
+ result = getResultFromUses(u, currentName)
}
}
-
+ if (result == null) {
+ i = i + 1\r
+ currentName = (parent as SchemaNode).QName.localName
+ }
+ } while (result == null);
+\r
+ if (result != null) {
+ result = getTargetNode(tmpPath, result)\r
+ }
+ return result;
+ }\r
+\r
+ private def getResultFromUses(UsesNode u, String currentName) {
+ var SchemaNode targetGrouping = findNodeInSchemaContext(schemaContext, u.groupingPath.path)
+ if (!(targetGrouping instanceof GroupingDefinition)) {
+ throw new IllegalArgumentException("Failed to generate code for augment in " + u)
+ }
+ var gr = targetGrouping as GroupingDefinition
+ return gr.getDataChildByName(currentName)
+ }\r
+\r
+ private def getTargetNode(List<String> tmpPath, DataSchemaNode node) {
+ var DataSchemaNode result = node
+ if (tmpPath.size == 1) {
+ if (result != null && result.addedByUses) {
+ result = findOriginal(result);
+ }
return result;
+ } else {
+ var DataSchemaNode newParent = result;
+ Collections.reverse(tmpPath);
+
+ tmpPath.remove(0);
+ for (name : tmpPath) {
+ newParent = (newParent as DataNodeContainer).getDataChildByName(name);
+ }
+ if (newParent != null && newParent.addedByUses) {
+ newParent = findOriginal(newParent);
+ }
+ return newParent;
}
- }
+ }\r
+
/**\r
* Convenient method to find node added by uses statement.\r
genCtx.get(module).addCaseType(caseNode.path, caseTypeBuilder)
val Set<DataSchemaNode> caseChildNodes = caseNode.childNodes
if (caseChildNodes !== null) {
- val parentNode = choiceNode.parent
+ var Object parentNode = null\r
+ val SchemaPath nodeSp = choiceNode.path\r
+ val List<QName> nodeNames = nodeSp.path\r
+ val List<QName> nodeNewNames = new ArrayList(nodeNames)\r
+ nodeNewNames.remove(nodeNewNames.size - 1)\r
+ val SchemaPath nodeNewSp = new SchemaPath(nodeNewNames, nodeSp.absolute)\r
+ parentNode = findDataSchemaNode(schemaContext, nodeNewSp)\r
+
var SchemaNode parent
if (parentNode instanceof AugmentationSchema) {
val augSchema = parentNode as AugmentationSchema;
}
parent = targetSchemaNode
} else {
- parent = choiceNode.parent as SchemaNode
+ val SchemaPath sp = choiceNode.path\r
+ val List<QName> names = sp.path\r
+ val List<QName> newNames = new ArrayList(names)\r
+ newNames.remove(newNames.size - 1)\r
+ val SchemaPath newSp = new SchemaPath(newNames, sp.absolute)\r
+ parent = findDataSchemaNode(schemaContext, newSp)\r
}
var GeneratedTypeBuilder childOfType = findChildNodeByPath(parent.path)
resolveDataSchemaNodes(module, basePackageName, caseTypeBuilder, childOfType, caseChildNodes)
val caseTypeBuilder = addDefaultInterfaceDefinition(packageName, caseNode);
caseTypeBuilder.addImplementsType(targetType);
- val SchemaNode parent = targetNode.parent as SchemaNode;
+ var SchemaNode parent = null\r
+ val SchemaPath nodeSp = targetNode.path\r
+ val List<QName> nodeNames = nodeSp.path\r
+ val List<QName> nodeNewNames = new ArrayList(nodeNames)\r
+ nodeNewNames.remove(nodeNewNames.size - 1)\r
+ val SchemaPath nodeNewSp = new SchemaPath(nodeNewNames, nodeSp.absolute)\r
+ parent = findDataSchemaNode(schemaContext, nodeNewSp)\r
+
var GeneratedTypeBuilder childOfType = null;
if (parent instanceof Module) {
childOfType = genCtx.get(parent as Module).moduleNode
private def GeneratedTypeBuilder addDefaultInterfaceDefinition(String packageName, SchemaNode schemaNode,
Type parent) {
val it = addRawInterfaceDefinition(packageName, schemaNode, "");\r
- val qname = schemaNode.QName;
qnameConstant(BindingMapping.QNAME_STATIC_FIELD_NAME,schemaNode.QName);\r
if (parent === null) {
addImplementsType(DATA_OBJECT);
* <li>if <code>schemaNode</code> equals null</li>\r
* <li>if <code>packageName</code> equals null</li>\r
* <li>if Q name of schema node is null</li>\r
- * <li>if schema node name is nul</li>\r
+ * <li>if schema node name is null</li>\r
* </ul>\r
*\r
*/
}
/**\r
- * Creates the name of the getter method from <code>localName</code>.\r
+ * Creates the name of the getter method from <code>methodName</code>.\r
*\r
- * @param localName\r
+ * @param methodName\r
* string with the name of the getter method\r
* @param returnType return type\r
* @return string with the name of the getter method for\r
- * <code>localName</code> in JAVA method format\r
+ * <code>methodName</code> in JAVA method format\r
*/
public static def String getterMethodName(String localName, Type returnType) {
val method = new StringBuilder();
* Adds the implemented types to type builder.\r
*\r
* The method passes through the list of <i>uses</i> in\r
- * {@code dataNodeContainer}. For every <i>use</i> is obtained coresponding\r
+ * {@code dataNodeContainer}. For every <i>use</i> is obtained corresponding\r
* generated type from {@link BindingGeneratorImpl#allGroupings\r
* allGroupings} which is added as <i>implements type</i> to\r
* <code>builder</code>\r
return null
}
\r
+ private def Module getParentModule(SchemaNode node) {\r
+ val QName qname = node.getPath().getPath().get(0);\r
+ val URI namespace = qname.getNamespace();\r
+ val Date revision = qname.getRevision();\r
+ return schemaContext.findModuleByNamespaceAndRevision(namespace, revision);\r
+ }\r
\r
public def getModuleContexts() {\r
genCtx;\r
- }
+ }\r
+\r
}
*/
package org.opendaylight.yangtools.sal.binding.generator.impl;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileNotFoundException;
-import java.io.InputStream;
+import java.io.*;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.URI;
import java.net.URISyntaxException;
-import java.util.ArrayList;
-import java.util.Date;
-import java.util.GregorianCalendar;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-import org.junit.Ignore;
+import java.util.*;
+
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.MustDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.AnyXmlBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ConstraintsBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.LeafListSchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ModuleBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.UnknownSchemaNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.impl.*;
import org.opendaylight.yangtools.yang.parser.impl.YangParserImpl;
import org.opendaylight.yangtools.yang.parser.util.RefineHolder;
import org.opendaylight.yangtools.yang.parser.util.RefineUtils;
}
private void findUnknownNode(DataSchemaNodeBuilder childNode, String unknownNodeValue, String unknownNodeName) {
- List<UnknownSchemaNodeBuilder> unknownSchemaNodesBuilder = childNode.getUnknownNodeBuilders();
+ List<UnknownSchemaNodeBuilder> unknownSchemaNodesBuilder = childNode.getUnknownNodes();
boolean refinedUnknownNodeLflstFound = false;
for (UnknownSchemaNodeBuilder unknownSchemaNodeBuilders : unknownSchemaNodesBuilder) {
assertTrue("Must element in 'lflst' is missing.", mustLflstFound);
}
- @Ignore
@Test
public void usesInGroupingDependenciesTest() {
loadTestResources();
refineHolders = usesNodeBuilder.getRefines();
// FIXME
//GroupingUtils.updateUsesParent(usesNodeBuilder);
- dataSchemaNodeBuilders = usesNodeBuilder.getParent().getChildNodeBuilders();
+ dataSchemaNodeBuilders = usesNodeBuilder.getParent().getChildNodes();
break;
}
}
RefineHolder refHolderChc2 = getRefineHolder("chc2", refineHolders);
QName qname = createQname();
- DataSchemaNodeBuilder builderChc2 = new ChoiceBuilder("module", 4, qname);
+ List<QName> path = Lists.newArrayList(qname);
+ DataSchemaNodeBuilder builderChc2 = new ChoiceBuilder("module", 4, qname, new SchemaPath(path, true));
assertNotNull("Refine holder chc2 wasn't initialized.", refHolderChc2);
RefineUtils.refineChoice((ChoiceBuilder) builderChc2, refHolderChc2);
RefineHolder refHolderChc = getRefineHolder("chc", refineHolders);
QName qname = createQname();
- DataSchemaNodeBuilder builderChc = new ChoiceBuilder("module", 4, qname);
+ List<QName> path = Lists.newArrayList(qname);
+ DataSchemaNodeBuilder builderChc = new ChoiceBuilder("module", 4, qname, new SchemaPath(path, true));
assertNotNull("Refine holder chc wasn't initialized.", refHolderChc);
assertNotNull("Data schema node builder chc wasn't initialized.", builderChc);
reference "http://www.opendaylight.org/";
}
- augment "at:topology" {
+ augment "/at:topology" {
container interfaces {
list interface {
key "interface-id";
}
}
- augment "at:topology/at:network-links/at:network-link" {
+ augment "/at:topology/at:network-links/at:network-link" {
container tunnels {
list tunnel {
key "tunnel-id";
}
}
- augment "at:topology/at:network-links/at:network-link" {
+ augment "/at:topology/at:network-links/at:network-link" {
leaf interface {
type leafref {
path "../atp:interfaces/atp:interface/atp:interface-id";
reference "http://www.opendaylight.org/";
}
- augment "at:topology" {
+ augment "/at:topology" {
container interfaces {
list interface {
key "interface-id";
}
}
- augment "at:topology/at:network-links/at:network-link" {
+ augment "/at:topology/at:network-links/at:network-link" {
container tunnels {
list tunnel {
key "tunnel-id";
}
}
- augment "at:topology/at:network-links/at:network-link" {
+ augment "/at:topology/at:network-links/at:network-link" {
leaf interface {
type leafref {
path "/at:topology/atp:interfaces/atp:interface/atp:interface-id";
reference "http://www.opendaylight.org/";
}
- augment "at:topology/at:network-links/at:network-link/at:attributes" {
+ augment "/at:topology/at:network-links/at:network-link/at:attributes" {
leaf longitude {
type decimal64 {
fraction-digits 2;
reference "http://www.opendaylight.org/";
}
- augment "at:topology/at:network-links/at:network-link/aug-at:tunnels/aug-at:tunnel" {
+ augment "/at:topology/at:network-links/at:network-link/aug-at:tunnels/aug-at:tunnel" {
leaf tunnel-name {
type string;
}
import java.math.BigDecimal;
import java.math.BigInteger;
+import java.net.URI;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.apache.commons.lang3.StringEscapeUtils;
-import org.opendaylight.yangtools.binding.generator.util.*;
-import org.opendaylight.yangtools.binding.generator.util.generated.type.builder.*;
+import org.opendaylight.yangtools.binding.generator.util.BindingGeneratorUtil;
+import org.opendaylight.yangtools.binding.generator.util.TypeConstants;
+import org.opendaylight.yangtools.binding.generator.util.Types;
+import org.opendaylight.yangtools.binding.generator.util.generated.type.builder.EnumerationBuilderImpl;
+import org.opendaylight.yangtools.binding.generator.util.generated.type.builder.GeneratedPropertyBuilderImpl;
+import org.opendaylight.yangtools.binding.generator.util.generated.type.builder.GeneratedTOBuilderImpl;
import org.opendaylight.yangtools.sal.binding.generator.spi.TypeProvider;
-import org.opendaylight.yangtools.sal.binding.model.api.*;
+import org.opendaylight.yangtools.sal.binding.model.api.AccessModifier;
+import org.opendaylight.yangtools.sal.binding.model.api.ConcreteType;
import org.opendaylight.yangtools.sal.binding.model.api.Enumeration;
-import org.opendaylight.yangtools.sal.binding.model.api.type.builder.*;
+import org.opendaylight.yangtools.sal.binding.model.api.GeneratedTransferObject;
+import org.opendaylight.yangtools.sal.binding.model.api.Restrictions;
+import org.opendaylight.yangtools.sal.binding.model.api.Type;
+import org.opendaylight.yangtools.sal.binding.model.api.type.builder.EnumBuilder;
+import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedPropertyBuilder;
+import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedTOBuilder;
+import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedTypeBuilderBase;
+import org.opendaylight.yangtools.sal.binding.model.api.type.builder.MethodSignatureBuilder;
import org.opendaylight.yangtools.yang.binding.BindingMapping;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.*;
+import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
+import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.Module;
+import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath;
+import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.SchemaNode;
+import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.*;
import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition.Bit;
import org.opendaylight.yangtools.yang.model.util.*;
} else if (base instanceof BitsTypeDefinition) {
String parentName;
String className;
- YangNode parent = node.getParent();
- if (parent instanceof Module) {
- parentName = parseToClassName(((Module) parent).getName()) + "Data";
- String basePackageName = BindingGeneratorUtil.moduleNamespaceToPackageName((Module) parent);
- className = basePackageName + "." + parentName + "." + parseToClassName(node.getQName().getLocalName());
+ SchemaPath nodePath = node.getPath();
+ Module parent = getParentModule(node);
+ if (nodePath.getPath().size() == 1) {
+ parentName = BindingMapping.getClassName((parent).getName()) + "Data";
+ String basePackageName = BindingGeneratorUtil.moduleNamespaceToPackageName(parent);
+ className = basePackageName + "." + parentName + "." + BindingMapping.getClassName(node.getQName());
} else {
- Module parentModule = getParentModule(node);
- String basePackageName = BindingGeneratorUtil.moduleNamespaceToPackageName(parentModule);
+ String basePackageName = BindingGeneratorUtil.moduleNamespaceToPackageName(parent);
String packageName = packageNameForGeneratedType(basePackageName, type.getPath());
- parentName = parseToClassName(((SchemaNode) parent).getQName().getLocalName());
- className = packageName + "." + parentName + "." + parseToClassName(node.getQName().getLocalName());
+ parentName = BindingMapping.getClassName(((SchemaNode) parent).getQName());
+ className = packageName + "." + parentName + "." + BindingMapping.getClassName(node.getQName());
}
result = bitsToDef((BitsTypeDefinition) base, className, defaultValue, type instanceof ExtendedType);
} else if (base instanceof BooleanTypeDefinition) {
String newDefVal = new String(defValArray);
String className;
if (type instanceof ExtendedType) {
- QName qname = type.getPath().getPath().get(0);
- Module m = schemaContext.findModuleByNamespaceAndRevision(qname.getNamespace(), qname.getRevision());
+ Module m = getParentModule(type);
String basePackageName = BindingGeneratorUtil.moduleNamespaceToPackageName(m);
String packageName = packageNameForGeneratedType(basePackageName, type.getPath());
- className = packageName + "." + parseToClassName(typeQName.getLocalName());
+ className = packageName + "." + BindingMapping.getClassName(typeQName);
} else {
Module parentModule = getParentModule(node);
String basePackageName = BindingGeneratorUtil.moduleNamespaceToPackageName(parentModule);
String packageName = packageNameForGeneratedType(basePackageName, node.getPath());
- className = packageName + "." + parseToClassName(node.getQName().getLocalName());
+ className = packageName + "." + BindingMapping.getClassName(node.getQName());
}
result = className + "." + newDefVal;
} else if (base instanceof IdentityrefTypeDefinition) {
if (type instanceof ExtendedType && !(base instanceof LeafrefTypeDefinition)
&& !(base instanceof EnumerationType) && !(base instanceof UnionTypeDefinition)) {
- QName qname = type.getPath().getPath().get(0);
- Module m = schemaContext.findModuleByNamespaceAndRevision(qname.getNamespace(), qname.getRevision());
+ Module m = getParentModule(type);
String basePackageName = BindingGeneratorUtil.moduleNamespaceToPackageName(m);
String packageName = packageNameForGeneratedType(basePackageName, type.getPath());
String className = packageName + "." + BindingMapping.getClassName(typeQName);
return sb.toString();
}
- private Module getParentModule(YangNode node) {
- if (node instanceof Module) {
- return (Module) node;
- }
-
- YangNode parent = null;
- if (node instanceof DataSchemaNode) {
- parent = ((DataSchemaNode) node).getParent();
- } else if (node instanceof DataNodeContainer) {
- parent = ((DataNodeContainer) node).getParent();
- } else {
- parent = null;
- }
-
- while (parent != null && !(parent instanceof Module)) {
- if (parent instanceof DataSchemaNode) {
- parent = ((DataSchemaNode) parent).getParent();
- } else if (parent instanceof DataNodeContainer) {
- parent = ((DataNodeContainer) parent).getParent();
- } else {
- parent = null;
- }
- }
- return (Module) parent;
+ private Module getParentModule(SchemaNode node) {
+ QName qname = node.getPath().getPath().get(0);
+ URI namespace = qname.getNamespace();
+ Date revision = qname.getRevision();
+ return schemaContext.findModuleByNamespaceAndRevision(namespace, revision);
}
private String leafrefToDef(LeafSchemaNode parentNode, LeafrefTypeDefinition leafrefType) {
String basePackageName = BindingGeneratorUtil.moduleNamespaceToPackageName(module);
className = basePackageName + "." + BindingMapping.getClassName(typeQName);
} else {
- YangNode parent = node.getParent();
- if (parent instanceof Module) {
- parentName = parseToClassName(((Module) parent).getName()) + "Data";
- String basePackageName = BindingGeneratorUtil.moduleNamespaceToPackageName((Module) parent);
+ SchemaPath nodePath = node.getPath();
+ if (nodePath.getPath().size() == 1) {
+ QName first = nodePath.getPath().get(0);
+ URI namespace = first.getNamespace();
+ Date revision = first.getRevision();
+ Module parent = schemaContext.findModuleByNamespaceAndRevision(namespace, revision);
+ parentName = BindingMapping.getClassName((parent).getName()) + "Data";
+ String basePackageName = BindingGeneratorUtil.moduleNamespaceToPackageName(parent);
className = basePackageName + "." + parentName + "." + BindingMapping.getClassName(node.getQName());
} else {
- Module parentModule = getParentModule(node);
+ QName first = node.getPath().getPath().get(0);
+ URI namespace = first.getNamespace();
+ Date revision = first.getRevision();
+ Module parentModule = schemaContext.findModuleByNamespaceAndRevision(namespace, revision);
String basePackageName = BindingGeneratorUtil.moduleNamespaceToPackageName(parentModule);
String packageName = packageNameForGeneratedType(basePackageName, node.getType().getPath());
className = packageName + "." + BindingMapping.getClassName(node.getQName());
private def resourceParams() '''
«FOR pathParam : pathListParams»
+ «IF pathParam != null»
«val prefix = pathParam.type.QName.prefix»
«val type = if (prefix.nullOrEmpty) pathParam.type.QName.localName else prefix + ":" + pathParam.type.QName.localName»
<param required="true" style="template" name="«pathParam.QName.localName»" type="«type»"/>
+ «ENDIF»
«ENDFOR»
'''
import org.opendaylight.yangtools.yang.data.api.Node;
import org.opendaylight.yangtools.yang.data.api.SimpleNode;
import org.opendaylight.yangtools.yang.data.impl.codec.TypeDefinitionAwareCodec;
-import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
-import org.opendaylight.yangtools.yang.model.api.ChoiceNode;
-import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.YangNode;
+import org.opendaylight.yangtools.yang.model.api.*;
import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
}
if (schema instanceof ContainerSchemaNode || schema instanceof ListSchemaNode) {
- doc.appendChild(createXmlRootElement(doc, data, schema, codecProvider));
+ doc.appendChild(createXmlRootElement(doc, data, (SchemaNode) schema, codecProvider));
return doc;
} else {
throw new UnsupportedDataTypeException(
}
}
- private static Element createXmlRootElement(Document doc, Node<?> data, YangNode schema,
+ private static Element createXmlRootElement(Document doc, Node<?> data, SchemaNode schema,
XmlCodecProvider codecProvider) throws UnsupportedDataTypeException {
QName dataType = data.getNodeType();
Element itemEl = doc.createElementNS(dataType.getNamespace().toString(), dataType.getLocalName());
baseType.getQName().getLocalName(), //
node.getValue().getClass());
element.setTextContent(String.valueOf(node.getValue()));
- }
+ }
} else {
if (node.getValue() != null) {
try {
/**\r
* Node which can contains other nodes.\r
*/\r
-public interface DataNodeContainer extends YangNode {\r
-\r
- YangNode getParent();\r
+public interface DataNodeContainer {\r
\r
/**\r
* Returns set of all newly defined types within this DataNodeContainer.\r
* which contains data.
*
*/
-public interface DataSchemaNode extends SchemaNode, YangNode {
-
- YangNode getParent();
+public interface DataSchemaNode extends SchemaNode {
/**
* Returns <code>true</code> if the data node was added by augmentation,
*/
public interface UsesNode extends YangNode {
- YangNode getParent();
-
/**
* Returns the schema path to used grouping.
*
protected final int line;
protected Builder parentBuilder;
- protected List<UnknownSchemaNode> unknownNodes = new ArrayList<>();
+ protected final List<UnknownSchemaNode> unknownNodes = new ArrayList<>();
protected final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
protected AbstractBuilder(final String moduleName, final int line) {
}
@Override
- public List<UnknownSchemaNodeBuilder> getUnknownNodeBuilders() {
+ public List<UnknownSchemaNodeBuilder> getUnknownNodes() {
return addedUnknownNodes;
}
addedUnknownNodes.add(unknownNode);
}
- public void setUnknownNodes(List<UnknownSchemaNode> unknownNodes) {
- this.unknownNodes = unknownNodes;
- }
-
}
*/
package org.opendaylight.yangtools.yang.parser.builder.api;
-import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Map;
public abstract class AbstractDataNodeContainerBuilder extends AbstractBuilder implements DataNodeContainerBuilder {
protected QName qname;
- protected Map<QName, DataSchemaNode> childNodes = new TreeMap<QName, DataSchemaNode>(Comparators.QNAME_COMP);
- protected final Set<DataSchemaNodeBuilder> addedChildNodes = new HashSet<DataSchemaNodeBuilder>();
+ protected final Map<QName, DataSchemaNode> childNodes = new TreeMap<>(Comparators.QNAME_COMP);
+ protected final Set<DataSchemaNodeBuilder> addedChildNodes = new HashSet<>();
- protected Set<GroupingDefinition> groupings = new TreeSet<GroupingDefinition>(Comparators.SCHEMA_NODE_COMP);
- protected final Set<GroupingBuilder> addedGroupings = new HashSet<GroupingBuilder>();
+ protected final Set<GroupingDefinition> groupings = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
+ protected final Set<GroupingBuilder> addedGroupings = new HashSet<>();
- protected Set<TypeDefinition<?>> typedefs = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
+ protected final Set<TypeDefinition<?>> typedefs = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
protected final Set<TypeDefinitionBuilder> addedTypedefs = new HashSet<>();
- protected Set<UsesNode> usesNodes = new HashSet<>();
+ protected final Set<UsesNode> usesNodes = new HashSet<>();
protected final Set<UsesNodeBuilder> addedUsesNodes = new HashSet<>();
protected AbstractDataNodeContainerBuilder(final String moduleName, final int line, final QName qname) {
}
@Override
- public Collection<DataSchemaNode> getChildNodes() {
- if (childNodes == null) {
- return Collections.emptySet();
- }
- return childNodes.values();
- }
-
- @Override
- public Set<DataSchemaNodeBuilder> getChildNodeBuilders() {
+ public Set<DataSchemaNodeBuilder> getChildNodes() {
return addedChildNodes;
}
addedChildNodes.add(child);
}
+ @Override
+ public void addChildNodeToContext(DataSchemaNodeBuilder child) {
+ addedChildNodes.add(child);
+ }
+
@Override
public void addChildNode(DataSchemaNode child) {
QName childName = child.getQName();
return groupings;
}
- public void setGroupings(final Set<GroupingDefinition> groupings) {
- this.groupings = groupings;
- }
-
public Set<GroupingBuilder> getGroupingBuilders() {
return addedGroupings;
}
return addedUsesNodes;
}
- public void setUsesnodes(final Set<UsesNode> usesNodes) {
- this.usesNodes = usesNodes;
- }
-
@Override
public void addUsesNode(UsesNodeBuilder usesNode) {
addedUsesNodes.add(usesNode);
\r
import org.opendaylight.yangtools.yang.common.QName;\r
import org.opendaylight.yangtools.yang.model.api.SchemaPath;\r
-import org.opendaylight.yangtools.yang.model.api.Status;\r
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;\r
\r
/**\r
* Basic implementation of SchemaNodeBuilder.\r
*/\r
public abstract class AbstractSchemaNodeBuilder extends AbstractBuilder implements SchemaNodeBuilder {\r
- protected QName qname;\r
+ protected final QName qname;\r
protected SchemaPath schemaPath;\r
- protected String description;\r
- protected String reference;\r
- protected Status status = Status.CURRENT;\r
\r
protected AbstractSchemaNodeBuilder(final String moduleName, final int line, final QName qname) {\r
super(moduleName, line);\r
return true;\r
}\r
\r
+ @Override\r
public QName getQName() {\r
return qname;\r
}\r
\r
- @Override\r
- public SchemaPath getPath() {\r
- return schemaPath;\r
- }\r
-\r
- @Override\r
- public void setPath(SchemaPath schemaPath) {\r
- this.schemaPath = schemaPath;\r
- }\r
-\r
- @Override\r
- public String getDescription() {\r
- return description;\r
- }\r
-\r
- @Override\r
- public void setDescription(String description) {\r
- this.description = description;\r
- }\r
-\r
- @Override\r
- public String getReference() {\r
- return reference;\r
- }\r
-\r
- @Override\r
- public void setReference(String reference) {\r
- this.reference = reference;\r
- }\r
-\r
- @Override\r
- public Status getStatus() {\r
- return status;\r
- }\r
-\r
- @Override\r
- public void setStatus(Status status) {\r
- if (status != null) {\r
- this.status = status;\r
- }\r
- }\r
-\r
public void setUnknownNodes(List<UnknownSchemaNode> unknownNodes) {\r
- this.unknownNodes = unknownNodes;\r
+ this.unknownNodes.addAll(unknownNodes);\r
}\r
\r
}\r
*/
package org.opendaylight.yangtools.yang.parser.builder.api;
-import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-import org.opendaylight.yangtools.yang.model.api.Status;
-import org.opendaylight.yangtools.yang.model.api.YangNode;
+import org.opendaylight.yangtools.yang.model.api.*;
/**
* Interface for builders of 'augment' statement.
*/
void setTargetNodeSchemaPath(SchemaPath path);
- AugmentationSchema build(YangNode parent);
+ AugmentationSchema build();
/**
* Get information about augmentation process.
*/
void addAugmentation(AugmentationSchemaBuilder augment);
- /**
- * Build again already built data node.
- *
- * In general, when Builder.build is called first time, it creates YANG data
- * model node instance. With every other call it just return this instance
- * without checking for properties change. This method causes that builder
- * object process again all its properties and return an updated instance of
- * YANG data node.
- */
- void rebuild();
-
}
import java.util.List;
-import org.opendaylight.yangtools.yang.model.api.YangNode;
import org.opendaylight.yangtools.yang.parser.builder.impl.UnknownSchemaNodeBuilder;
/**
*
* @return collection of UnknownSchemaNodeBuilder objects
*/
- List<UnknownSchemaNodeBuilder> getUnknownNodeBuilders();
+ List<UnknownSchemaNodeBuilder> getUnknownNodes();
/**
* Build YANG data model node.
*
* @return YANG data model node
*/
- Object build(YangNode parent);
+ Object build();
- interface Rebuildable<T extends Builder> {
- T toBuilder();
- }
}
*/
package org.opendaylight.yangtools.yang.parser.builder.api;
-import java.util.Collection;
import java.util.Set;
import org.opendaylight.yangtools.yang.common.QName;
*/
SchemaPath getPath();
- /**
- * Get already built child nodes.
- *
- * @return collection of child nodes
- */
- Collection<DataSchemaNode> getChildNodes();
-
/**
* Get builders of child nodes.
*
* @return collection child nodes builders
*/
- Set<DataSchemaNodeBuilder> getChildNodeBuilders();
+ Set<DataSchemaNodeBuilder> getChildNodes();
/**
* Get child node by name.
void addChildNode(DataSchemaNode childNode);
+ void addChildNodeToContext(DataSchemaNodeBuilder childNode);
+
/**
* Get already built groupings defined in this node.
*
*/
package org.opendaylight.yangtools.yang.parser.builder.api;
-import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.YangNode;
+import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.parser.builder.impl.ConstraintsBuilder;
/**
*/
public interface DataSchemaNodeBuilder extends SchemaNodeBuilder, GroupingMember {
- void setQName(QName qname);
-
/**
* Build DataSchemaNode object from this builder.
*/
- DataSchemaNode build(YangNode parent);
+ DataSchemaNode build();
+
+ void setPath(SchemaPath path);
/**
*
import java.util.Set;
-import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
-import org.opendaylight.yangtools.yang.model.api.YangNode;
import org.opendaylight.yangtools.yang.parser.builder.impl.UnknownSchemaNodeBuilder;
/**
/**
* Build GroupingDefinition object from this builder.
*/
- GroupingDefinition build(YangNode parent);
-
- void setQName(QName qname);
+ GroupingDefinition build();
Set<DataSchemaNodeBuilder> instantiateChildNodes(Builder newParent);
import org.opendaylight.yangtools.yang.model.api.SchemaNode;\r
import org.opendaylight.yangtools.yang.model.api.SchemaPath;\r
import org.opendaylight.yangtools.yang.model.api.Status;\r
-import org.opendaylight.yangtools.yang.model.api.YangNode;\r
\r
/**\r
* Interface for all builders of SchemaNode nodes.\r
*/\r
SchemaPath getPath();\r
\r
- /**\r
- * Set schema path to this node.\r
- *\r
- * @param schemaPath\r
- */\r
- void setPath(SchemaPath schemaPath);\r
-\r
/**\r
* Get description of this node.\r
*\r
/**\r
* Build SchemaNode object from this builder.\r
*/\r
- SchemaNode build(YangNode parent);\r
+ SchemaNode build();\r
\r
}\r
\r
import org.opendaylight.yangtools.yang.common.QName;\r
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;\r
-import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;\r
-import org.opendaylight.yangtools.yang.model.api.YangNode;\r
import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint;\r
import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;\r
import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;\r
\r
void setQName(QName qname);\r
\r
- TypeDefinition<?> build(YangNode parent);\r
+ TypeDefinition<?> build();\r
\r
List<RangeConstraint> getRanges();\r
\r
\r
void setFractionDigits(Integer fractionDigits);\r
\r
- List<UnknownSchemaNode> getUnknownNodes();\r
-\r
Object getDefaultValue();\r
\r
void setDefaultValue(Object defaultValue);\r
import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.UsesNode;
-import org.opendaylight.yangtools.yang.model.api.YangNode;
import org.opendaylight.yangtools.yang.parser.util.RefineHolder;
/**
* Interface for builders of 'uses' statement.
*/
-public interface UsesNodeBuilder extends GroupingMember, Builder {
+public interface UsesNodeBuilder extends GroupingMember {
/**
* Get parent of this uses node. Since uses can be defined only under on of
/**
* Build new UsesNode object.
*/
- UsesNode build(YangNode parent);
+ UsesNode build();
boolean isResolved();
*/
package org.opendaylight.yangtools.yang.parser.builder.impl;
+import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.YangNode;
import org.opendaylight.yangtools.yang.parser.builder.api.AbstractSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.util.Comparators;
private final AnyXmlSchemaNodeImpl instance;
private final ConstraintsBuilder constraints;
- private Boolean configuration;
- private boolean augmenting;
- private boolean addedByUses;
-
- public AnyXmlBuilder(final String moduleName, final int line, final QName qname, final SchemaPath schemaPath) {
+ public AnyXmlBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path) {
super(moduleName, line, qname);
- this.schemaPath = schemaPath;
- instance = new AnyXmlSchemaNodeImpl(qname);
+ this.schemaPath = path;
+ instance = new AnyXmlSchemaNodeImpl(qname, schemaPath);
constraints = new ConstraintsBuilder(moduleName, line);
}
+ public AnyXmlBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path,
+ final AnyXmlSchemaNode base) {
+ super(moduleName, line, qname);
+ this.schemaPath = path;
+ this.instance = new AnyXmlSchemaNodeImpl(qname, schemaPath);
+ constraints = new ConstraintsBuilder(moduleName, line, base.getConstraints());
+
+ instance.description = base.getDescription();
+ instance.reference = base.getReference();
+ instance.status = base.getStatus();
+ instance.augmenting = base.isAugmenting();
+ instance.addedByUses = base.isAddedByUses();
+ instance.configuration = base.isConfiguration();
+ instance.constraintsDef = base.getConstraints();
+ instance.unknownNodes.addAll(base.getUnknownSchemaNodes());
+ }
+
@Override
- public AnyXmlSchemaNode build(YangNode parent) {
+ public AnyXmlSchemaNode build() {
if (!built) {
- instance.setParent(parent);
- instance.setPath(schemaPath);
instance.setConstraints(constraints.build());
- instance.setDescription(description);
- instance.setReference(reference);
- instance.setStatus(status);
- instance.setConfiguration(configuration);
- instance.setAugmenting(augmenting);
- instance.setAddedByUses(addedByUses);
// UNKNOWN NODES
for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
- unknownNodes.add(b.build(instance));
+ unknownNodes.add(b.build());
}
Collections.sort(unknownNodes, Comparators.SCHEMA_NODE_COMP);
instance.setUnknownSchemaNodes(unknownNodes);
}
@Override
- public void setQName(QName qname) {
- this.qname = qname;
- instance.setQName(qname);
+ public SchemaPath getPath() {
+ return instance.path;
+ }
+
+ @Override
+ public void setPath(SchemaPath path) {
+ instance.path = path;
}
@Override
return constraints;
}
+ @Override
+ public String getDescription() {
+ return instance.description;
+ }
+
+ @Override
+ public void setDescription(final String description) {
+ instance.description = description;
+ }
+
+ @Override
+ public String getReference() {
+ return instance.reference;
+ }
+
+ @Override
+ public void setReference(final String reference) {
+ instance.reference = reference;
+ }
+
+ @Override
+ public Status getStatus() {
+ return instance.status;
+ }
+
+ @Override
+ public void setStatus(Status status) {
+ if (status != null) {
+ instance.status = status;
+ }
+ }
+
public List<UnknownSchemaNodeBuilder> getUnknownNodes() {
return addedUnknownNodes;
}
@Override
public boolean isAugmenting() {
- return augmenting;
+ return instance.augmenting;
}
@Override
public void setAugmenting(final boolean augmenting) {
- this.augmenting = augmenting;
+ instance.augmenting = augmenting;
}
@Override
public boolean isAddedByUses() {
- return addedByUses;
+ return instance.addedByUses;
}
@Override
public void setAddedByUses(final boolean addedByUses) {
- this.addedByUses = addedByUses;
+ instance.addedByUses = addedByUses;
}
@Override
public Boolean isConfiguration() {
- return configuration;
+ return instance.configuration;
}
@Override
public void setConfiguration(final Boolean configuration) {
- this.configuration = configuration;
+ instance.configuration = configuration;
}
@Override
}
private final class AnyXmlSchemaNodeImpl implements AnyXmlSchemaNode {
- private QName qname;
+ private final QName qname;
private SchemaPath path;
- private YangNode parent;
private String description;
private String reference;
private Status status = Status.CURRENT;
private ConstraintDefinition constraintsDef;
private boolean augmenting;
private boolean addedByUses;
- private List<UnknownSchemaNode> unknownNodes = Collections.emptyList();
+ private final List<UnknownSchemaNode> unknownNodes = new ArrayList<>();
- private AnyXmlSchemaNodeImpl(final QName qname) {
+ private AnyXmlSchemaNodeImpl(final QName qname, final SchemaPath path) {
this.qname = qname;
+ this.path = path;
}
@Override
return qname;
}
- private void setQName(QName qname) {
- this.qname = qname;
- }
-
@Override
public SchemaPath getPath() {
return path;
}
- private void setPath(final SchemaPath path) {
- this.path = path;
- }
-
- @Override
- public YangNode getParent() {
- return parent;
- }
-
- private void setParent(YangNode parent) {
- this.parent = parent;
- }
-
@Override
public String getDescription() {
return description;
}
- private void setDescription(String description) {
- this.description = description;
- }
-
@Override
public String getReference() {
return reference;
}
- private void setReference(String reference) {
- this.reference = reference;
- }
-
@Override
public Status getStatus() {
return status;
}
- private void setStatus(Status status) {
- if (status != null) {
- this.status = status;
- }
- }
-
@Override
public boolean isAugmenting() {
return augmenting;
}
- private void setAugmenting(boolean augmenting) {
- this.augmenting = augmenting;
- }
-
@Override
public boolean isAddedByUses() {
return addedByUses;
}
- private void setAddedByUses(boolean addedByUses) {
- this.addedByUses = addedByUses;
- }
-
@Override
public boolean isConfiguration() {
return configuration;
}
- private void setConfiguration(boolean configuration) {
- this.configuration = configuration;
- }
-
@Override
public ConstraintDefinition getConstraints() {
return constraintsDef;
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
- return unknownNodes;
+ return Collections.unmodifiableList(unknownNodes);
}
private void setUnknownSchemaNodes(List<UnknownSchemaNode> unknownNodes) {
if (unknownNodes != null) {
- this.unknownNodes = unknownNodes;
+ this.unknownNodes.addAll(unknownNodes);
}
}
*/
package org.opendaylight.yangtools.yang.parser.builder.impl;
+import java.util.ArrayList;
import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.UsesNode;
-import org.opendaylight.yangtools.yang.model.api.YangNode;
import org.opendaylight.yangtools.yang.model.util.RevisionAwareXPathImpl;
import org.opendaylight.yangtools.yang.parser.builder.api.AbstractDataNodeContainerBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
private final AugmentationSchemaImpl instance;
private String whenCondition;
- private String description;
- private String reference;
- private Status status = Status.CURRENT;
private final String augmentTargetStr;
private SchemaPath targetPath;
}
@Override
- public AugmentationSchema build(YangNode parent) {
+ public AugmentationSchema build() {
if (!built) {
- instance.setParent(parent);
- instance.setDescription(description);
- instance.setReference(reference);
- instance.setStatus(status);
instance.setTargetPath(targetNodeSchemaPath);
RevisionAwareXPath whenStmt;
// CHILD NODES
for (DataSchemaNodeBuilder node : addedChildNodes) {
- DataSchemaNode child = node.build(instance);
+ DataSchemaNode child = node.build();
childNodes.put(child.getQName(), child);
}
- instance.setChildNodes(childNodes);
+ instance.addChildNodes(childNodes);
// USES
for (UsesNodeBuilder builder : addedUsesNodes) {
- usesNodes.add(builder.build(instance));
+ usesNodes.add(builder.build());
}
- instance.setUses(usesNodes);
+ instance.addUses(usesNodes);
// UNKNOWN NODES
for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
- unknownNodes.add(b.build(instance));
+ unknownNodes.add(b.build());
}
Collections.sort(unknownNodes, Comparators.SCHEMA_NODE_COMP);
- instance.setUnknownSchemaNodes(unknownNodes);
+ instance.addUnknownSchemaNodes(unknownNodes);
built = true;
}
@Override
public String getDescription() {
- return description;
+ return instance.description;
}
@Override
- public void setDescription(String description) {
- this.description = description;
+ public void setDescription(final String description) {
+ instance.description = description;
}
@Override
public String getReference() {
- return reference;
+ return instance.reference;
}
@Override
- public void setReference(String reference) {
- this.reference = reference;
+ public void setReference(final String reference) {
+ instance.reference = reference;
}
@Override
public Status getStatus() {
- return status;
+ return instance.status;
}
@Override
public void setStatus(Status status) {
if (status != null) {
- this.status = status;
+ instance.status = status;
}
}
}
private final class AugmentationSchemaImpl implements AugmentationSchema {
- private YangNode parent;
private SchemaPath targetPath;
private RevisionAwareXPath whenCondition;
- private Map<QName, DataSchemaNode> childNodes = Collections.emptyMap();
- private Set<UsesNode> uses = Collections.emptySet();
+ private final Map<QName, DataSchemaNode> childNodes = new HashMap<>();
+ private final Set<UsesNode> uses = new HashSet<>();
private String description;
private String reference;
private Status status;
- private List<UnknownSchemaNode> unknownNodes = Collections.emptyList();
+ private final List<UnknownSchemaNode> unknownNodes = new ArrayList<>();
private AugmentationSchemaImpl(SchemaPath targetPath) {
this.targetPath = targetPath;
}
- @Override
- public YangNode getParent() {
- return parent;
- }
-
- private void setParent(YangNode parent) {
- this.parent = parent;
- }
-
@Override
public SchemaPath getTargetPath() {
return targetPath;
public Set<DataSchemaNode> getChildNodes() {
final Set<DataSchemaNode> result = new TreeSet<DataSchemaNode>(Comparators.SCHEMA_NODE_COMP);
result.addAll(childNodes.values());
- return result;
+ return Collections.unmodifiableSet(result);
}
- private void setChildNodes(Map<QName, DataSchemaNode> childNodes) {
+ private void addChildNodes(Map<QName, DataSchemaNode> childNodes) {
if (childNodes != null) {
- this.childNodes = childNodes;
+ this.childNodes.putAll(childNodes);
}
}
@Override
public Set<UsesNode> getUses() {
- return uses;
+ return Collections.unmodifiableSet(uses);
}
- private void setUses(Set<UsesNode> uses) {
+ private void addUses(Set<UsesNode> uses) {
if (uses != null) {
- this.uses = uses;
+ this.uses.addAll(uses);
}
}
return description;
}
- private void setDescription(String description) {
- this.description = description;
- }
-
@Override
public String getReference() {
return reference;
}
- private void setReference(String reference) {
- this.reference = reference;
- }
-
@Override
public Status getStatus() {
return status;
}
- private void setStatus(Status status) {
- this.status = status;
- }
-
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
- return unknownNodes;
+ return Collections.unmodifiableList(unknownNodes);
}
- private void setUnknownSchemaNodes(List<UnknownSchemaNode> unknownSchemaNodes) {
+ private void addUnknownSchemaNodes(List<UnknownSchemaNode> unknownSchemaNodes) {
if (unknownSchemaNodes != null) {
- this.unknownNodes = unknownSchemaNodes;
+ this.unknownNodes.addAll(unknownSchemaNodes);
}
}
*/
package org.opendaylight.yangtools.yang.parser.builder.impl;
+import java.net.URI;
import java.util.ArrayList;
import java.util.Collections;
+import java.util.Date;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
import org.opendaylight.yangtools.yang.model.api.ChoiceNode;
import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition;
+import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.YangNode;
import org.opendaylight.yangtools.yang.parser.builder.api.AbstractSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationTargetBuilder;
AugmentationTargetBuilder {
private boolean isBuilt;
private final ChoiceNodeImpl instance;
- private YangNode parent;
// DataSchemaNode args
- private boolean augmenting;
- private boolean addedByUses;
- private Boolean configuration;
private final ConstraintsBuilder constraints;
// AugmentationTarget args
private final List<AugmentationSchema> augmentations = new ArrayList<>();
private final Set<ChoiceCaseBuilder> caseBuilders = new HashSet<>();
private String defaultCase;
- public ChoiceBuilder(final String moduleName, final int line, final QName qname) {
+ public ChoiceBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path) {
super(moduleName, line, qname);
- instance = new ChoiceNodeImpl(qname);
+ this.schemaPath = path;
+ instance = new ChoiceNodeImpl(qname, path);
constraints = new ConstraintsBuilder(moduleName, line);
}
+ public ChoiceBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path,
+ final ChoiceNode base) {
+ super(moduleName, line, qname);
+ this.schemaPath = path;
+ instance = new ChoiceNodeImpl(qname, path);
+ constraints = new ConstraintsBuilder(moduleName, line, base.getConstraints());
+
+ instance.description = base.getDescription();
+ instance.reference = base.getReference();
+ instance.status = base.getStatus();
+ instance.augmenting = base.isAugmenting();
+ instance.addedByUses = base.isAddedByUses();
+ instance.configuration = base.isConfiguration();
+ instance.constraints = base.getConstraints();
+ instance.augmentations.addAll(base.getAvailableAugmentations());
+
+ URI ns = qname.getNamespace();
+ Date rev = qname.getRevision();
+ String pref = qname.getPrefix();
+ Set<DataSchemaNodeBuilder> wrapped = ParserUtils.wrapChildNodes(moduleName, line, new HashSet<DataSchemaNode>(
+ base.getCases()), path, ns, rev, pref);
+ for (DataSchemaNodeBuilder wrap : wrapped) {
+ if (wrap instanceof ChoiceCaseBuilder) {
+ caseBuilders.add((ChoiceCaseBuilder) wrap);
+ }
+ }
+
+ instance.unknownNodes.addAll(base.getUnknownSchemaNodes());
+ }
+
@Override
- public ChoiceNode build(YangNode parent) {
+ public ChoiceNode build() {
if (!isBuilt) {
- this.parent = parent;
- instance.setParent(parent);
- instance.setPath(schemaPath);
- instance.setDescription(description);
- instance.setReference(reference);
- instance.setStatus(status);
- instance.setAugmenting(augmenting);
- instance.setAddedByUses(addedByUses);
- instance.setConfiguration(configuration);
instance.setConstraints(constraints.build());
instance.setDefaultCase(defaultCase);
// CASES
for (ChoiceCaseBuilder caseBuilder : caseBuilders) {
- cases.add(caseBuilder.build(instance));
+ cases.add(caseBuilder.build());
}
- instance.setCases(cases);
+ instance.addCases(cases);
// AUGMENTATIONS
for (AugmentationSchemaBuilder builder : augmentationBuilders) {
- augmentations.add(builder.build(instance));
+ augmentations.add(builder.build());
}
- instance.setAvailableAugmentations(new HashSet<>(augmentations));
+ instance.addAvailableAugmentations(new HashSet<>(augmentations));
// UNKNOWN NODES
for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
- unknownNodes.add(b.build(instance));
+ unknownNodes.add(b.build());
}
Collections.sort(unknownNodes, Comparators.SCHEMA_NODE_COMP);
- instance.setUnknownSchemaNodes(unknownNodes);
+ instance.addUnknownSchemaNodes(unknownNodes);
isBuilt = true;
}
return instance;
}
- @Override
- public void rebuild() {
- isBuilt = false;
- build(parent);
+ public Set<ChoiceCaseBuilder> getCases() {
+ return caseBuilders;
}
@Override
- public void setQName(QName qname) {
- this.qname = qname;
- instance.setQName(qname);
+ public SchemaPath getPath() {
+ return instance.path;
}
- public Set<ChoiceCaseBuilder> getCases() {
- return caseBuilders;
+ @Override
+ public void setPath(SchemaPath path) {
+ instance.path = path;
}
/**
caseBuilders.add((ChoiceCaseBuilder) caseNode);
} else {
ChoiceCaseBuilder caseBuilder = new ChoiceCaseBuilder(caseNode.getModuleName(), caseNode.getLine(),
- caseQName);
+ caseQName, caseNode.getPath());
if (caseNode.isAugmenting()) {
// if node is added by augmentation, set case builder augmenting
// as true and node augmenting as false
caseBuilder.setAugmenting(true);
caseNode.setAugmenting(false);
}
- caseBuilder.setPath(caseNode.getPath());
SchemaPath newPath = ParserUtils.createSchemaPath(caseNode.getPath(), caseQName);
caseNode.setPath(newPath);
caseBuilder.addChildNode(caseNode);
}
}
- public void setCases(Set<ChoiceCaseNode> cases) {
- this.cases = cases;
+ @Override
+ public String getDescription() {
+ return instance.description;
+ }
+
+ @Override
+ public void setDescription(final String description) {
+ instance.description = description;
+ }
+
+ @Override
+ public String getReference() {
+ return instance.reference;
+ }
+
+ @Override
+ public void setReference(final String reference) {
+ instance.reference = reference;
+ }
+
+ @Override
+ public Status getStatus() {
+ return instance.status;
+ }
+
+ @Override
+ public void setStatus(Status status) {
+ if (status != null) {
+ instance.status = status;
+ }
}
@Override
public boolean isAugmenting() {
- return augmenting;
+ return instance.augmenting;
}
@Override
public void setAugmenting(boolean augmenting) {
- this.augmenting = augmenting;
+ instance.augmenting = augmenting;
}
@Override
public boolean isAddedByUses() {
- return addedByUses;
+ return instance.addedByUses;
}
@Override
public void setAddedByUses(final boolean addedByUses) {
- this.addedByUses = addedByUses;
+ instance.addedByUses = addedByUses;
}
+ @Override
public Boolean isConfiguration() {
- return configuration;
+ return instance.configuration;
}
@Override
public void setConfiguration(Boolean configuration) {
- this.configuration = configuration;
+ instance.configuration = configuration;
}
@Override
return augmentationBuilders;
}
- public List<UnknownSchemaNodeBuilder> getUnknownNodes() {
- return addedUnknownNodes;
- }
-
public String getDefaultCase() {
return defaultCase;
}
}
public final class ChoiceNodeImpl implements ChoiceNode {
- private QName qname;
+ private final QName qname;
private SchemaPath path;
- private YangNode parent;
private String description;
private String reference;
private Status status = Status.CURRENT;
private boolean addedByUses;
private boolean configuration;
private ConstraintDefinition constraints;
- private Set<ChoiceCaseNode> cases = Collections.emptySet();
- private Set<AugmentationSchema> augmentations = Collections.emptySet();
- private List<UnknownSchemaNode> unknownNodes = Collections.emptyList();
+ private final Set<ChoiceCaseNode> cases = new HashSet<>();
+ private final Set<AugmentationSchema> augmentations = new HashSet<>();
+ private final List<UnknownSchemaNode> unknownNodes = new ArrayList<>();
private String defaultCase;
- private ChoiceNodeImpl(QName qname) {
+ private ChoiceNodeImpl(QName qname, SchemaPath path) {
this.qname = qname;
+ this.path = path;
}
@Override
return qname;
}
- private void setQName(QName qname) {
- this.qname = qname;
- }
-
@Override
public SchemaPath getPath() {
return path;
}
- private void setPath(SchemaPath path) {
- this.path = path;
- }
-
- @Override
- public YangNode getParent() {
- return parent;
- }
-
- private void setParent(YangNode parent) {
- this.parent = parent;
- }
-
@Override
public String getDescription() {
return description;
}
- private void setDescription(String description) {
- this.description = description;
- }
-
@Override
public String getReference() {
return reference;
}
- private void setReference(String reference) {
- this.reference = reference;
- }
-
@Override
public Status getStatus() {
return status;
}
- private void setStatus(Status status) {
- if (status != null) {
- this.status = status;
- }
- }
-
@Override
public boolean isAugmenting() {
return augmenting;
}
- private void setAugmenting(boolean augmenting) {
- this.augmenting = augmenting;
- }
-
@Override
public boolean isAddedByUses() {
return addedByUses;
}
- private void setAddedByUses(boolean addedByUses) {
- this.addedByUses = addedByUses;
- }
-
@Override
public boolean isConfiguration() {
return configuration;
}
- private void setConfiguration(boolean configuration) {
- this.configuration = configuration;
- }
-
@Override
public ConstraintDefinition getConstraints() {
return constraints;
@Override
public Set<AugmentationSchema> getAvailableAugmentations() {
- return augmentations;
+ return Collections.unmodifiableSet(augmentations);
}
- private void
setAvailableAugmentations(Set<AugmentationSchema> availableAugmentations) {
+ private void
addAvailableAugmentations(Set<AugmentationSchema> availableAugmentations) {
if (availableAugmentations != null) {
- this.augmentations = availableAugmentations;
+ this.augmentations.addAll(availableAugmentations);
}
}
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
- return unknownNodes;
+ return Collections.unmodifiableList(unknownNodes);
}
- private void setUnknownSchemaNodes(List<UnknownSchemaNode> unknownSchemaNodes) {
+ private void addUnknownSchemaNodes(List<UnknownSchemaNode> unknownSchemaNodes) {
if (unknownSchemaNodes != null) {
- this.unknownNodes = unknownSchemaNodes;
+ this.unknownNodes.addAll(unknownSchemaNodes);
}
}
@Override
public Set<ChoiceCaseNode> getCases() {
- return cases;
+ return Collections.unmodifiableSet(cases);
}
@Override
return null;
}
- private void setCases(Set<ChoiceCaseNode> cases) {
+ private void addCases(Set<ChoiceCaseNode> cases) {
if (cases != null) {
- this.cases = cases;
+ this.cases.addAll(cases);
}
}
this.defaultCase = defaultCase;
}
- public ChoiceBuilder toBuilder() {
- return ChoiceBuilder.this;
- }
-
@Override
public int hashCode() {
final int prime = 31;
package org.opendaylight.yangtools.yang.parser.builder.impl;
+import java.net.URI;
import java.util.ArrayList;
import java.util.Collections;
+import java.util.Date;
+import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
-import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
-import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-import org.opendaylight.yangtools.yang.model.api.Status;
-import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.UsesNode;
-import org.opendaylight.yangtools.yang.model.api.YangNode;
+import org.opendaylight.yangtools.yang.model.api.*;
import org.opendaylight.yangtools.yang.parser.builder.api.AbstractDataNodeContainerBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationTargetBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
import org.opendaylight.yangtools.yang.parser.util.Comparators;
+import org.opendaylight.yangtools.yang.parser.util.ParserUtils;
import org.opendaylight.yangtools.yang.parser.util.YangParseException;
public final class ChoiceCaseBuilder extends AbstractDataNodeContainerBuilder implements DataSchemaNodeBuilder,
AugmentationTargetBuilder {
private boolean isBuilt;
private final ChoiceCaseNodeImpl instance;
- private YangNode parent;
// SchemaNode args
private SchemaPath schemaPath;
- private String description;
- private String reference;
- private Status status = Status.CURRENT;
- // DataSchemaNode args
- private boolean augmenting;
- private boolean addedByUses;
private final ConstraintsBuilder constraints;
// AugmentationTarget args
private final List<AugmentationSchema> augmentations = new ArrayList<>();
private final List<AugmentationSchemaBuilder> augmentationBuilders = new ArrayList<>();
- public ChoiceCaseBuilder(final String moduleName, final int line, final QName qname) {
+ public ChoiceCaseBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path) {
super(moduleName, line, qname);
- instance = new ChoiceCaseNodeImpl(qname);
+ this.schemaPath = path;
+ instance = new ChoiceCaseNodeImpl(qname, path);
constraints = new ConstraintsBuilder(moduleName, line);
}
+ public ChoiceCaseBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path, final ChoiceCaseNode base) {
+ super(moduleName, line, qname);
+ this.schemaPath = path;
+ instance = new ChoiceCaseNodeImpl(qname, path);
+ constraints = new ConstraintsBuilder(moduleName, line, base.getConstraints());
+
+ instance.description = base.getDescription();
+ instance.reference = base.getReference();
+ instance.status = base.getStatus();
+ instance.augmenting = base.isAugmenting();
+ instance.addedByUses = base.isAddedByUses();
+ instance.constraints = base.getConstraints();
+ instance.augmentations.addAll(base.getAvailableAugmentations());
+
+ URI ns = qname.getNamespace();
+ Date rev = qname.getRevision();
+ String pref = qname.getPrefix();
+ addedChildNodes.addAll(ParserUtils.wrapChildNodes(moduleName, line, base.getChildNodes(), path, ns, rev, pref));
+ addedGroupings.addAll(ParserUtils.wrapGroupings(moduleName, line, base.getGroupings(), path, ns, rev, pref));
+
+ instance.uses.addAll(base.getUses());
+ instance.unknownNodes.addAll(base.getUnknownSchemaNodes());
+ }
+
@Override
- public ChoiceCaseNode build(YangNode parent) {
+ public ChoiceCaseNode build() {
if (!isBuilt) {
- this.parent = parent;
- instance.setParent(parent);
instance.setConstraints(constraints.build());
- instance.setPath(schemaPath);
- instance.setDescription(description);
- instance.setReference(reference);
- instance.setStatus(status);
- instance.setAugmenting(augmenting);
- instance.setAddedByUses(addedByUses);
// CHILD NODES
for (DataSchemaNodeBuilder node : addedChildNodes) {
- DataSchemaNode child = node.build(instance);
+ DataSchemaNode child = node.build();
childNodes.put(child.getQName(), child);
}
- instance.setChildNodes(childNodes);
+ instance.addChildNodes(childNodes);
// USES
for (UsesNodeBuilder builder : addedUsesNodes) {
- usesNodes.add(builder.build(instance));
+ usesNodes.add(builder.build());
}
- instance.setUses(usesNodes);
+ instance.addUses(usesNodes);
// UNKNOWN NODES
for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
- unknownNodes.add(b.build(instance));
+ unknownNodes.add(b.build());
}
Collections.sort(unknownNodes, Comparators.SCHEMA_NODE_COMP);
- instance.setUnknownSchemaNodes(unknownNodes);
+ instance.addUnknownSchemaNodes(unknownNodes);
// AUGMENTATIONS
for (AugmentationSchemaBuilder builder : augmentationBuilders) {
- augmentations.add(builder.build(instance));
+ augmentations.add(builder.build());
}
- instance.setAvailableAugmentations(new HashSet<>(augmentations));
+ instance.addAvailableAugmentations(new HashSet<>(augmentations));
isBuilt = true;
}
return instance;
}
- @Override
- public void rebuild() {
- isBuilt = false;
- build(parent);
- }
-
- @Override
- public void setQName(QName qname) {
- this.qname = qname;
- instance.setQName(qname);
- }
@Override
public SchemaPath getPath() {
- return schemaPath;
+ return instance.path;
}
@Override
- public void setPath(final SchemaPath schemaPath) {
- this.schemaPath = schemaPath;
- instance.setPath(schemaPath);
+ public void setPath(SchemaPath path) {
+ instance.path = path;
}
public String getDescription() {
- return description;
+ return instance.description;
}
@Override
public void setDescription(final String description) {
- this.description = description;
+ instance.description = description;
}
public String getReference() {
- return reference;
+ return instance.reference;
}
@Override
public void setReference(String reference) {
- this.reference = reference;
+ instance.reference = reference;
}
public Status getStatus() {
- return status;
+ return instance.status;
}
@Override
public void setStatus(Status status) {
if (status != null) {
- this.status = status;
+ instance.status = status;
}
}
@Override
public boolean isAugmenting() {
- return augmenting;
+ return instance.augmenting;
}
@Override
public void setAugmenting(boolean augmenting) {
- this.augmenting = augmenting;
+ instance.augmenting = augmenting;
}
@Override
public boolean isAddedByUses() {
- return addedByUses;
+ return instance.addedByUses;
}
@Override
public void setAddedByUses(boolean addedByUses) {
- this.addedByUses = addedByUses;
+ instance.addedByUses = addedByUses;
}
@Override
}
public final class ChoiceCaseNodeImpl implements ChoiceCaseNode {
- private QName qname;
+ private final QName qname;
private SchemaPath path;
- private YangNode parent;
private String description;
private String reference;
private Status status = Status.CURRENT;
private boolean augmenting;
private boolean addedByUses;
private ConstraintDefinition constraints;
- private Map<QName, DataSchemaNode> childNodes = Collections.emptyMap();
- private Set<AugmentationSchema> augmentations = Collections.emptySet();
- private Set<UsesNode> uses = Collections.emptySet();
- private List<UnknownSchemaNode> unknownNodes = Collections.emptyList();
+ private final Map<QName, DataSchemaNode> childNodes = new HashMap<>();
+ private final Set<AugmentationSchema> augmentations = new HashSet<>();
+ private final Set<UsesNode> uses = new HashSet<>();
+ private final List<UnknownSchemaNode> unknownNodes = new ArrayList<>();
- private ChoiceCaseNodeImpl(QName qname) {
+ private ChoiceCaseNodeImpl(QName qname, SchemaPath path) {
this.qname = qname;
+ this.path = path;
}
@Override
return qname;
}
- private void setQName(QName qname) {
- this.qname = qname;
- }
-
@Override
public SchemaPath getPath() {
return path;
}
- private void setPath(SchemaPath path) {
- this.path = path;
- }
-
- @Override
- public YangNode getParent() {
- return parent;
- }
-
- private void setParent(YangNode parent) {
- this.parent = parent;
- }
-
@Override
public String getDescription() {
return description;
}
- private void setDescription(String description) {
- this.description = description;
- }
-
@Override
public String getReference() {
return reference;
}
- private void setReference(String reference) {
- this.reference = reference;
- }
-
@Override
public Status getStatus() {
return status;
}
- private void setStatus(Status status) {
- if (status != null) {
- this.status = status;
- }
- }
-
@Override
public boolean isConfiguration() {
return false;
return augmenting;
}
- private void setAugmenting(boolean augmenting) {
- this.augmenting = augmenting;
- }
-
@Override
public boolean isAddedByUses() {
return addedByUses;
}
- private void setAddedByUses(boolean addedByUses) {
- this.addedByUses = addedByUses;
- }
-
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
- return unknownNodes;
+ return Collections.unmodifiableList(unknownNodes);
}
- private void setUnknownSchemaNodes(List<UnknownSchemaNode> unknownNodes) {
+ private void addUnknownSchemaNodes(List<UnknownSchemaNode> unknownNodes) {
if (unknownNodes != null) {
- this.unknownNodes = unknownNodes;
+ this.unknownNodes.addAll(unknownNodes);
}
}
@Override
public Set<DataSchemaNode> getChildNodes() {
- return new HashSet<>(childNodes.values());
+ return Collections.unmodifiableSet(new HashSet<>(childNodes.values()));
}
- private void setChildNodes(Map<QName, DataSchemaNode> childNodes) {
+ private void addChildNodes(Map<QName, DataSchemaNode> childNodes) {
if (childNodes != null) {
- this.childNodes = childNodes;
+ this.childNodes.putAll(childNodes);
}
}
@Override
public Set<UsesNode> getUses() {
- return uses;
+ return Collections.unmodifiableSet(uses);
}
- private void setUses(Set<UsesNode> uses) {
+ private void addUses(Set<UsesNode> uses) {
if (uses != null) {
- this.uses = uses;
+ this.uses.addAll(uses);
}
}
@Override
public Set<AugmentationSchema> getAvailableAugmentations() {
- return augmentations;
+ return Collections.unmodifiableSet(augmentations);
}
- private void
setAvailableAugmentations(Set<AugmentationSchema> augmentations) {
+ private void
addAvailableAugmentations(Set<AugmentationSchema> augmentations) {
if (augmentations != null) {
- this.augmentations = augmentations;
+ this.augmentations.addAll(augmentations);
}
}
- public ChoiceCaseBuilder toBuilder() {
- return ChoiceCaseBuilder.this;
- }
-
@Override
public int hashCode() {
final int prime = 31;
*/
package org.opendaylight.yangtools.yang.parser.builder.impl;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.Set;
+import java.util.*;
-import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition;
-import org.opendaylight.yangtools.yang.model.api.MustDefinition;
-import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath;
+import org.opendaylight.yangtools.yang.model.api.*;
import org.opendaylight.yangtools.yang.model.util.RevisionAwareXPathImpl;
public final class ConstraintsBuilder {
private final int line;
private final ConstraintDefinitionImpl instance;
private final Set<MustDefinition> mustDefinitions;
+ private RevisionAwareXPath whenStmt;
private String whenCondition;
private boolean mandatory;
private Integer min;
max = b.getMaxElements();
}
+ ConstraintsBuilder(final String moduleName, final int line, final ConstraintDefinition base) {
+ this.moduleName = moduleName;
+ this.line = line;
+ instance = new ConstraintDefinitionImpl();
+ whenStmt = base.getWhenCondition();
+ mustDefinitions = new HashSet<MustDefinition>(base.getMustConstraints());
+ mandatory = base.isMandatory();
+ min = base.getMinElements();
+ max = base.getMaxElements();
+ }
+
public ConstraintDefinition build() {
- RevisionAwareXPath whenStmt;
- if (whenCondition == null) {
- whenStmt = null;
- } else {
- whenStmt = new RevisionAwareXPathImpl(whenCondition, false);
+ if (whenStmt == null) {
+ if (whenCondition == null) {
+ whenStmt = null;
+ } else {
+ whenStmt = new RevisionAwareXPathImpl(whenCondition, false);
+ }
}
instance.setWhenCondition(whenStmt);
instance.setMustConstraints(mustDefinitions);
*/
package org.opendaylight.yangtools.yang.parser.builder.impl;
+import java.net.URI;
import java.util.ArrayList;
import java.util.Collections;
+import java.util.Date;
+import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
+import java.util.TreeSet;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
-import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition;
-import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-import org.opendaylight.yangtools.yang.model.api.Status;
-import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.UsesNode;
-import org.opendaylight.yangtools.yang.model.api.YangNode;
+import org.opendaylight.yangtools.yang.model.api.*;
import org.opendaylight.yangtools.yang.parser.builder.api.AbstractDataNodeContainerBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationTargetBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
import org.opendaylight.yangtools.yang.parser.util.Comparators;
+import org.opendaylight.yangtools.yang.parser.util.ParserUtils;
import org.opendaylight.yangtools.yang.parser.util.YangParseException;
public final class ContainerSchemaNodeBuilder extends AbstractDataNodeContainerBuilder implements
private final ContainerSchemaNodeImpl instance;
private YangNode parent;
- // SchemaNode args
- private SchemaPath schemaPath;
- private String description;
- private String reference;
- private Status status = Status.CURRENT;
+ private final SchemaPath path;
// DataSchemaNode args
- private boolean augmenting;
- private boolean addedByUses;
private Boolean configuration;
private final ConstraintsBuilder constraints;
// AugmentationTarget args
- private final List<AugmentationSchema> augmentations = new ArrayList<>();
private final List<AugmentationSchemaBuilder> augmentationBuilders = new ArrayList<>();
- // ContainerSchemaNode args
- private boolean presence;
+ public ContainerSchemaNodeBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path) {
+ super(moduleName, line, qname);
+ this.path = path;
+ this.instance = new ContainerSchemaNodeImpl(qname, path);
+ this.constraints = new ConstraintsBuilder(moduleName, line);
+ }
+
+ // constructor for uses
public ContainerSchemaNodeBuilder(final String moduleName, final int line, final QName qname,
- final SchemaPath schemaPath) {
+ final SchemaPath path, final ContainerSchemaNode base) {
super(moduleName, line, qname);
- this.schemaPath = schemaPath;
- instance = new ContainerSchemaNodeImpl(qname);
- constraints = new ConstraintsBuilder(moduleName, line);
+ this.path = path;
+ instance = new ContainerSchemaNodeImpl(qname, path);
+ constraints = new ConstraintsBuilder(moduleName, line, base.getConstraints());
+
+ instance.description = base.getDescription();
+ instance.reference = base.getReference();
+ instance.status = base.getStatus();
+ instance.augmenting = base.isAugmenting();
+ instance.addedByUses = base.isAddedByUses();
+ instance.configuration = base.isConfiguration();
+ instance.constraints = base.getConstraints();
+ instance.augmentations.addAll(base.getAvailableAugmentations());
+
+ URI ns = qname.getNamespace();
+ Date rev = qname.getRevision();
+ String pref = qname.getPrefix();
+ addedChildNodes.addAll(ParserUtils.wrapChildNodes(moduleName, line, base.getChildNodes(), path, ns, rev, pref));
+ addedGroupings.addAll(ParserUtils.wrapGroupings(moduleName, line, base.getGroupings(), path, ns, rev, pref));
+ addedTypedefs.addAll(ParserUtils.wrapTypedefs(moduleName, line, base, path, ns, rev, pref));
+ addedUnknownNodes.addAll(ParserUtils.wrapUnknownNodes(moduleName, line, base.getUnknownSchemaNodes(), path, ns,
+ rev, pref));
+
+ instance.uses.addAll(base.getUses());
+ instance.presence = base.isPresenceContainer();
+ instance.configuration = base.isConfiguration();
+ this.configuration = base.isConfiguration();
}
@Override
- public ContainerSchemaNode build(YangNode parent) {
+ public ContainerSchemaNode build() {
if (!isBuilt) {
- this.parent = parent;
- instance.setParent(parent);
- instance.setPath(schemaPath);
- instance.setDescription(description);
- instance.setReference(reference);
- instance.setStatus(status);
- instance.setPresenceContainer(presence);
- instance.setAugmenting(augmenting);
- instance.setAddedByUses(addedByUses);
// if this builder represents rpc input or output, it can has
// configuration value set to null
// USES
for (UsesNodeBuilder builder : addedUsesNodes) {
- usesNodes.add(builder.build(instance));
+ usesNodes.add(builder.build());
}
- instance.setUses(usesNodes);
+ instance.addUses(usesNodes);
// CHILD NODES
for (DataSchemaNodeBuilder node : addedChildNodes) {
- DataSchemaNode child = node.build(instance);
- childNodes.put(child.getQName(), node.build(instance));
+ DataSchemaNode child = node.build();
+ childNodes.put(child.getQName(), child);
}
- instance.setChildNodes(childNodes);
+ instance.addChildNodes(childNodes);
// GROUPINGS
for (GroupingBuilder builder : addedGroupings) {
- groupings.add(builder.build(instance));
+ groupings.add(builder.build());
}
- instance.setGroupings(groupings);
+ instance.addGroupings(groupings);
// TYPEDEFS
for (TypeDefinitionBuilder entry : addedTypedefs) {
- typedefs.add(entry.build(instance));
+ typedefs.add(entry.build());
}
- instance.setTypeDefinitions(typedefs);
+ instance.addTypeDefinitions(typedefs);
// AUGMENTATIONS
+ final List<AugmentationSchema> augmentations = new ArrayList<>();
for (AugmentationSchemaBuilder builder : augmentationBuilders) {
- augmentations.add(builder.build(instance));
+ augmentations.add(builder.build());
}
- instance.setAvailableAugmentations(new HashSet<>(augmentations));
+ instance.addAvailableAugmentations(new HashSet<>(augmentations));
// UNKNOWN NODES
for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
- unknownNodes.add(b.build(instance));
+ unknownNodes.add(b.build());
}
Collections.sort(unknownNodes, Comparators.SCHEMA_NODE_COMP);
- instance.setUnknownSchemaNodes(unknownNodes);
+ instance.addUnknownSchemaNodes(unknownNodes);
- instance.setConstraints(constraints.build());
+ if (constraints != null) {
+ instance.setConstraints(constraints.build());
+ }
isBuilt = true;
}
return instance;
}
- @Override
- public void rebuild() {
- isBuilt = false;
- build(parent);
- }
-
- @Override
- public void setQName(QName qname) {
- this.qname = qname;
- instance.setQName(qname);
- }
-
@Override
public Set<TypeDefinitionBuilder> getTypeDefinitionBuilders() {
return addedTypedefs;
addedTypedefs.add(type);
}
- public void setTypedefs(final Set<TypeDefinition<?>> typedefs) {
- this.typedefs = typedefs;
- }
-
- public List<AugmentationSchema> getAugmentations() {
- return augmentations;
- }
-
public List<AugmentationSchemaBuilder> getAugmentationBuilders() {
return augmentationBuilders;
}
augmentationBuilders.add(augment);
}
+ @Override
public SchemaPath getPath() {
- return schemaPath;
+ return instance.path;
}
@Override
- public void setPath(final SchemaPath schemaPath) {
- this.schemaPath = schemaPath;
+ public void setPath(SchemaPath path) {
+ instance.path = path;
}
@Override
public String getDescription() {
- return description;
+ return instance.description;
}
@Override
public void setDescription(final String description) {
- this.description = description;
+ instance.description = description;
}
@Override
public String getReference() {
- return reference;
+ return instance.reference;
}
@Override
- public void setReference(String reference) {
- this.reference = reference;
+ public void setReference(final String reference) {
+ instance.reference = reference;
}
@Override
public Status getStatus() {
- return status;
+ return instance.status;
}
@Override
public void setStatus(Status status) {
if (status != null) {
- this.status = status;
+ instance.status = status;
}
}
@Override
public boolean isAugmenting() {
- return augmenting;
+ return instance.augmenting;
}
@Override
public void setAugmenting(boolean augmenting) {
- this.augmenting = augmenting;
+ instance.augmenting = augmenting;
}
@Override
public boolean isAddedByUses() {
- return addedByUses;
+ return instance.addedByUses;
}
@Override
public void setAddedByUses(final boolean addedByUses) {
- this.addedByUses = addedByUses;
+ instance.addedByUses = addedByUses;
}
@Override
public Boolean isConfiguration() {
- return configuration;
+ return instance.configuration;
}
@Override
public void setConfiguration(Boolean configuration) {
- this.configuration = configuration;
+ instance.configuration = configuration;
}
@Override
}
public boolean isPresence() {
- return presence;
+ return instance.presence;
}
public void setPresence(boolean presence) {
- this.presence = presence;
+ instance.presence = presence;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
- result = prime * result + ((schemaPath == null) ? 0 : schemaPath.hashCode());
+ result = prime * result + ((path == null) ? 0 : path.hashCode());
return result;
}
return false;
}
ContainerSchemaNodeBuilder other = (ContainerSchemaNodeBuilder) obj;
- if (schemaPath == null) {
- if (other.schemaPath != null) {
+ if (path == null) {
+ if (other.path != null) {
return false;
}
- } else if (!schemaPath.equals(other.schemaPath)) {
+ } else if (!path.equals(other.path)) {
return false;
}
if (parent == null) {
}
public final class ContainerSchemaNodeImpl implements ContainerSchemaNode {
- private QName qname;
+ private final QName qname;
private SchemaPath path;
- private YangNode parent;
private String description;
private String reference;
private Status status = Status.CURRENT;
private boolean addedByUses;
private boolean configuration;
private ConstraintDefinition constraints;
- private Set<AugmentationSchema> augmentations = Collections.emptySet();
- private Map<QName, DataSchemaNode> childNodes = Collections.emptyMap();
- private Set<GroupingDefinition> groupings = Collections.emptySet();
- private Set<TypeDefinition<?>> typeDefinitions = Collections.emptySet();
- private Set<UsesNode> uses = Collections.emptySet();
- private List<UnknownSchemaNode> unknownNodes = Collections.emptyList();
+ private final Set<AugmentationSchema> augmentations = new HashSet<>();
+ private final Map<QName, DataSchemaNode> childNodes = new HashMap<>();
+ private final Set<GroupingDefinition> groupings = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
+ private final Set<TypeDefinition<?>> typeDefinitions = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
+ private final Set<UsesNode> uses = new HashSet<>();
+ private final List<UnknownSchemaNode> unknownNodes = new ArrayList<>();
private boolean presence;
- private ContainerSchemaNodeImpl(QName qname) {
+ private ContainerSchemaNodeImpl(QName qname, SchemaPath path) {
this.qname = qname;
+ this.path = path;
}
@Override
return qname;
}
- private void setQName(QName qname) {
- this.qname = qname;
- }
-
@Override
public SchemaPath getPath() {
return path;
}
- private void setPath(SchemaPath path) {
- this.path = path;
- }
-
- @Override
- public YangNode getParent() {
- return parent;
- }
-
- private void setParent(YangNode parent) {
- this.parent = parent;
- }
-
@Override
public String getDescription() {
return description;
}
- private void setDescription(String description) {
- this.description = description;
- }
-
@Override
public String getReference() {
return reference;
}
- private void setReference(String reference) {
- this.reference = reference;
- }
-
@Override
public Status getStatus() {
return status;
}
- private void setStatus(Status status) {
- if (status != null) {
- this.status = status;
- }
- }
-
@Override
public boolean isAugmenting() {
return augmenting;
}
- private void setAugmenting(boolean augmenting) {
- this.augmenting = augmenting;
- }
-
@Override
public boolean isAddedByUses() {
return addedByUses;
}
- private void setAddedByUses(boolean addedByUses) {
- this.addedByUses = addedByUses;
- }
-
@Override
public boolean isConfiguration() {
return configuration;
@Override
public Set<AugmentationSchema> getAvailableAugmentations() {
- return augmentations;
+ return Collections.unmodifiableSet(augmentations);
}
- private void
setAvailableAugmentations(Set<AugmentationSchema> augmentations) {
+ private void
addAvailableAugmentations(Set<AugmentationSchema> augmentations) {
if (augmentations != null) {
- this.augmentations = augmentations;
+ this.augmentations.addAll(augmentations);
}
}
@Override
public Set<DataSchemaNode> getChildNodes() {
- return new HashSet<>(childNodes.values());
+ final Set<DataSchemaNode> result = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
+ result.addAll(childNodes.values());
+ return Collections.unmodifiableSet(result);
}
- private void setChildNodes(Map<QName, DataSchemaNode> childNodes) {
+ private void addChildNodes(Map<QName, DataSchemaNode> childNodes) {
if (childNodes != null) {
- this.childNodes = childNodes;
+ this.childNodes.putAll(childNodes);
}
}
@Override
public Set<GroupingDefinition> getGroupings() {
- return groupings;
+ return Collections.unmodifiableSet(groupings);
}
- private void setGroupings(Set<GroupingDefinition> groupings) {
+ private void addGroupings(Set<GroupingDefinition> groupings) {
if (groupings != null) {
- this.groupings = groupings;
+ this.groupings.addAll(groupings);
}
}
@Override
public Set<UsesNode> getUses() {
- return uses;
+ return Collections.unmodifiableSet(uses);
}
- private void setUses(Set<UsesNode> uses) {
+ private void addUses(Set<UsesNode> uses) {
if (uses != null) {
- this.uses = uses;
+ this.uses.addAll(uses);
}
}
return presence;
}
- private void setPresenceContainer(boolean presence) {
- this.presence = presence;
- }
-
@Override
public Set<TypeDefinition<?>> getTypeDefinitions() {
- return typeDefinitions;
+ return Collections.unmodifiableSet(typeDefinitions);
}
- private void setTypeDefinitions(Set<TypeDefinition<?>> typeDefinitions) {
+ private void addTypeDefinitions(Set<TypeDefinition<?>> typeDefinitions) {
if (typeDefinitions != null) {
- this.typeDefinitions = typeDefinitions;
+ this.typeDefinitions.addAll(typeDefinitions);
}
}
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
- return unknownNodes;
+ return Collections.unmodifiableList(unknownNodes);
}
- private void setUnknownSchemaNodes(List<UnknownSchemaNode> unknownSchemaNodes) {
+ private void addUnknownSchemaNodes(List<UnknownSchemaNode> unknownSchemaNodes) {
if (unknownSchemaNodes != null) {
- this.unknownNodes = unknownSchemaNodes;
+ this.unknownNodes.addAll(unknownSchemaNodes);
}
}
- public ContainerSchemaNodeBuilder toBuilder() {
- return ContainerSchemaNodeBuilder.this;
- }
-
@Override
public int hashCode() {
final int prime = 31;
@Override
public String toString() {
- StringBuilder sb = new StringBuilder(ContainerSchemaNodeImpl.class.getSimpleName());
- sb.append("[");
- sb.append("qname=");
- sb.append(qname);
- sb.append("]");
- return sb.toString();
+ return "container " + qname.getLocalName();
}
}
*/
package org.opendaylight.yangtools.yang.parser.builder.impl;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
+import java.util.*;
-import org.opendaylight.yangtools.yang.model.api.Deviation;
+import org.opendaylight.yangtools.yang.model.api.*;
import org.opendaylight.yangtools.yang.model.api.Deviation.Deviate;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.YangNode;
import org.opendaylight.yangtools.yang.parser.builder.api.AbstractBuilder;
-import org.opendaylight.yangtools.yang.parser.util.Comparators;
-import org.opendaylight.yangtools.yang.parser.util.ParserUtils;
-import org.opendaylight.yangtools.yang.parser.util.YangParseException;
+import org.opendaylight.yangtools.yang.parser.util.*;
public final class DeviationBuilder extends AbstractBuilder {
- private final String targetPathStr;
private boolean isBuilt;
private final DeviationImpl instance;
-
+ private final String targetPathStr;
private SchemaPath targetPath;
- private String reference;
- private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
DeviationBuilder(final String moduleName, final int line, final String targetPathStr) {
super(moduleName, line);
}
@Override
- public Deviation build(YangNode parent) {
+ public Deviation build() {
if (targetPath == null) {
throw new YangParseException(moduleName, line, "Unresolved deviation target");
}
if (!isBuilt) {
instance.setTargetPath(targetPath);
- instance.setReference(reference);
// UNKNOWN NODES
for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
- unknownNodes.add(b.build(instance));
+ unknownNodes.add(b.build());
}
Collections.sort(unknownNodes, Comparators.SCHEMA_NODE_COMP);
- instance.setUnknownSchemaNodes(unknownNodes);
+ instance.addUnknownSchemaNodes(unknownNodes);
isBuilt = true;
}
}
public void setReference(final String reference) {
- this.reference = reference;
+ instance.reference = reference;
}
@Override
private SchemaPath targetPath;
private Deviate deviate;
private String reference;
- private List<UnknownSchemaNode> unknownNodes = Collections.emptyList();
+ private final List<UnknownSchemaNode> unknownNodes = new ArrayList<>();
private DeviationImpl() {
}
return reference;
}
- private void setReference(final String reference) {
- this.reference = reference;
- }
-
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
- return unknownNodes;
+ return Collections.unmodifiableList(unknownNodes);
}
- private void setUnknownSchemaNodes(List<UnknownSchemaNode> unknownSchemaNodes) {
+ private void addUnknownSchemaNodes(List<UnknownSchemaNode> unknownSchemaNodes) {
if (unknownSchemaNodes != null) {
- this.unknownNodes = unknownSchemaNodes;
+ this.unknownNodes.addAll(unknownSchemaNodes);
}
}
*/
package org.opendaylight.yangtools.yang.parser.builder.impl;
+import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.YangNode;
import org.opendaylight.yangtools.yang.parser.builder.api.AbstractSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.util.Comparators;
private boolean isBuilt;
private final ExtensionDefinitionImpl instance;
- ExtensionBuilder(final String moduleName, final int line, final QName qname) {
+ ExtensionBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path) {
super(moduleName, line, qname);
- instance = new ExtensionDefinitionImpl(qname);
+ this.schemaPath = path;
+ instance = new ExtensionDefinitionImpl(qname, path);
}
@Override
- public ExtensionDefinition build(YangNode parent) {
+ public ExtensionDefinition build() {
if (!isBuilt) {
- instance.setPath(schemaPath);
- instance.setDescription(description);
- instance.setReference(reference);
- instance.setStatus(status);
-
// UNKNOWN NODES
for (UnknownSchemaNodeBuilder un : addedUnknownNodes) {
- unknownNodes.add(un.build(null));
+ unknownNodes.add(un.build());
}
Collections.sort(unknownNodes, Comparators.SCHEMA_NODE_COMP);
- instance.setUnknownSchemaNodes(unknownNodes);
+ instance.addUnknownSchemaNodes(unknownNodes);
isBuilt = true;
}
return instance;
}
+ @Override
+ public SchemaPath getPath() {
+ return instance.schemaPath;
+ }
+
+ @Override
+ public String getDescription() {
+ return instance.description;
+ }
+
+ @Override
+ public void setDescription(final String description) {
+ instance.description = description;
+ }
+
+ @Override
+ public String getReference() {
+ return instance.reference;
+ }
+
+ @Override
+ public void setReference(final String reference) {
+ instance.reference = reference;
+ }
+
+ @Override
+ public Status getStatus() {
+ return instance.status;
+ }
+
+ @Override
+ public void setStatus(Status status) {
+ if (status != null) {
+ instance.status = status;
+ }
+ }
+
public void setYinElement(boolean yin) {
- instance.setYinElement(yin);
+ instance.yin = yin;
}
public void setArgument(String argument) {
- instance.setArgument(argument);
+ instance.argument = argument;
}
@Override
private final class ExtensionDefinitionImpl implements ExtensionDefinition {
private final QName qname;
private String argument;
- private SchemaPath schemaPath;
+ private final SchemaPath schemaPath;
private String description;
private String reference;
private Status status = Status.CURRENT;
- private List<UnknownSchemaNode> unknownNodes = Collections.emptyList();
+ private final List<UnknownSchemaNode> unknownNodes = new ArrayList<>();
private boolean yin;
- private ExtensionDefinitionImpl(QName qname) {
+ private ExtensionDefinitionImpl(QName qname, SchemaPath path) {
this.qname = qname;
+ this.schemaPath = path;
}
@Override
return schemaPath;
}
- private void setPath(SchemaPath schemaPath) {
- this.schemaPath = schemaPath;
- }
-
@Override
public String getDescription() {
return description;
}
- private void setDescription(String description) {
- this.description = description;
- }
-
@Override
public String getReference() {
return reference;
}
- private void setReference(String reference) {
- this.reference = reference;
- }
-
@Override
public Status getStatus() {
return status;
}
- private void setStatus(Status status) {
- if (status != null) {
- this.status = status;
- }
- }
-
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
- return unknownNodes;
+ return Collections.unmodifiableList(unknownNodes);
}
- private void setUnknownSchemaNodes(List<UnknownSchemaNode> unknownNodes) {
+ private void addUnknownSchemaNodes(List<UnknownSchemaNode> unknownNodes) {
if (unknownNodes != null) {
- this.unknownNodes = unknownNodes;
+ this.unknownNodes.addAll(unknownNodes);
}
}
return argument;
}
- private void setArgument(String argument) {
- this.argument = argument;
- }
-
@Override
public boolean isYinElement() {
return yin;
}
- private void setYinElement(boolean yin) {
- this.yin = yin;
- }
-
@Override
public int hashCode() {
final int prime = 31;
*/
package org.opendaylight.yangtools.yang.parser.builder.impl;
+import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.YangNode;
import org.opendaylight.yangtools.yang.parser.builder.api.AbstractSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.util.Comparators;
private boolean isBuilt;
private final FeatureDefinitionImpl instance;
- FeatureBuilder(final String moduleName, final int line, final QName qname) {
+ FeatureBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path) {
super(moduleName, line, qname);
- instance = new FeatureDefinitionImpl(qname);
+ this.schemaPath = path;
+ instance = new FeatureDefinitionImpl(qname, path);
}
@Override
- public FeatureDefinitionImpl build(YangNode parent) {
+ public FeatureDefinitionImpl build() {
if (!isBuilt) {
- instance.setPath(schemaPath);
- instance.setDescription(description);
- instance.setReference(reference);
- instance.setStatus(status);
-
// UNKNOWN NODES
for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
- unknownNodes.add(b.build(null));
+ unknownNodes.add(b.build());
}
Collections.sort(unknownNodes, Comparators.SCHEMA_NODE_COMP);
- instance.setUnknownSchemaNodes(unknownNodes);
+ instance.addUnknownSchemaNodes(unknownNodes);
isBuilt = true;
}
return instance;
}
+ @Override
+ public SchemaPath getPath() {
+ return instance.path;
+ }
+
+ @Override
+ public String getDescription() {
+ return instance.description;
+ }
+
+ @Override
+ public void setDescription(final String description) {
+ instance.description = description;
+ }
+
+ @Override
+ public String getReference() {
+ return instance.reference;
+ }
+
+ @Override
+ public void setReference(final String reference) {
+ instance.reference = reference;
+ }
+
+ @Override
+ public Status getStatus() {
+ return instance.status;
+ }
+
+ @Override
+ public void setStatus(Status status) {
+ if (status != null) {
+ instance.status = status;
+ }
+ }
+
@Override
public String toString() {
return "feature " + qname.getLocalName();
private final class FeatureDefinitionImpl implements FeatureDefinition {
private final QName qname;
- private SchemaPath path;
+ private final SchemaPath path;
private String description;
private String reference;
private Status status = Status.CURRENT;
- private List<UnknownSchemaNode> unknownNodes = Collections.emptyList();
+ private final List<UnknownSchemaNode> unknownNodes = new ArrayList<>();
- private FeatureDefinitionImpl(final QName qname) {
+ private FeatureDefinitionImpl(final QName qname, final SchemaPath path) {
this.qname = qname;
+ this.path = path;
}
@Override
return path;
}
- private void setPath(final SchemaPath path) {
- this.path = path;
- }
-
@Override
public String getDescription() {
return description;
}
- private void setDescription(final String description) {
- this.description = description;
- }
-
@Override
public String getReference() {
return reference;
}
- private void setReference(final String reference) {
- this.reference = reference;
- }
-
@Override
public Status getStatus() {
return status;
}
- private void setStatus(Status status) {
- if (status != null) {
- this.status = status;
- }
- }
-
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
- return unknownNodes;
+ return Collections.unmodifiableList(unknownNodes);
}
- private void setUnknownSchemaNodes(final List<UnknownSchemaNode> unknownNodes) {
+ private void addUnknownSchemaNodes(final List<UnknownSchemaNode> unknownNodes) {
if (unknownNodes != null) {
- this.unknownNodes = unknownNodes;
+ this.unknownNodes.addAll(unknownNodes);
}
}
*/
package org.opendaylight.yangtools.yang.parser.builder.impl;
+import java.net.URI;
+import java.util.ArrayList;
import java.util.Collections;
+import java.util.Date;
+import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.UsesNode;
-import org.opendaylight.yangtools.yang.model.api.YangNode;
import org.opendaylight.yangtools.yang.parser.builder.api.AbstractDataNodeContainerBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.Builder;
import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
private boolean isBuilt;
private final GroupingDefinitionImpl instance;
private SchemaPath schemaPath;
- private String description;
- private String reference;
- private Status status = Status.CURRENT;
- private boolean addedByUses;
- public GroupingBuilderImpl(final String moduleName, final int line, final QName qname) {
+ public GroupingBuilderImpl(final String moduleName, final int line, final QName qname, final SchemaPath path) {
super(moduleName, line, qname);
- instance = new GroupingDefinitionImpl(qname);
+ schemaPath = path;
+ instance = new GroupingDefinitionImpl(qname, path);
+ }
+
+ public GroupingBuilderImpl(final String moduleName, final int line, final QName qname, final SchemaPath path, final GroupingDefinition base) {
+ super(moduleName, line, base.getQName());
+ schemaPath = path;
+ instance = new GroupingDefinitionImpl(qname, path);
+
+ instance.description = base.getDescription();
+ instance.reference = base.getReference();
+ instance.status = base.getStatus();
+ instance.addedByUses = base.isAddedByUses();
+
+ URI ns = qname.getNamespace();
+ Date rev = qname.getRevision();
+ String pref = qname.getPrefix();
+ addedChildNodes.addAll(ParserUtils.wrapChildNodes(moduleName, line, base.getChildNodes(), path, ns, rev, pref));
+ addedGroupings.addAll(ParserUtils.wrapGroupings(moduleName, line, base.getGroupings(), path, ns, rev, pref));
+ addedTypedefs.addAll(ParserUtils.wrapTypedefs(moduleName, line, base, path, ns, rev, pref));
+ addedUnknownNodes.addAll(ParserUtils.wrapUnknownNodes(moduleName, line, base.getUnknownSchemaNodes(), path, ns,
+ rev, pref));
+
+ instance.uses.addAll(base.getUses());
}
@Override
- public GroupingDefinition build(YangNode parent) {
+ public GroupingDefinition build() {
if (!isBuilt) {
- instance.setParent(parent);
- instance.setPath(schemaPath);
- instance.setDescription(description);
- instance.setReference(reference);
- instance.setStatus(status);
- instance.setAddedByUses(addedByUses);
-
// CHILD NODES
for (DataSchemaNodeBuilder node : addedChildNodes) {
- DataSchemaNode child = node.build(instance);
+ DataSchemaNode child = node.build();
childNodes.put(child.getQName(), child);
}
- instance.setChildNodes(childNodes);
+ instance.addChildNodes(childNodes);
// GROUPINGS
for (GroupingBuilder builder : addedGroupings) {
- groupings.add(builder.build(instance));
+ groupings.add(builder.build());
}
- instance.setGroupings(groupings);
+ instance.addGroupings(groupings);
// TYPEDEFS
for (TypeDefinitionBuilder entry : addedTypedefs) {
- typedefs.add(entry.build(instance));
+ typedefs.add(entry.build());
}
- instance.setTypeDefinitions(typedefs);
+ instance.addTypeDefinitions(typedefs);
// USES
for (UsesNodeBuilder builder : addedUsesNodes) {
- usesNodes.add(builder.build(instance));
+ usesNodes.add(builder.build());
}
- instance.setUses(usesNodes);
+ instance.addUses(usesNodes);
// UNKNOWN NODES
for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
- unknownNodes.add(b.build(instance));
+ unknownNodes.add(b.build());
}
Collections.sort(unknownNodes, Comparators.SCHEMA_NODE_COMP);
- instance.setUnknownSchemaNodes(unknownNodes);
+ instance.addUnknownSchemaNodes(unknownNodes);
isBuilt = true;
}
for (GroupingBuilder node : addedGroupings) {
GroupingBuilder copy = CopyUtils.copy(node, newParent, true);
copy.setAddedByUses(true);
- for (DataSchemaNodeBuilder childNode : copy.getChildNodeBuilders()) {
+ for (DataSchemaNodeBuilder childNode : copy.getChildNodes()) {
ParserUtils.setNodeAddedByUses(childNode);
}
nodes.add(copy);
return nodes;
}
- @Override
- public void setQName(QName qname) {
- this.qname = qname;
- }
-
@Override
public Set<TypeDefinitionBuilder> getTypeDefinitionBuilders() {
return addedTypedefs;
addedTypedefs.add(type);
}
- public void setTypedefs(final Set<TypeDefinition<?>> typedefs) {
- this.typedefs = typedefs;
- }
-
@Override
public SchemaPath getPath() {
return schemaPath;
}
- @Override
- public void setPath(SchemaPath schemaPath) {
- this.schemaPath = schemaPath;
- }
-
@Override
public String getDescription() {
- return description;
+ return instance.description;
}
@Override
public void setDescription(final String description) {
- this.description = description;
+ instance.description = description;
}
@Override
public String getReference() {
- return reference;
+ return instance.reference;
}
@Override
public void setReference(final String reference) {
- this.reference = reference;
+ instance.reference = reference;
}
@Override
public Status getStatus() {
- return status;
+ return instance.status;
}
@Override
- public void setStatus(final Status status) {
- this.status = status;
+ public void setStatus(Status status) {
+ if (status != null) {
+ instance.status = status;
+ }
}
@Override
public boolean isAddedByUses() {
- return addedByUses;
+ return instance.addedByUses;
}
@Override
public void setAddedByUses(final boolean addedByUses) {
- this.addedByUses = addedByUses;
+ instance.addedByUses = addedByUses;
}
@Override
private final class GroupingDefinitionImpl implements GroupingDefinition {
private final QName qname;
- private SchemaPath path;
- private YangNode parent;
+ private final SchemaPath path;
private String description;
private String reference;
private Status status;
private boolean addedByUses;
- private Map<QName, DataSchemaNode> childNodes = Collections.emptyMap();
- private Set<GroupingDefinition> groupings = Collections.emptySet();
- private Set<TypeDefinition<?>> typeDefinitions = Collections.emptySet();
- private Set<UsesNode> uses = Collections.emptySet();
- private List<UnknownSchemaNode> unknownNodes = Collections.emptyList();
+ private final Map<QName, DataSchemaNode> childNodes = new HashMap<>();
+ private final Set<GroupingDefinition> groupings = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
+ private final Set<TypeDefinition<?>> typeDefinitions = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
+ private final Set<UsesNode> uses = new HashSet<>();
+ private final List<UnknownSchemaNode> unknownNodes = new ArrayList<>();
- private GroupingDefinitionImpl(final QName qname) {
+ private GroupingDefinitionImpl(final QName qname, final SchemaPath path) {
this.qname = qname;
+ this.path = path;
}
@Override
return path;
}
- private void setPath(SchemaPath path) {
- this.path = path;
- }
-
- @Override
- public YangNode getParent() {
- return parent;
- }
-
- private void setParent(YangNode parent) {
- this.parent = parent;
- }
-
@Override
public String getDescription() {
return description;
}
- private void setDescription(String description) {
- this.description = description;
- }
-
@Override
public String getReference() {
return reference;
}
- private void setReference(String reference) {
- this.reference = reference;
- }
-
@Override
public Status getStatus() {
return status;
}
- private void setStatus(Status status) {
- this.status = status;
- }
-
@Override
public boolean isAddedByUses() {
return addedByUses;
}
- private void setAddedByUses(final boolean addedByUses) {
- this.addedByUses = addedByUses;
- }
-
@Override
public Set<DataSchemaNode> getChildNodes() {
- final Set<DataSchemaNode> result = new TreeSet<DataSchemaNode>(Comparators.SCHEMA_NODE_COMP);
+ final Set<DataSchemaNode> result = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
result.addAll(childNodes.values());
- return result;
+ return Collections.unmodifiableSet(result);
}
- private void setChildNodes(Map<QName, DataSchemaNode> childNodes) {
- this.childNodes = childNodes;
+ private void addChildNodes(Map<QName, DataSchemaNode> childNodes) {
+ if (childNodes != null) {
+ this.childNodes.putAll(childNodes);
+ }
+
}
@Override
public Set<GroupingDefinition> getGroupings() {
- return groupings;
+ return Collections.unmodifiableSet(groupings);
}
- private void setGroupings(Set<GroupingDefinition> groupings) {
- this.groupings = groupings;
+ private void addGroupings(Set<GroupingDefinition> groupings) {
+ if (groupings != null) {
+ this.groupings.addAll(groupings);
+ }
}
@Override
public Set<UsesNode> getUses() {
- return uses;
+ return Collections.unmodifiableSet(uses);
}
- private void setUses(Set<UsesNode> uses) {
- this.uses = uses;
+ private void addUses(Set<UsesNode> uses) {
+ if (uses != null) {
+ this.uses.addAll(uses);
+ }
}
@Override
public Set<TypeDefinition<?>> getTypeDefinitions() {
- return typeDefinitions;
+ return Collections.unmodifiableSet(typeDefinitions);
}
- private void setTypeDefinitions(Set<TypeDefinition<?>> typeDefinitions) {
- this.typeDefinitions = typeDefinitions;
+ private void addTypeDefinitions(Set<TypeDefinition<?>> typeDefinitions) {
+ if (typeDefinitions != null) {
+ this.typeDefinitions.addAll(typeDefinitions);
+ }
}
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
- return unknownNodes;
+ return Collections.unmodifiableList(unknownNodes);
}
- private void setUnknownSchemaNodes(List<UnknownSchemaNode> unknownNodes) {
+ private void addUnknownSchemaNodes(List<UnknownSchemaNode> unknownNodes) {
if (unknownNodes != null) {
- this.unknownNodes = unknownNodes;
+ this.unknownNodes.addAll(unknownNodes);
}
}
*/
package org.opendaylight.yangtools.yang.parser.builder.impl;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
+import java.util.*;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-import org.opendaylight.yangtools.yang.model.api.Status;
-import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.YangNode;
+import org.opendaylight.yangtools.yang.model.api.*;
import org.opendaylight.yangtools.yang.parser.builder.api.AbstractSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.util.Comparators;
import org.opendaylight.yangtools.yang.parser.util.YangParseException;
private final Set<IdentitySchemaNode> derivedIdentities = new HashSet<>();
private String baseIdentityName;
- IdentitySchemaNodeBuilder(final String moduleName, final int line, final QName qname) {
+ IdentitySchemaNodeBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path) {
super(moduleName, line, qname);
- instance = new IdentitySchemaNodeImpl(qname);
- instance.setDerivedIdentities(derivedIdentities);
+ this.schemaPath = path;
+ instance = new IdentitySchemaNodeImpl(qname, path, derivedIdentities);
}
@Override
- public IdentitySchemaNode build(YangNode parent) {
+ public IdentitySchemaNode build() {
if (!isBuilt) {
if (!(parentBuilder instanceof ModuleBuilder)) {
throw new YangParseException(moduleName, line, "Identity can be defined only under module (was" + parentBuilder + ")");
}
- instance.setPath(schemaPath);
- instance.setDescription(description);
- instance.setReference(reference);
- instance.setStatus(status);
-
if (baseIdentity == null) {
if(baseIdentityBuilder != null) {
baseIdentityBuilder.addDerivedIdentity(instance);
- baseIdentity = baseIdentityBuilder.build(null);
+ baseIdentity = baseIdentityBuilder.build();
}
} else {
if(baseIdentity instanceof IdentitySchemaNodeImpl) {
// UNKNOWN NODES
for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
- unknownNodes.add(b.build(null));
+ unknownNodes.add(b.build());
}
Collections.sort(unknownNodes, Comparators.SCHEMA_NODE_COMP);
- instance.setUnknownSchemaNodes(unknownNodes);
+ instance.addUnknownSchemaNodes(unknownNodes);
isBuilt = true;
}
return instance;
}
+ @Override
+ public SchemaPath getPath() {
+ return instance.path;
+ }
+
+ @Override
+ public String getDescription() {
+ return instance.description;
+ }
+
+ @Override
+ public void setDescription(final String description) {
+ instance.description = description;
+ }
+
+ @Override
+ public String getReference() {
+ return instance.reference;
+ }
+
+ @Override
+ public void setReference(final String reference) {
+ instance.reference = reference;
+ }
+
+ @Override
+ public Status getStatus() {
+ return instance.status;
+ }
+
+ @Override
+ public void setStatus(Status status) {
+ if (status != null) {
+ instance.status = status;
+ }
+ }
+
public String getBaseIdentityName() {
return baseIdentityName;
}
public final class IdentitySchemaNodeImpl implements IdentitySchemaNode {
private final QName qname;
+ private final SchemaPath path;
private IdentitySchemaNode baseIdentity;
- private Set<IdentitySchemaNode> derivedIdentities = Collections.emptySet();
+ private final Set<IdentitySchemaNode> derivedIdentities;
private String description;
private String reference;
private Status status = Status.CURRENT;
- private SchemaPath path;
- private List<UnknownSchemaNode> unknownNodes = Collections.emptyList();
+ private final List<UnknownSchemaNode> unknownNodes = new ArrayList<>();
- private IdentitySchemaNodeImpl(final QName qname) {
+ private IdentitySchemaNodeImpl(final QName qname, final SchemaPath path, final Set<IdentitySchemaNode> derivedIdentities) {
this.qname = qname;
+ this.path = path;
+ this.derivedIdentities = derivedIdentities;
}
@Override
@Override
public Set<IdentitySchemaNode> getDerivedIdentities() {
- return derivedIdentities;
- }
-
- private void setDerivedIdentities(Set<IdentitySchemaNode> derivedIdentities) {
- if (derivedIdentities != null) {
- this.derivedIdentities = derivedIdentities;
- }
+ return Collections.unmodifiableSet(derivedIdentities);
}
@Override
return description;
}
- private void setDescription(final String description) {
- this.description = description;
- }
-
@Override
public String getReference() {
return reference;
}
- private void setReference(final String reference) {
- this.reference = reference;
- }
-
@Override
public Status getStatus() {
return status;
}
- private void setStatus(final Status status) {
- if (status != null) {
- this.status = status;
- }
- }
-
@Override
public SchemaPath getPath() {
return path;
}
- private void setPath(final SchemaPath path) {
- this.path = path;
- }
-
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
- return unknownNodes;
+ return Collections.unmodifiableList(unknownNodes);
}
- private void setUnknownSchemaNodes(List<UnknownSchemaNode> unknownSchemaNodes) {
+ private void addUnknownSchemaNodes(List<UnknownSchemaNode> unknownSchemaNodes) {
if (unknownSchemaNodes != null) {
- this.unknownNodes = unknownSchemaNodes;
+ this.unknownNodes.addAll(unknownSchemaNodes);
}
}
import java.util.List;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-import org.opendaylight.yangtools.yang.model.api.Status;
-import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.YangNode;
-import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint;
-import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
-import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
+import org.opendaylight.yangtools.yang.model.api.*;
+import org.opendaylight.yangtools.yang.model.api.type.*;
import org.opendaylight.yangtools.yang.model.util.BaseTypes;
import org.opendaylight.yangtools.yang.model.util.IdentityrefType;
import org.opendaylight.yangtools.yang.parser.builder.api.AbstractTypeAwareBuilder;
}
@Override
- public IdentityrefType build(YangNode parent) {
- return new IdentityrefType(baseIdentity.build(parent), schemaPath);
+ public IdentityrefType build() {
+ return new IdentityrefType(baseIdentity.build(), schemaPath);
}
public String getBaseString() {
throw new YangParseException(moduleName, line, "Can not set type to " + NAME);
}
- @Override
- public void setPath(final SchemaPath schemaPath) {
- throw new YangParseException(moduleName, line, "Can not set path to " + NAME);
- }
-
@Override
public void setDescription(final String description) {
throw new YangParseException(moduleName, line, "Can not set description to " + NAME);
throw new YangParseException(moduleName, line, "Identityref type can not be added by uses.");
}
- @Override
- public List<UnknownSchemaNode> getUnknownNodes() {
- return Collections.emptyList();
- }
-
@Override
public void addUnknownNodeBuilder(final UnknownSchemaNodeBuilder unknownNode) {
throw new YangParseException(moduleName, line, "Can not add unknown node to " + NAME);
}
@Override
- public List<UnknownSchemaNodeBuilder> getUnknownNodeBuilders() {
+ public List<UnknownSchemaNodeBuilder> getUnknownNodes() {
return Collections.emptyList();
}
*/
package org.opendaylight.yangtools.yang.parser.builder.impl;
+import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.YangNode;
import org.opendaylight.yangtools.yang.parser.builder.api.AbstractTypeAwareBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.util.Comparators;
private final LeafListSchemaNodeImpl instance;
// SchemaNode args
private SchemaPath schemaPath;
- private String description;
- private String reference;
- private Status status = Status.CURRENT;
// DataSchemaNode args
- private boolean augmenting;
- private boolean addedByUses;
- private Boolean configuration;
private final ConstraintsBuilder constraints;
- // LeafListSchemaNode args
- private boolean userOrdered;
- public LeafListSchemaNodeBuilder(final String moduleName, final int line, final QName qname,
- final SchemaPath schemaPath) {
+ public LeafListSchemaNodeBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path) {
super(moduleName, line, qname);
- this.schemaPath = schemaPath;
- instance = new LeafListSchemaNodeImpl(qname);
+ this.schemaPath = path;
+ instance = new LeafListSchemaNodeImpl(qname, path);
constraints = new ConstraintsBuilder(moduleName, line);
}
+ public LeafListSchemaNodeBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path, final LeafListSchemaNode base) {
+ super(moduleName, line, qname);
+ schemaPath = path;
+ instance = new LeafListSchemaNodeImpl(qname, path);
+ constraints = new ConstraintsBuilder(moduleName, line, base.getConstraints());
+
+ instance.description = base.getDescription();
+ instance.reference = base.getReference();
+ instance.status = base.getStatus();
+ instance.augmenting = base.isAugmenting();
+ instance.addedByUses = base.isAddedByUses();
+ instance.configuration = base.isConfiguration();
+ instance.constraintsDef = base.getConstraints();
+ this.type = base.getType();
+ instance.userOrdered = base.isUserOrdered();
+ instance.unknownNodes.addAll(base.getUnknownSchemaNodes());
+ }
+
@Override
- public LeafListSchemaNode build(YangNode parent) {
+ public LeafListSchemaNode build() {
if (!isBuilt) {
- instance.setParent(parent);
instance.setConstraints(constraints.build());
- instance.setPath(schemaPath);
- instance.setDescription(description);
- instance.setReference(reference);
- instance.setStatus(status);
- instance.setAugmenting(augmenting);
- instance.setAddedByUses(addedByUses);
- instance.setConfiguration(configuration);
- instance.setUserOrdered(userOrdered);
if (type == null) {
- instance.setType(typedef.build(instance));
+ instance.setType(typedef.build());
} else {
instance.setType(type);
}
// UNKNOWN NODES
for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
- unknownNodes.add(b.build(instance));
+ unknownNodes.add(b.build());
}
Collections.sort(unknownNodes, Comparators.SCHEMA_NODE_COMP);
- instance.setUnknownSchemaNodes(unknownNodes);
+ instance.addUnknownSchemaNodes(unknownNodes);
isBuilt = true;
}
return instance;
}
- @Override
- public void setQName(QName qname) {
- this.qname = qname;
- instance.setQName(qname);
- }
-
@Override
public SchemaPath getPath() {
return schemaPath;
}
@Override
- public void setPath(final SchemaPath schemaPath) {
- this.schemaPath = schemaPath;
+ public void setPath(SchemaPath path) {
+ instance.path = path;
}
@Override
public String getDescription() {
- return description;
+ return instance.description;
}
@Override
public void setDescription(final String description) {
- this.description = description;
+ instance.description = description;
}
@Override
public String getReference() {
- return reference;
+ return instance.reference;
}
@Override
- public void setReference(String reference) {
- this.reference = reference;
+ public void setReference(final String reference) {
+ instance.reference = reference;
}
@Override
public Status getStatus() {
- return status;
+ return instance.status;
}
@Override
public void setStatus(Status status) {
if (status != null) {
- this.status = status;
+ instance.status = status;
}
}
@Override
public boolean isAugmenting() {
- return augmenting;
+ return instance.augmenting;
}
@Override
public void setAugmenting(boolean augmenting) {
- this.augmenting = augmenting;
+ instance.augmenting = augmenting;
}
@Override
public boolean isAddedByUses() {
- return addedByUses;
+ return instance.addedByUses;
}
@Override
public void setAddedByUses(final boolean addedByUses) {
- this.addedByUses = addedByUses;
+ instance.addedByUses = addedByUses;
}
@Override
public Boolean isConfiguration() {
- return configuration;
+ return instance.configuration;
}
@Override
public void setConfiguration(Boolean configuration) {
- this.configuration = configuration;
+ instance.configuration = configuration;
}
@Override
}
public boolean isUserOrdered() {
- return userOrdered;
+ return instance.userOrdered;
}
public void setUserOrdered(final boolean userOrdered) {
- this.userOrdered = userOrdered;
+ instance.userOrdered = userOrdered;
}
@Override
}
private final class LeafListSchemaNodeImpl implements LeafListSchemaNode {
- private QName qname;
+ private final QName qname;
private SchemaPath path;
- private YangNode parent;
private String description;
private String reference;
private Status status = Status.CURRENT;
private ConstraintDefinition constraintsDef;
private TypeDefinition<?> type;
private boolean userOrdered;
- private List<UnknownSchemaNode> unknownNodes = Collections.emptyList();
+ private final List<UnknownSchemaNode> unknownNodes = new ArrayList<>();
- private LeafListSchemaNodeImpl(final QName qname) {
+ private LeafListSchemaNodeImpl(final QName qname, final SchemaPath path) {
this.qname = qname;
+ this.path = path;
}
@Override
return qname;
}
- private void setQName(QName qname) {
- this.qname = qname;
- }
-
@Override
public SchemaPath getPath() {
return path;
}
- private void setPath(final SchemaPath path) {
- this.path = path;
- }
-
- @Override
- public YangNode getParent() {
- return parent;
- }
-
- private void setParent(YangNode parent) {
- this.parent = parent;
- }
-
@Override
public String getDescription() {
return description;
}
- private void setDescription(String description) {
- this.description = description;
- }
-
@Override
public String getReference() {
return reference;
}
- private void setReference(String reference) {
- this.reference = reference;
- }
-
@Override
public Status getStatus() {
return status;
}
- private void setStatus(Status status) {
- this.status = status;
- }
-
@Override
public boolean isAugmenting() {
return augmenting;
}
- private void setAugmenting(boolean augmenting) {
- this.augmenting = augmenting;
- }
-
@Override
public boolean isAddedByUses() {
return addedByUses;
}
- private void setAddedByUses(final boolean addedByUses) {
- this.addedByUses = addedByUses;
- }
-
@Override
public boolean isConfiguration() {
return configuration;
}
- private void setConfiguration(boolean configuration) {
- this.configuration = configuration;
- }
-
@Override
public ConstraintDefinition getConstraints() {
return constraintsDef;
return userOrdered;
}
- private void setUserOrdered(boolean userOrdered) {
- this.userOrdered = userOrdered;
- }
-
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
- return unknownNodes;
+ return Collections.unmodifiableList(unknownNodes);
}
- private void setUnknownSchemaNodes(List<UnknownSchemaNode> unknownNodes) {
+ private void addUnknownSchemaNodes(List<UnknownSchemaNode> unknownNodes) {
if (unknownNodes != null) {
- this.unknownNodes = unknownNodes;
+ this.unknownNodes.addAll(unknownNodes);
}
}
*/
package org.opendaylight.yangtools.yang.parser.builder.impl;
+import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.YangNode;
import org.opendaylight.yangtools.yang.parser.builder.api.AbstractTypeAwareBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.util.Comparators;
private final LeafSchemaNodeImpl instance;
// SchemaNode args
private SchemaPath schemaPath;
- private String description;
- private String reference;
- private Status status = Status.CURRENT;
// DataSchemaNode args
- private boolean augmenting;
- private boolean addedByUses;
- private Boolean configuration;
private final ConstraintsBuilder constraints;
- // leaf args
- private String defaultStr;
- private String unitsStr;
public LeafSchemaNodeBuilder(final String moduleName, final int line, final QName qname, final SchemaPath schemaPath) {
super(moduleName, line, qname);
this.schemaPath = schemaPath;
- instance = new LeafSchemaNodeImpl(qname);
+ instance = new LeafSchemaNodeImpl(qname, schemaPath);
constraints = new ConstraintsBuilder(moduleName, line);
}
+ public LeafSchemaNodeBuilder(String moduleName, int line, QName qname, SchemaPath path, LeafSchemaNode base) {
+ super(moduleName, line, qname);
+ this.schemaPath = path;
+ instance = new LeafSchemaNodeImpl(qname, path);
+ constraints = new ConstraintsBuilder(moduleName, line, base.getConstraints());
+
+ instance.description = base.getDescription();
+ instance.reference = base.getReference();
+ instance.status = base.getStatus();
+ instance.augmenting = base.isAugmenting();
+ instance.addedByUses = base.isAddedByUses();
+ instance.configuration = base.isConfiguration();
+ instance.constraintsDef = base.getConstraints();
+ this.type = base.getType();
+ instance.unknownNodes.addAll(base.getUnknownSchemaNodes());
+ instance.defaultStr = base.getDefault();
+ instance.unitsStr = base.getUnits();
+ }
+
@Override
- public LeafSchemaNode build(YangNode parent) {
+ public LeafSchemaNode build() {
if (!isBuilt) {
- instance.setParent(parent);
- instance.setPath(schemaPath);
instance.setConstraints(constraints.build());
- instance.setDescription(description);
- instance.setReference(reference);
- instance.setStatus(status);
- instance.setAugmenting(augmenting);
- instance.setAddedByUses(addedByUses);
- instance.setConfiguration(configuration);
- instance.setDefault(defaultStr);
- instance.setUnits(unitsStr);
if (type == null && typedef == null) {
throw new YangParseException(moduleName, line, "Failed to resolve leaf type.");
// TYPE
if (type == null) {
- instance.setType(typedef.build(instance));
+ instance.setType(typedef.build());
} else {
instance.setType(type);
}
// UNKNOWN NODES
for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
- unknownNodes.add(b.build(instance));
+ unknownNodes.add(b.build());
}
Collections.sort(unknownNodes, Comparators.SCHEMA_NODE_COMP);
- instance.setUnknownSchemaNodes(unknownNodes);
+ instance.addUnknownSchemaNodes(unknownNodes);
isBuilt = true;
}
return instance;
}
- @Override
- public void setQName(QName qname) {
- this.qname = qname;
- instance.setQName(qname);
- }
@Override
public SchemaPath getPath() {
}
@Override
- public void setPath(final SchemaPath path) {
- this.schemaPath = path;
+ public void setPath(SchemaPath path) {
+ instance.path = path;
}
@Override
@Override
public String getDescription() {
- return description;
+ return instance.description;
}
@Override
public void setDescription(final String description) {
- this.description = description;
+ instance.description = description;
}
@Override
public String getReference() {
- return reference;
+ return instance.reference;
}
@Override
public void setReference(final String reference) {
- this.reference = reference;
+ instance.reference = reference;
}
@Override
public Status getStatus() {
- return status;
+ return instance.status;
}
@Override
- public void setStatus(final Status status) {
+ public void setStatus(Status status) {
if (status != null) {
- this.status = status;
+ instance.status = status;
}
}
@Override
public boolean isAugmenting() {
- return augmenting;
+ return instance.augmenting;
}
@Override
public void setAugmenting(final boolean augmenting) {
- this.augmenting = augmenting;
+ instance.augmenting = augmenting;
}
@Override
public boolean isAddedByUses() {
- return addedByUses;
+ return instance.addedByUses;
}
@Override
public void setAddedByUses(final boolean addedByUses) {
- this.addedByUses = addedByUses;
+ instance.addedByUses = addedByUses;
}
@Override
public Boolean isConfiguration() {
- return configuration;
+ return instance.configuration;
}
@Override
public void setConfiguration(final Boolean configuration) {
- this.configuration = configuration;
+ instance.configuration = configuration;
}
public String getDefaultStr() {
- return defaultStr;
+ return instance.defaultStr;
}
public void setDefaultStr(String defaultStr) {
- this.defaultStr = defaultStr;
+ instance.defaultStr = defaultStr;
}
public String getUnits() {
- return unitsStr;
+ return instance.unitsStr;
}
public void setUnits(String unitsStr) {
- this.unitsStr = unitsStr;
+ instance.unitsStr = unitsStr;
}
@Override
}
private final class LeafSchemaNodeImpl implements LeafSchemaNode {
- private QName qname;
+ private final QName qname;
private SchemaPath path;
- private YangNode parent;
private String description;
private String reference;
private Status status = Status.CURRENT;
private boolean configuration;
private ConstraintDefinition constraintsDef;
private TypeDefinition<?> type;
- private List<UnknownSchemaNode> unknownNodes = Collections.emptyList();
+ private final List<UnknownSchemaNode> unknownNodes = new ArrayList<>();
private String defaultStr;
private String unitsStr;
- private LeafSchemaNodeImpl(final QName qname) {
+ private LeafSchemaNodeImpl(final QName qname, final SchemaPath path) {
this.qname = qname;
+ this.path = path;
}
@Override
return qname;
}
- private void setQName(QName qname) {
- this.qname = qname;
- }
-
@Override
public SchemaPath getPath() {
return path;
}
- private void setPath(final SchemaPath path) {
- this.path = path;
- }
-
- @Override
- public YangNode getParent() {
- return parent;
- }
-
- private void setParent(YangNode parent) {
- this.parent = parent;
- }
-
@Override
public String getDescription() {
return description;
}
- private void setDescription(String description) {
- this.description = description;
- }
-
@Override
public String getReference() {
return reference;
}
- private void setReference(String reference) {
- this.reference = reference;
- }
-
@Override
public Status getStatus() {
return status;
}
- private void setStatus(Status status) {
- if (status != null) {
- this.status = status;
- }
- }
-
@Override
public boolean isAugmenting() {
return augmenting;
}
- private void setAugmenting(boolean augmenting) {
- this.augmenting = augmenting;
- }
-
@Override
public boolean isAddedByUses() {
return addedByUses;
}
- private void setAddedByUses(final boolean addedByUses) {
- this.addedByUses = addedByUses;
- }
-
@Override
public boolean isConfiguration() {
return configuration;
}
- private void setConfiguration(boolean configuration) {
- this.configuration = configuration;
- }
-
@Override
public ConstraintDefinition getConstraints() {
return constraintsDef;
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
- return unknownNodes;
+ return Collections.unmodifiableList(unknownNodes);
}
- private void setUnknownSchemaNodes(List<UnknownSchemaNode> unknownNodes) {
+ private void addUnknownSchemaNodes(List<UnknownSchemaNode> unknownNodes) {
if (unknownNodes != null) {
- this.unknownNodes = unknownNodes;
+ this.unknownNodes.addAll(unknownNodes);
}
}
return defaultStr;
}
- private void setDefault(String defaultStr) {
- this.defaultStr = defaultStr;
- }
-
@Override
public String getUnits() {
return unitsStr;
}
- public void setUnits(String unitsStr) {
- this.unitsStr = unitsStr;
- }
-
@Override
public int hashCode() {
final int prime = 31;
*/
package org.opendaylight.yangtools.yang.parser.builder.impl;
+import java.net.URI;
import java.util.ArrayList;
import java.util.Collections;
+import java.util.Date;
+import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
+import java.util.TreeSet;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
-import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
-import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-import org.opendaylight.yangtools.yang.model.api.Status;
-import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.UsesNode;
-import org.opendaylight.yangtools.yang.model.api.YangNode;
+import org.opendaylight.yangtools.yang.model.api.*;
import org.opendaylight.yangtools.yang.parser.builder.api.AbstractDataNodeContainerBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationTargetBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
import org.opendaylight.yangtools.yang.parser.util.Comparators;
+import org.opendaylight.yangtools.yang.parser.util.ParserUtils;
import org.opendaylight.yangtools.yang.parser.util.YangParseException;
public final class ListSchemaNodeBuilder extends AbstractDataNodeContainerBuilder implements DataSchemaNodeBuilder,
AugmentationTargetBuilder {
private boolean isBuilt;
private final ListSchemaNodeImpl instance;
- private YangNode parent;
// SchemaNode args
private SchemaPath schemaPath;
- private String description;
- private String reference;
- private Status status = Status.CURRENT;
// DataSchemaNode args
- private boolean augmenting;
- private boolean addedByUses;
- private Boolean configuration;
private final ConstraintsBuilder constraints;
// AugmentationTarget args
private final List<AugmentationSchema> augmentations = new ArrayList<>();
private final List<AugmentationSchemaBuilder> augmentationBuilders = new ArrayList<>();
- // ListSchemaNode args
- private List<QName> keyDefinition = Collections.emptyList();
- private boolean userOrdered;
- public ListSchemaNodeBuilder(final String moduleName, final int line, final QName qname, final SchemaPath schemaPath) {
+
+ public ListSchemaNodeBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path) {
super(moduleName, line, qname);
- this.schemaPath = schemaPath;
- instance = new ListSchemaNodeImpl(qname);
+ this.schemaPath = path;
+ instance = new ListSchemaNodeImpl(qname, path);
constraints = new ConstraintsBuilder(moduleName, line);
}
+ public ListSchemaNodeBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path, final ListSchemaNode base) {
+ super(moduleName, line, qname);
+ schemaPath = path;
+ instance = new ListSchemaNodeImpl(qname, path);
+ constraints = new ConstraintsBuilder(moduleName, line, base.getConstraints());
+
+ instance.keyDefinition = base.getKeyDefinition();
+ instance.userOrdered = base.isUserOrdered();
+
+ instance.description = base.getDescription();
+ instance.reference = base.getReference();
+ instance.status = base.getStatus();
+ instance.augmenting = base.isAugmenting();
+ instance.addedByUses = base.isAddedByUses();
+ instance.configuration = base.isConfiguration();
+ instance.constraints = base.getConstraints();
+ instance.augmentations.addAll(base.getAvailableAugmentations());
+
+ URI ns = qname.getNamespace();
+ Date rev = qname.getRevision();
+ String pref = qname.getPrefix();
+ addedChildNodes.addAll(ParserUtils.wrapChildNodes(moduleName, line, base.getChildNodes(), path, ns, rev, pref));
+ addedGroupings.addAll(ParserUtils.wrapGroupings(moduleName, line, base.getGroupings(), path, ns, rev, pref));
+ addedTypedefs.addAll(ParserUtils.wrapTypedefs(moduleName, line, base, path, ns, rev, pref));
+ addedUnknownNodes.addAll(ParserUtils.wrapUnknownNodes(moduleName, line, base.getUnknownSchemaNodes(), path, ns,
+ rev, pref));
+
+ instance.uses.addAll(base.getUses());
+ }
+
@Override
- public ListSchemaNode build(YangNode parent) {
+ public ListSchemaNode build() {
if (!isBuilt) {
- this.parent = parent;
- instance.setParent(parent);
- instance.setKeyDefinition(keyDefinition);
- instance.setPath(schemaPath);
- instance.setDescription(description);
- instance.setReference(reference);
- instance.setStatus(status);
- instance.setAugmenting(augmenting);
- instance.setAddedByUses(addedByUses);
- instance.setConfiguration(configuration);
- instance.setUserOrdered(userOrdered);
-
// CHILD NODES
for (DataSchemaNodeBuilder node : addedChildNodes) {
- DataSchemaNode child = node.build(instance);
+ DataSchemaNode child = node.build();
childNodes.put(child.getQName(), child);
}
- instance.setChildNodes(childNodes);
+ instance.addChildNodes(childNodes);
// TYPEDEFS
for (TypeDefinitionBuilder entry : addedTypedefs) {
- typedefs.add(entry.build(instance));
+ typedefs.add(entry.build());
}
- instance.setTypeDefinitions(typedefs);
+ instance.addTypeDefinitions(typedefs);
// USES
for (UsesNodeBuilder builder : addedUsesNodes) {
- usesNodes.add(builder.build(instance));
+ usesNodes.add(builder.build());
}
- instance.setUses(usesNodes);
+ instance.addUses(usesNodes);
// GROUPINGS
for (GroupingBuilder builder : addedGroupings) {
- groupings.add(builder.build(instance));
+ groupings.add(builder.build());
}
- instance.setGroupings(groupings);
+ instance.addGroupings(groupings);
// AUGMENTATIONS
for (AugmentationSchemaBuilder builder : augmentationBuilders) {
- augmentations.add(builder.build(instance));
+ augmentations.add(builder.build());
}
- instance.setAvailableAugmentations(new HashSet<>(augmentations));
+ instance.addAvailableAugmentations(new HashSet<>(augmentations));
// UNKNOWN NODES
for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
- unknownNodes.add(b.build(instance));
+ unknownNodes.add(b.build());
}
Collections.sort(unknownNodes, Comparators.SCHEMA_NODE_COMP);
- instance.setUnknownSchemaNodes(unknownNodes);
+ instance.addUnknownSchemaNodes(unknownNodes);
instance.setConstraints(constraints.build());
return instance;
}
- @Override
- public void rebuild() {
- isBuilt = false;
- build(parent);
- }
-
- @Override
- public void setQName(QName qname) {
- this.qname = qname;
- instance.setQName(qname);
- }
-
@Override
public Set<TypeDefinitionBuilder> getTypeDefinitionBuilders() {
return addedTypedefs;
addedTypedefs.add(type);
}
- public void setTypedefs(final Set<TypeDefinition<?>> typedefs) {
- this.typedefs = typedefs;
- }
-
@Override
public SchemaPath getPath() {
- return schemaPath;
+ return instance.path;
}
@Override
- public void setPath(final SchemaPath schemaPath) {
- this.schemaPath = schemaPath;
+ public void setPath(SchemaPath path) {
+ instance.path = path;
}
@Override
public String getDescription() {
- return description;
+ return instance.description;
}
@Override
public void setDescription(final String description) {
- this.description = description;
+ instance.description = description;
}
@Override
public String getReference() {
- return reference;
+ return instance.reference;
}
@Override
- public void setReference(String reference) {
- this.reference = reference;
+ public void setReference(final String reference) {
+ instance.reference = reference;
}
@Override
public Status getStatus() {
- return status;
+ return instance.status;
}
@Override
public void setStatus(Status status) {
if (status != null) {
- this.status = status;
+ instance.status = status;
}
}
augmentationBuilders.add(augment);
}
- public List<AugmentationSchema> getAugmentations() {
- return augmentations;
- }
-
public List<AugmentationSchemaBuilder> getAugmentationBuilders() {
return augmentationBuilders;
}
public List<QName> getKeyDefinition() {
- return keyDefinition;
+ return instance.keyDefinition;
}
public void setKeyDefinition(final List<QName> keyDefinition) {
- if (keyDefinition != null) {
- this.keyDefinition = keyDefinition;
- }
+ instance.keyDefinition = keyDefinition;
}
+ @Override
public boolean isAugmenting() {
- return augmenting;
+ return instance.augmenting;
}
@Override
public void setAugmenting(boolean augmenting) {
- this.augmenting = augmenting;
+ instance.augmenting = augmenting;
}
@Override
public boolean isAddedByUses() {
- return addedByUses;
+ return instance.addedByUses;
}
@Override
public void setAddedByUses(final boolean addedByUses) {
- this.addedByUses = addedByUses;
+ instance.addedByUses = addedByUses;
}
+ @Override
public Boolean isConfiguration() {
- return configuration;
+ return instance.configuration;
}
@Override
public void setConfiguration(Boolean configuration) {
- this.configuration = configuration;
+ instance.configuration = configuration;
}
@Override
}
public boolean isUserOrdered() {
- return userOrdered;
+ return instance.userOrdered;
}
public void setUserOrdered(final boolean userOrdered) {
- this.userOrdered = userOrdered;
+ instance.userOrdered = userOrdered;
}
@Override
}
public final class ListSchemaNodeImpl implements ListSchemaNode {
- private QName qname;
+ private final QName qname;
private SchemaPath path;
- private YangNode parent;
private String description;
private String reference;
private Status status = Status.CURRENT;
private boolean addedByUses;
private boolean configuration;
private ConstraintDefinition constraints;
- private Set<AugmentationSchema> augmentations = Collections.emptySet();
- private Map<QName, DataSchemaNode> childNodes = Collections.emptyMap();
- private Set<TypeDefinition<?>> typeDefinitions = Collections.emptySet();
- private Set<GroupingDefinition> groupings = Collections.emptySet();
- private Set<UsesNode> uses = Collections.emptySet();
+ private final Set<AugmentationSchema> augmentations = new HashSet<>();
+ private final Map<QName, DataSchemaNode> childNodes = new HashMap<>();
+ private final Set<TypeDefinition<?>> typeDefinitions = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
+ private final Set<GroupingDefinition> groupings = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
+ private final Set<UsesNode> uses = new HashSet<>();
private boolean userOrdered;
- private List<UnknownSchemaNode> unknownNodes = Collections.emptyList();
+ private final List<UnknownSchemaNode> unknownNodes = new ArrayList<>();
- private ListSchemaNodeImpl(final QName qname) {
+ private ListSchemaNodeImpl(final QName qname, final SchemaPath path) {
this.qname = qname;
+ this.path = path;
}
@Override
return qname;
}
- private void setQName(QName qname) {
- this.qname = qname;
- }
-
@Override
public SchemaPath getPath() {
return path;
}
- private void setPath(final SchemaPath path) {
- this.path = path;
- }
-
- @Override
- public YangNode getParent() {
- return parent;
- }
-
- private void setParent(YangNode parent) {
- this.parent = parent;
- }
-
@Override
public String getDescription() {
return description;
}
- private void setDescription(final String description) {
- this.description = description;
- }
-
@Override
public String getReference() {
return reference;
}
- private void setReference(final String reference) {
- this.reference = reference;
- }
-
@Override
public Status getStatus() {
return status;
}
- private void setStatus(Status status) {
- this.status = status;
- }
-
@Override
public List<QName> getKeyDefinition() {
return keyDefinition;
}
- private void setKeyDefinition(List<QName> keyDefinition) {
- if (keyDefinition != null) {
- this.keyDefinition = keyDefinition;
- }
- }
-
@Override
public boolean isAugmenting() {
return augmenting;
}
- private void setAugmenting(boolean augmenting) {
- this.augmenting = augmenting;
- }
-
@Override
public boolean isAddedByUses() {
return addedByUses;
}
- private void setAddedByUses(final boolean addedByUses) {
- this.addedByUses = addedByUses;
- }
-
@Override
public boolean isConfiguration() {
return configuration;
}
- private void setConfiguration(boolean configuration) {
- this.configuration = configuration;
- }
-
@Override
public ConstraintDefinition getConstraints() {
return constraints;
@Override
public Set<AugmentationSchema> getAvailableAugmentations() {
- return augmentations;
+ return Collections.unmodifiableSet(augmentations);
}
- private void
setAvailableAugmentations(Set<AugmentationSchema> augmentations) {
+ private void
addAvailableAugmentations(Set<AugmentationSchema> augmentations) {
if (augmentations != null) {
- this.augmentations = augmentations;
+ this.augmentations.addAll(augmentations);
}
}
@Override
public Set<DataSchemaNode> getChildNodes() {
- return new HashSet<>(childNodes.values());
+ final Set<DataSchemaNode> result = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
+ result.addAll(childNodes.values());
+ return Collections.unmodifiableSet(result);
}
- private void setChildNodes(Map<QName, DataSchemaNode> childNodes) {
+ private void addChildNodes(Map<QName, DataSchemaNode> childNodes) {
if (childNodes != null) {
- this.childNodes = childNodes;
+ this.childNodes.putAll(childNodes);
}
}
@Override
public Set<GroupingDefinition> getGroupings() {
- return groupings;
+ return Collections.unmodifiableSet(groupings);
}
- private void setGroupings(Set<GroupingDefinition> groupings) {
+ private void addGroupings(Set<GroupingDefinition> groupings) {
if (groupings != null) {
- this.groupings = groupings;
+ this.groupings.addAll(groupings);
}
}
@Override
public Set<TypeDefinition<?>> getTypeDefinitions() {
- return typeDefinitions;
+ return Collections.unmodifiableSet(typeDefinitions);
}
- private void setTypeDefinitions(Set<TypeDefinition<?>> typeDefinitions) {
+ private void addTypeDefinitions(Set<TypeDefinition<?>> typeDefinitions) {
if (typeDefinitions != null) {
- this.typeDefinitions = typeDefinitions;
+ this.typeDefinitions.addAll(typeDefinitions);
}
}
@Override
public Set<UsesNode> getUses() {
- return uses;
+ return Collections.unmodifiableSet(uses);
}
- private void setUses(Set<UsesNode> uses) {
+ private void addUses(Set<UsesNode> uses) {
if (uses != null) {
- this.uses = uses;
+ this.uses.addAll(uses);
}
}
return userOrdered;
}
- private void setUserOrdered(boolean userOrdered) {
- this.userOrdered = userOrdered;
- }
-
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
- return unknownNodes;
+ return Collections.unmodifiableList(unknownNodes);
}
- private void setUnknownSchemaNodes(List<UnknownSchemaNode> unknownNodes) {
+ private void addUnknownSchemaNodes(List<UnknownSchemaNode> unknownNodes) {
if (unknownNodes != null) {
- this.unknownNodes = unknownNodes;
+ this.unknownNodes.addAll(unknownNodes);
}
}
- public ListSchemaNodeBuilder toBuilder() {
- return ListSchemaNodeBuilder.this;
- }
-
@Override
public int hashCode() {
final int prime = 31;
@Override
public String toString() {
- StringBuilder sb = new StringBuilder();
- sb.append("list ");
- sb.append(qname.getLocalName());
- sb.append("[");
- sb.append(path);
- sb.append("]");
- return sb.toString();
+ return "list " + qname.getLocalName();
}
}
package org.opendaylight.yangtools.yang.parser.builder.impl;
import java.net.URI;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Date;
-import java.util.Deque;
-import java.util.HashSet;
-import java.util.LinkedHashSet;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.TreeSet;
+import java.util.*;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.Deviation;
-import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
-import org.opendaylight.yangtools.yang.model.api.FeatureDefinition;
-import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
-import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
-import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.ModuleImport;
-import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
-import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.UsesNode;
-import org.opendaylight.yangtools.yang.model.api.YangNode;
-import org.opendaylight.yangtools.yang.parser.builder.api.AbstractDataNodeContainerBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.api.Builder;
-import org.opendaylight.yangtools.yang.parser.builder.api.DataNodeContainerBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.api.SchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.api.TypeAwareBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
+import org.opendaylight.yangtools.yang.model.api.*;
+import org.opendaylight.yangtools.yang.parser.builder.api.*;
import org.opendaylight.yangtools.yang.parser.util.Comparators;
import org.opendaylight.yangtools.yang.parser.util.ModuleImportImpl;
import org.opendaylight.yangtools.yang.parser.util.RefineHolder;
actualPath.push(this);
}
- public Module build() {
- return build(null);
+ public ModuleBuilder(Module base) {
+ super(base.getName(), 0, null);
+ this.name = base.getName();
+ schemaPath = new SchemaPath(Collections.<QName> emptyList(), true);
+ instance = new ModuleImpl(base.getName());
+ actualPath.push(this);
+
+ namespace = base.getNamespace();
+ prefix = base.getPrefix();
+ revision = base.getRevision();
+
+ for (DataSchemaNode childNode : base.getChildNodes()) {
+ childNodes.put(childNode.getQName(), childNode);
+ }
+
+ typedefs.addAll(base.getTypeDefinitions());
+ groupings.addAll(base.getGroupings());
+ usesNodes.addAll(base.getUses());
+ augments.addAll(base.getAugmentations());
+ rpcs.addAll(base.getRpcs());
+ notifications.addAll(base.getNotifications());
+ identities.addAll(base.getIdentities());
+ features.addAll(base.getFeatures());
+ deviations.addAll(base.getDeviations());
+ extensions.addAll(base.getExtensionSchemaNodes());
+ unknownNodes.addAll(base.getUnknownSchemaNodes());
}
/**
* Build new Module object based on this builder.
*/
@Override
- public Module build(YangNode parent) {
+ public Module build() {
instance.setPrefix(prefix);
instance.setRevision(revision);
instance.setImports(imports);
// TYPEDEFS
for (TypeDefinitionBuilder tdb : addedTypedefs) {
- typedefs.add(tdb.build(instance));
+ typedefs.add(tdb.build());
}
instance.setTypeDefinitions(typedefs);
// CHILD NODES
for (DataSchemaNodeBuilder child : addedChildNodes) {
- DataSchemaNode childNode = child.build(instance);
+ DataSchemaNode childNode = child.build();
childNodes.put(childNode.getQName(), childNode);
}
- instance.setChildNodes(childNodes);
+ instance.addChildNodes(childNodes);
// GROUPINGS
for (GroupingBuilder gb : addedGroupings) {
- groupings.add(gb.build(instance));
+ groupings.add(gb.build());
}
instance.setGroupings(groupings);
// USES
for (UsesNodeBuilder unb : addedUsesNodes) {
- usesNodes.add(unb.build(instance));
+ usesNodes.add(unb.build());
}
instance.setUses(usesNodes);
// FEATURES
for (FeatureBuilder fb : addedFeatures) {
- features.add(fb.build(instance));
+ features.add(fb.build());
}
instance.setFeatures(features);
// NOTIFICATIONS
for (NotificationBuilder entry : addedNotifications) {
- notifications.add(entry.build(instance));
+ notifications.add(entry.build());
}
instance.setNotifications(notifications);
// AUGMENTATIONS
for (AugmentationSchemaBuilder builder : augmentBuilders) {
- augments.add(builder.build(instance));
+ augments.add(builder.build());
}
instance.setAugmentations(augments);
// RPCs
for (RpcDefinitionBuilder rpc : addedRpcs) {
- rpcs.add(rpc.build(instance));
+ rpcs.add(rpc.build());
}
instance.setRpcs(rpcs);
// DEVIATIONS
for (DeviationBuilder entry : deviationBuilders) {
- deviations.add(entry.build(instance));
+ deviations.add(entry.build());
}
instance.setDeviations(deviations);
// EXTENSIONS
for (ExtensionBuilder eb : addedExtensions) {
- extensions.add(eb.build(instance));
+ extensions.add(eb.build());
}
Collections.sort(extensions, Comparators.SCHEMA_NODE_COMP);
instance.setExtensionSchemaNodes(extensions);
// IDENTITIES
for (IdentitySchemaNodeBuilder id : addedIdentities) {
- identities.add(id.build(instance));
+ identities.add(id.build());
}
instance.setIdentities(identities);
// UNKNOWN NODES
for (UnknownSchemaNodeBuilder unb : addedUnknownNodes) {
- unknownNodes.add(unb.build(instance));
+ unknownNodes.add(unb.build());
}
Collections.sort(unknownNodes, Comparators.SCHEMA_NODE_COMP);
instance.setUnknownSchemaNodes(unknownNodes);
return imports;
}
- public ExtensionBuilder addExtension(final QName qname, final int line) {
+ public ExtensionBuilder addExtension(final QName qname, final int line, final SchemaPath path) {
Builder parent = getActualNode();
if (!(parent.equals(this))) {
throw new YangParseException(name, line, "extension can be defined only in module or submodule");
raiseYangParserException("extension", "node", extName, line, addedExtension.getLine());
}
}
- final ExtensionBuilder builder = new ExtensionBuilder(name, line, qname);
+ final ExtensionBuilder builder = new ExtensionBuilder(name, line, qname, path);
builder.setParent(parent);
addedExtensions.add(builder);
return builder;
return builder;
}
- public GroupingBuilder addGrouping(final int line, final QName qname) {
- final GroupingBuilder builder = new GroupingBuilderImpl(name, line, qname);
+ public GroupingBuilder addGrouping(final int line, final QName qname, final SchemaPath path) {
+ final GroupingBuilder builder = new GroupingBuilderImpl(name, line, qname, path);
Builder parent = getActualNode();
builder.setParent(parent);
if (parent.equals(this)) {
// augment can be declared only under 'module' ...
+ if (!(augmentTargetStr.startsWith("/"))) {
+ throw new YangParseException(
+ name,
+ line,
+ "If the 'augment' statement is on the top level in a module, the absolute form of a schema node identifier MUST be used.");
+ }
augmentBuilders.add(builder);
} else {
// ... or 'uses' statement
}
((DataNodeContainerBuilder) parent).addUsesNode(usesBuilder);
}
- if(parent instanceof AugmentationSchemaBuilder) {
+ if (parent instanceof AugmentationSchemaBuilder) {
usesBuilder.setAugmenting(true);
}
refine.setParent(parent);
}
- public RpcDefinitionBuilder addRpc(final int line, final QName qname) {
+ public RpcDefinitionBuilder addRpc(final int line, final QName qname, final SchemaPath path) {
Builder parent = getActualNode();
if (!(parent.equals(this))) {
throw new YangParseException(name, line, "rpc can be defined only in module or submodule");
}
- final RpcDefinitionBuilder rpcBuilder = new RpcDefinitionBuilder(name, line, qname);
+ final RpcDefinitionBuilder rpcBuilder = new RpcDefinitionBuilder(name, line, qname, path);
rpcBuilder.setParent(parent);
String rpcName = qname.getLocalName();
notifications.add(notification);
}
- public NotificationBuilder addNotification(final int line, final QName qname) {
+ public NotificationBuilder addNotification(final int line, final QName qname, final SchemaPath path) {
final Builder parent = getActualNode();
if (!(parent.equals(this))) {
throw new YangParseException(name, line, "notification can be defined only in module or submodule");
}
}
- final NotificationBuilder builder = new NotificationBuilder(name, line, qname);
+ final NotificationBuilder builder = new NotificationBuilder(name, line, qname, path);
builder.setParent(parent);
addedNotifications.add(builder);
return builder;
}
- public FeatureBuilder addFeature(final int line, final QName qname) {
+ public FeatureBuilder addFeature(final int line, final QName qname, final SchemaPath path) {
Builder parent = getActualNode();
if (!(parent.equals(this))) {
throw new YangParseException(name, line, "feature can be defined only in module or submodule");
}
- final FeatureBuilder builder = new FeatureBuilder(name, line, qname);
+ final FeatureBuilder builder = new FeatureBuilder(name, line, qname, path);
builder.setParent(parent);
String featureName = qname.getLocalName();
return builder;
}
- public ChoiceBuilder addChoice(final int line, final QName qname) {
- final ChoiceBuilder builder = new ChoiceBuilder(name, line, qname);
+ public ChoiceBuilder addChoice(final int line, final QName qname, final SchemaPath path) {
+ final ChoiceBuilder builder = new ChoiceBuilder(name, line, qname, path);
Builder parent = getActualNode();
builder.setParent(parent);
return builder;
}
- public ChoiceCaseBuilder addCase(final int line, final QName qname) {
+ public ChoiceCaseBuilder addCase(final int line, final QName qname, final SchemaPath path) {
Builder parent = getActualNode();
if (parent == null || parent.equals(this)) {
throw new YangParseException(name, line, "'case' parent not found");
}
- final ChoiceCaseBuilder builder = new ChoiceCaseBuilder(name, line, qname);
+ final ChoiceCaseBuilder builder = new ChoiceCaseBuilder(name, line, qname, path);
builder.setParent(parent);
if (parent instanceof ChoiceBuilder) {
addedTypedefs.add(typedefBuilder);
}
- public TypeDefinitionBuilderImpl addTypedef(final int line, final QName qname) {
- final TypeDefinitionBuilderImpl builder = new TypeDefinitionBuilderImpl(name, line, qname);
+ public TypeDefinitionBuilderImpl addTypedef(final int line, final QName qname, final SchemaPath path) {
+ final TypeDefinitionBuilderImpl builder = new TypeDefinitionBuilderImpl(name, line, qname, path);
Builder parent = getActualNode();
builder.setParent(parent);
return builder;
}
- public IdentitySchemaNodeBuilder addIdentity(final QName qname, final int line) {
+ public IdentitySchemaNodeBuilder addIdentity(final QName qname, final int line, final SchemaPath path) {
Builder parent = getActualNode();
if (!(parent.equals(this))) {
throw new YangParseException(name, line, "identity can be defined only in module or submodule");
}
}
- final IdentitySchemaNodeBuilder builder = new IdentitySchemaNodeBuilder(name, line, qname);
+ final IdentitySchemaNodeBuilder builder = new IdentitySchemaNodeBuilder(name, line, qname, path);
builder.setParent(parent);
addedIdentities.add(builder);
return builder;
allUnknownNodes.add(builder);
}
- public UnknownSchemaNodeBuilder addUnknownSchemaNode(final int line, final QName qname) {
+ public UnknownSchemaNodeBuilder addUnknownSchemaNode(final int line, final QName qname, final SchemaPath path) {
final Builder parent = getActualNode();
- final UnknownSchemaNodeBuilder builder = new UnknownSchemaNodeBuilder(name, line, qname);
+ final UnknownSchemaNodeBuilder builder = new UnknownSchemaNodeBuilder(name, line, qname, path);
builder.setParent(parent);
allUnknownNodes.add(builder);
private String reference;
private String organization;
private String contact;
- private Set<ModuleImport> imports = Collections.emptySet();
- private Set<FeatureDefinition> features = Collections.emptySet();
- private Set<TypeDefinition<?>> typeDefinitions = Collections.emptySet();
- private Set<NotificationDefinition> notifications = Collections.emptySet();
- private Set<AugmentationSchema> augmentations = Collections.emptySet();
- private Set<RpcDefinition> rpcs = Collections.emptySet();
- private Set<Deviation> deviations = Collections.emptySet();
- private Map<QName, DataSchemaNode> childNodes = Collections.emptyMap();
- private Set<GroupingDefinition> groupings = Collections.emptySet();
- private Set<UsesNode> uses = Collections.emptySet();
- private List<ExtensionDefinition> extensionNodes = Collections.emptyList();
- private Set<IdentitySchemaNode> identities = Collections.emptySet();
- private List<UnknownSchemaNode> unknownNodes = Collections.emptyList();
+ private final Set<ModuleImport> imports = new HashSet<>();
+ private final Set<FeatureDefinition> features = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
+ private final Set<TypeDefinition<?>> typeDefinitions = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
+ private final Set<NotificationDefinition> notifications = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
+ private final Set<AugmentationSchema> augmentations = new HashSet<>();
+ private final Set<RpcDefinition> rpcs = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
+ private final Set<Deviation> deviations = new HashSet<>();
+ private final Map<QName, DataSchemaNode> childNodes = new TreeMap<>(Comparators.QNAME_COMP);
+ private final Set<GroupingDefinition> groupings = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
+ private final Set<UsesNode> uses = new HashSet<>();
+ private final List<ExtensionDefinition> extensionNodes = new ArrayList<>();
+ private final Set<IdentitySchemaNode> identities = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
+ private final List<UnknownSchemaNode> unknownNodes = new ArrayList<>();
private ModuleImpl(String name) {
this.name = name;
}
- @Override
- public YangNode getParent() {
- return null;
- }
-
@Override
public URI getNamespace() {
return namespace;
private void setImports(Set<ModuleImport> imports) {
if (imports != null) {
- this.imports = imports;
+ this.imports.addAll(imports);
}
}
private void setFeatures(Set<FeatureDefinition> features) {
if (features != null) {
- this.features = features;
+ this.features.addAll(features);
}
}
private void setTypeDefinitions(Set<TypeDefinition<?>> typeDefinitions) {
if (typeDefinitions != null) {
- this.typeDefinitions = typeDefinitions;
+ this.typeDefinitions.addAll(typeDefinitions);
}
}
private void setNotifications(Set<NotificationDefinition> notifications) {
if (notifications != null) {
- this.notifications = notifications;
+ this.notifications.addAll(notifications);
}
}
private void setAugmentations(Set<AugmentationSchema> augmentations) {
if (augmentations != null) {
- this.augmentations = augmentations;
+ this.augmentations.addAll(augmentations);
}
}
private void setRpcs(Set<RpcDefinition> rpcs) {
if (rpcs != null) {
- this.rpcs = rpcs;
+ this.rpcs.addAll(rpcs);
}
}
private void setDeviations(Set<Deviation> deviations) {
if (deviations != null) {
- this.deviations = deviations;
+ this.deviations.addAll(deviations);
}
}
@Override
public Set<DataSchemaNode> getChildNodes() {
- return new LinkedHashSet<DataSchemaNode>(childNodes.values());
+ final Set<DataSchemaNode> result = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
+ result.addAll(childNodes.values());
+ return Collections.unmodifiableSet(result);
}
- private void setChildNodes(Map<QName, DataSchemaNode> childNodes) {
+ private void addChildNodes(Map<QName, DataSchemaNode> childNodes) {
if (childNodes != null) {
- this.childNodes = childNodes;
+ this.childNodes.putAll(childNodes);
}
}
private void setGroupings(Set<GroupingDefinition> groupings) {
if (groupings != null) {
- this.groupings = groupings;
+ this.groupings.addAll(groupings);
}
}
private void setUses(Set<UsesNode> uses) {
if (uses != null) {
- this.uses = uses;
+ this.uses.addAll(uses);
}
}
@Override
public List<ExtensionDefinition> getExtensionSchemaNodes() {
+ Collections.sort(extensionNodes, Comparators.SCHEMA_NODE_COMP);
return extensionNodes;
}
private void setExtensionSchemaNodes(final List<ExtensionDefinition> extensionNodes) {
if (extensionNodes != null) {
- this.extensionNodes = extensionNodes;
+ this.extensionNodes.addAll(extensionNodes);
}
}
private void setIdentities(final Set<IdentitySchemaNode> identities) {
if (identities != null) {
- this.identities = identities;
+ this.identities.addAll(identities);
}
}
private void setUnknownSchemaNodes(final List<UnknownSchemaNode> unknownNodes) {
if (unknownNodes != null) {
- this.unknownNodes = unknownNodes;
+ this.unknownNodes.addAll(unknownNodes);
}
}
// defined only under module or submodule
if (parent instanceof DataNodeContainerBuilder) {
DataNodeContainerBuilder parentNode = (DataNodeContainerBuilder) parent;
- for (DataSchemaNodeBuilder childNode : parentNode.getChildNodeBuilders()) {
+ for (DataSchemaNodeBuilder childNode : parentNode.getChildNodes()) {
if (childNode.getQName().getLocalName().equals(childName)) {
raiseYangParserException("'" + child + "'", "node", childName, lineNum, childNode.getLine());
}
*/
package org.opendaylight.yangtools.yang.parser.builder.impl;
+import java.net.URI;
import java.util.ArrayList;
import java.util.Collections;
+import java.util.Date;
+import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.UsesNode;
-import org.opendaylight.yangtools.yang.model.api.YangNode;
import org.opendaylight.yangtools.yang.parser.builder.api.AbstractDataNodeContainerBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationTargetBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
import org.opendaylight.yangtools.yang.parser.util.Comparators;
+import org.opendaylight.yangtools.yang.parser.util.ParserUtils;
import org.opendaylight.yangtools.yang.parser.util.YangParseException;
public final class NotificationBuilder extends AbstractDataNodeContainerBuilder implements SchemaNodeBuilder,
AugmentationTargetBuilder {
private boolean isBuilt;
private final NotificationDefinitionImpl instance;
- private YangNode parent;
private SchemaPath schemaPath;
- private String description;
- private String reference;
- private Status status = Status.CURRENT;
private final List<AugmentationSchema> augmentations = new ArrayList<>();
private final List<AugmentationSchemaBuilder> augmentationBuilders = new ArrayList<>();
- NotificationBuilder(final String moduleName, final int line, final QName qname) {
+ NotificationBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path) {
super(moduleName, line, qname);
- instance = new NotificationDefinitionImpl(qname);
+ this.schemaPath = path;
+ instance = new NotificationDefinitionImpl(qname, path);
+ }
+
+ NotificationBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path, NotificationDefinition base) {
+ super(moduleName, line, qname);
+ this.schemaPath = path;
+ instance = new NotificationDefinitionImpl(qname, path);
+
+ instance.description = base.getDescription();
+ instance.reference = base.getReference();
+ instance.status = base.getStatus();
+ instance.augmentations.addAll(base.getAvailableAugmentations());
+
+ URI ns = qname.getNamespace();
+ Date rev = qname.getRevision();
+ String pref = qname.getPrefix();
+ addedChildNodes.addAll(ParserUtils.wrapChildNodes(moduleName, line, base.getChildNodes(), path, ns, rev, pref));
+ addedGroupings.addAll(ParserUtils.wrapGroupings(moduleName, line, base.getGroupings(), path, ns, rev, pref));
+
+ instance.groupings.addAll(base.getGroupings());
+ instance.typeDefinitions.addAll(base.getTypeDefinitions());
+ instance.uses.addAll(base.getUses());
+ instance.unknownNodes.addAll(base.getUnknownSchemaNodes());
}
@Override
- public NotificationDefinition build(YangNode parent) {
+ public NotificationDefinition build() {
if (!(parentBuilder instanceof ModuleBuilder)) {
throw new YangParseException(moduleName, line, "Notification can be defined only under module (was " + parentBuilder + ")");
}
if (!isBuilt) {
- this.parent = parent;
- instance.setParent(parent);
- instance.setPath(schemaPath);
- instance.setDescription(description);
- instance.setReference(reference);
- instance.setStatus(status);
-
// CHILD NODES
for (DataSchemaNodeBuilder node : addedChildNodes) {
- DataSchemaNode child = node.build(instance);
+ DataSchemaNode child = node.build();
childNodes.put(child.getQName(), child);
}
instance.setChildNodes(childNodes);
// GROUPINGS
for (GroupingBuilder builder : addedGroupings) {
- groupings.add(builder.build(instance));
+ groupings.add(builder.build());
}
instance.setGroupings(groupings);
// TYPEDEFS
for (TypeDefinitionBuilder entry : addedTypedefs) {
- typedefs.add(entry.build(instance));
+ typedefs.add(entry.build());
}
instance.setTypeDefinitions(typedefs);
// USES
for (UsesNodeBuilder builder : addedUsesNodes) {
- usesNodes.add(builder.build(instance));
+ usesNodes.add(builder.build());
}
instance.setUses(usesNodes);
// AUGMENTATIONS
for (AugmentationSchemaBuilder builder : augmentationBuilders) {
- augmentations.add(builder.build(instance));
+ augmentations.add(builder.build());
}
instance.setAvailableAugmentations(new HashSet<>(augmentations));
// UNKNOWN NODES
for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
- unknownNodes.add(b.build(instance));
+ unknownNodes.add(b.build());
}
Collections.sort(unknownNodes, Comparators.SCHEMA_NODE_COMP);
instance.setUnknownSchemaNodes(unknownNodes);
return instance;
}
- @Override
- public void rebuild() {
- isBuilt = false;
- build(parent);
- }
@Override
public Set<TypeDefinitionBuilder> getTypeDefinitionBuilders() {
return schemaPath;
}
- @Override
- public void setPath(SchemaPath schemaPath) {
- this.schemaPath = schemaPath;
- }
-
@Override
public String getDescription() {
- return description;
+ return instance.description;
}
@Override
public void setDescription(final String description) {
- this.description = description;
+ instance.description = description;
}
@Override
public String getReference() {
- return reference;
+ return instance.reference;
}
@Override
public void setReference(final String reference) {
- this.reference = reference;
+ instance.reference = reference;
}
@Override
public Status getStatus() {
- return status;
+ return instance.status;
}
@Override
- public void setStatus(final Status status) {
+ public void setStatus(Status status) {
if (status != null) {
- this.status = status;
+ instance.status = status;
}
}
public final class NotificationDefinitionImpl implements NotificationDefinition {
private final QName qname;
- private SchemaPath path;
- private YangNode parent;
+ private final SchemaPath path;
private String description;
private String reference;
private Status status = Status.CURRENT;
- private Map<QName, DataSchemaNode> childNodes = Collections.emptyMap();
- private Set<GroupingDefinition> groupings = Collections.emptySet();
- private Set<TypeDefinition<?>> typeDefinitions = Collections.emptySet();
- private Set<UsesNode> uses = Collections.emptySet();
- private Set<AugmentationSchema> augmentations = Collections.emptySet();
- private List<UnknownSchemaNode> unknownNodes = Collections.emptyList();
-
- private NotificationDefinitionImpl(final QName qname) {
+ private final Map<QName, DataSchemaNode> childNodes = new HashMap<>();
+ private final Set<GroupingDefinition> groupings = new HashSet<>();
+ private final Set<TypeDefinition<?>> typeDefinitions = new HashSet<>();
+ private final Set<UsesNode> uses = new HashSet<>();
+ private final Set<AugmentationSchema> augmentations = new HashSet<>();
+ private final List<UnknownSchemaNode> unknownNodes = new ArrayList<>();
+
+ private NotificationDefinitionImpl(final QName qname, final SchemaPath path) {
this.qname = qname;
+ this.path = path;
}
@Override
return path;
}
- private void setPath(final SchemaPath path) {
- this.path = path;
- }
-
- @Override
- public YangNode getParent() {
- return parent;
- }
-
- private void setParent(YangNode parent) {
- this.parent = parent;
- }
-
@Override
public String getDescription() {
return description;
}
- private void setDescription(final String description) {
- this.description = description;
- }
-
@Override
public String getReference() {
return reference;
}
- private void setReference(String reference) {
- this.reference = reference;
- }
-
@Override
public Status getStatus() {
return status;
}
- private void setStatus(Status status) {
- if (status != null) {
- this.status = status;
- }
- }
-
@Override
public Set<DataSchemaNode> getChildNodes() {
- return new HashSet<DataSchemaNode>(childNodes.values());
+ return Collections.unmodifiableSet(new HashSet<DataSchemaNode>(childNodes.values()));
}
private void setChildNodes(Map<QName, DataSchemaNode> childNodes) {
if (childNodes != null) {
- this.childNodes = childNodes;
+ this.childNodes.putAll(childNodes);
}
}
@Override
public Set<GroupingDefinition> getGroupings() {
- return groupings;
+ return Collections.unmodifiableSet(groupings);
}
private void setGroupings(Set<GroupingDefinition> groupings) {
if (groupings != null) {
- this.groupings = groupings;
+ this.groupings.addAll(groupings);
}
}
@Override
public Set<UsesNode> getUses() {
- return uses;
+ return Collections.unmodifiableSet(uses);
}
private void setUses(Set<UsesNode> uses) {
if (uses != null) {
- this.uses = uses;
+ this.uses.addAll(uses);
}
}
@Override
public Set<TypeDefinition<?>> getTypeDefinitions() {
- return typeDefinitions;
+ return Collections.unmodifiableSet(typeDefinitions);
}
private void setTypeDefinitions(final Set<TypeDefinition<?>> typeDefinitions) {
if (typeDefinitions != null) {
- this.typeDefinitions = typeDefinitions;
+ this.typeDefinitions.addAll(typeDefinitions);
}
}
@Override
public Set<AugmentationSchema> getAvailableAugmentations() {
- return augmentations;
+ return Collections.unmodifiableSet(augmentations);
}
private void setAvailableAugmentations(Set<AugmentationSchema> augmentations) {
if (augmentations != null) {
- this.augmentations = augmentations;
+ this.augmentations.addAll(augmentations);
}
}
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
- return unknownNodes;
+ return Collections.unmodifiableList(unknownNodes);
}
private void setUnknownSchemaNodes(final List<UnknownSchemaNode> unknownNodes) {
if (unknownNodes != null) {
- this.unknownNodes = unknownNodes;
+ this.unknownNodes.addAll(unknownNodes);
}
}
return result;
}
- public NotificationBuilder toBuilder() {
- return NotificationBuilder.this;
- }
-
@Override
public int hashCode() {
final int prime = 31;
*/
package org.opendaylight.yangtools.yang.parser.builder.impl;
+import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
-import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.YangNode;
import org.opendaylight.yangtools.yang.parser.builder.api.AbstractSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
import org.opendaylight.yangtools.yang.parser.util.Comparators;
-import org.opendaylight.yangtools.yang.parser.util.YangParseException;
public final class RpcDefinitionBuilder extends AbstractSchemaNodeBuilder {
private boolean isBuilt;
return outputBuilder;
}
- RpcDefinitionBuilder(final String moduleName, final int line, final QName qname) {
+ RpcDefinitionBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path) {
super(moduleName, line, qname);
- this.instance = new RpcDefinitionImpl(qname);
+ this.schemaPath = path;
+ this.instance = new RpcDefinitionImpl(qname, path);
}
@Override
- public RpcDefinition build(YangNode parent) {
- if (!(parent instanceof Module)) {
- throw new YangParseException(moduleName, line, "Rpc can be defined only under module");
- }
+ public RpcDefinition build() {
if (!isBuilt) {
- instance.setDescription(description);
- instance.setReference(reference);
- instance.setStatus(status);
-
- final ContainerSchemaNode input = inputBuilder == null ? null : inputBuilder.build(instance);
- final ContainerSchemaNode output = outputBuilder == null ? null : outputBuilder.build(instance);
+ final ContainerSchemaNode input = inputBuilder == null ? null : inputBuilder.build();
+ final ContainerSchemaNode output = outputBuilder == null ? null : outputBuilder.build();
instance.setInput(input);
instance.setOutput(output);
- instance.setPath(schemaPath);
-
// TYPEDEFS
for (TypeDefinitionBuilder entry : addedTypedefs) {
- typedefs.add(entry.build(instance));
+ typedefs.add(entry.build());
}
instance.setTypeDefinitions(typedefs);
// GROUPINGS
for (GroupingBuilder entry : addedGroupings) {
- groupings.add(entry.build(instance));
+ groupings.add(entry.build());
}
instance.setGroupings(groupings);
// UNKNOWN NODES
for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
- unknownNodes.add(b.build(instance));
+ unknownNodes.add(b.build());
}
Collections.sort(unknownNodes, Comparators.SCHEMA_NODE_COMP);
instance.setUnknownSchemaNodes(unknownNodes);
return instance;
}
+ @Override
+ public SchemaPath getPath() {
+ return instance.path;
+ }
+
+ @Override
+ public String getDescription() {
+ return instance.description;
+ }
+
+ @Override
+ public void setDescription(final String description) {
+ instance.description = description;
+ }
+
+ @Override
+ public String getReference() {
+ return instance.reference;
+ }
+
+ @Override
+ public void setReference(final String reference) {
+ instance.reference = reference;
+ }
+
+ @Override
+ public Status getStatus() {
+ return instance.status;
+ }
+
+ @Override
+ public void setStatus(Status status) {
+ if (status != null) {
+ instance.status = status;
+ }
+ }
+
void setInput(final ContainerSchemaNodeBuilder inputBuilder) {
this.inputBuilder = inputBuilder;
}
private final class RpcDefinitionImpl implements RpcDefinition {
private final QName qname;
- private SchemaPath path;
+ private final SchemaPath path;
private String description;
private String reference;
private Status status;
private ContainerSchemaNode input;
private ContainerSchemaNode output;
- private Set<TypeDefinition<?>> typeDefinitions;
- private Set<GroupingDefinition> groupings;
- private List<UnknownSchemaNode> unknownNodes = Collections.emptyList();
+ private final Set<TypeDefinition<?>> typeDefinitions = new HashSet<>();
+ private final Set<GroupingDefinition> groupings = new HashSet<>();
+ private final List<UnknownSchemaNode> unknownNodes = new ArrayList<>();
- private RpcDefinitionImpl(final QName qname) {
+ private RpcDefinitionImpl(final QName qname, final SchemaPath path) {
this.qname = qname;
+ this.path = path;
}
@Override
return path;
}
- private void setPath(SchemaPath path) {
- this.path = path;
- }
-
@Override
public String getDescription() {
return description;
}
- private void setDescription(String description) {
- this.description = description;
- }
-
@Override
public String getReference() {
return reference;
}
- private void setReference(String reference) {
- this.reference = reference;
- }
-
@Override
public Status getStatus() {
return status;
}
- private void setStatus(Status status) {
- this.status = status;
- }
-
@Override
public ContainerSchemaNode getInput() {
return input;
@Override
public Set<TypeDefinition<?>> getTypeDefinitions() {
- return typeDefinitions;
+ return Collections.unmodifiableSet(typeDefinitions);
}
private void setTypeDefinitions(Set<TypeDefinition<?>> typeDefinitions) {
- this.typeDefinitions = typeDefinitions;
+ this.typeDefinitions.addAll(typeDefinitions);
}
@Override
public Set<GroupingDefinition> getGroupings() {
- return groupings;
+ return Collections.unmodifiableSet(groupings);
}
private void setGroupings(Set<GroupingDefinition> groupings) {
- this.groupings = groupings;
+ this.groupings.addAll(groupings);
}
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
- return unknownNodes;
+ return Collections.unmodifiableList(unknownNodes);
}
private void setUnknownSchemaNodes(List<UnknownSchemaNode> unknownNodes) {
if (unknownNodes != null) {
- this.unknownNodes = unknownNodes;
+ this.unknownNodes.addAll(unknownNodes);
}
}
import java.util.List;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-import org.opendaylight.yangtools.yang.model.api.Status;
-import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.YangNode;
-import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint;
-import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
-import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
+import org.opendaylight.yangtools.yang.model.api.*;
+import org.opendaylight.yangtools.yang.model.api.type.*;
import org.opendaylight.yangtools.yang.model.util.ExtendedType;
import org.opendaylight.yangtools.yang.model.util.UnknownType;
import org.opendaylight.yangtools.yang.parser.builder.api.AbstractTypeAwareBuilder;
import org.opendaylight.yangtools.yang.parser.util.YangParseException;
public final class TypeDefinitionBuilderImpl extends AbstractTypeAwareBuilder implements TypeDefinitionBuilder {
- private SchemaPath schemaPath;
+ private final SchemaPath schemaPath;
private List<RangeConstraint> ranges = Collections.emptyList();
private List<LengthConstraint> lengths = Collections.emptyList();
private List<PatternConstraint> patterns = Collections.emptyList();
private Object defaultValue;
private boolean addedByUses;
- public TypeDefinitionBuilderImpl(final String moduleName, final int line, final QName qname) {
+ public TypeDefinitionBuilderImpl(final String moduleName, final int line, final QName qname, final SchemaPath path) {
super(moduleName, line, qname);
+ this.schemaPath = path;
+ }
+
+ public TypeDefinitionBuilderImpl(final String moduleName, final int line, final QName qname, final SchemaPath path, final ExtendedType base) {
+ super(moduleName, line, base.getQName());
+ this.schemaPath = path;
+
+ this.type = base.getBaseType();
+ this.description = base.getDescription();
+ this.reference = base.getReference();
+ this.status = base.getStatus();
+ this.units = base.getUnits();
+ this.defaultValue = base.getDefaultValue();
+
+ ExtendedType ext = base;
+ this.addedByUses = ext.isAddedByUses();
+ this.ranges = ext.getRangeConstraints();
+ this.lengths = ext.getLengthConstraints();
+ this.patterns = ext.getPatternConstraints();
+ this.fractionDigits = ext.getFractionDigits();
+ this.unknownNodes.addAll(base.getUnknownSchemaNodes());
}
@Override
- public TypeDefinition<? extends TypeDefinition<?>> build(YangNode parent) {
+ public TypeDefinition<? extends TypeDefinition<?>> build() {
TypeDefinition<?> result = null;
ExtendedType.Builder typeBuilder = null;
if ((type == null || type instanceof UnknownType) && typedef == null) {
throw new YangParseException("Unresolved type: '" + qname.getLocalName() + "'.");
}
if (type == null || type instanceof UnknownType) {
- type = typedef.build(parent);
+ type = typedef.build();
}
typeBuilder = new ExtendedType.Builder(qname, type, description, reference, schemaPath);
-
typeBuilder.status(status);
typeBuilder.units(units);
typeBuilder.defaultValue(defaultValue);
typeBuilder.addedByUses(addedByUses);
-
typeBuilder.ranges(ranges);
typeBuilder.lengths(lengths);
typeBuilder.patterns(patterns);
// UNKNOWN NODES
for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
- unknownNodes.add(b.build(null));
+ unknownNodes.add(b.build());
}
Collections.sort(unknownNodes, Comparators.SCHEMA_NODE_COMP);
typeBuilder.unknownSchemaNodes(unknownNodes);
return schemaPath;
}
- @Override
- public void setPath(final SchemaPath schemaPath) {
- this.schemaPath = schemaPath;
- }
-
@Override
public String getDescription() {
return description;
}
@Override
- public List<UnknownSchemaNode> getUnknownNodes() {
+ public List<UnknownSchemaNodeBuilder> getUnknownNodes() {
return Collections.emptyList();
}
*/
package org.opendaylight.yangtools.yang.parser.builder.impl;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
+import java.util.*;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-import org.opendaylight.yangtools.yang.model.api.Status;
-import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.YangNode;
-import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint;
-import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
-import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
+import org.opendaylight.yangtools.yang.model.api.*;
+import org.opendaylight.yangtools.yang.model.api.type.*;
import org.opendaylight.yangtools.yang.model.util.BaseTypes;
import org.opendaylight.yangtools.yang.model.util.UnionType;
import org.opendaylight.yangtools.yang.parser.builder.api.AbstractTypeAwareBuilder;
}
@Override
- public UnionType build(YangNode parent) {
+ public UnionType build() {
if (!isBuilt) {
instance = new UnionType(types);
for (TypeDefinitionBuilder tdb : typedefs) {
- types.add(tdb.build(null));
+ types.add(tdb.build());
}
isBuilt = true;
}
return instance;
}
- @Override
- public void setPath(final SchemaPath schemaPath) {
- throw new YangParseException(moduleName, line, "Can not set path to " + NAME);
- }
-
@Override
public void setDescription(final String description) {
throw new YangParseException(moduleName, line, "Can not set description to " + NAME);
throw new YangParseException(moduleName, line, "Union type can not be added by uses.");
}
- @Override
- public List<UnknownSchemaNode> getUnknownNodes() {
- return Collections.emptyList();
- }
-
@Override
public void addUnknownNodeBuilder(final UnknownSchemaNodeBuilder unknownNode) {
// not yet supported
}
@Override
- public List<UnknownSchemaNodeBuilder> getUnknownNodeBuilders() {
+ public List<UnknownSchemaNodeBuilder> getUnknownNodes() {
return Collections.emptyList();
}
*/
package org.opendaylight.yangtools.yang.parser.builder.impl;
+import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.YangNode;
import org.opendaylight.yangtools.yang.parser.builder.api.AbstractSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.util.Comparators;
public final class UnknownSchemaNodeBuilder extends AbstractSchemaNodeBuilder {
private boolean isBuilt;
private final UnknownSchemaNodeImpl instance;
- private boolean addedByUses;
private QName nodeType;
private String nodeParameter;
private ExtensionDefinition extensionDefinition;
private ExtensionBuilder extensionBuilder;
- public UnknownSchemaNodeBuilder(final String moduleName, final int line, final QName qname) {
+ public UnknownSchemaNodeBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path) {
super(moduleName, line, qname);
- instance = new UnknownSchemaNodeImpl(qname);
+ this.schemaPath = path;
+ instance = new UnknownSchemaNodeImpl(qname, path);
+ }
+
+ public UnknownSchemaNodeBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path, final UnknownSchemaNode base) {
+ super(moduleName, line, base.getQName());
+ this.schemaPath = path;
+ instance = new UnknownSchemaNodeImpl(qname, path);
+
+ instance.nodeType = base.getNodeType();
+ instance.nodeParameter = base.getNodeParameter();
+ instance.description = base.getDescription();
+ instance.reference = base.getReference();
+ instance.status = base.getStatus();
+ instance.addedByUses = base.isAddedByUses();
+ instance.extension = base.getExtensionDefinition();
+ instance.unknownNodes.addAll(base.getUnknownSchemaNodes());
+ }
+
+ @Override
+ public SchemaPath getPath() {
+ return instance.path;
}
@Override
}
@Override
- public UnknownSchemaNode build(YangNode parent) {
+ public UnknownSchemaNode build() {
if (!isBuilt) {
- instance.setPath(schemaPath);
instance.setNodeType(nodeType);
instance.setNodeParameter(nodeParameter);
- instance.setDescription(description);
- instance.setReference(reference);
- instance.setStatus(status);
- instance.setAddedByUses(addedByUses);
// EXTENSION
if (extensionDefinition != null) {
instance.setExtensionDefinition(extensionDefinition);
} else {
if (extensionBuilder != null) {
- instance.setExtensionDefinition(extensionBuilder.build(null));
+ instance.setExtensionDefinition(extensionBuilder.build());
}
}
// UNKNOWN NODES
for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
- unknownNodes.add(b.build(null));
+ unknownNodes.add(b.build());
}
Collections.sort(unknownNodes, Comparators.SCHEMA_NODE_COMP);
instance.setUnknownSchemaNodes(unknownNodes);
return instance;
}
- public void setQName(QName qname) {
- this.qname = qname;
+ @Override
+ public String getDescription() {
+ return instance.description;
+ }
+
+ @Override
+ public void setDescription(final String description) {
+ instance.description = description;
+ }
+
+ @Override
+ public String getReference() {
+ return instance.reference;
+ }
+
+ @Override
+ public void setReference(final String reference) {
+ instance.reference = reference;
+ }
+
+ @Override
+ public Status getStatus() {
+ return instance.status;
+ }
+
+ @Override
+ public void setStatus(Status status) {
+ if (status != null) {
+ instance.status = status;
+ }
}
public boolean isAddedByUses() {
- return addedByUses;
+ return instance.addedByUses;
}
public void setAddedByUses(final boolean addedByUses) {
- this.addedByUses = addedByUses;
+ instance.addedByUses = addedByUses;
}
public QName getNodeType() {
private final class UnknownSchemaNodeImpl implements UnknownSchemaNode {
private final QName qname;
- private SchemaPath path;
+ private final SchemaPath path;
private ExtensionDefinition extension;
private String description;
private String reference;
private Status status = Status.CURRENT;
- private List<UnknownSchemaNode> unknownNodes = Collections.emptyList();
+ private final List<UnknownSchemaNode> unknownNodes = new ArrayList<>();
private QName nodeType;
private String nodeParameter;
private boolean addedByUses;
- private UnknownSchemaNodeImpl(final QName qname) {
+ private UnknownSchemaNodeImpl(final QName qname, final SchemaPath path) {
this.qname = qname;
+ this.path = path;
}
@Override
return path;
}
- private void setPath(final SchemaPath path) {
- this.path = path;
- }
-
@Override
public ExtensionDefinition getExtensionDefinition() {
return extension;
return description;
}
- private void setDescription(final String description) {
- this.description = description;
- }
-
@Override
public String getReference() {
return reference;
}
- private void setReference(final String reference) {
- this.reference = reference;
- }
-
@Override
public Status getStatus() {
return status;
}
- private void setStatus(final Status status) {
- if (status != null) {
- this.status = status;
- }
- }
-
@Override
public boolean isAddedByUses() {
return addedByUses;
}
- private void setAddedByUses(final boolean addedByUses) {
- this.addedByUses = addedByUses;
- }
-
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
return unknownNodes;
private void setUnknownSchemaNodes(final List<UnknownSchemaNode> unknownNodes) {
if (unknownNodes != null) {
- this.unknownNodes = unknownNodes;
+ this.unknownNodes.addAll(unknownNodes);
}
}
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.UsesNode;
-import org.opendaylight.yangtools.yang.model.api.YangNode;
import org.opendaylight.yangtools.yang.parser.builder.api.AbstractBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.Builder;
}
@Override
- public UsesNode build(YangNode parent) {
+ public UsesNode build() {
if (!isBuilt) {
instance = new UsesNodeImpl(groupingPath);
instance.setAddedByUses(addedByUses);
- instance.setParent(parent);
// AUGMENTATIONS
for (AugmentationSchemaBuilder builder : addedAugments) {
- augments.add(builder.build(instance));
+ augments.add(builder.build());
}
instance.setAugmentations(augments);
// REFINES
final Map<SchemaPath, SchemaNode> refineNodes = new HashMap<>();
for (SchemaNodeBuilder refineBuilder : refineBuilders) {
- SchemaNode refineNode = refineBuilder.build(instance);
+ SchemaNode refineNode = refineBuilder.build();
refineNodes.put(refineNode.getPath(), refineNode);
}
instance.setRefines(refineNodes);
// UNKNOWN NODES
for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
- unknownNodes.add(b.build(instance));
+ unknownNodes.add(b.build());
}
instance.setUnknownSchemaNodes(unknownNodes);
}
public final class UsesNodeImpl implements UsesNode {
- private YangNode parent;
private final SchemaPath groupingPath;
private Set<AugmentationSchema> augmentations = Collections.emptySet();
private boolean addedByUses;
private Map<SchemaPath, SchemaNode> refines = Collections.emptyMap();
private List<UnknownSchemaNode> unknownNodes = Collections.emptyList();
- @Override
- public YangNode getParent() {
- return parent;
- }
-
- private void setParent(YangNode parent) {
- this.parent = parent;
- }
-
private UsesNodeImpl(final SchemaPath groupingPath) {
this.groupingPath = groupingPath;
}
package org.opendaylight.yangtools.yang.parser.impl;
import static org.opendaylight.yangtools.yang.parser.util.ParserUtils.*;
-import static org.opendaylight.yangtools.yang.parser.util.TypeUtils.*;
+import static org.opendaylight.yangtools.yang.parser.util.TypeUtils.resolveType;
+import static org.opendaylight.yangtools.yang.parser.util.TypeUtils.resolveTypeUnion;
+import static org.opendaylight.yangtools.yang.parser.util.TypeUtils.resolveTypeUnionWithContext;
+import static org.opendaylight.yangtools.yang.parser.util.TypeUtils.resolveTypeWithContext;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URI;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Date;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.LinkedHashMap;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
import java.util.Map.Entry;
-import java.util.Set;
-import java.util.TreeMap;
import org.antlr.v4.runtime.ANTLRInputStream;
import org.antlr.v4.runtime.CommonTokenStream;
import org.opendaylight.yangtools.antlrv4.code.gen.YangLexer;
import org.opendaylight.yangtools.antlrv4.code.gen.YangParser;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
-import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
-import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
-import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
-import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.ModuleImport;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.model.api.*;
import org.opendaylight.yangtools.yang.model.parser.api.YangModelParser;
import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.Builder;
import org.opendaylight.yangtools.yang.parser.builder.api.TypeAwareBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceCaseBuilder;
import org.opendaylight.yangtools.yang.parser.builder.impl.DeviationBuilder;
import org.opendaylight.yangtools.yang.parser.builder.impl.ExtensionBuilder;
import org.opendaylight.yangtools.yang.parser.builder.impl.IdentitySchemaNodeBuilder;
}
}
- return new LinkedHashSet<>(buildWithContext(modules, context).values());
+ Collection<Module> built = buildWithContext(modules, context).values();
+ for (Module m : context.getModules()) {
+ if (!built.contains(m)) {
+ built.add(m);
+ }
+ }
+ return new LinkedHashSet<>(built);
}
return Collections.emptySet();
}
Map<ModuleBuilder, InputStream> builderToStreamMap = Maps.newHashMap();
final Map<String, TreeMap<Date, ModuleBuilder>> modules = resolveModuleBuildersWithContext(
yangModelStreams, builderToStreamMap, context);
- return new LinkedHashSet<>(buildWithContext(modules, context).values());
+
+ final Set<Module> built = new LinkedHashSet<>(buildWithContext(modules, context).values());
+ for (Module m : context.getModules()) {
+ if (!built.contains(m)) {
+ built.add(m);
+ }
+ }
+ return built;
}
return Collections.emptySet();
}
resolveUsesTargetGrouping(modules, null);
resolveUsesForGroupings(modules, null);
resolveUsesForNodes(modules, null);
- resolveAugments(modules);
+ resolveAugments(modules, null);
resolveDeviations(modules);
// build
resolveUsesTargetGrouping(modules, context);
resolveUsesForGroupings(modules, context);
resolveUsesForNodes(modules, context);
- resolveAugmentsWithContext(modules, context);
+ resolveAugments(modules, context);
resolveDeviationsWithContext(modules, context);
// build
throw new YangParseException(module.getName(), idref.getLine(), "Failed to find base identity");
}
idref.setBaseIdentity(identity);
- nodeToResolve.setType(idref.build(null));
+ nodeToResolve.setType(idref.build());
} else {
resolveType(nodeToResolve, modules, module);
}
IdentitySchemaNodeBuilder identity = findBaseIdentity(modules, module, idref.getBaseString(),
idref.getLine());
idref.setBaseIdentity(identity);
- nodeToResolve.setType(idref.build(null));
+ nodeToResolve.setType(idref.build());
} else {
resolveTypeWithContext(nodeToResolve, modules, module, context);
}
}
augment.setTargetNodeSchemaPath(new SchemaPath(newPath, augment.getTargetPath().isAbsolute()));
- for (DataSchemaNodeBuilder childNode : augment.getChildNodeBuilders()) {
+ for (DataSchemaNodeBuilder childNode : augment.getChildNodes()) {
correctPathForAugmentNodes(childNode, augment.getTargetNodeSchemaPath());
}
}
private void correctPathForAugmentNodes(DataSchemaNodeBuilder node, SchemaPath parentPath) {
- node.setPath(ParserUtils.createSchemaPath(parentPath, node.getQName()));
+ SchemaPath newPath = ParserUtils.createSchemaPath(parentPath, node.getQName());
+ node.setPath(newPath);
if (node instanceof DataNodeContainerBuilder) {
- for (DataSchemaNodeBuilder child : ((DataNodeContainerBuilder) node).getChildNodeBuilders()) {
+ for (DataSchemaNodeBuilder child : ((DataNodeContainerBuilder) node).getChildNodes()) {
correctPathForAugmentNodes(child, node.getPath());
}
}
- }
-
- /**
- * Go through all augment definitions and perform augmentation. It is
- * expected that modules are already sorted by their dependencies.
- *
- * @param modules
- * all loaded modules
- */
- private void resolveAugments(final Map<String, TreeMap<Date, ModuleBuilder>> modules) {
- // collect augments from all loaded modules
- final List<AugmentationSchemaBuilder> allAugments = new ArrayList<>();
- for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
- for (Map.Entry<Date, ModuleBuilder> inner : entry.getValue().entrySet()) {
- allAugments.addAll(inner.getValue().getAllAugments());
- }
- }
-
- checkAugmentMandatoryNodes(allAugments);
-
- for (int i = 0; i < allAugments.size(); i++) {
- // pick one augment
- final AugmentationSchemaBuilder augment = allAugments.get(i);
- // create collection of others
- List<AugmentationSchemaBuilder> others = new ArrayList<>(allAugments);
- others.remove(augment);
-
- // try to resolve it
- boolean resolved = resolveAugment(modules, augment);
- // while not resolved
- int j = 0;
- while (!(resolved) && j < others.size()) {
- // try to resolve next augment
- resolveAugment(modules, others.get(j));
- // then try to resolve first again
- resolved = resolveAugment(modules, augment);
- j++;
-
- }
-
- if (!resolved) {
- throw new YangParseException(augment.getModuleName(), augment.getLine(),
- "Error in augment parsing: failed to find augment target");
+ if (node instanceof ChoiceBuilder) {
+ for (ChoiceCaseBuilder child : ((ChoiceBuilder)node).getCases()) {
+ correctPathForAugmentNodes(child, node.getPath());
}
}
}
continue;
}
- for (DataSchemaNodeBuilder childNode : augment.getChildNodeBuilders()) {
+ for (DataSchemaNodeBuilder childNode : augment.getChildNodes()) {
if (childNode.getConstraints().isMandatory()) {
throw new YangParseException(augment.getModuleName(), augment.getLine(),
"Error in augment parsing: cannot augment mandatory node "
}
}
- /**
- * Search for augment target and perform augmentation.
- *
- * @param modules
- * all loaded modules
- * @param augment
- * augment to resolve
- * @return true if target node found, false otherwise
- */
- private boolean resolveAugment(final Map<String, TreeMap<Date, ModuleBuilder>> modules,
- final AugmentationSchemaBuilder augment) {
- if (augment.isResolved()) {
- return true;
- }
-
- int line = augment.getLine();
- ModuleBuilder module = getParentModule(augment);
- List<QName> path = augment.getTargetPath().getPath();
- Builder augmentParent = augment.getParent();
-
- Builder firstNodeParent;
- if (augmentParent instanceof ModuleBuilder) {
- // if augment is defined under module, parent of first node is
- // target module
- final QName firstNameInPath = path.get(0);
- String prefix = firstNameInPath.getPrefix();
- if (prefix == null) {
- prefix = module.getPrefix();
- }
- firstNodeParent = findModuleFromBuilders(modules, module, prefix, line);
- } else if (augmentParent instanceof UsesNodeBuilder) {
- firstNodeParent = augmentParent.getParent();
- } else {
- // augment can be defined only under module or uses
- throw new YangParseException(augment.getModuleName(), line,
- "Failed to parse augment: Unresolved parent of augment: " + augmentParent);
- }
-
- return processAugmentation(augment, firstNodeParent);
- }
-
/**
* Go through all augment definitions and resolve them. This method works in
* same way as {@link #resolveAugments(Map)} except that if target node is
* @param context
* SchemaContext containing already resolved modules
*/
- private void resolveAugmentsWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,
- final SchemaContext context) {
- // collect augments from all loaded modules
- final List<AugmentationSchemaBuilder> allAugments = new ArrayList<>();
+ private void resolveAugments(final Map<String, TreeMap<Date, ModuleBuilder>> modules, final SchemaContext context) {
+ List<ModuleBuilder> all = new ArrayList<>();
for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
for (Map.Entry<Date, ModuleBuilder> inner : entry.getValue().entrySet()) {
- allAugments.addAll(inner.getValue().getAllAugments());
+ all.add(inner.getValue());
}
}
- for (int i = 0; i < allAugments.size(); i++) {
- // pick augment from list
- final AugmentationSchemaBuilder augment = allAugments.get(i);
- // try to resolve it
- boolean resolved = resolveAugmentWithContext(modules, augment, context);
- // while not resolved
- int j = i + 1;
- while (!(resolved) && j < allAugments.size()) {
- // try to resolve next augment
- resolveAugmentWithContext(modules, allAugments.get(j), context);
- // then try to resolve first again
- resolved = resolveAugmentWithContext(modules, augment, context);
- j++;
- }
+ List<ModuleBuilder> sorted;
+ if (context == null) {
+ sorted = ModuleDependencySort.sort(all.toArray(new ModuleBuilder[all.size()]));
+ } else {
+ sorted = ModuleDependencySort.sortWithContext(context, all.toArray(new ModuleBuilder[all.size()]));
+ }
+
+ // resolve other augments
+ for (ModuleBuilder mb : sorted) {
+ if (mb != null) {
+ List<AugmentationSchemaBuilder> augments = mb.getAllAugments();
+ checkAugmentMandatoryNodes(augments);
+ for (AugmentationSchemaBuilder augment : augments) {
+ if (!(augment.isResolved())) {
+ boolean resolved = resolveAugment(augment, mb, modules, context);
+ if (!resolved) {
+ throw new YangParseException(augment.getModuleName(), augment.getLine(),
+ "Error in augment parsing: failed to find augment target: " + augment);
- if (!resolved) {
- throw new YangParseException(augment.getModuleName(), augment.getLine(),
- "Error in augment parsing: failed to find augment target");
+ }
+ }
+ }
}
}
}
+ private boolean resolveUsesAugment(final AugmentationSchemaBuilder augment, final ModuleBuilder module,
+ final Map<String, TreeMap<Date, ModuleBuilder>> modules, final SchemaContext context) {
+ if (augment.isResolved()) {
+ return true;
+ }
+
+ UsesNodeBuilder usesNode = (UsesNodeBuilder) augment.getParent();
+ DataNodeContainerBuilder parentNode = usesNode.getParent();
+ SchemaNodeBuilder targetNode;
+ if (parentNode instanceof ModuleBuilder) {
+ targetNode = findSchemaNodeInModule(augment.getTargetPath().getPath(), (ModuleBuilder)parentNode);
+ } else {
+ targetNode = findSchemaNode(augment.getTargetPath().getPath(), (SchemaNodeBuilder)parentNode);
+ }
+
+ fillAugmentTarget(augment, targetNode);
+ augment.setResolved(true);
+ return true;
+ }
+
+ private boolean resolveAugment(final AugmentationSchemaBuilder augment, final ModuleBuilder module,
+ final Map<String, TreeMap<Date, ModuleBuilder>> modules, final SchemaContext context) {
+ if (augment.isResolved()) {
+ return true;
+ }
+
+ List<QName> targetPath = augment.getTargetPath().getPath();
+ ModuleBuilder targetModule = findTargetModule(targetPath.get(0), module, modules, context, augment.getLine());
+ if (targetModule == null) {
+ throw new YangParseException(module.getModuleName(), augment.getLine(), "Failed to resolve augment "
+ + augment);
+ }
+
+ return processAugmentation(augment, targetModule);
+ }
+
/**
- * Search for augment target and perform augmentation.
+ * Find module from loaded modules or from context based on given qname. If
+ * module is found in context, create wrapper over this module and add it to
+ * collection of loaded modules.
*
+ * @param qname
+ * @param module
+ * current module
* @param modules
* all loaded modules
- * @param augment
- * augment to resolve
* @param context
- * SchemaContext containing already resolved modules
- * @return true if target node found, false otherwise
+ * schema context
+ * @param line
+ * current line
+ * @return
*/
- private boolean resolveAugmentWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,
- final AugmentationSchemaBuilder augment, final SchemaContext context) {
- if (augment.isResolved()) {
- return true;
- }
- int line = augment.getLine();
- ModuleBuilder module = getParentModule(augment);
- List<QName> path = augment.getTargetNodeSchemaPath().getPath();
- final QName firstNameInPath = path.get(0);
- String prefix = firstNameInPath.getPrefix();
- if (prefix == null) {
- prefix = module.getPrefix();
- }
- Builder augmentParent = augment.getParent();
- Builder currentParent;
- if (augmentParent instanceof ModuleBuilder) {
- // if augment is defined under module, first parent is target module
- currentParent = findModuleFromBuilders(modules, module, prefix, line);
- } else if (augmentParent instanceof UsesNodeBuilder) {
- currentParent = augmentParent.getParent();
+ private ModuleBuilder findTargetModule(final QName qname, final ModuleBuilder module,
+ final Map<String, TreeMap<Date, ModuleBuilder>> modules, final SchemaContext context, final int line) {
+ ModuleBuilder targetModule = null;
+
+ String prefix = qname.getPrefix();
+ if (prefix == null || prefix.equals("")) {
+ targetModule = module;
} else {
- // augment can be defined only under module or uses
- throw new YangParseException(augment.getModuleName(), augment.getLine(),
- "Error in augment parsing: Unresolved parent of augment: " + augmentParent);
+ targetModule = findModuleFromBuilders(modules, module, qname.getPrefix(), line);
}
- if (currentParent == null) {
- return processAugmentationOnContext(augment, path, module, prefix, context);
- } else {
- return processAugmentation(augment, currentParent);
+ if (targetModule == null && context != null) {
+ Module m = findModuleFromContext(context, module, prefix, line);
+ targetModule = new ModuleBuilder(m);
+ DataSchemaNode firstNode = m.getDataChildByName(qname.getLocalName());
+ DataSchemaNodeBuilder firstNodeWrapped = wrapChildNode(targetModule.getModuleName(), line, firstNode,
+ targetModule.getPath(), firstNode.getQName());
+ targetModule.addChildNode(firstNodeWrapped);
+
+ TreeMap<Date, ModuleBuilder> map = new TreeMap<>();
+ map.put(targetModule.getRevision(), targetModule);
+ modules.put(targetModule.getModuleName(), map);
}
+
+ return targetModule;
}
/**
private void resolveUses(UsesNodeBuilder usesNode,
final Map<String, TreeMap<Date, ModuleBuilder>> modules, final SchemaContext context) {
if (!usesNode.isResolved()) {
- final int line = usesNode.getLine();
DataNodeContainerBuilder parent = usesNode.getParent();
ModuleBuilder module = ParserUtils.getParentModule(parent);
GroupingBuilder target = GroupingUtils.getTargetGroupingFromModules(usesNode, modules, module);
if (target == null) {
- URI ns = null;
- Date rev = null;
- String prefix = null;
- if (parent instanceof AugmentationSchemaBuilder || parent instanceof ModuleBuilder) {
- ns = module.getNamespace();
- rev = module.getRevision();
- prefix = module.getPrefix();
- } else {
- ns = ((DataSchemaNodeBuilder) parent).getQName().getNamespace();
- rev = ((DataSchemaNodeBuilder) parent).getQName().getRevision();
- prefix = ((DataSchemaNodeBuilder) parent).getQName().getPrefix();
- }
-
- Set<DataSchemaNodeBuilder> childNodes = GroupingUtils.getTargetGroupingDefinitionNodesWithNewNamespace(
- usesNode, ns, rev, prefix, module.getName(), line);
- parent.getChildNodeBuilders().addAll(childNodes);
- Set<TypeDefinitionBuilder> typedefs = GroupingUtils
- .getTargetGroupingDefinitionTypedefsWithNewNamespace(usesNode, ns, rev, prefix,
- module.getName(), line);
- parent.getTypeDefinitionBuilders().addAll(typedefs);
- Set<GroupingBuilder> groupings = GroupingUtils.getTargetGroupingDefinitionGroupingsWithNewNamespace(
- usesNode, ns, rev, prefix, module.getName(), line);
- parent.getGroupingBuilders().addAll(groupings);
- List<UnknownSchemaNodeBuilder> unknownNodes = GroupingUtils
- .getTargetGroupingDefinitionUnknownNodesWithNewNamespace(usesNode, ns, rev, prefix,
- module.getName(), line);
- parent.getUnknownNodeBuilders().addAll(unknownNodes);
+ resolveUsesWithContext(usesNode);
usesNode.setResolved(true);
-
for (AugmentationSchemaBuilder augment : usesNode.getAugmentations()) {
- processAugmentationOnContext(augment, augment.getTargetPath().getPath(), module, prefix, context);
+ resolveUsesAugment(augment, module, modules, context);
}
} else {
- parent.getChildNodeBuilders().addAll(target.instantiateChildNodes(parent));
+ parent.getChildNodes().addAll(target.instantiateChildNodes(parent));
parent.getTypeDefinitionBuilders().addAll(target.instantiateTypedefs(parent));
parent.getGroupingBuilders().addAll(target.instantiateGroupings(parent));
- parent.getUnknownNodeBuilders().addAll(target.instantiateUnknownNodes(parent));
+ parent.getUnknownNodes().addAll(target.instantiateUnknownNodes(parent));
usesNode.setResolved(true);
-
for (AugmentationSchemaBuilder augment : usesNode.getAugmentations()) {
- processAugmentation(augment, parent);
+ resolveUsesAugment(augment, module, modules, context);
}
}
GroupingUtils.performRefine(usesNode);
}
}
+ private void resolveUsesWithContext(UsesNodeBuilder usesNode) {
+ final int line = usesNode.getLine();
+ DataNodeContainerBuilder parent = usesNode.getParent();
+ ModuleBuilder module = ParserUtils.getParentModule(parent);
+ SchemaPath parentPath;
+ URI ns = null;
+ Date rev = null;
+ String pref = null;
+ if (parent instanceof AugmentationSchemaBuilder || parent instanceof ModuleBuilder) {
+ ns = module.getNamespace();
+ rev = module.getRevision();
+ pref = module.getPrefix();
+ if (parent instanceof AugmentationSchemaBuilder) {
+ parentPath = ((AugmentationSchemaBuilder)parent).getTargetNodeSchemaPath();
+ } else {
+ parentPath = ((ModuleBuilder)parent).getPath();
+ }
+ } else {
+ ns = ((DataSchemaNodeBuilder) parent).getQName().getNamespace();
+ rev = ((DataSchemaNodeBuilder) parent).getQName().getRevision();
+ pref = ((DataSchemaNodeBuilder) parent).getQName().getPrefix();
+ parentPath = ((DataSchemaNodeBuilder)parent).getPath();
+ }
+
+ GroupingDefinition gd = usesNode.getGroupingDefinition();
+
+ Set<DataSchemaNodeBuilder> childNodes = wrapChildNodes(module.getModuleName(), line,
+ gd.getChildNodes(), parentPath, ns, rev, pref);
+ parent.getChildNodes().addAll(childNodes);
+ for (DataSchemaNodeBuilder childNode : childNodes) {
+ setNodeAddedByUses(childNode);
+ }
+
+ Set<TypeDefinitionBuilder> typedefs = wrapTypedefs(module.getModuleName(), line, gd, parentPath, ns,
+ rev, pref);
+ parent.getTypeDefinitionBuilders().addAll(typedefs);
+ for (TypeDefinitionBuilder typedef : typedefs) {
+ setNodeAddedByUses(typedef);
+ }
+
+ Set<GroupingBuilder> groupings = wrapGroupings(module.getModuleName(), line, usesNode
+ .getGroupingDefinition().getGroupings(), parentPath, ns, rev, pref);
+ parent.getGroupingBuilders().addAll(groupings);
+ for (GroupingBuilder gb : groupings) {
+ setNodeAddedByUses(gb);
+ }
+
+ List<UnknownSchemaNodeBuilder> unknownNodes = wrapUnknownNodes(module.getModuleName(), line,
+ gd.getUnknownSchemaNodes(), parentPath, ns, rev, pref);
+ parent.getUnknownNodes().addAll(unknownNodes);
+ for (UnknownSchemaNodeBuilder un : unknownNodes) {
+ un.setAddedByUses(true);
+ }
+ }
+
private void resolveUnknownNodes(final Map<String, TreeMap<Date, ModuleBuilder>> modules, final ModuleBuilder module) {
for (UnknownSchemaNodeBuilder usnb : module.getAllUnknownNodes()) {
QName nodeType = usnb.getNodeType();
import static org.opendaylight.yangtools.yang.parser.util.ParserListenerUtils.*;
import java.net.URI;
-import java.text.DateFormat;
-import java.text.ParseException;
-import java.text.SimpleDateFormat;
-import java.util.Date;
-import java.util.List;
-import java.util.Stack;
+import java.text.*;
+import java.util.*;
import org.antlr.v4.runtime.tree.ParseTree;
import org.opendaylight.yangtools.antlrv4.code.gen.*;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.util.BaseTypes;
import org.opendaylight.yangtools.yang.model.util.YangTypesConverter;
-import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.api.Builder;
-import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.AnyXmlBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceCaseBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ContainerSchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.DeviationBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ExtensionBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.FeatureBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.IdentitySchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.LeafListSchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.LeafSchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ListSchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ModuleBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.NotificationBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.RpcDefinitionBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.UnionTypeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.UnknownSchemaNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.*;
+import org.opendaylight.yangtools.yang.parser.builder.impl.*;
import org.opendaylight.yangtools.yang.parser.util.RefineHolder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
addNodeToPath(qname);
SchemaPath path = createActualSchemaPath(actualPath.peek());
- ExtensionBuilder builder = moduleBuilder.addExtension(qname, line);
- builder.setPath(path);
+ ExtensionBuilder builder = moduleBuilder.addExtension(qname, line, path);
parseSchemaNodeArgs(ctx, builder);
String argument = null;
addNodeToPath(typedefQName);
SchemaPath path = createActualSchemaPath(actualPath.peek());
- TypeDefinitionBuilder builder = moduleBuilder.addTypedef(line, typedefQName);
- builder.setPath(path);
+ TypeDefinitionBuilder builder = moduleBuilder.addTypedef(line, typedefQName, path);
parseSchemaNodeArgs(ctx, builder);
builder.setUnits(parseUnits(ctx));
builder.setDefaultValue(parseDefault(ctx));
addNodeToPath(groupQName);
SchemaPath path = createActualSchemaPath(actualPath.peek());
- GroupingBuilder builder = moduleBuilder.addGrouping(ctx.getStart().getLine(), groupQName);
- builder.setPath(path);
+ GroupingBuilder builder = moduleBuilder.addGrouping(ctx.getStart().getLine(), groupQName, path);
parseSchemaNodeArgs(ctx, builder);
moduleBuilder.enterNode(builder);
addNodeToPath(choiceQName);
SchemaPath path = createActualSchemaPath(actualPath.peek());
- ChoiceBuilder builder = moduleBuilder.addChoice(line, choiceQName);
- builder.setPath(path);
+ ChoiceBuilder builder = moduleBuilder.addChoice(line, choiceQName, path);
moduleBuilder.enterNode(builder);
parseSchemaNodeArgs(ctx, builder);
addNodeToPath(caseQName);
SchemaPath path = createActualSchemaPath(actualPath.peek());
- ChoiceCaseBuilder builder = moduleBuilder.addCase(line, caseQName);
- builder.setPath(path);
+ ChoiceCaseBuilder builder = moduleBuilder.addCase(line, caseQName, path);
moduleBuilder.enterNode(builder);
parseSchemaNodeArgs(ctx, builder);
addNodeToPath(notificationQName);
SchemaPath path = createActualSchemaPath(actualPath.peek());
- NotificationBuilder builder = moduleBuilder.addNotification(line, notificationQName);
- builder.setPath(path);
+ NotificationBuilder builder = moduleBuilder.addNotification(line, notificationQName, path);
moduleBuilder.enterNode(builder);
parseSchemaNodeArgs(ctx, builder);
qname = new QName(namespace, revision, yangModelPrefix, nodeParameter);
}
- UnknownSchemaNodeBuilder builder = moduleBuilder.addUnknownSchemaNode(line, qname);
+ addNodeToPath(new QName(namespace, revision, yangModelPrefix, nodeParameter));
+ SchemaPath path = createActualSchemaPath(actualPath.peek());
+
+ UnknownSchemaNodeBuilder builder = moduleBuilder.addUnknownSchemaNode(line, qname, path);
builder.setNodeType(nodeType);
builder.setNodeParameter(nodeParameter);
- addNodeToPath(new QName(namespace, revision, yangModelPrefix, nodeParameter));
- SchemaPath path = createActualSchemaPath(actualPath.peek());
- builder.setPath(path);
parseSchemaNodeArgs(ctx, builder);
moduleBuilder.enterNode(builder);
enterLog("rpc", rpcName, line);
QName rpcQName = new QName(namespace, revision, yangModelPrefix, rpcName);
- RpcDefinitionBuilder rpcBuilder = moduleBuilder.addRpc(line, rpcQName);
- moduleBuilder.enterNode(rpcBuilder);
addNodeToPath(rpcQName);
-
SchemaPath path = createActualSchemaPath(actualPath.peek());
- rpcBuilder.setPath(path);
+
+ RpcDefinitionBuilder rpcBuilder = moduleBuilder.addRpc(line, rpcQName, path);
+ moduleBuilder.enterNode(rpcBuilder);
+
parseSchemaNodeArgs(ctx, rpcBuilder);
}
enterLog("feature", featureName, line);
QName featureQName = new QName(namespace, revision, yangModelPrefix, featureName);
- FeatureBuilder featureBuilder = moduleBuilder.addFeature(line, featureQName);
- moduleBuilder.enterNode(featureBuilder);
addNodeToPath(featureQName);
-
SchemaPath path = createActualSchemaPath(actualPath.peek());
- featureBuilder.setPath(path);
+
+ FeatureBuilder featureBuilder = moduleBuilder.addFeature(line, featureQName, path);
+ moduleBuilder.enterNode(featureBuilder);
+
parseSchemaNodeArgs(ctx, featureBuilder);
}
enterLog("identity", identityName, line);
final QName identityQName = new QName(namespace, revision, yangModelPrefix, identityName);
- IdentitySchemaNodeBuilder builder = moduleBuilder.addIdentity(identityQName, line);
- moduleBuilder.enterNode(builder);
addNodeToPath(identityQName);
-
SchemaPath path = createActualSchemaPath(actualPath.peek());
- builder.setPath(path);
+
+ IdentitySchemaNodeBuilder builder = moduleBuilder.addIdentity(identityQName, line, path);
+ moduleBuilder.enterNode(builder);
+
parseSchemaNodeArgs(ctx, builder);
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
-import java.util.Set;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.ChoiceNode;
-import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition;
-import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
-import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.MustDefinition;
-import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
-import org.opendaylight.yangtools.yang.model.util.ExtendedType;
import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.Builder;
import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.SchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.AnyXmlBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.AugmentationSchemaBuilderImpl;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceCaseBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ConstraintsBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ContainerSchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.GroupingBuilderImpl;
-import org.opendaylight.yangtools.yang.parser.builder.impl.IdentityrefTypeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.LeafListSchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.LeafSchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ListSchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ModuleBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.TypeDefinitionBuilderImpl;
-import org.opendaylight.yangtools.yang.parser.builder.impl.UnionTypeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.UnknownSchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.UsesNodeBuilderImpl;
+import org.opendaylight.yangtools.yang.parser.builder.impl.*;
public final class CopyUtils {
AnyXmlBuilder copy = new AnyXmlBuilder(newParent.getModuleName(), newParent.getLine(), newQName, newSchemaPath);
copyConstraints(copy.getConstraints(), old.getConstraints());
copy.setParent(newParent);
- copy.setPath(newSchemaPath);
copy.setDescription(old.getDescription());
copy.setReference(old.getReference());
copy.setStatus(old.getStatus());
copy.setAugmenting(old.isAugmenting());
copy.setAddedByUses(old.isAddedByUses());
copy.setConfiguration(old.isConfiguration());
- for (UnknownSchemaNodeBuilder un : old.getUnknownNodeBuilders()) {
+ for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
copy.addUnknownNodeBuilder((copy(un, copy, updateQName)));
}
QName newQName = data.qname;
SchemaPath newSchemaPath = data.schemaPath;
- ChoiceBuilder copy = new ChoiceBuilder(newParent.getModuleName(), newParent.getLine(), newQName);
+ ChoiceBuilder copy = new ChoiceBuilder(newParent.getModuleName(), newParent.getLine(), newQName, newSchemaPath);
copyConstraints(copy.getConstraints(), old.getConstraints());
copy.setParent(newParent);
- copy.setPath(newSchemaPath);
copy.setDescription(old.getDescription());
copy.setReference(old.getReference());
copy.setStatus(old.getStatus());
for (AugmentationSchemaBuilder augment : old.getAugmentationBuilders()) {
copy.addAugmentation(copyAugment(augment, copy));
}
- for (UnknownSchemaNodeBuilder un : old.getUnknownNodeBuilders()) {
+ for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
copy.addUnknownNodeBuilder((copy(un, copy, updateQName)));
}
QName newQName = data.qname;
SchemaPath newSchemaPath = data.schemaPath;
- ChoiceCaseBuilder copy = new ChoiceCaseBuilder(newParent.getModuleName(), newParent.getLine(), newQName);
+ ChoiceCaseBuilder copy = new ChoiceCaseBuilder(newParent.getModuleName(), newParent.getLine(), newQName, newSchemaPath);
copyConstraints(copy.getConstraints(), old.getConstraints());
copy.setParent(newParent);
- copy.setPath(newSchemaPath);
copy.setDescription(old.getDescription());
copy.setReference(old.getReference());
copy.setStatus(old.getStatus());
copy.setAugmenting(old.isAugmenting());
- copy.getChildNodes().addAll(old.getChildNodes());
- for (DataSchemaNodeBuilder childNode : old.getChildNodeBuilders()) {
+ for (DataSchemaNodeBuilder childNode : old.getChildNodes()) {
copy.addChildNode(copy(childNode, copy, updateQName));
}
copy.getGroupings().addAll(old.getGroupings());
for (UsesNodeBuilder oldUses : old.getUsesNodes()) {
copy.addUsesNode(copyUses(oldUses, copy));
}
- for (UnknownSchemaNodeBuilder un : old.getUnknownNodeBuilders()) {
+ for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
copy.addUnknownNodeBuilder((copy(un, copy, updateQName)));
}
newParent.getLine(), newQName, newSchemaPath);
copyConstraints(copy.getConstraints(), old.getConstraints());
copy.setParent(newParent);
- copy.setPath(newSchemaPath);
copy.setDescription(old.getDescription());
copy.setReference(old.getReference());
copy.setStatus(old.getStatus());
copy.setAugmenting(old.isAugmenting());
copy.setAddedByUses(old.isAddedByUses());
copy.setConfiguration(old.isConfiguration());
- for (DataSchemaNodeBuilder childNode : old.getChildNodeBuilders()) {
+ for (DataSchemaNodeBuilder childNode : old.getChildNodes()) {
copy.addChildNode(copy(childNode, copy, updateQName));
}
copy.getGroupings().addAll(old.getGroupings());
for (AugmentationSchemaBuilder augment : old.getAugmentationBuilders()) {
copy.addAugmentation(copyAugment(augment, copy));
}
- for (UnknownSchemaNodeBuilder un : old.getUnknownNodeBuilders()) {
+ for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
copy.addUnknownNodeBuilder((copy(un, copy, updateQName)));
}
newQName, newSchemaPath);
copyConstraints(copy.getConstraints(), old.getConstraints());
copy.setParent(newParent);
- copy.setPath(newSchemaPath);
copy.setDescription(old.getDescription());
copy.setReference(old.getReference());
copy.setStatus(old.getStatus());
copy.setAugmenting(old.isAugmenting());
copy.setAddedByUses(old.isAddedByUses());
copy.setConfiguration(old.isConfiguration());
- for (UnknownSchemaNodeBuilder un : old.getUnknownNodeBuilders()) {
+ for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
copy.addUnknownNodeBuilder((copy(un, copy, updateQName)));
}
newQName, newSchemaPath);
copyConstraints(copy.getConstraints(), old.getConstraints());
copy.setParent(newParent);
- copy.setPath(newSchemaPath);
copy.setDescription(old.getDescription());
copy.setReference(old.getReference());
copy.setStatus(old.getStatus());
copy.setAugmenting(old.isAugmenting());
copy.setAddedByUses(old.isAddedByUses());
copy.setConfiguration(old.isConfiguration());
- for (UnknownSchemaNodeBuilder un : old.getUnknownNodeBuilders()) {
+ for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
copy.addUnknownNodeBuilder((copy(un, copy, updateQName)));
}
newQName, newSchemaPath);
copyConstraints(copy.getConstraints(), old.getConstraints());
copy.setParent(newParent);
- copy.setPath(newSchemaPath);
copy.setDescription(old.getDescription());
copy.setReference(old.getReference());
copy.setStatus(old.getStatus());
copy.setAugmenting(old.isAugmenting());
copy.setAddedByUses(old.isAddedByUses());
copy.setConfiguration(old.isConfiguration());
- for (DataSchemaNodeBuilder childNode : old.getChildNodeBuilders()) {
+ for (DataSchemaNodeBuilder childNode : old.getChildNodes()) {
copy.addChildNode(copy(childNode, copy, updateQName));
}
copy.getGroupings().addAll(old.getGroupings());
for (AugmentationSchemaBuilder augment : old.getAugmentationBuilders()) {
copy.addAugmentation(copyAugment(augment, copy));
}
- for (UnknownSchemaNodeBuilder un : old.getUnknownNodeBuilders()) {
+ for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
copy.addUnknownNodeBuilder((copy(un, copy, updateQName)));
}
QName newQName = data.qname;
SchemaPath newSchemaPath = data.schemaPath;
- GroupingBuilderImpl copy = new GroupingBuilderImpl(newParent.getModuleName(), newParent.getLine(), newQName);
+ GroupingBuilderImpl copy = new GroupingBuilderImpl(newParent.getModuleName(), newParent.getLine(), newQName, newSchemaPath);
copy.setParent(newParent);
- copy.setPath(newSchemaPath);
copy.setDescription(old.getDescription());
copy.setReference(old.getReference());
copy.setStatus(old.getStatus());
copy.setAddedByUses(old.isAddedByUses());
- for (DataSchemaNodeBuilder childNode : old.getChildNodeBuilders()) {
+ for (DataSchemaNodeBuilder childNode : old.getChildNodes()) {
copy.addChildNode(copy(childNode, copy, updateQName));
}
copy.getGroupings().addAll(old.getGroupings());
for (UsesNodeBuilder oldUses : old.getUsesNodes()) {
copy.addUsesNode(copyUses(oldUses, copy));
}
- for (UnknownSchemaNodeBuilder un : old.getUnknownNodeBuilders()) {
+ for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
copy.addUnknownNodeBuilder((copy(un, copy, updateQName)));
}
type = new IdentityrefTypeBuilder(newParent.getModuleName(), newParent.getLine(),
((IdentityrefTypeBuilder) old).getBaseString(), newSchemaPath);
type.setParent(newParent);
- type.setPath(newSchemaPath);
} else {
- type = new TypeDefinitionBuilderImpl(old.getModuleName(), newParent.getLine(), newQName);
+ type = new TypeDefinitionBuilderImpl(old.getModuleName(), newParent.getLine(), newQName, old.getPath());
type.setParent(newParent);
- // TODO
- // type.setPath(newSchemaPath);
- type.setPath(old.getPath());
if (old.getType() == null) {
type.setTypedef(copy(old.getTypedef(), type, updateQName));
type.setType(old.getType());
}
- for (UnknownSchemaNodeBuilder un : old.getUnknownNodeBuilders()) {
+ for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
type.addUnknownNodeBuilder((copy(un, type, updateQName)));
}
copy.setStatus(old.getStatus());
copy.addWhenCondition(old.getWhenCondition());
copy.setTargetNodeSchemaPath(old.getTargetNodeSchemaPath());
- for (DataSchemaNodeBuilder childNode : old.getChildNodeBuilders()) {
+ for (DataSchemaNodeBuilder childNode : old.getChildNodes()) {
copy.addChildNode(copy(childNode, copy, false));
}
for (UsesNodeBuilder oldUses : old.getUsesNodes()) {
copy.addUsesNode(copyUses(oldUses, copy));
}
- for (UnknownSchemaNodeBuilder un : old.getUnknownNodeBuilders()) {
+ for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
copy.addUnknownNodeBuilder((copy(un, copy, false)));
}
SchemaPath newSchemaPath = data.schemaPath;
UnknownSchemaNodeBuilder c = new UnknownSchemaNodeBuilder(newParent.getModuleName(), newParent.getLine(),
- newQName);
+ newQName, newSchemaPath);
c.setParent(newParent);
- c.setPath(newSchemaPath);
c.setDescription(old.getDescription());
c.setReference(old.getReference());
c.setStatus(old.getStatus());
c.setAddedByUses(old.isAddedByUses());
- for (UnknownSchemaNodeBuilder un : old.getUnknownNodeBuilders()) {
+ for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
c.addUnknownNodeBuilder((copy(un, c, updateQName)));
}
}
}
- /**
- * Create AnyXmlBuilder from given AnyXmlSchemaNode.
- *
- * @param anyxml
- * base anyxml
- * @param qname
- * new qname
- * @param moduleName
- * current module name
- * @param line
- * current line in module
- * @return anyxml builder based on given anyxml node
- */
- public static AnyXmlBuilder createAnyXml(AnyXmlSchemaNode anyxml, QName qname, String moduleName, int line) {
- final AnyXmlBuilder builder = new AnyXmlBuilder(moduleName, line, qname, anyxml.getPath());
- convertDataSchemaNode(anyxml, builder);
- builder.setConfiguration(anyxml.isConfiguration());
- builder.setUnknownNodes(anyxml.getUnknownSchemaNodes());
- return builder;
- }
-
- /**
- * Create GroupingBuilder from given GroupingDefinition.
- *
- * @param grouping
- * base grouping
- * @param qname
- * new qname
- * @param moduleName
- * current module name
- * @param line
- * current line in module
- * @return grouping builder based on given grouping node
- */
- public static GroupingBuilder createGrouping(GroupingDefinition grouping, QName qname, String moduleName, int line) {
- final GroupingBuilderImpl builder = new GroupingBuilderImpl(moduleName, line, qname);
- builder.setPath(grouping.getPath());
- for (DataSchemaNode child : grouping.getChildNodes()) {
- builder.addChildNode(child);
- }
- builder.setGroupings(grouping.getGroupings());
- builder.setTypedefs(grouping.getTypeDefinitions());
- builder.setUsesnodes(grouping.getUses());
- builder.setUnknownNodes(grouping.getUnknownSchemaNodes());
- builder.setDescription(grouping.getDescription());
- builder.setReference(grouping.getReference());
- builder.setStatus(grouping.getStatus());
- return builder;
- }
-
- /**
- * Create TypeDefinitionBuilder from given ExtendedType.
- *
- * @param typedef
- * base typedef
- * @param qname
- * new qname
- * @param moduleName
- * current module name
- * @param line
- * current line in module
- * @return typedef builder based on given typedef node
- */
- public static TypeDefinitionBuilder createTypedef(ExtendedType typedef, QName qname, String moduleName, int line) {
- final TypeDefinitionBuilderImpl builder = new TypeDefinitionBuilderImpl(moduleName, line, qname);
- builder.setPath(typedef.getPath());
- builder.setDefaultValue(typedef.getDefaultValue());
- builder.setUnits(typedef.getUnits());
- builder.setDescription(typedef.getDescription());
- builder.setReference(typedef.getReference());
- builder.setStatus(typedef.getStatus());
- builder.setRanges(typedef.getRangeConstraints());
- builder.setLengths(typedef.getLengthConstraints());
- builder.setPatterns(typedef.getPatternConstraints());
- builder.setFractionDigits(typedef.getFractionDigits());
- final TypeDefinition<?> type = typedef.getBaseType();
- builder.setType(type);
- builder.setUnits(typedef.getUnits());
- builder.setUnknownNodes(typedef.getUnknownSchemaNodes());
- return builder;
- }
-
- /**
- * Create UnknownSchemaNodeBuilder from given UnknownSchemaNode.
- *
- * @param unknownNode
- * base unknown node
- * @param qname
- * new qname
- * @param moduleName
- * current module name
- * @param line
- * current line in module
- * @return unknown node builder based on given unknown node
- */
- public static UnknownSchemaNodeBuilder createUnknownSchemaNode(UnknownSchemaNode unknownNode, QName qname,
- String moduleName, int line) {
- final UnknownSchemaNodeBuilder builder = new UnknownSchemaNodeBuilder(moduleName, line, qname);
- builder.setPath(unknownNode.getPath());
- builder.setUnknownNodes(unknownNode.getUnknownSchemaNodes());
- builder.setDescription(unknownNode.getDescription());
- builder.setReference(unknownNode.getReference());
- builder.setStatus(unknownNode.getStatus());
- builder.setAddedByUses(unknownNode.isAddedByUses());
- builder.setNodeType(unknownNode.getNodeType());
- builder.setNodeParameter(unknownNode.getNodeParameter());
- return builder;
- }
-
- /**
- * Create LeafSchemaNodeBuilder from given LeafSchemaNode.
- *
- * @param leaf
- * leaf from which to create builder
- * @param qname
- * new qname
- * @param moduleName
- * current module name
- * @param line
- * line in module
- * @return leaf builder based on given leaf node
- */
- public static LeafSchemaNodeBuilder createLeafBuilder(LeafSchemaNode leaf, QName qname, String moduleName, int line) {
- final LeafSchemaNodeBuilder builder = new LeafSchemaNodeBuilder(moduleName, line, qname, leaf.getPath());
- convertDataSchemaNode(leaf, builder);
- builder.setConfiguration(leaf.isConfiguration());
- final TypeDefinition<?> type = leaf.getType();
- builder.setType(type);
- builder.setPath(leaf.getPath());
- builder.setUnknownNodes(leaf.getUnknownSchemaNodes());
- builder.setDefaultStr(leaf.getDefault());
- builder.setUnits(leaf.getUnits());
- return builder;
- }
-
- /**
- * Create ContainerSchemaNodeBuilder from given ContainerSchemaNode.
- *
- * @param container
- * base container
- * @param qname
- * new qname
- * @param moduleName
- * current module name
- * @param line
- * current line in module
- * @return container builder based on given container node
- */
- public static ContainerSchemaNodeBuilder createContainer(ContainerSchemaNode container, QName qname,
- String moduleName, int line) {
- final ContainerSchemaNodeBuilder builder = new ContainerSchemaNodeBuilder(moduleName, line, qname,
- container.getPath());
- convertDataSchemaNode(container, builder);
- builder.setConfiguration(container.isConfiguration());
- builder.setUnknownNodes(container.getUnknownSchemaNodes());
- for (DataSchemaNode child : container.getChildNodes()) {
- builder.addChildNode(child);
- }
- builder.setGroupings(container.getGroupings());
- builder.setTypedefs(container.getTypeDefinitions());
- builder.getAugmentations().addAll(container.getAvailableAugmentations());
- builder.setUsesnodes(container.getUses());
- builder.setPresence(container.isPresenceContainer());
- return builder;
- }
-
- /**
- * Create ListSchemaNodeBuilder from given ListSchemaNode.
- *
- * @param list
- * base list
- * @param qname
- * new qname
- * @param moduleName
- * current module name
- * @param line
- * current line in module
- * @return list builder based on given list node
- */
- public static ListSchemaNodeBuilder createList(ListSchemaNode list, QName qname, String moduleName, int line) {
- ListSchemaNodeBuilder builder = new ListSchemaNodeBuilder(moduleName, line, qname, list.getPath());
- convertDataSchemaNode(list, builder);
- builder.setConfiguration(list.isConfiguration());
- builder.setUnknownNodes(list.getUnknownSchemaNodes());
- builder.setTypedefs(list.getTypeDefinitions());
- for (DataSchemaNode child : list.getChildNodes()) {
- builder.addChildNode(child);
- }
- builder.setGroupings(list.getGroupings());
- builder.getAugmentations().addAll(list.getAvailableAugmentations());
- builder.setUsesnodes(list.getUses());
- builder.setUserOrdered(builder.isUserOrdered());
- return builder;
- }
-
- /**
- * Create LeafListSchemaNodeBuilder from given LeafListSchemaNode.
- *
- * @param leafList
- * base leaf-list
- * @param qname
- * new qname
- * @param moduleName
- * current module name
- * @param line
- * current line in module
- * @return leaf-list builder based on given leaf-list node
- */
- public static LeafListSchemaNodeBuilder createLeafList(LeafListSchemaNode leafList, QName qname, String moduleName,
- int line) {
- final LeafListSchemaNodeBuilder builder = new LeafListSchemaNodeBuilder(moduleName, line, qname,
- leafList.getPath());
- convertDataSchemaNode(leafList, builder);
- builder.setConfiguration(leafList.isConfiguration());
- builder.setType(leafList.getType());
- builder.setUnknownNodes(leafList.getUnknownSchemaNodes());
- builder.setUserOrdered(leafList.isUserOrdered());
- return builder;
- }
-
- /**
- * Create ChoiceBuilder from given ChoiceNode.
- *
- * @param choice
- * base choice
- * @param qname
- * new qname
- * @param moduleName
- * current module name
- * @param line
- * current line in module
- * @return choice builder based on given choice node
- */
- public static ChoiceBuilder createChoice(ChoiceNode choice, QName qname, String moduleName, int line) {
- final ChoiceBuilder builder = new ChoiceBuilder(moduleName, line, qname);
- convertDataSchemaNode(choice, builder);
- builder.setConfiguration(choice.isConfiguration());
- builder.setCases(choice.getCases());
- builder.setUnknownNodes(choice.getUnknownSchemaNodes());
- builder.setDefaultCase(choice.getDefaultCase());
- return builder;
- }
-
- /**
- * Set DataSchemaNode arguments to builder object
- *
- * @param node
- * node from which arguments should be read
- * @param builder
- * builder to which arguments should be set
- */
- private static void convertDataSchemaNode(DataSchemaNode node, DataSchemaNodeBuilder builder) {
- builder.setPath(node.getPath());
- builder.setDescription(node.getDescription());
- builder.setReference(node.getReference());
- builder.setStatus(node.getStatus());
- builder.setAugmenting(node.isAugmenting());
- copyConstraintsFromDefinition(node.getConstraints(), builder.getConstraints());
- }
-
- /**
- * Copy constraints from constraints definition to constraints builder.
- *
- * @param nodeConstraints
- * definition from which constraints will be copied
- * @param constraints
- * builder to which constraints will be added
- */
- private static void copyConstraintsFromDefinition(final ConstraintDefinition nodeConstraints,
- final ConstraintsBuilder constraints) {
- final RevisionAwareXPath when = nodeConstraints.getWhenCondition();
- final Set<MustDefinition> must = nodeConstraints.getMustConstraints();
-
- if (when != null) {
- constraints.addWhenCondition(when.toString());
- }
- if (must != null) {
- for (MustDefinition md : must) {
- constraints.addMustDefinition(md);
- }
- }
- constraints.setMandatory(nodeConstraints.isMandatory());
- constraints.setMinElements(nodeConstraints.getMinElements());
- constraints.setMaxElements(nodeConstraints.getMaxElements());
- }
-
}
*/
package org.opendaylight.yangtools.yang.parser.util;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
+import java.util.*;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.api.DataNodeContainerBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.*;
import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceBuilder;
import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceCaseBuilder;
import org.opendaylight.yangtools.yang.parser.util.TopologicalSort.Node;
final NodeWrappedType nodeWrappedType = (NodeWrappedType) node;
final GroupingBuilder groupingDefinition = (GroupingBuilder) nodeWrappedType.getWrappedType();
- if (groupingDefinition.getQName().getLocalName().equals("rp-object")) {
- System.out.println();
- }
-
Set<UsesNodeBuilder> usesNodes = getAllUsesNodes(groupingDefinition);
for (UsesNodeBuilder usesNode : usesNodes) {
SchemaPath schemaPath = usesNode.getGroupingBuilder().getPath();
for (GroupingBuilder groupingDefinition : groupings) {
ret.addAll(getAllUsesNodes(groupingDefinition));
}
- Set<DataSchemaNodeBuilder> childNodes = container.getChildNodeBuilders();
+ Set<DataSchemaNodeBuilder> childNodes = container.getChildNodes();
for (DataSchemaNodeBuilder childNode : childNodes) {
if (childNode instanceof DataNodeContainerBuilder) {
ret.addAll(getAllUsesNodes((DataNodeContainerBuilder) childNode));
*/
package org.opendaylight.yangtools.yang.parser.util;
-import java.net.URI;
-import java.util.ArrayList;
import java.util.Comparator;
import java.util.Date;
-import java.util.HashSet;
-import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.ChoiceNode;
-import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
-import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
-import org.opendaylight.yangtools.yang.model.util.ExtendedType;
import org.opendaylight.yangtools.yang.parser.builder.api.Builder;
import org.opendaylight.yangtools.yang.parser.builder.api.DataNodeContainerBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.api.GroupingMember;
-import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceBuilder;
import org.opendaylight.yangtools.yang.parser.builder.impl.ModuleBuilder;
import org.opendaylight.yangtools.yang.parser.builder.impl.RpcDefinitionBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.UnknownSchemaNodeBuilder;
public final class GroupingUtils {
return null;
}
- /**
- * Read data defined in target grouping definition, make a copy and add them
- * to uses node builder.
- *
- * @param usesNode
- * used node builder to which are copied nodes from its
- * <code>GroupingDefinition</code>
- * @param namespace
- * URI with parent namespace
- * @param revision
- * date with parent revision date
- * @param prefix
- * string with parent prefix
- * @param moduleName
- * string with parent module name
- * @param line
- * line from YANG file where parent node is defined
- */
- public static Set<DataSchemaNodeBuilder> getTargetGroupingDefinitionNodesWithNewNamespace(
- final UsesNodeBuilder usesNode, final URI namespace, final Date revision, final String prefix,
- final String moduleName, final int line) {
- final Set<DataSchemaNodeBuilder> newChildren = new HashSet<>();
- for (DataSchemaNode child : usesNode.getGroupingDefinition().getChildNodes()) {
- if (child != null) {
- DataSchemaNodeBuilder newChild = null;
- QName newQName = new QName(namespace, revision, prefix, child.getQName().getLocalName());
- if (child instanceof AnyXmlSchemaNode) {
- newChild = CopyUtils.createAnyXml((AnyXmlSchemaNode) child, newQName, moduleName, line);
- } else if (child instanceof ChoiceNode) {
- newChild = CopyUtils.createChoice((ChoiceNode) child, newQName, moduleName, line);
- } else if (child instanceof ContainerSchemaNode) {
- newChild = CopyUtils.createContainer((ContainerSchemaNode) child, newQName, moduleName, line);
- } else if (child instanceof LeafListSchemaNode) {
- newChild = CopyUtils.createLeafList((LeafListSchemaNode) child, newQName, moduleName, line);
- } else if (child instanceof LeafSchemaNode) {
- newChild = CopyUtils.createLeafBuilder((LeafSchemaNode) child, newQName, moduleName, line);
- } else if (child instanceof ListSchemaNode) {
- newChild = CopyUtils.createList((ListSchemaNode) child, newQName, moduleName, line);
- }
-
- if (newChild == null) {
- throw new YangParseException(moduleName, line,
- "Unknown member of target grouping while resolving uses node.");
- }
-
- ((GroupingMember) newChild).setAddedByUses(true);
- newChildren.add(newChild);
- }
- }
- return newChildren;
- }
-
- public static Set<TypeDefinitionBuilder> getTargetGroupingDefinitionTypedefsWithNewNamespace(
- UsesNodeBuilder usesNode, URI namespace, Date revision, String prefix, String moduleName, int line) {
- final Set<TypeDefinitionBuilder> newTypedefs = new HashSet<>();
- for (TypeDefinition<?> td : usesNode.getGroupingDefinition().getTypeDefinitions()) {
- QName newQName = new QName(namespace, revision, prefix, td.getQName().getLocalName());
- TypeDefinitionBuilder newType = CopyUtils.createTypedef((ExtendedType) td, newQName, moduleName, line);
- newType.setAddedByUses(true);
- newTypedefs.add(newType);
- }
- return newTypedefs;
- }
-
- public static Set<GroupingBuilder> getTargetGroupingDefinitionGroupingsWithNewNamespace(UsesNodeBuilder usesNode,
- URI namespace, Date revision, String prefix, String moduleName, int line) {
- final Set<GroupingBuilder> newGroupings = new HashSet<>();
- for (GroupingDefinition g : usesNode.getGroupingDefinition().getGroupings()) {
- QName newQName = new QName(namespace, revision, prefix, g.getQName().getLocalName());
- GroupingBuilder newGrouping = CopyUtils.createGrouping(g, newQName, moduleName, line);
- newGrouping.setAddedByUses(true);
- newGroupings.add(newGrouping);
- }
- return newGroupings;
- }
-
- public static List<UnknownSchemaNodeBuilder> getTargetGroupingDefinitionUnknownNodesWithNewNamespace(
- UsesNodeBuilder usesNode, URI namespace, Date revision, String prefix, String moduleName, int line) {
- final List<UnknownSchemaNodeBuilder> newUnknownNodes = new ArrayList<>();
- for (UnknownSchemaNode un : usesNode.getGroupingDefinition().getUnknownSchemaNodes()) {
- QName newQName = new QName(namespace, revision, prefix, un.getQName().getLocalName());
- UnknownSchemaNodeBuilder newNode = CopyUtils.createUnknownSchemaNode(un, newQName, moduleName, line);
- newNode.setAddedByUses(true);
- newUnknownNodes.add(newNode);
- }
- return newUnknownNodes;
- }
-
/**
* Perform refinement of uses target grouping nodes. Uses process has to be
* already performed.
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ChoiceNode;
-import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.ModuleImport;
-import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationTargetBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.SchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceBuilder.ChoiceNodeImpl;
import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceCaseBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceCaseBuilder.ChoiceCaseNodeImpl;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ContainerSchemaNodeBuilder.ContainerSchemaNodeImpl;
import org.opendaylight.yangtools.yang.parser.builder.impl.IdentitySchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ListSchemaNodeBuilder.ListSchemaNodeImpl;
import org.opendaylight.yangtools.yang.parser.builder.impl.ModuleBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.NotificationBuilder.NotificationDefinitionImpl;
-import org.opendaylight.yangtools.yang.model.api.AugmentationTarget
import org.opendaylight.yangtools.yang.parser.builder.impl.RpcDefinitionBuilder
import org.opendaylight.yangtools.yang.parser.builder.api.GroupingMember
+import org.opendaylight.yangtools.yang.model.api.DataSchemaNode
+import java.util.HashSet
+import java.net.URI
+import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode
+import org.opendaylight.yangtools.yang.parser.builder.impl.AnyXmlBuilder
+import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode
+import org.opendaylight.yangtools.yang.model.api.ListSchemaNode
+import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode
+import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode
+import org.opendaylight.yangtools.yang.parser.builder.impl.ContainerSchemaNodeBuilder
+import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode
+import org.opendaylight.yangtools.yang.parser.builder.impl.ListSchemaNodeBuilder
+import org.opendaylight.yangtools.yang.parser.builder.impl.LeafListSchemaNodeBuilder
+import org.opendaylight.yangtools.yang.parser.builder.impl.LeafSchemaNodeBuilder
+import org.opendaylight.yangtools.yang.model.api.GroupingDefinition
+import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder
+import org.opendaylight.yangtools.yang.parser.builder.impl.GroupingBuilderImpl
+import org.opendaylight.yangtools.yang.model.api.TypeDefinition
+import org.opendaylight.yangtools.yang.parser.builder.impl.TypeDefinitionBuilderImpl
+import org.opendaylight.yangtools.yang.model.util.ExtendedType
+import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder
+import org.opendaylight.yangtools.yang.parser.builder.impl.UnknownSchemaNodeBuilder
+import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode
+import org.opendaylight.yangtools.yang.model.api.DataNodeContainer
public final class ParserUtils {
public static def Module findModuleFromContext(SchemaContext context, ModuleBuilder currentModule,
String prefix, int line) {
if (context === null) {
- throw new YangParseException(currentModule.getName(), line, "Cannot find module with prefix '" + prefix + "'.");
+ throw new YangParseException(currentModule.getName(), line,
+ "Cannot find module with prefix '" + prefix + "'.");
}
val modulesByRevision = new TreeMap<Date, Module>();
return new SchemaPath(path, absolute);
}
+ public static def dispatch fillAugmentTarget(AugmentationSchemaBuilder augment, Builder target) {
+ }
+
/**
* Add all augment's child nodes to given target.
*
* @param target
* augmentation target node
*/
- public static def void fillAugmentTarget(AugmentationSchemaBuilder augment, DataNodeContainerBuilder target) {
- for (DataSchemaNodeBuilder child : augment.getChildNodeBuilders()) {
+ public static def dispatch fillAugmentTarget(AugmentationSchemaBuilder augment, DataNodeContainerBuilder target) {
+ for (DataSchemaNodeBuilder child : augment.getChildNodes()) {
val childCopy = CopyUtils.copy(child, target, false);
if (augment.parent instanceof UsesNodeBuilder) {
setNodeAddedByUses(childCopy);
}
setNodeAugmenting(childCopy);
- correctNodePath(child, target.getPath());
- correctNodePath(childCopy, target.getPath());
try {
target.addChildNode(childCopy);
} catch (YangParseException e) {
+
// more descriptive message
throw new YangParseException(augment.getModuleName(), augment.getLine(),
"Failed to perform augmentation: " + e.getMessage());
}
}
- private static def void setNodeAugmenting(DataSchemaNodeBuilder child) {
- child.setAugmenting(true);
- if (child instanceof DataNodeContainerBuilder) {
- val DataNodeContainerBuilder dataNodeChild = child as DataNodeContainerBuilder;
- for (inner : dataNodeChild.getChildNodeBuilders()) {
- setNodeAugmenting(inner);
- }
- } else if (child instanceof ChoiceBuilder) {
- val ChoiceBuilder choiceChild = child as ChoiceBuilder;
- for (inner : choiceChild.cases) {
- setNodeAugmenting(inner);
- }
- }
- }
-
- public static def void setNodeAddedByUses(GroupingMember child) {
- child.setAddedByUses(true);
- if (child instanceof DataNodeContainerBuilder) {
- val DataNodeContainerBuilder dataNodeChild = child as DataNodeContainerBuilder;
- for (inner : dataNodeChild.getChildNodeBuilders()) {
- setNodeAddedByUses(inner);
- }
- } else if (child instanceof ChoiceBuilder) {
- val ChoiceBuilder choiceChild = child as ChoiceBuilder;
- for (inner : choiceChild.cases) {
- setNodeAddedByUses(inner);
- }
- }
- }
-
/**
* Add all augment's child nodes to given target.
*
* @param target
* augmentation target choice node
*/
- public static def void fillAugmentTarget(AugmentationSchemaBuilder augment, ChoiceBuilder target) {
- for (DataSchemaNodeBuilder builder : augment.getChildNodeBuilders()) {
+ public static def dispatch fillAugmentTarget(AugmentationSchemaBuilder augment, ChoiceBuilder target) {
+ for (DataSchemaNodeBuilder builder : augment.getChildNodes()) {
val childCopy = CopyUtils.copy(builder, target, false);
if (augment.parent instanceof UsesNodeBuilder) {
setNodeAddedByUses(childCopy);
}
setNodeAugmenting(childCopy)
- correctNodePath(builder, target.getPath());
- correctNodePath(childCopy, target.getPath());
target.addCase(childCopy);
}
for (UsesNodeBuilder usesNode : augment.getUsesNodes()) {
}
/**
- * Create new schema path of node based on parent node schema path.
- *
- * @param node
- * node to correct
- * @param parentSchemaPath
- * schema path of node parent
+ * Set augmenting flag to true for node and all its child nodes.
*/
- static def void correctNodePath(SchemaNodeBuilder node, SchemaPath parentSchemaPath) {
- // set correct path
- val targetNodePath = new ArrayList<QName>(parentSchemaPath.getPath());
- targetNodePath.add(node.getQName());
- node.setPath(new SchemaPath(targetNodePath, true));
-
- // set correct path for all child nodes
- if (node instanceof DataNodeContainerBuilder) {
- val dataNodeContainer = node as DataNodeContainerBuilder;
- for (DataSchemaNodeBuilder child : dataNodeContainer.getChildNodeBuilders()) {
- correctNodePath(child, node.getPath());
+ private static def void setNodeAugmenting(DataSchemaNodeBuilder child) {
+ child.setAugmenting(true);
+ if (child instanceof DataNodeContainerBuilder) {
+ val DataNodeContainerBuilder dataNodeChild = child as DataNodeContainerBuilder;
+ for (inner : dataNodeChild.getChildNodes()) {
+ setNodeAugmenting(inner);
+ }
+ } else if (child instanceof ChoiceBuilder) {
+ val ChoiceBuilder choiceChild = child as ChoiceBuilder;
+ for (inner : choiceChild.cases) {
+ setNodeAugmenting(inner);
}
}
+ }
- // set correct path for all cases
- if (node instanceof ChoiceBuilder) {
- val choiceBuilder = node as ChoiceBuilder;
- for (ChoiceCaseBuilder choiceCaseBuilder : choiceBuilder.getCases()) {
- correctNodePath(choiceCaseBuilder, node.getPath());
+ /**
+ * Set addedByUses flag to true for node and all its child nodes.
+ */
+ public static def void setNodeAddedByUses(GroupingMember child) {
+ child.setAddedByUses(true);
+ if (child instanceof DataNodeContainerBuilder) {
+ val DataNodeContainerBuilder dataNodeChild = child as DataNodeContainerBuilder;
+ for (inner : dataNodeChild.getChildNodes()) {
+ setNodeAddedByUses(inner);
+ }
+ } else if (child instanceof ChoiceBuilder) {
+ val ChoiceBuilder choiceChild = child as ChoiceBuilder;
+ for (inner : choiceChild.cases) {
+ setNodeAddedByUses(inner);
}
}
}
-
- private static def Builder findNode(Builder firstNodeParent, List<QName> path, String moduleName, int line) {
- var currentName = "";
- var currentParent = firstNodeParent;
-
- val max = path.size();
- var i = 0;
- while(i < max) {
- var qname = path.get(i);
-
- currentName = qname.getLocalName();
- if (currentParent instanceof DataNodeContainerBuilder) {
- var dataNodeContainerParent = currentParent as DataNodeContainerBuilder;
- var SchemaNodeBuilder nodeFound = dataNodeContainerParent.getDataChildByName(currentName);
- // if not found, search in notifications
- if (nodeFound == null && currentParent instanceof ModuleBuilder) {
- nodeFound = searchNotifications(currentParent as ModuleBuilder, currentName);
- }
- // if not found, search in rpcs
- if (nodeFound == null && currentParent instanceof ModuleBuilder) {
- nodeFound = searchRpcs(currentParent as ModuleBuilder, currentName);
- }
- if (nodeFound == null) {
- return null
+ public static def DataSchemaNodeBuilder findSchemaNode(List<QName> path, SchemaNodeBuilder parentNode) {
+ var DataSchemaNodeBuilder node
+ var SchemaNodeBuilder parent = parentNode
+ var int i = 0;
+ while (i < path.size) {
+ val String name = path.get(i).localName
+ if (parent instanceof DataNodeContainerBuilder) {
+ node = (parent as DataNodeContainerBuilder).getDataChildByName(name)
+ } else if (parent instanceof ChoiceBuilder) {
+ node = (parent as ChoiceBuilder).getCaseNodeByName(name)
+ } else if (parent instanceof RpcDefinitionBuilder) {
+ if ("input".equals(name)) {
+ node = (parent as RpcDefinitionBuilder).input
+ } else if ("output".equals(name)) {
+ node = (parent as RpcDefinitionBuilder).output
} else {
- currentParent = nodeFound
- }
- } else if (currentParent instanceof ChoiceBuilder) {
- val choiceParent = currentParent as ChoiceBuilder;
- currentParent = choiceParent.getCaseNodeByName(currentName);
- } else if (currentParent instanceof RpcDefinitionBuilder) {
- val rpc = currentParent as RpcDefinitionBuilder;
- if ("input".equals(currentName)) {
- currentParent = rpc.input;
- } else if ("output".equals(currentName)) {
- currentParent = rpc.output;
+ return null
}
} else {
- throw new YangParseException(moduleName, line,
- "Error in augment parsing: failed to find node " + currentName);
+ return null
}
- // if node in path not found, return null
- if (currentParent == null) {
- return null;
+ if (i < path.size - 1) {
+ parent = node
}
- i = i + 1;
+ i = i + 1
}
- return currentParent;
+
+ return node
}
- private static def searchNotifications(ModuleBuilder parent, String name) {
- for(notification : parent.notifications) {
- if(notification.getQName().localName.equals(name)) {
- return notification;
+ public static def SchemaNodeBuilder findSchemaNodeInModule(List<QName> pathToNode, ModuleBuilder module) {
+ val List<QName> path = new ArrayList(pathToNode)
+ val QName first = path.remove(0)
+
+ var SchemaNodeBuilder node = module.getDataChildByName(first.localName)
+ if (node == null) {
+ val notifications = module.notifications
+ for (notification : notifications) {
+ if (notification.QName.localName.equals(first.localName)) {
+ node = notification
+ }
}
}
- return null;
- }
-
- private static def searchRpcs(ModuleBuilder parent, String name) {
- for(rpc : parent.rpcs) {
- if(rpc.getQName().localName.equals(name)) {
- return rpc;
+ if (node == null) {
+ val rpcs = module.rpcs
+ for (rpc : rpcs) {
+ if (rpc.QName.localName.equals(first.localName)) {
+ node = rpc
+ }
}
}
- return null;
- }
+ if (node == null) {
+ return null;
+ }
+
+ if (!path.empty) {
+ node = findSchemaNode(path, node)
+ }
- private static def nextLevel(List<QName> path){
- return path.subList(1,path.size)
+ return node
}
-
+
/**
* Find augment target node and perform augmentation.
*
* path to augment target
* @return true if augmentation process succeed, false otherwise
*/
- public static def boolean processAugmentation(AugmentationSchemaBuilder augment, Builder firstNodeParent) {
+ public static def boolean processAugmentation(AugmentationSchemaBuilder augment, ModuleBuilder firstNodeParent) {
val path = augment.targetPath.path
- // traverse augment target path and try to reach target node
- val targetNode = findNode(firstNodeParent, path, augment.moduleName, augment.line);
+ var Builder targetNode = findSchemaNodeInModule(path, firstNodeParent as ModuleBuilder)
if(targetNode === null) return false;
if ((targetNode instanceof DataNodeContainerBuilder)) {
val targetDataNodeContainer = targetNode as DataNodeContainerBuilder;
augment.setTargetNodeSchemaPath(targetDataNodeContainer.getPath());
- fillAugmentTarget(augment, targetDataNodeContainer);
} else if (targetNode instanceof ChoiceBuilder) {
val targetChoiceBuilder = targetNode as ChoiceBuilder;
augment.setTargetNodeSchemaPath(targetChoiceBuilder.getPath());
- fillAugmentTarget(augment, targetChoiceBuilder);
} else {
throw new YangParseException(augment.getModuleName(), augment.getLine(),
"Error in augment parsing: The target node MUST be either a container, list, choice, case, input, output, or notification node.");
}
+ fillAugmentTarget(augment, targetNode);
(targetNode as AugmentationTargetBuilder).addAugmentation(augment);
augment.setResolved(true);
return true;
}
- /**
- * Find augment target node in given context and perform augmentation.
- *
- * @param augment
- * @param path
- * path to augment target
- * @param module
- * current module
- * @param prefix
- * current prefix of target module
- * @param context
- * SchemaContext containing already resolved modules
- * @return true if augment process succeed, false otherwise
- */
- public static def boolean processAugmentationOnContext(AugmentationSchemaBuilder augment, List<QName> path,
- ModuleBuilder module, String prefix, SchemaContext context) {
- val int line = augment.getLine();
- val Module dependentModule = findModuleFromContext(context, module, prefix, line);
- if (dependentModule === null) {
- throw new YangParseException(module.getName(), line,
- "Error in augment parsing: failed to find module with prefix " + prefix + ".");
- }
-
- var currentName = path.get(0).getLocalName();
- var SchemaNode currentParent = dependentModule.getDataChildByName(currentName);
- if (currentParent === null) {
- val notifications = dependentModule.getNotifications();
- for (NotificationDefinition ntf : notifications) {
- if (ntf.getQName().getLocalName().equals(currentName)) {
- currentParent = ntf;
- }
- }
- }
- if (currentParent === null) {
- throw new YangParseException(module.getName(), line,
- "Error in augment parsing: failed to find node " + currentName + ".");
- }
-
- for (qname : path.nextLevel) {
- currentName = qname.getLocalName();
- if (currentParent instanceof DataNodeContainer) {
- currentParent = (currentParent as DataNodeContainer).getDataChildByName(currentName);
- } else if (currentParent instanceof ChoiceNode) {
- currentParent = (currentParent as ChoiceNode).getCaseNodeByName(currentName);
- } else {
- throw new YangParseException(augment.getModuleName(), line,
- "Error in augment parsing: failed to find node " + currentName);
- }
-
- // if node in path not found, return false
- if (currentParent === null) {
- throw new YangParseException(module.getName(), line,
- "Error in augment parsing: failed to find node " + currentName + ".");
- }
- }
-
- val oldPath = currentParent.path;
-
- if (!(currentParent instanceof AugmentationTarget)) {
- throw new YangParseException(module.getName(), line,
- "Target of type " + currentParent.class + " cannot be augmented.");
- }
-
- switch (currentParent) {
- case (currentParent instanceof ContainerSchemaNodeImpl): {
-
- // includes container, input and output statement
- val c = currentParent as ContainerSchemaNodeImpl;
- val cb = c.toBuilder();
- fillAugmentTarget(augment, cb);
- (cb as AugmentationTargetBuilder ).addAugmentation(augment);
- cb.rebuild();
- }
- case (currentParent instanceof ListSchemaNodeImpl): {
- val l = currentParent as ListSchemaNodeImpl;
- val lb = l.toBuilder();
- fillAugmentTarget(augment, lb);
- (lb as AugmentationTargetBuilder ).addAugmentation(augment);
- lb.rebuild();
- augment.setTargetNodeSchemaPath(new SchemaPath(oldPath.getPath(), oldPath.isAbsolute()));
- augment.setResolved(true);
- }
- case (currentParent instanceof ChoiceNodeImpl): {
- val ch = currentParent as ChoiceNodeImpl;
- val chb = ch.toBuilder();
- fillAugmentTarget(augment, chb);
- (chb as AugmentationTargetBuilder ).addAugmentation(augment);
- chb.rebuild();
- augment.setTargetNodeSchemaPath(new SchemaPath(oldPath.getPath(), oldPath.isAbsolute()));
- augment.setResolved(true);
- }
- case (currentParent instanceof ChoiceCaseNodeImpl): {
- val chc = currentParent as ChoiceCaseNodeImpl;
- val chcb = chc.toBuilder();
- fillAugmentTarget(augment, chcb);
- (chcb as AugmentationTargetBuilder ).addAugmentation(augment);
- chcb.rebuild();
- augment.setTargetNodeSchemaPath(new SchemaPath(oldPath.getPath(), oldPath.isAbsolute()));
- augment.setResolved(true);
- }
- case (currentParent instanceof NotificationDefinitionImpl): {
- val nd = currentParent as NotificationDefinitionImpl;
- val nb = nd.toBuilder();
- fillAugmentTarget(augment, nb);
- (nb as AugmentationTargetBuilder ).addAugmentation(augment);
- nb.rebuild();
- augment.setTargetNodeSchemaPath(new SchemaPath(oldPath.getPath(), oldPath.isAbsolute()));
- augment.setResolved(true);
- }
- }
- augment.setTargetNodeSchemaPath(new SchemaPath(oldPath.getPath(), oldPath.isAbsolute()));
- augment.setResolved(true);
- return true;
- }
-
public static def IdentitySchemaNodeBuilder findBaseIdentity(Map<String, TreeMap<Date, ModuleBuilder>> modules,
ModuleBuilder module, String baseString, int line) {
var IdentitySchemaNodeBuilder result = null;
if (baseString.contains(":")) {
val String[] splittedBase = baseString.split(":");
if (splittedBase.length > 2) {
- throw new YangParseException(module.getName(), line, "Failed to parse identityref base: " +
- baseString);
+ throw new YangParseException(module.getName(), line,
+ "Failed to parse identityref base: " + baseString);
}
val prefix = splittedBase.get(0);
val name = splittedBase.get(1);
}
public static def IdentitySchemaNode findBaseIdentityFromContext(Map<String, TreeMap<Date, ModuleBuilder>> modules,
- ModuleBuilder module, String baseString, int line, SchemaContext context) {
+ ModuleBuilder module, String baseString, int line, SchemaContext context) {
var IdentitySchemaNode result = null;
val String[] splittedBase = baseString.split(":");
return parent as ModuleBuilder;
}
-}
+ public static def Set<DataSchemaNodeBuilder> wrapChildNodes(String moduleName, int line, Set<DataSchemaNode> nodes,
+ SchemaPath parentPath, URI ns, Date rev, String pref) {
+ val Set<DataSchemaNodeBuilder> result = new HashSet()
+ for (DataSchemaNode node : nodes) {
+ val qname = new QName(ns, rev, pref, node.QName.localName)
+ val DataSchemaNodeBuilder wrapped = wrapChildNode(moduleName, line, node, parentPath, qname)
+ result.add(wrapped)
+ }
+ return result
+ }
+
+ public static def DataSchemaNodeBuilder wrapChildNode(String moduleName, int line, DataSchemaNode node,
+ SchemaPath parentPath, QName qname) {
+ val List<QName> path = new ArrayList(parentPath.getPath())
+ path.add(qname)
+ val SchemaPath schemaPath = new SchemaPath(path, parentPath.isAbsolute())
+
+ if (node instanceof AnyXmlSchemaNode) {
+ return new AnyXmlBuilder(moduleName, line, qname, schemaPath, (node as AnyXmlSchemaNode));
+ } else if (node instanceof ChoiceNode) {
+ return new ChoiceBuilder(moduleName, line, qname, schemaPath, (node as ChoiceNode));
+ } else if (node instanceof ContainerSchemaNode) {
+ return new ContainerSchemaNodeBuilder(moduleName, line, qname, schemaPath, (node as ContainerSchemaNode));
+ } else if (node instanceof LeafSchemaNode) {
+ return new LeafSchemaNodeBuilder(moduleName, line, qname, schemaPath, (node as LeafSchemaNode));
+ } else if (node instanceof LeafListSchemaNode) {
+ return new LeafListSchemaNodeBuilder(moduleName, line, qname, schemaPath, (node as LeafListSchemaNode));
+ } else if (node instanceof ListSchemaNode) {
+ return new ListSchemaNodeBuilder(moduleName, line, qname, schemaPath, (node as ListSchemaNode));
+ } else if (node instanceof ChoiceCaseNode) {
+ return new ChoiceCaseBuilder(moduleName, line, qname, schemaPath, (node as ChoiceCaseNode));
+ } else {
+ throw new YangParseException(moduleName, line,
+ "Failed to copy node: Unknown type of DataSchemaNode: " + node)
+ }
+ }
+
+ public static def Set<GroupingBuilder> wrapGroupings(String moduleName, int line, Set<GroupingDefinition> nodes,
+ SchemaPath parentPath, URI ns, Date rev, String pref) {
+ val Set<GroupingBuilder> result = new HashSet()
+ for (GroupingDefinition node : nodes) {
+ val qname = new QName(ns, rev, pref, node.QName.localName)
+ val List<QName> path = new ArrayList(parentPath.getPath())
+ path.add(qname)
+ val SchemaPath schemaPath = new SchemaPath(path, parentPath.isAbsolute())
+ result.add(new GroupingBuilderImpl(moduleName, line, qname, schemaPath, node))
+ }
+ return result
+ }
+
+ public static def Set<TypeDefinitionBuilder> wrapTypedefs(String moduleName, int line, DataNodeContainer dataNode,
+ SchemaPath parentPath, URI ns, Date rev, String pref) {
+ val Set<TypeDefinition<?>> nodes = dataNode.typeDefinitions
+ val Set<TypeDefinitionBuilder> result = new HashSet()
+ for (TypeDefinition<?> node : nodes) {
+ val qname = new QName(ns, rev, pref, node.QName.localName)
+ val List<QName> path = new ArrayList(parentPath.getPath())
+ path.add(qname)
+ val SchemaPath schemaPath = new SchemaPath(path, parentPath.isAbsolute())
+ result.add(new TypeDefinitionBuilderImpl(moduleName, line, qname, schemaPath, (node as ExtendedType)))
+ }
+ return result
+ }
+
+ public static def List<UnknownSchemaNodeBuilder> wrapUnknownNodes(String moduleName, int line,
+ List<UnknownSchemaNode> nodes, SchemaPath parentPath, URI ns, Date rev, String pref) {
+ val List<UnknownSchemaNodeBuilder> result = new ArrayList()
+ for (UnknownSchemaNode node : nodes) {
+ val qname = new QName(ns, rev, pref, node.QName.localName)
+ val List<QName> path = new ArrayList(parentPath.getPath())
+ path.add(qname)
+ val SchemaPath schemaPath = new SchemaPath(path, parentPath.isAbsolute())
+ result.add(new UnknownSchemaNodeBuilder(moduleName, line, qname, schemaPath, (node as UnknownSchemaNode)))
+ }
+ return result
+ }
+
+}
package org.opendaylight.yangtools.yang.parser.util;
import org.opendaylight.yangtools.yang.model.api.MustDefinition;
-import org.opendaylight.yangtools.yang.model.api.YangNode;
import org.opendaylight.yangtools.yang.parser.builder.api.AbstractBuilder;
public final class RefineHolder extends AbstractBuilder {
}
@Override
- public Object build(YangNode parent) {
+ public Object build() {
return null;
}
String defaultStr = refine.getDefaultStr();
Boolean mandatory = refine.isMandatory();
MustDefinition must = refine.getMust();
- List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodeBuilders();
+ List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodes();
if (defaultStr != null && !("".equals(defaultStr))) {
leaf.setDefaultStr(defaultStr);
public static void refineContainer(ContainerSchemaNodeBuilder container, RefineHolder refine) {
Boolean presence = refine.isPresence();
MustDefinition must = refine.getMust();
- List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodeBuilders();
+ List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodes();
if (presence != null) {
container.setPresence(presence);
MustDefinition must = refine.getMust();
Integer min = refine.getMinElements();
Integer max = refine.getMaxElements();
- List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodeBuilders();
+ List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodes();
if (must != null) {
list.getConstraints().addMustDefinition(must);
MustDefinition must = refine.getMust();
Integer min = refine.getMinElements();
Integer max = refine.getMaxElements();
- List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodeBuilders();
+ List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodes();
if (must != null) {
leafList.getConstraints().addMustDefinition(must);
public static void refineChoice(ChoiceBuilder choice, RefineHolder refine) {
String defaultStr = refine.getDefaultStr();
Boolean mandatory = refine.isMandatory();
- List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodeBuilders();
+ List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodes();
if (defaultStr != null) {
choice.setDefaultCase(defaultStr);
public static void refineAnyxml(AnyXmlBuilder anyXml, RefineHolder refine) {
Boolean mandatory = refine.isMandatory();
MustDefinition must = refine.getMust();
- List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodeBuilders();
+ List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodes();
if (mandatory != null) {
anyXml.getConstraints().setMandatory(mandatory);
import static org.opendaylight.yangtools.yang.parser.util.ParserUtils.findModuleFromBuilders;
import static org.opendaylight.yangtools.yang.parser.util.ParserUtils.findModuleFromContext;
-import java.util.ArrayList;
-import java.util.Date;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.TreeMap;
+import java.util.*;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.BinaryTypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.DecimalTypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.IntegerTypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.StringTypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.UnsignedIntegerTypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.*;
+import org.opendaylight.yangtools.yang.model.api.type.*;
import org.opendaylight.yangtools.yang.model.util.ExtendedType;
import org.opendaylight.yangtools.yang.model.util.UnknownType;
-import org.opendaylight.yangtools.yang.parser.builder.api.Builder;
-import org.opendaylight.yangtools.yang.parser.builder.api.DataNodeContainerBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.api.TypeAwareBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.IdentityrefTypeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ModuleBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.RpcDefinitionBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.TypeDefinitionBuilderImpl;
-import org.opendaylight.yangtools.yang.parser.builder.impl.UnionTypeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.*;
+import org.opendaylight.yangtools.yang.parser.builder.impl.*;
/**
* Utility class which contains helper methods for dealing with type operations.
/**
* Resolve unknown type of node. It is assumed that type of node is either
* UnknownType or ExtendedType with UnknownType as base type.
- *
+ *
* @param nodeToResolve
* node with type to resolve
* @param modules
/**
* Resolve unknown type of node. It is assumed that type of node is either
* UnknownType or ExtendedType with UnknownType as base type.
- *
+ *
* @param nodeToResolve
* node with type to resolve
* @param modules
/**
* Resolve union type which contains one or more unresolved types.
- *
+ *
* @param union
* union type builder to resolve
* @param modules
/**
* Find type definition of type of unresolved node.
- *
+ *
* @param nodeToResolve
* node with unresolved type
* @param dependentModuleBuilder
/**
* Search types for type with given name.
- *
+ *
* @param types
* types to search
* @param name
/**
* Find type by name.
- *
+ *
* @param types
* collection of types
* @param typeName
/**
* Pull restriction from type and add them to constraints.
- *
+ *
* @param type
* type from which constraints will be read
* @param constraints
/**
* Create new type builder based on old type with new base type. Note: only
* one of newBaseTypeBuilder or newBaseType can be specified.
- *
+ *
* @param newBaseTypeBuilder
* new base type builder or null
* @param newBaseType
}
final TypeDefinitionBuilderImpl newType = new TypeDefinitionBuilderImpl(module.getModuleName(), line,
- oldExtendedType.getQName());
+ oldExtendedType.getQName(), oldExtendedType.getPath());
final TypeConstraints tc = new TypeConstraints(module.getName(), line);
TypeConstraints constraints;
if (newBaseType == null) {
newType.setType(newBaseType);
}
- newType.setPath(oldExtendedType.getPath());
newType.setDescription(oldExtendedType.getDescription());
newType.setReference(oldExtendedType.getReference());
newType.setStatus(oldExtendedType.getStatus());
newType.setFractionDigits(constraints.getFractionDigits());
newType.setUnits(oldExtendedType.getUnits());
newType.setDefaultValue(oldExtendedType.getDefaultValue());
- newType.setUnknownNodes(oldExtendedType.getUnknownSchemaNodes());
return newType;
}
/**
* Pull restrictions from type and add them to constraints.
- *
+ *
* @param typeToResolve
* type from which constraints will be read
* @param constraints
/**
* Search for type definition builder by name.
- *
+ *
* @param nodeToResolve
* node which contains unresolved type
* @param dependentModule
import static org.junit.Assert.assertEquals;
-import java.io.File;
-import java.io.FileNotFoundException;
-import java.io.IOException;
-import java.io.InputStream;
+import java.io.*;
import java.net.URI;
-import java.text.DateFormat;
-import java.text.ParseException;
-import java.text.SimpleDateFormat;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Date;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
+import java.text.*;
+import java.util.*;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
-import org.opendaylight.yangtools.yang.model.api.ChoiceNode;
-import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
-import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.ModuleImport;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.*;
import org.opendaylight.yangtools.yang.model.parser.api.YangModelParser;
final class TestUtils {
return modules.iterator().next();
}
- public static Module loadModuleWithContext(final InputStream stream, final SchemaContext context)
+ public static Module loadModuleWithContext(final String name, final InputStream stream, final SchemaContext context)
throws IOException {
final YangModelParser parser = new YangParserImpl();
final List<InputStream> input = Collections.singletonList(stream);
final Set<Module> modules = new HashSet<>(parser.parseYangModelsFromStreams(input, context));
stream.close();
- return modules.iterator().next();
+ Module result = null;
+ for (Module module : modules) {
+ if (module.getName().equals(name)) {
+ result = module;
+ break;
+ }
+ }
+ return result;
}
public static Set<Module> loadModulesWithContext(final List<InputStream> input, final SchemaContext context)
*/
package org.opendaylight.yangtools.yang.parser.impl;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
+import java.io.*;
+import java.util.*;
import org.junit.Test;
import org.opendaylight.yangtools.yang.model.parser.api.YangModelParser;
}
}
} catch (YangParseException e) {
- assertEquals("Error in module 'test3' at line 10: Error in augment parsing: failed to find augment target",
+ assertEquals(
+ "Error in module 'test3' at line 10: Error in augment parsing: failed to find augment target: augment /data:unknown",
e.getMessage());
}
}
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.ChoiceNode;
-import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition;
-import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
-import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.MustDefinition;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-import org.opendaylight.yangtools.yang.model.api.Status;
-import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.UsesNode;
+import org.opendaylight.yangtools.yang.model.api.*;
public class YangParserSimpleTest {
private final URI snNS = URI.create("urn:opendaylight:simple-nodes");
assertEquals(Status.OBSOLETE, data.getStatus());
assertEquals(0, data.getUnknownSchemaNodes().size());
// test DataSchemaNode args
- assertEquals(testModule, data.getParent());
assertFalse(data.isAugmenting());
assertFalse(data.isConfiguration());
ConstraintDefinition constraints = data.getConstraints();
assertEquals(Status.CURRENT, nodes.getStatus());
assertEquals(0, nodes.getUnknownSchemaNodes().size());
// test DataSchemaNode args
- assertEquals(test, nodes.getParent());
assertFalse(nodes.isAugmenting());
assertFalse(nodes.isConfiguration());
// child nodes
// total size = 8: defined 6, inserted by uses 2
assertEquals(8, nodes.getChildNodes().size());
- AnyXmlSchemaNode text = (AnyXmlSchemaNode)nodes.getDataChildByName("text");
- assertEquals(nodes, text.getParent());
- ChoiceNode level = (ChoiceNode)nodes.getDataChildByName("level");
- assertEquals(nodes, level.getParent());
- ContainerSchemaNode node = (ContainerSchemaNode)nodes.getDataChildByName("node");
- assertEquals(nodes, node.getParent());
- LeafSchemaNode nodesId = (LeafSchemaNode)nodes.getDataChildByName("nodes-id");
- assertEquals(nodes, nodesId.getParent());
LeafListSchemaNode added = (LeafListSchemaNode)nodes.getDataChildByName("added");
- assertEquals(nodes, added.getParent());
assertEquals(createPath("nodes", "added"), added.getPath());
assertEquals(createPath("mytype"), added.getType().getPath());
ListSchemaNode links = (ListSchemaNode) nodes.getDataChildByName("links");
- assertEquals(nodes, links.getParent());
assertFalse(links.isUserOrdered());
- LeafSchemaNode source = (LeafSchemaNode)nodes.getDataChildByName("source");
- assertEquals(nodes, source.getParent());
- LeafSchemaNode target = (LeafSchemaNode)nodes.getDataChildByName("target");
- assertEquals(nodes, target.getParent());
Set<GroupingDefinition> groupings = nodes.getGroupings();
assertEquals(1, groupings.size());
GroupingDefinition nodeGroup = groupings.iterator().next();
- assertEquals(nodes, nodeGroup.getParent());
QName groupQName = new QName(snNS, snRev, snPref, "node-group");
assertEquals(groupQName, nodeGroup.getQName());
SchemaPath nodeGroupPath = TestUtils.createPath(true, snNS, snRev, snPref, "nodes", "node-group");
Set<UsesNode> uses = nodes.getUses();
assertEquals(1, uses.size());
UsesNode use = uses.iterator().next();
- assertEquals(nodes, use.getParent());
assertEquals(nodeGroupPath, use.getGroupingPath());
}
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
-import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
-import org.opendaylight.yangtools.yang.model.api.ChoiceNode;
-import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition;
-import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.Deviation;
+import org.opendaylight.yangtools.yang.model.api.*;
import org.opendaylight.yangtools.yang.model.api.Deviation.Deviate;
-import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
-import org.opendaylight.yangtools.yang.model.api.FeatureDefinition;
-import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
-import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.ModuleImport;
-import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
-import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-import org.opendaylight.yangtools.yang.model.api.Status;
-import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint;
import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
assertEquals(Status.CURRENT, ifEntry.getStatus());
assertEquals(0, ifEntry.getUnknownSchemaNodes().size());
// test DataSchemaNode args
- assertEquals(interfaces, ifEntry.getParent());
assertFalse(ifEntry.isAugmenting());
assertTrue(ifEntry.isConfiguration());
ConstraintDefinition constraints = ifEntry.getConstraints();
Module foo = TestUtils.findModule(modules, "foo");
ContainerSchemaNode transfer = (ContainerSchemaNode) foo.getDataChildByName("transfer");
ChoiceNode how = (ChoiceNode) transfer.getDataChildByName("how");
- assertEquals(transfer, how.getParent());
Set<ChoiceCaseNode> cases = how.getCases();
assertEquals(5, cases.size());
ChoiceCaseNode input = null;
assertEquals(0, notification.getUses().size());
LeafSchemaNode eventClass = (LeafSchemaNode) notification.getDataChildByName("event-class");
- assertEquals(notification, eventClass.getParent());
assertTrue(eventClass.getType() instanceof StringType);
- AnyXmlSchemaNode reportingEntity = (AnyXmlSchemaNode) notification.getDataChildByName("reporting-entity");
- assertEquals(notification, reportingEntity.getParent());
LeafSchemaNode severity = (LeafSchemaNode) notification.getDataChildByName("severity");
- assertEquals(notification, severity.getParent());
assertTrue(severity.getType() instanceof StringType);
}
RpcDefinition rpc = rpcs.iterator().next();
assertEquals("Retrieve all or part of a specified configuration.", rpc.getDescription());
assertEquals("RFC 6241, Section 7.1", rpc.getReference());
-
- ContainerSchemaNode input = rpc.getInput();
- assertEquals(rpc, input.getParent());
- DataSchemaNode source = input.getDataChildByName("source");
- assertEquals(input, source.getParent());
- DataSchemaNode filter = input.getDataChildByName("filter");
- assertEquals(input, filter.getParent());
- ContainerSchemaNode output = rpc.getOutput();
- assertEquals(rpc, output.getParent());
- DataSchemaNode data = output.getDataChildByName("data");
- assertEquals(output, data.getParent());
}
@Test
*/
package org.opendaylight.yangtools.yang.parser.impl;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
import java.io.File;
import java.io.FileInputStream;
import java.util.Map;
import java.util.Set;
+import org.junit.Ignore;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.ChoiceNode;
-import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.Deviation;
+import org.opendaylight.yangtools.yang.model.api.*;
import org.opendaylight.yangtools.yang.model.api.Deviation.Deviate;
-import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
-import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
-import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.MustDefinition;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.UsesNode;
import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
import org.opendaylight.yangtools.yang.model.parser.api.YangModelParser;
import org.opendaylight.yangtools.yang.model.util.ExtendedType;
resource = "/context-test/test1.yang";
InputStream stream2 = new FileInputStream(getClass().getResource(resource).getPath());
- Module module = TestUtils.loadModuleWithContext(stream2, context);
+ Module module = TestUtils.loadModuleWithContext("test1", stream2, context);
stream2.close();
assertNotNull(module);
}
Module testModule;
try (InputStream stream = new FileInputStream(getClass().getResource("/context-test/test2.yang").getPath())) {
- testModule = TestUtils.loadModuleWithContext(stream, context);
+ testModule = TestUtils.loadModuleWithContext("test2", stream, context);
}
assertNotNull(testModule);
}
Module module;
try (InputStream stream = new FileInputStream(getClass().getResource("/context-test/test2.yang").getPath())) {
- module = TestUtils.loadModuleWithContext(stream, context);
+ module = TestUtils.loadModuleWithContext("test2", stream, context);
}
assertNotNull(module);
Module module;
try (InputStream stream = new FileInputStream(getClass().getResource("/context-test/test3.yang").getPath())) {
- module = TestUtils.loadModuleWithContext(stream, context);
+ module = TestUtils.loadModuleWithContext("test3", stream, context);
}
assertNotNull(module);
Module module;
try (InputStream stream = new FileInputStream(getClass().getResource("/context-test/test3.yang").getPath())) {
- module = TestUtils.loadModuleWithContext(stream, context);
+ module = TestUtils.loadModuleWithContext("test3", stream, context);
}
ContainerSchemaNode network = (ContainerSchemaNode) module.getDataChildByName("network");
assertNotNull(un.getExtensionDefinition());
}
+ @Ignore
@Test
public void testAugment() throws Exception {
// load first module
context = parser.resolveSchemaContext(TestUtils.loadModules(Lists.newArrayList(stream)));
}
- Set<Module> contextModules = context.getModules();
- Module t3 = TestUtils.findModule(contextModules, "test4");
- ContainerSchemaNode interfaces = (ContainerSchemaNode) t3.getDataChildByName("interfaces");
- ListSchemaNode ifEntry = (ListSchemaNode) interfaces.getDataChildByName("ifEntry");
-
// load another modules and parse them against already existing context
Set<Module> modules;
try (InputStream stream1 = new FileInputStream(getClass().getResource("/context-augment-test/test1.yang")
}
assertNotNull(modules);
+ Module t3 = TestUtils.findModule(modules, "test4");
+ ContainerSchemaNode interfaces = (ContainerSchemaNode) t3.getDataChildByName("interfaces");
+ ListSchemaNode ifEntry = (ListSchemaNode) interfaces.getDataChildByName("ifEntry");
+
// test augmentation process
ContainerSchemaNode augmentHolder = (ContainerSchemaNode) ifEntry.getDataChildByName("augment-holder");
assertNotNull(augmentHolder);
package org.opendaylight.yangtools.yang.parser.util;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
import java.net.URI;
import java.net.URISyntaxException;
-import java.util.ArrayList;
-import java.util.Date;
-import java.util.List;
+import java.util.*;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-import org.opendaylight.yangtools.yang.model.api.Status;
-import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.*;
import org.opendaylight.yangtools.yang.parser.builder.impl.ModuleBuilder;
import org.opendaylight.yangtools.yang.parser.builder.impl.UnknownSchemaNodeBuilder;
assertEquals("Incorrect hash code for biA.", 923522, biA.hashCode());
List<UnknownSchemaNode> unknownNodes = new ArrayList<>();
- UnknownSchemaNodeBuilder usnb = new UnknownSchemaNodeBuilder("module", 3, qnameB);
+ SchemaPath path = org.mockito.Mockito.mock(SchemaPath.class);
+ UnknownSchemaNodeBuilder usnb = new UnknownSchemaNodeBuilder("module", 3, qnameB, path);
ModuleBuilder parent = org.mockito.Mockito.mock(ModuleBuilder.class);
usnb.setParent(parent);
- unknownNodes.add(usnb.build(null));
+ unknownNodes.add(usnb.build());
biA = new BitImpl(55L, qnameA, schemaPathA, "description", "reference", Status.CURRENT, unknownNodes);
package org.opendaylight.yangtools.yang.parser.util;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
import java.net.URI;
import java.net.URISyntaxException;
}
-
@Test
public void testRefineEquality() {
// hashCode method test
simpleUri = getUri("very:simple:URI");
assertNotNull("URI can't be null", simpleUri);
- UnknownSchemaNodeBuilder usnb = new UnknownSchemaNodeBuilder("usnb", 151, new QName(simpleUri, "tst"));
- UnknownSchemaNodeBuilder usnb1 = new UnknownSchemaNodeBuilder("usnb", 151, new QName(simpleUri, "tst"));
-
URI uriA = getUri("some:uriA");
assertNotNull("URI can't be null", simpleUri);
QName qnameA = new QName(uriA, new Date(5000000), "some nameA");
List<QName> qnamesB = new ArrayList<>();
qnamesA.add(qnameA);
qnamesB.add(qnameB);
- SchemaPath schemaPathA = new SchemaPath(qnamesA, true);
SchemaPath schemaPathB = new SchemaPath(qnamesB, true);
- usnb.setPath(schemaPathB);
- usnb1.setPath(schemaPathB);
+ UnknownSchemaNodeBuilder usnb = new UnknownSchemaNodeBuilder("usnb", 151, new QName(simpleUri, "tst"), schemaPathB);
+ UnknownSchemaNodeBuilder usnb1 = new UnknownSchemaNodeBuilder("usnb", 151, new QName(simpleUri, "tst"), schemaPathB);
assertEquals("rh should equal to rh1", rh, rh1);
rh1.addUnknownNodeBuilder(usnb);
assertFalse("rh shouldn't equal to rh1", rh.equals(rh1));
rh.addUnknownNodeBuilder(usnb1);
assertEquals("rh should equal to rh1", rh, rh1);
- usnb.setPath(schemaPathA);
- assertFalse("rh shouldn't equal to rh1", rh.equals(rh1));
- usnb1.setPath(schemaPathA);
}
@Test
URI simpleUriA = getUri("very:simple:URI:a");
URI simpleUriB = getUri("very:simple:URI:b");
- UnknownSchemaNodeBuilder usnbA = new UnknownSchemaNodeBuilder("usnbA", 151, new QName(simpleUriA, "tst"));
- UnknownSchemaNodeBuilder usnbB = new UnknownSchemaNodeBuilder("usnbB", 151, new QName(simpleUriB, "tst"));
+ SchemaPath path = org.mockito.Mockito.mock(SchemaPath.class);
+
+ UnknownSchemaNodeBuilder usnbA = new UnknownSchemaNodeBuilder("usnbA", 151, new QName(simpleUriA, "tst"), path);
+ UnknownSchemaNodeBuilder usnbB = new UnknownSchemaNodeBuilder("usnbB", 151, new QName(simpleUriB, "tst"), path);
UnknownSchemaNodeBuilder usnbAParent = new UnknownSchemaNodeBuilder("usnbAParent", 151, new QName(simpleUriA,
- "tst"));
+ "tst"), path);
usnbA.setParent(usnbAParent);
assertEquals("rh should equal to rh1", rh, rh1);
Code Review / yangtools.git / commitdiff