Uses statement now add nodes from referenced grouping to context where uses is defined. Added GroupingMember interface as marker interface for nodes defined in grouping.
Fixed parsing of config statement: when config is not specified, the default is same as parent schema node. If top node does not specify config, default is true.
Added ConfigNode as marker interface for nodes which can contains 'config' statement.
Added AbstractSchemaNodeBuilder as base class for builders of SchemaNode nodes.
Updated tests.
Change-Id: Ibabcf590608bdf482258826fa250692507a71c01
Signed-off-by: Martin Vitez <mvitez@cisco.com>
*/
package org.opendaylight.controller.sal.binding.generator.impl;
+import static org.junit.Assert.*;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+
import org.junit.Test;
import org.opendaylight.controller.binding.generator.util.ReferencedTypeImpl;
import org.opendaylight.controller.sal.binding.generator.api.BindingGenerator;
import org.opendaylight.controller.yang.model.parser.api.YangModelParser;
import org.opendaylight.controller.yang.parser.impl.YangParserImpl;
-import java.io.File;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Set;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-
public class GenEnumResolvingTest {
private SchemaContext resolveSchemaContextFromFiles(
assertNotNull("Generated Interface cannot contain NULL reference for " +
"Method Signature Definitions!", methods);
- assertEquals("Expected count of method signature definitions is 26",
- 26, methods.size());
+ assertEquals("Expected count of method signature definitions is 21",
+ 21, methods.size());
Enumeration ianaIfType = null;
for (final MethodSignature method : methods) {
if (method.getName().equals("getType")) {
final List<MethodSignature> methods = genInterface.getMethodDefinitions();
assertNotNull("Generated Type Interface cannot contain NULL reference" +
" to Enumeration types!", methods);
- assertEquals("Generated Type Interface MUST contain 7 Methods ",
- 7, methods.size());
+ assertEquals("Generated Type Interface MUST contain 4 Methods ",
+ 4, methods.size());
for (final MethodSignature method : methods) {
if (method.getName().equals("getLinkUpDownTrapEnable")) {
linkUpDownTrapEnable = method.getReturnType();
package org.opendaylight.controller.sal.binding.generator.impl;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.*;
import java.io.File;
import java.util.ArrayList;
assertTrue(getByteLeafMethodFound);
assertEquals(nameReturnParamType,"ByteType");
- assertTrue(setByteLeafMethodFound);
- assertEquals(setByteLeafMethodParamNum,1);
- assertEquals(nameMethodeParamType,"ByteType");
-
+ assertFalse(setByteLeafMethodFound);
+ assertEquals(0, setByteLeafMethodParamNum);
}
}
\ No newline at end of file
assertEquals("SimpleContainer", simpleContainer.getName());
assertEquals("NestedContainer", nestedContainer.getName());
- assertEquals(5, simpleContainer.getMethodDefinitions().size());
- assertEquals(4, nestedContainer.getMethodDefinitions().size());
+ assertEquals(3, simpleContainer.getMethodDefinitions().size());
+ assertEquals(2, nestedContainer.getMethodDefinitions().size());
int setFooMethodCounter = 0;
int getFooMethodCounter = 0;
assertEquals(getFooMethodCounter, 1);
assertEquals(getFooMethodReturnTypeName, "Integer");
- assertEquals(setFooMethodCounter, 1);
- assertEquals(setFooMethodInputParamName, "foo");
- assertEquals(setFooMethodInputParamTypeName, "Integer");
+ // TODO no setter methods, because 'config' is default true
+ // assertEquals(setFooMethodCounter, 1);
+ // assertEquals(setFooMethodInputParamName, "foo");
+ // assertEquals(setFooMethodInputParamTypeName, "Integer");
assertEquals(getBarMethodCounter, 1);
assertEquals(getBarMethodReturnTypeName, "String");
assertEquals(1, getFooMethodCounter);
assertEquals(getFooMethodReturnTypeName, "Short");
- assertEquals(1, setFooMethodCounter);
- assertEquals(setFooMethodInputParamName, "foo");
- assertEquals(setFooMethodInputParamTypeName, "Short");
+ // TODO no setter methods, because 'config' is default true
+ // assertEquals(1, setFooMethodCounter);
+ // assertEquals(setFooMethodInputParamName, "foo");
+ // assertEquals(setFooMethodInputParamTypeName, "Short");
assertEquals(1, getBarMethodCounter);
assertEquals(getBarMethodReturnTypeName, "String");
- assertEquals(1, setBarMethodCounter);
- assertEquals(setBarMethodInputParamName, "bar");
- assertEquals(setBarMethodInputParamTypeName, "String");
+ // TODO no setter methods, because 'config' is default true
+ // assertEquals(1, setBarMethodCounter);
+ // assertEquals(setBarMethodInputParamName, "bar");
+ // assertEquals(setBarMethodInputParamTypeName, "String");
}
@Test
assertEquals("SimpleContainer", simpleContainer.getName());
assertEquals("NestedContainer", nestedContainer.getName());
- assertEquals(5, simpleContainer.getMethodDefinitions().size());
- assertEquals(3, nestedContainer.getMethodDefinitions().size());
+ assertEquals(3, simpleContainer.getMethodDefinitions().size());
+ assertEquals(2, nestedContainer.getMethodDefinitions().size());
int setFooMethodCounter = 0;
int getFooMethodCounter = 0;
assertEquals(1, getFooMethodCounter);
assertEquals(getFooMethodReturnTypeName, "List");
- assertEquals(1, setFooMethodCounter);
- assertEquals(setFooMethodInputParamName, "foo");
- assertEquals(setFooMethodInputParamTypeName, "List");
+ // TODO no setter methods, because 'config' is default true
+ // assertEquals(1, setFooMethodCounter);
+ // assertEquals(setFooMethodInputParamName, "foo");
+ // assertEquals(setFooMethodInputParamTypeName, "List");
assertEquals(1, getBarMethodCounter);
assertEquals(getBarMethodReturnTypeName, "String");
assertEquals(1, getFooMethodCounter);
assertEquals(getFooMethodReturnTypeName, "Short");
- assertEquals(1, setFooMethodCounter);
- assertEquals(setFooMethodInputParamName, "foo");
- assertEquals(setFooMethodInputParamTypeName, "Short");
+ // TODO no setter methods, because 'config' is default true
+ // assertEquals(1, setFooMethodCounter);
+ // assertEquals(setFooMethodInputParamName, "foo");
+ // assertEquals(setFooMethodInputParamTypeName, "Short");
assertEquals(1, getBarMethodCounter);
assertEquals(getBarMethodReturnTypeName, "List");
}
}
- assertEquals(2, listParentContainerMethodsCount);
- assertEquals(2, listChildContainerMethodsCount);
+ assertEquals(1, listParentContainerMethodsCount);
+ assertEquals(1, listChildContainerMethodsCount);
assertEquals(1, getSimpleListKeyMethodCount);
assertEquals(1, listKeyClassCount);
assertEquals(1, getListChildContainerMethodCount);
assertEquals("ListChildContainer", getListChildContainerMethodReturnTypeName);
assertEquals(1, getFooMethodCount);
- assertEquals(1, setFooMethodCount);
+ assertEquals(0, setFooMethodCount);
assertEquals(1, getSimpleLeafListMethodCount);
- assertEquals(1, setSimpleLeafListMethodCount);
+ assertEquals(0, setSimpleLeafListMethodCount);
assertEquals(1, getBarMethodCount);
- assertEquals(8, simpleListMethodsCount);
+ assertEquals(5, simpleListMethodsCount);
}
@Test
import org.opendaylight.controller.yang.model.api.GroupingDefinition;
public abstract class AbstractDataNodeContainerBuilder implements DataNodeContainerBuilder {
-
private final QName qname;
protected Set<DataSchemaNode> childNodes;
}
@Override
- public Set<DataSchemaNodeBuilder> getChildNodes() {
+ public Set<DataSchemaNode> getChildNodes() {
+ return childNodes;
+ }
+
+ @Override
+ public Set<DataSchemaNodeBuilder> getChildNodeBuilders() {
return addedChildNodes;
}
this.childNodes = childNodes;
}
- public Set<GroupingBuilder> getGroupings() {
+ @Override
+ public Set<GroupingDefinition> getGroupings() {
+ return groupings;
+ }
+
+ public Set<GroupingBuilder> getGroupingBuilders() {
return addedGroupings;
}
--- /dev/null
+/*\r
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.\r
+ *\r
+ * This program and the accompanying materials are made available under the\r
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
+ * and is available at http://www.eclipse.org/legal/epl-v10.html\r
+ */\r
+package org.opendaylight.controller.yang.parser.builder.api;\r
+\r
+import java.util.ArrayList;\r
+import java.util.List;\r
+\r
+import org.opendaylight.controller.yang.common.QName;\r
+import org.opendaylight.controller.yang.model.api.SchemaPath;\r
+import org.opendaylight.controller.yang.model.api.Status;\r
+import org.opendaylight.controller.yang.parser.builder.impl.UnknownSchemaNodeBuilder;\r
+\r
+/**\r
+ * Basic implementation of SchemaNodeBuilder.\r
+ */\r
+public abstract class AbstractSchemaNodeBuilder implements SchemaNodeBuilder {\r
+ protected final int line;\r
+ protected final QName qname;\r
+ protected SchemaPath path;\r
+ protected String description;\r
+ protected String reference;\r
+ protected Status status = Status.CURRENT;\r
+ protected final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();\r
+\r
+ protected AbstractSchemaNodeBuilder(final QName qname, final int line) {\r
+ this.qname = qname;\r
+ this.line = line;\r
+ }\r
+\r
+ @Override\r
+ public int getLine() {\r
+ return line;\r
+ }\r
+\r
+ public QName getQName() {\r
+ return qname;\r
+ }\r
+\r
+ public SchemaPath getPath() {\r
+ return path;\r
+ }\r
+\r
+ public void setPath(SchemaPath schemaPath) {\r
+ this.path = schemaPath;\r
+ }\r
+\r
+ public String getDescription() {\r
+ return description;\r
+ }\r
+\r
+ public void setDescription(String description) {\r
+ this.description = description;\r
+ }\r
+\r
+ public String getReference() {\r
+ return reference;\r
+ }\r
+\r
+ public void setReference(String reference) {\r
+ this.reference = reference;\r
+ }\r
+\r
+ public Status getStatus() {\r
+ return status;\r
+ }\r
+\r
+ public void setStatus(Status status) {\r
+ if (status != null) {\r
+ this.status = status;\r
+ }\r
+ }\r
+\r
+ @Override\r
+ public void addUnknownSchemaNode(UnknownSchemaNodeBuilder unknownNode) {\r
+ addedUnknownNodes.add(unknownNode);\r
+ }\r
+\r
+}\r
*/
package org.opendaylight.controller.yang.parser.builder.api;
-import java.util.Set;
-
import org.opendaylight.controller.yang.model.api.AugmentationSchema;
import org.opendaylight.controller.yang.model.api.SchemaPath;
import org.opendaylight.controller.yang.model.api.Status;
*/
public interface AugmentationSchemaBuilder extends DataNodeContainerBuilder {
+ Builder getParent();
+
String getWhenCondition();
void addWhenCondition(String whenCondition);
void setTargetPath(SchemaPath path);
- Set<DataSchemaNodeBuilder> getChildNodes();
-
AugmentationSchema build();
boolean isResolved();
*/
package org.opendaylight.controller.yang.parser.builder.api;
+import org.opendaylight.controller.yang.parser.builder.impl.UnknownSchemaNodeBuilder;
+
/**
* Parent interface for all builder interfaces.
*/
int getLine();
+ void addUnknownSchemaNode(UnknownSchemaNodeBuilder unknownNode);
+
}
--- /dev/null
+/*
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.controller.yang.parser.builder.api;
+
+/**
+ * Interface for all nodes which can have 'config' statement.
+ * [container, leaf, leaf-list, list, choice, anyxml, deviate]
+ *
+ */
+public interface ConfigNode {
+
+ Boolean isConfiguration();
+
+ void setConfiguration(Boolean config);
+
+}
import java.util.Set;
import org.opendaylight.controller.yang.common.QName;
+import org.opendaylight.controller.yang.model.api.DataSchemaNode;
+import org.opendaylight.controller.yang.model.api.GroupingDefinition;
import org.opendaylight.controller.yang.model.api.SchemaPath;
/**
QName getQName();
- Set<DataSchemaNodeBuilder> getChildNodes();
+ SchemaPath getPath();
+
+ Set<DataSchemaNode> getChildNodes();
+
+ Set<DataSchemaNodeBuilder> getChildNodeBuilders();
void addChildNode(DataSchemaNodeBuilder childNode);
- Set<GroupingBuilder> getGroupings();
+ Set<GroupingDefinition> getGroupings();
+
+ Set<GroupingBuilder> getGroupingBuilders();
void addGrouping(GroupingBuilder groupingBuilder);
void addUsesNode(UsesNodeBuilder usesBuilder);
- Set<TypeDefinitionBuilder> getTypeDefinitions();
+ Set<TypeDefinitionBuilder> getTypeDefinitionBuilders();
void addTypedef(TypeDefinitionBuilder typedefBuilder);
- SchemaPath getPath();
-
}
void setAugmenting(boolean augmenting);
- boolean isConfiguration();
-
- void setConfiguration(boolean configuration);
-
ConstraintsBuilder getConstraints();
}
import java.util.Set;
import org.opendaylight.controller.yang.model.api.GroupingDefinition;
-import org.opendaylight.controller.yang.model.api.Status;
import org.opendaylight.controller.yang.parser.builder.impl.UnknownSchemaNodeBuilder;
/**
* Interface for builders of 'grouping' statement.
*/
-public interface GroupingBuilder extends DataNodeContainerBuilder, SchemaNodeBuilder,
- TypeDefinitionAwareBuilder {
-
- String getDescription();
-
- String getReference();
-
- Status getStatus();
+public interface GroupingBuilder extends DataNodeContainerBuilder, SchemaNodeBuilder, TypeDefinitionAwareBuilder, GroupingMember {
GroupingDefinition build();
List<UnknownSchemaNodeBuilder> getUnknownNodes();
- Set<GroupingBuilder> getGroupings();
-
Set<UsesNodeBuilder> getUses();
}
--- /dev/null
+/*
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.controller.yang.parser.builder.api;
+
+/**
+ * Marker interface for nodes which can be defined in grouping statement.
+ * [anyxml, choice, container, grouping, leaf, leaf-list, list, typedef, uses]
+ */
+public interface GroupingMember extends Builder {
+
+ boolean isAddedByUses();
+
+ void setAddedByUses(boolean addedByUses);
+
+}
\r
import java.util.List;\r
\r
-import org.opendaylight.controller.yang.model.api.Status;\r
import org.opendaylight.controller.yang.model.api.TypeDefinition;\r
+import org.opendaylight.controller.yang.model.api.UnknownSchemaNode;\r
import org.opendaylight.controller.yang.model.api.type.LengthConstraint;\r
import org.opendaylight.controller.yang.model.api.type.PatternConstraint;\r
import org.opendaylight.controller.yang.model.api.type.RangeConstraint;\r
/**\r
* Interface for builders of 'typedef' statement.\r
*/\r
-public interface TypeDefinitionBuilder extends TypeAwareBuilder,\r
- SchemaNodeBuilder {\r
+public interface TypeDefinitionBuilder extends TypeAwareBuilder, SchemaNodeBuilder, GroupingMember {\r
\r
TypeDefinition<?> build();\r
\r
- String getDescription();\r
-\r
- String getReference();\r
-\r
- Status getStatus();\r
-\r
List<RangeConstraint> getRanges();\r
\r
void setRanges(List<RangeConstraint> ranges);\r
\r
void setFractionDigits(Integer fractionDigits);\r
\r
- List<UnknownSchemaNodeBuilder> getUnknownNodes();\r
+ List<UnknownSchemaNode> getUnknownNodes();\r
+\r
+ List<UnknownSchemaNodeBuilder> getUnknownNodeBuilders();\r
\r
Object getDefaultValue();\r
\r
/**
* Interface for builders of 'uses' statement.
*/
-public interface UsesNodeBuilder extends Builder {
+public interface UsesNodeBuilder extends GroupingMember, Builder {
- String getGroupingName();
+ DataNodeContainerBuilder getParent();
- void setGroupingPath(SchemaPath groupingPath);
+ String getGroupingName();
- SchemaPath getPath();
+ SchemaPath getGroupingPath();
- void setPath(SchemaPath path);
+ void setGroupingPath(SchemaPath groupingPath);
Set<AugmentationSchemaBuilder> getAugmentations();
import org.opendaylight.controller.yang.model.api.SchemaPath;
import org.opendaylight.controller.yang.model.api.Status;
import org.opendaylight.controller.yang.model.api.UnknownSchemaNode;
+import org.opendaylight.controller.yang.parser.builder.api.AbstractSchemaNodeBuilder;
+import org.opendaylight.controller.yang.parser.builder.api.ConfigNode;
import org.opendaylight.controller.yang.parser.builder.api.DataSchemaNodeBuilder;
+import org.opendaylight.controller.yang.parser.builder.api.GroupingMember;
-public final class AnyXmlBuilder implements DataSchemaNodeBuilder {
+public final class AnyXmlBuilder extends AbstractSchemaNodeBuilder implements DataSchemaNodeBuilder, GroupingMember,
+ ConfigNode {
private boolean built;
- private final int line;
- private final QName qname;
- private SchemaPath path;
private final AnyXmlSchemaNodeImpl instance;
private final ConstraintsBuilder constraints;
private List<UnknownSchemaNode> unknownNodes;
- private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
- private String description;
- private String reference;
- private Status status = Status.CURRENT;
- private boolean configuration;
+ private Boolean configuration;
private boolean augmenting;
+ private boolean addedByUses;
- public AnyXmlBuilder(final QName qname, final int line) {
- this.qname = qname;
- this.line = line;
+ public AnyXmlBuilder(final QName qname, final SchemaPath schemaPath, final int line) {
+ super(qname, line);
+ this.path = schemaPath;
instance = new AnyXmlSchemaNodeImpl(qname);
constraints = new ConstraintsBuilder(line);
}
+ public AnyXmlBuilder(final AnyXmlBuilder builder) {
+ super(builder.qname, builder.line);
+ instance = new AnyXmlSchemaNodeImpl(qname);
+ constraints = builder.constraints;
+ path = builder.path;
+ unknownNodes = builder.unknownNodes;
+ for (UnknownSchemaNodeBuilder un : builder.addedUnknownNodes) {
+ addedUnknownNodes.add(un);
+ }
+ description = builder.description;
+ reference = builder.reference;
+ status = builder.status;
+ configuration = builder.configuration;
+ augmenting = builder.augmenting;
+ addedByUses = builder.addedByUses;
+ }
+
@Override
public AnyXmlSchemaNode build() {
if (!built) {
instance.setStatus(status);
instance.setConfiguration(configuration);
instance.setAugmenting(augmenting);
+ instance.setAddedByUses(addedByUses);
// UNKNOWN NODES
- if(unknownNodes == null) {
+ if (unknownNodes == null) {
unknownNodes = new ArrayList<UnknownSchemaNode>();
for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
unknownNodes.add(b.build());
return instance;
}
- @Override
- public int getLine() {
- return line;
- }
-
- @Override
- public QName getQName() {
- return qname;
- }
-
- public SchemaPath getPath() {
- return path;
- }
-
- @Override
- public void setPath(final SchemaPath path) {
- this.path = path;
- }
-
@Override
public ConstraintsBuilder getConstraints() {
return constraints;
}
- @Override
- public void addUnknownSchemaNode(final UnknownSchemaNodeBuilder unknownNode) {
- addedUnknownNodes.add(unknownNode);
- }
-
public List<UnknownSchemaNodeBuilder> getUnknownNodes() {
return addedUnknownNodes;
}
this.unknownNodes = unknownNodes;
}
- public String getDescription() {
- return description;
- }
-
@Override
- public void setDescription(final String description) {
- this.description = description;
- }
-
- public String getReference() {
- return reference;
+ public boolean isAugmenting() {
+ return augmenting;
}
@Override
- public void setReference(final String reference) {
- this.reference = reference;
- }
-
- public Status getStatus() {
- return status;
+ public void setAugmenting(final boolean augmenting) {
+ this.augmenting = augmenting;
}
@Override
- public void setStatus(final Status status) {
- if (status != null) {
- this.status = status;
- }
+ public boolean isAddedByUses() {
+ return addedByUses;
}
@Override
- public boolean isAugmenting() {
- return augmenting;
+ public void setAddedByUses(final boolean addedByUses) {
+ this.addedByUses = addedByUses;
}
@Override
- public void setAugmenting(final boolean augmenting) {
- this.augmenting = augmenting;
- }
-
- public boolean isConfiguration() {
+ public Boolean isConfiguration() {
return configuration;
}
@Override
- public void setConfiguration(final boolean configuration) {
- instance.setConfiguration(configuration);
+ public void setConfiguration(final Boolean configuration) {
+ this.configuration = configuration;
}
private final class AnyXmlSchemaNodeImpl implements AnyXmlSchemaNode {
private boolean configuration;
private ConstraintDefinition constraintsDef;
private boolean augmenting;
+ private boolean addedByUses;
private List<UnknownSchemaNode> unknownNodes = Collections.emptyList();
private AnyXmlSchemaNodeImpl(final QName qname) {
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 String toString() {
- StringBuilder sb = new StringBuilder(
- AnyXmlSchemaNodeImpl.class.getSimpleName());
+ StringBuilder sb = new StringBuilder(AnyXmlSchemaNodeImpl.class.getSimpleName());
sb.append("[");
sb.append("qname=" + qname);
sb.append(", path=" + path);
*/
package org.opendaylight.controller.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.controller.yang.model.api.SchemaPath;
import org.opendaylight.controller.yang.model.api.Status;
import org.opendaylight.controller.yang.model.api.TypeDefinition;
+import org.opendaylight.controller.yang.model.api.UnknownSchemaNode;
import org.opendaylight.controller.yang.model.api.UsesNode;
import org.opendaylight.controller.yang.model.util.RevisionAwareXPathImpl;
import org.opendaylight.controller.yang.parser.builder.api.AugmentationSchemaBuilder;
+import org.opendaylight.controller.yang.parser.builder.api.Builder;
import org.opendaylight.controller.yang.parser.builder.api.DataSchemaNodeBuilder;
import org.opendaylight.controller.yang.parser.builder.api.GroupingBuilder;
import org.opendaylight.controller.yang.parser.builder.api.TypeDefinitionBuilder;
private boolean built;
private final AugmentationSchemaImpl instance;
private final int line;
+ private final Builder parent;
+
+ private String whenCondition;
+ private String description;
+ private String reference;
+ private Status status = Status.CURRENT;
+
private final String augmentTargetStr;
- private SchemaPath augmentTarget;
+ private SchemaPath dirtyAugmentTarget;
private SchemaPath finalAugmentTarget;
- private String whenCondition;
+
private final Set<DataSchemaNodeBuilder> childNodes = new HashSet<DataSchemaNodeBuilder>();
private final Set<GroupingBuilder> groupings = new HashSet<GroupingBuilder>();
private final Set<UsesNodeBuilder> usesNodes = new HashSet<UsesNodeBuilder>();
+ private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
private boolean resolved;
- AugmentationSchemaBuilderImpl(final String augmentTargetStr, final int line) {
+ AugmentationSchemaBuilderImpl(final String augmentTargetStr, final int line, final Builder parent) {
this.augmentTargetStr = augmentTargetStr;
this.line = line;
+ this.parent = parent;
final SchemaPath targetPath = YangModelBuilderUtil
.parseAugmentPath(augmentTargetStr);
- augmentTarget = targetPath;
+ dirtyAugmentTarget = targetPath;
instance = new AugmentationSchemaImpl(targetPath);
}
return line;
}
+ @Override
+ public Builder getParent() {
+ return parent;
+ }
+
+
@Override
public void addChildNode(DataSchemaNodeBuilder childNode) {
childNodes.add(childNode);
}
@Override
- public Set<DataSchemaNodeBuilder> getChildNodes() {
+ public Set<DataSchemaNode> getChildNodes() {
+ return Collections.emptySet();
+ }
+
+ @Override
+ public Set<DataSchemaNodeBuilder> getChildNodeBuilders() {
return childNodes;
}
@Override
- public Set<GroupingBuilder> getGroupings() {
+ public Set<GroupingDefinition> getGroupings() {
+ return Collections.emptySet();
+ }
+
+ @Override
+ public Set<GroupingBuilder> getGroupingBuilders() {
return groupings;
}
@Override
public AugmentationSchema build() {
if (!built) {
+ instance.setDescription(description);
+ instance.setReference(reference);
+ instance.setStatus(status);
instance.setTargetPath(finalAugmentTarget);
RevisionAwareXPath whenStmt;
}
instance.setUses(usesNodeDefinitions);
+ // UNKNOWN NODES
+ List<UnknownSchemaNode> unknownNodes = new ArrayList<UnknownSchemaNode>();
+ for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
+ unknownNodes.add(b.build());
+ }
+ instance.setUnknownSchemaNodes(unknownNodes);
+
built = true;
}
return instance;
}
@Override
- public Set<TypeDefinitionBuilder> getTypeDefinitions() {
+ public Set<TypeDefinitionBuilder> getTypeDefinitionBuilders() {
return Collections.emptySet();
}
@Override
public void addTypedef(TypeDefinitionBuilder type) {
throw new YangParseException(line,
- "Augmentation can not contains type definitions");
+ "Augmentation can not contains typedef statement.");
}
@Override
public void setDescription(String description) {
- instance.setDescription(description);
+ this.description = description;
}
@Override
public void setReference(String reference) {
- instance.setReference(reference);
+ this.reference = reference;
}
@Override
public void setStatus(Status status) {
- instance.setStatus(status);
+ if(status != null) {
+ this.status = status;
+ }
}
@Override
public SchemaPath getTargetPath() {
- return augmentTarget;
+ return dirtyAugmentTarget;
}
@Override
return augmentTargetStr;
}
+ public List<UnknownSchemaNodeBuilder> getUnknownNodes() {
+ return addedUnknownNodes;
+ }
+
+ @Override
+ public void addUnknownSchemaNode(UnknownSchemaNodeBuilder unknownNode) {
+ addedUnknownNodes.add(unknownNode);
+ }
+
@Override
public int hashCode() {
final int prime = 17;
private Map<QName, DataSchemaNode> childNodes = Collections.emptyMap();
private Set<GroupingDefinition> groupings = Collections.emptySet();
private Set<UsesNode> uses = Collections.emptySet();
-
private String description;
private String reference;
private Status status;
+ private List<UnknownSchemaNode> unknownNodes = Collections.emptyList();
private AugmentationSchemaImpl(SchemaPath targetPath) {
this.targetPath = targetPath;
this.status = status;
}
+ public List<UnknownSchemaNode> getUnknownSchemaNodes() {
+ return unknownNodes;
+ }
+
+ private void setUnknownSchemaNodes(
+ List<UnknownSchemaNode> unknownSchemaNodes) {
+ if (unknownSchemaNodes != null) {
+ this.unknownNodes = unknownSchemaNodes;
+ }
+ }
+
@Override
public DataSchemaNode getDataChildByName(QName name) {
return childNodes.get(name);
AugmentationSchemaImpl.class.getSimpleName());
sb.append("[");
sb.append("targetPath=" + targetPath);
- sb.append(", childNodes=" + childNodes.values());
- sb.append(", groupings=" + groupings);
- sb.append(", uses=" + uses);
+ sb.append(", when=" + whenCondition);
sb.append("]");
return sb.toString();
}
import org.opendaylight.controller.yang.model.api.SchemaPath;
import org.opendaylight.controller.yang.model.api.Status;
import org.opendaylight.controller.yang.model.api.UnknownSchemaNode;
+import org.opendaylight.controller.yang.parser.builder.api.AbstractSchemaNodeBuilder;
import org.opendaylight.controller.yang.parser.builder.api.AugmentationSchemaBuilder;
import org.opendaylight.controller.yang.parser.builder.api.AugmentationTargetBuilder;
+import org.opendaylight.controller.yang.parser.builder.api.ConfigNode;
import org.opendaylight.controller.yang.parser.builder.api.DataSchemaNodeBuilder;
+import org.opendaylight.controller.yang.parser.builder.api.GroupingMember;
+import org.opendaylight.controller.yang.parser.util.ParserUtils;
-public final class ChoiceBuilder implements DataSchemaNodeBuilder, AugmentationTargetBuilder {
+public final class ChoiceBuilder extends AbstractSchemaNodeBuilder implements DataSchemaNodeBuilder,
+ AugmentationTargetBuilder, GroupingMember, ConfigNode {
private boolean isBuilt;
private final ChoiceNodeImpl instance;
- private final int line;
// SchemaNode args
- private final QName qname;
- private SchemaPath schemaPath;
- private String description;
- private String reference;
- private Status status = Status.CURRENT;
private List<UnknownSchemaNode> unknownNodes;
- private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
// DataSchemaNode args
private boolean augmenting;
- private boolean configuration;
+ private boolean addedByUses;
+ private Boolean configuration;
private final ConstraintsBuilder constraints;
// AugmentationTarget args
private final Set<AugmentationSchemaBuilder> addedAugmentations = new HashSet<AugmentationSchemaBuilder>();
private String defaultCase;
public ChoiceBuilder(final QName qname, final int line) {
- this.qname = qname;
- this.line = line;
+ super(qname, line);
instance = new ChoiceNodeImpl(qname);
constraints = new ConstraintsBuilder(line);
}
+ public ChoiceBuilder(ChoiceBuilder b) {
+ super(b.getQName(), b.getLine());
+ instance = new ChoiceNodeImpl(qname);
+ constraints = b.constraints;
+ path = b.getPath();
+ description = b.getDescription();
+ reference = b.getReference();
+ status = b.getStatus();
+ unknownNodes = b.unknownNodes;
+ addedUnknownNodes.addAll(b.getUnknownNodes());
+ augmenting = b.isAugmenting();
+ addedByUses = b.isAddedByUses();
+ configuration = b.isConfiguration();
+ addedAugmentations.addAll(b.getAugmentations());
+ cases = b.cases;
+ addedCases.addAll(b.getCases());
+ defaultCase = b.getDefaultCase();
+ }
+
@Override
public ChoiceNode build() {
if (!isBuilt) {
- instance.setPath(schemaPath);
+ instance.setPath(path);
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
- if(cases == null) {
+ if (cases == null) {
cases = new HashSet<ChoiceCaseNode>();
for (ChoiceCaseBuilder caseBuilder : addedCases) {
cases.add(caseBuilder.build());
instance.setAvailableAugmentations(augmentations);
// UNKNOWN NODES
- if(unknownNodes == null) {
+ if (unknownNodes == null) {
unknownNodes = new ArrayList<UnknownSchemaNode>();
for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
unknownNodes.add(b.build());
build();
}
- @Override
- public int getLine() {
- return line;
- }
-
public Set<ChoiceCaseBuilder> getCases() {
return addedCases;
}
public void addChildNode(DataSchemaNodeBuilder childNode) {
if (!(childNode instanceof ChoiceCaseBuilder)) {
- ChoiceCaseBuilder caseBuilder = new ChoiceCaseBuilder(childNode.getQName(), childNode.getLine());
+ ChoiceCaseBuilder caseBuilder = new ChoiceCaseBuilder(this, childNode.getQName(), childNode.getLine());
+ caseBuilder.setPath(childNode.getPath());
+ SchemaPath newPath = ParserUtils.createSchemaPath(childNode.getPath(), childNode.getQName().getLocalName());
+ childNode.setPath(newPath);
caseBuilder.addChildNode(childNode);
addedCases.add(caseBuilder);
} else {
this.cases = cases;
}
- @Override
- public QName getQName() {
- return qname;
- }
-
- public SchemaPath getPath() {
- return schemaPath;
- }
-
- @Override
- public void setPath(final SchemaPath schemaPath) {
- this.schemaPath = schemaPath;
- }
-
- public String getDescription() {
- return description;
- }
-
- @Override
- public void setDescription(final String description) {
- this.description = description;
- }
-
- public String getReference() {
- return reference;
+ public boolean isAugmenting() {
+ return augmenting;
}
@Override
- public void setReference(String reference) {
- this.reference = reference;
- }
-
- public Status getStatus() {
- return status;
+ public void setAugmenting(boolean augmenting) {
+ this.augmenting = augmenting;
}
@Override
- public void setStatus(Status status) {
- if (status != null) {
- this.status = status;
- }
- }
-
- public boolean isAugmenting() {
- return augmenting;
+ public boolean isAddedByUses() {
+ return addedByUses;
}
@Override
- public void setAugmenting(boolean augmenting) {
- this.augmenting = augmenting;
+ public void setAddedByUses(final boolean addedByUses) {
+ this.addedByUses = addedByUses;
}
- public boolean isConfiguration() {
+ public Boolean isConfiguration() {
return configuration;
}
@Override
- public void setConfiguration(boolean configuration) {
+ public void setConfiguration(Boolean configuration) {
this.configuration = configuration;
}
return addedUnknownNodes;
}
- @Override
- public void addUnknownSchemaNode(UnknownSchemaNodeBuilder unknownNode) {
- addedUnknownNodes.add(unknownNode);
- }
-
public void setUnknownNodes(List<UnknownSchemaNode> unknownNodes) {
this.unknownNodes = unknownNodes;
}
private String reference;
private Status status = Status.CURRENT;
private boolean augmenting;
+ private boolean addedByUses;
private boolean configuration;
private ConstraintDefinition constraints;
private Set<ChoiceCaseNode> cases = Collections.emptySet();
this.augmenting = augmenting;
}
+ @Override
+ public boolean isAddedByUses() {
+ return addedByUses;
+ }
+
+ private void setAddedByUses(boolean addedByUses) {
+ this.addedByUses = addedByUses;
+ }
+
@Override
public boolean isConfiguration() {
return configuration;
import org.opendaylight.controller.yang.parser.builder.api.UsesNodeBuilder;
import org.opendaylight.controller.yang.parser.util.YangParseException;
-public final class ChoiceCaseBuilder extends AbstractDataNodeContainerBuilder implements
- DataSchemaNodeBuilder, AugmentationTargetBuilder {
+public final class ChoiceCaseBuilder extends AbstractDataNodeContainerBuilder implements DataSchemaNodeBuilder,
+ AugmentationTargetBuilder {
private boolean isBuilt;
private final ChoiceCaseNodeImpl instance;
+ private final ChoiceBuilder parent;
private final int line;
+ // SchemaNode args
private SchemaPath schemaPath;
private String description;
private String reference;
private Status status = Status.CURRENT;
private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
+ // DataSchemaNode args
private boolean augmenting;
private final ConstraintsBuilder constraints;
+ // DataNodeContainer args
private final Set<UsesNodeBuilder> addedUsesNodes = new HashSet<UsesNodeBuilder>();
+ // AugmentationTarget args
private final Set<AugmentationSchemaBuilder> addedAugmentations = new HashSet<AugmentationSchemaBuilder>();
- ChoiceCaseBuilder(final QName qname, final int line) {
+ ChoiceCaseBuilder(final ChoiceBuilder parent, final QName qname, final int line) {
super(qname);
+ this.parent = parent;
this.line = line;
instance = new ChoiceCaseNodeImpl(qname);
constraints = new ConstraintsBuilder(line);
@Override
public ChoiceCaseNode build() {
- if(!isBuilt) {
+ if (!isBuilt) {
instance.setConstraints(constraints.build());
instance.setPath(schemaPath);
instance.setDescription(description);
return line;
}
+ public ChoiceBuilder getParent() {
+ return parent;
+ }
+
public SchemaPath getPath() {
return schemaPath;
}
}
@Override
- public Set<TypeDefinitionBuilder> getTypeDefinitions() {
+ public Set<TypeDefinitionBuilder> getTypeDefinitionBuilders() {
return Collections.emptySet();
}
@Override
public void addTypedef(TypeDefinitionBuilder typedefBuilder) {
- throw new YangParseException(line,
- "Can not add type definition to choice case.");
- }
-
- @Override
- public boolean isConfiguration() {
- return false;
- }
-
- @Override
- public void setConfiguration(boolean configuration) {
- throw new YangParseException(line,
- "Can not add config definition to choice case.");
+ throw new YangParseException(line, "Can not add type definition to choice case.");
}
@Override
this.augmenting = augmenting;
}
+ @Override
+ public boolean isAddedByUses() {
+ return false;
+ }
+
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
return unknownNodes;
return augmentations;
}
- private void setAvailableAugmentations(
- Set<AugmentationSchema> augmentations) {
+ private void setAvailableAugmentations(Set<AugmentationSchema> augmentations) {
if (augmentations != null) {
this.augmentations = augmentations;
}
@Override
public String toString() {
- StringBuilder sb = new StringBuilder(
- ChoiceCaseNodeImpl.class.getSimpleName());
+ StringBuilder sb = new StringBuilder(ChoiceCaseNodeImpl.class.getSimpleName());
sb.append("[");
sb.append("qname=" + qname);
sb.append("]");
import org.opendaylight.controller.yang.model.api.RevisionAwareXPath;
import org.opendaylight.controller.yang.model.util.RevisionAwareXPathImpl;
import org.opendaylight.controller.yang.parser.builder.api.Builder;
+import org.opendaylight.controller.yang.parser.util.YangParseException;
public final class ConstraintsBuilder implements Builder {
private final ConstraintDefinitionImpl instance;
return line;
}
+ @Override
+ public void addUnknownSchemaNode(UnknownSchemaNodeBuilder unknownNode) {
+ throw new YangParseException(line, "Can not add unknown node to constraints.");
+ }
+
public Integer getMinElements() {
return min;
}
this.mandatory = mandatory;
}
- private final class ConstraintDefinitionImpl implements
- ConstraintDefinition {
+ private final class ConstraintDefinitionImpl implements ConstraintDefinition {
private RevisionAwareXPath whenCondition;
private Set<MustDefinition> mustConstraints;
private boolean mandatory;
public int hashCode() {
final int prime = 31;
int result = 1;
- result = prime * result
- + ((whenCondition == null) ? 0 : whenCondition.hashCode());
- result = prime
- * result
- + ((mustConstraints == null) ? 0 : mustConstraints
- .hashCode());
- result = prime * result
- + ((minElements == null) ? 0 : minElements.hashCode());
- result = prime * result
- + ((maxElements == null) ? 0 : maxElements.hashCode());
+ result = prime * result + ((whenCondition == null) ? 0 : whenCondition.hashCode());
+ result = prime * result + ((mustConstraints == null) ? 0 : mustConstraints.hashCode());
+ result = prime * result + ((minElements == null) ? 0 : minElements.hashCode());
+ result = prime * result + ((maxElements == null) ? 0 : maxElements.hashCode());
result = prime * result + (mandatory ? 1231 : 1237);
return result;
}
@Override
public String toString() {
- StringBuilder sb = new StringBuilder(
- ConstraintDefinitionImpl.class.getSimpleName());
+ StringBuilder sb = new StringBuilder(ConstraintDefinitionImpl.class.getSimpleName());
sb.append("[");
sb.append("whenCondition=" + whenCondition);
sb.append(", mustConstraints=" + mustConstraints);
import org.opendaylight.controller.yang.parser.builder.api.AbstractDataNodeContainerBuilder;
import org.opendaylight.controller.yang.parser.builder.api.AugmentationSchemaBuilder;
import org.opendaylight.controller.yang.parser.builder.api.AugmentationTargetBuilder;
+import org.opendaylight.controller.yang.parser.builder.api.ConfigNode;
import org.opendaylight.controller.yang.parser.builder.api.DataSchemaNodeBuilder;
import org.opendaylight.controller.yang.parser.builder.api.GroupingBuilder;
+import org.opendaylight.controller.yang.parser.builder.api.GroupingMember;
import org.opendaylight.controller.yang.parser.builder.api.TypeDefinitionAwareBuilder;
import org.opendaylight.controller.yang.parser.builder.api.TypeDefinitionBuilder;
import org.opendaylight.controller.yang.parser.builder.api.UsesNodeBuilder;
-public final class ContainerSchemaNodeBuilder extends AbstractDataNodeContainerBuilder
- implements TypeDefinitionAwareBuilder, AugmentationTargetBuilder,
- DataSchemaNodeBuilder {
+public final class ContainerSchemaNodeBuilder extends AbstractDataNodeContainerBuilder implements
+ TypeDefinitionAwareBuilder, AugmentationTargetBuilder, DataSchemaNodeBuilder, GroupingMember, ConfigNode {
private boolean isBuilt;
private final ContainerSchemaNodeImpl instance;
private final int line;
- private final ConstraintsBuilder constraints;
+
+ // SchemaNode args
private SchemaPath schemaPath;
private String description;
private String reference;
private Status status = Status.CURRENT;
- private boolean presence;
+ private List<UnknownSchemaNode> unknownNodes;
+ private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
+ // DataSchemaNode args
private boolean augmenting;
- private boolean configuration;
+ private boolean addedByUses;
+ private Boolean configuration;
+ private final ConstraintsBuilder constraints;
+ // DataNodeContainer args
private Set<TypeDefinition<?>> typedefs;
private final Set<TypeDefinitionBuilder> addedTypedefs = new HashSet<TypeDefinitionBuilder>();
private Set<UsesNode> usesNodes;
private final Set<UsesNodeBuilder> addedUsesNodes = new HashSet<UsesNodeBuilder>();
+ // AugmentationTarget args
private Set<AugmentationSchema> augmentations;
private final Set<AugmentationSchemaBuilder> addedAugmentations = new HashSet<AugmentationSchemaBuilder>();
- private List<UnknownSchemaNode> unknownNodes;
- private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
+ // ContainerSchemaNode args
+ private boolean presence;
- public ContainerSchemaNodeBuilder(final QName qname, final int line) {
+ public ContainerSchemaNodeBuilder(final QName qname, final SchemaPath schemaPath, final int line) {
super(qname);
+ this.schemaPath = schemaPath;
this.line = line;
instance = new ContainerSchemaNodeImpl(qname);
constraints = new ConstraintsBuilder(line);
}
+ public ContainerSchemaNodeBuilder(final ContainerSchemaNodeBuilder b) {
+ super(b.getQName());
+ line = b.getLine();
+ instance = new ContainerSchemaNodeImpl(b.getQName());
+ constraints = b.getConstraints();
+ schemaPath = b.getPath();
+ description = b.getDescription();
+ reference = b.getReference();
+ status = b.getStatus();
+ presence = b.isPresence();
+ augmenting = b.isAugmenting();
+ addedByUses = b.isAddedByUses();
+ configuration = b.isConfiguration();
+ childNodes = b.getChildNodes();
+ addedChildNodes.addAll(b.getChildNodeBuilders());
+ groupings = b.getGroupings();
+ addedGroupings.addAll(b.getGroupingBuilders());
+ typedefs = b.typedefs;
+ addedTypedefs.addAll(b.getTypeDefinitionBuilders());
+ usesNodes = b.usesNodes;
+ addedUsesNodes.addAll(b.getUsesNodes());
+ augmentations = b.augmentations;
+ addedAugmentations.addAll(b.getAugmentations());
+ unknownNodes = b.unknownNodes;
+ addedUnknownNodes.addAll(b.getUnknownNodes());
+ }
+
@Override
public ContainerSchemaNode build() {
if (!isBuilt) {
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
+ if(configuration == null) {
+ configuration = false;
+ }
instance.setConfiguration(configuration);
// CHILD NODES
final Map<QName, DataSchemaNode> childs = new HashMap<QName, DataSchemaNode>();
- if(childNodes == null) {
+ if (childNodes == null) {
for (DataSchemaNodeBuilder node : addedChildNodes) {
childs.put(node.getQName(), node.build());
}
} else {
- for(DataSchemaNode node : childNodes) {
+ for (DataSchemaNode node : childNodes) {
childs.put(node.getQName(), node);
}
}
instance.setChildNodes(childs);
// GROUPINGS
- if(groupings == null) {
+ if (groupings == null) {
groupings = new HashSet<GroupingDefinition>();
for (GroupingBuilder builder : addedGroupings) {
groupings.add(builder.build());
instance.setGroupings(groupings);
// TYPEDEFS
- if(typedefs == null) {
+ if (typedefs == null) {
typedefs = new HashSet<TypeDefinition<?>>();
for (TypeDefinitionBuilder entry : addedTypedefs) {
typedefs.add(entry.build());
instance.setTypeDefinitions(typedefs);
// USES
- if(usesNodes == null) {
+ if (usesNodes == null) {
usesNodes = new HashSet<UsesNode>();
for (UsesNodeBuilder builder : addedUsesNodes) {
usesNodes.add(builder.build());
instance.setUses(usesNodes);
// AUGMENTATIONS
- if(augmentations == null) {
+ if (augmentations == null) {
augmentations = new HashSet<AugmentationSchema>();
for (AugmentationSchemaBuilder builder : addedAugmentations) {
augmentations.add(builder.build());
instance.setAvailableAugmentations(augmentations);
// UNKNOWN NODES
- if(unknownNodes == null) {
+ if (unknownNodes == null) {
unknownNodes = new ArrayList<UnknownSchemaNode>();
for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
unknownNodes.add(b.build());
}
@Override
- public Set<TypeDefinitionBuilder> getTypeDefinitions() {
+ public Set<TypeDefinitionBuilder> getTypeDefinitionBuilders() {
return addedTypedefs;
}
}
@Override
- public boolean isConfiguration() {
+ public boolean isAddedByUses() {
+ return addedByUses;
+ }
+
+ @Override
+ public void setAddedByUses(final boolean addedByUses) {
+ this.addedByUses = addedByUses;
+ }
+
+ @Override
+ public Boolean isConfiguration() {
return configuration;
}
@Override
- public void setConfiguration(boolean configuration) {
+ public void setConfiguration(Boolean configuration) {
this.configuration = configuration;
}
private String reference;
private Status status = Status.CURRENT;
private boolean augmenting;
+ private boolean addedByUses;
private boolean configuration;
private ConstraintDefinition constraints;
private Set<AugmentationSchema> augmentations = Collections.emptySet();
this.augmenting = augmenting;
}
+ @Override
+ public boolean isAddedByUses() {
+ return addedByUses;
+ }
+
+ private void setAddedByUses(boolean addedByUses) {
+ this.addedByUses = addedByUses;
+ }
+
@Override
public boolean isConfiguration() {
return configuration;
return augmentations;
}
- private void setAvailableAugmentations(
- Set<AugmentationSchema> augmentations) {
+ private void setAvailableAugmentations(Set<AugmentationSchema> augmentations) {
if (augmentations != null) {
this.augmentations = augmentations;
}
return unknownNodes;
}
- private void setUnknownSchemaNodes(
- List<UnknownSchemaNode> unknownSchemaNodes) {
+ private void setUnknownSchemaNodes(List<UnknownSchemaNode> unknownSchemaNodes) {
if (unknownSchemaNodes != null) {
this.unknownNodes = unknownSchemaNodes;
}
@Override
public String toString() {
- StringBuilder sb = new StringBuilder(
- ContainerSchemaNodeImpl.class.getSimpleName());
+ StringBuilder sb = new StringBuilder(ContainerSchemaNodeImpl.class.getSimpleName());
sb.append("[");
sb.append("qname=" + qname);
sb.append("]");
*/
package org.opendaylight.controller.yang.parser.builder.impl;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
import org.opendaylight.controller.yang.model.api.Deviation;
import org.opendaylight.controller.yang.model.api.Deviation.Deviate;
import org.opendaylight.controller.yang.model.api.SchemaPath;
+import org.opendaylight.controller.yang.model.api.UnknownSchemaNode;
import org.opendaylight.controller.yang.parser.builder.api.Builder;
import org.opendaylight.controller.yang.parser.util.YangModelBuilderUtil;
import org.opendaylight.controller.yang.parser.util.YangParseException;
public final class DeviationBuilder implements Builder {
private final DeviationImpl instance;
private final int line;
+ private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
DeviationBuilder(final String targetPathStr, final int line) {
this.line = line;
@Override
public Deviation build() {
+ // UNKNOWN NODES
+ List<UnknownSchemaNode> unknownNodes = new ArrayList<UnknownSchemaNode>();
+ for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
+ unknownNodes.add(b.build());
+ }
+ instance.setUnknownSchemaNodes(unknownNodes);
+
return instance;
}
return line;
}
+ @Override
+ public void addUnknownSchemaNode(UnknownSchemaNodeBuilder unknownNode) {
+ addedUnknownNodes.add(unknownNode);
+ }
+
public void setDeviate(final String deviate) {
if ("not-supported".equals(deviate)) {
instance.setDeviate(Deviate.NOT_SUPPORTED);
private final SchemaPath targetPath;
private Deviate deviate;
private String reference;
+ private List<UnknownSchemaNode> unknownNodes = Collections.emptyList();
private DeviationImpl(final SchemaPath targetPath) {
this.targetPath = targetPath;
this.reference = reference;
}
+ public List<UnknownSchemaNode> getUnknownSchemaNodes() {
+ return unknownNodes;
+ }
+
+ private void setUnknownSchemaNodes(List<UnknownSchemaNode> unknownSchemaNodes) {
+ if (unknownSchemaNodes != null) {
+ this.unknownNodes = unknownSchemaNodes;
+ }
+ }
+
@Override
public int hashCode() {
final int prime = 31;
import org.opendaylight.controller.yang.model.api.SchemaPath;
import org.opendaylight.controller.yang.model.api.Status;
import org.opendaylight.controller.yang.model.api.UnknownSchemaNode;
-import org.opendaylight.controller.yang.parser.builder.api.SchemaNodeBuilder;
+import org.opendaylight.controller.yang.parser.builder.api.AbstractSchemaNodeBuilder;
-public final class ExtensionBuilder implements SchemaNodeBuilder {
+public final class ExtensionBuilder extends AbstractSchemaNodeBuilder {
private boolean isBuilt;
private final ExtensionDefinitionImpl instance;
- private final int line;
- private final QName qname;
- private SchemaPath schemaPath;
- private String description;
- private String reference;
- private Status status = Status.CURRENT;
private final List<UnknownSchemaNodeBuilder> addedExtensions = new ArrayList<UnknownSchemaNodeBuilder>();
- private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
ExtensionBuilder(final QName qname, final int line) {
- this.qname = qname;
- this.line = line;
+ super(qname, line);
instance = new ExtensionDefinitionImpl(qname);
}
@Override
public ExtensionDefinition build() {
if(!isBuilt) {
- instance.setPath(schemaPath);
+ instance.setPath(path);
instance.setDescription(description);
instance.setReference(reference);
instance.setStatus(status);
return instance;
}
- @Override
- public int getLine() {
- return line;
- }
public void addExtension(UnknownSchemaNodeBuilder extension) {
addedExtensions.add(extension);
instance.setArgument(argument);
}
- @Override
- public QName getQName() {
- return qname;
- }
-
- @Override
- public SchemaPath getPath() {
- return schemaPath;
- }
-
- @Override
- public void setPath(SchemaPath schemaPath) {
- this.schemaPath = schemaPath;
- }
-
- @Override
- public String getDescription() {
- return description;
- }
-
- @Override
- public void setDescription(final String description) {
- this.description = description;
- }
-
- @Override
- public String getReference() {
- return reference;
- }
-
- @Override
- public void setReference(final String reference) {
- this.reference = reference;
- }
-
- @Override
- public Status getStatus() {
- return status;
- }
-
- @Override
- public void setStatus(final Status status) {
- instance.setStatus(status);
- }
-
- @Override
- public void addUnknownSchemaNode(final UnknownSchemaNodeBuilder unknownNode) {
- addedUnknownNodes.add(unknownNode);
- }
private final class ExtensionDefinitionImpl implements ExtensionDefinition {
private final QName qname;
import org.opendaylight.controller.yang.model.api.SchemaPath;
import org.opendaylight.controller.yang.model.api.Status;
import org.opendaylight.controller.yang.model.api.UnknownSchemaNode;
-import org.opendaylight.controller.yang.parser.builder.api.SchemaNodeBuilder;
+import org.opendaylight.controller.yang.parser.builder.api.AbstractSchemaNodeBuilder;
-public final class FeatureBuilder implements SchemaNodeBuilder {
+public final class FeatureBuilder extends AbstractSchemaNodeBuilder {
private boolean isBuilt;
private final FeatureDefinitionImpl instance;
- private final int line;
- private final QName qname;
- private SchemaPath schemaPath;
- private String description;
- private String reference;
- private Status status = Status.CURRENT;
- private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
FeatureBuilder(final QName qname, final int line) {
- this.qname = qname;
- this.line = line;
+ super(qname, line);
instance = new FeatureDefinitionImpl(qname);
}
@Override
public FeatureDefinitionImpl build() {
- if(!isBuilt) {
- instance.setPath(schemaPath);
+ if (!isBuilt) {
+ instance.setPath(path);
instance.setDescription(description);
instance.setReference(reference);
instance.setStatus(status);
return instance;
}
- @Override
- public int getLine() {
- return line;
- }
-
- @Override
- public QName getQName() {
- return qname;
- }
-
- @Override
- public SchemaPath getPath() {
- return schemaPath;
- }
-
- @Override
- public void setPath(SchemaPath schemaPath) {
- this.schemaPath = schemaPath;
- }
-
- @Override
- public String getDescription() {
- return description;
- }
-
- @Override
- public void setDescription(final String description) {
- this.description = description;
- }
-
- @Override
- public String getReference() {
- return reference;
- }
-
- @Override
- public void setReference(final String reference) {
- this.reference = reference;
- }
-
- @Override
- public Status getStatus() {
- return status;
- }
-
- @Override
- public void setStatus(final Status status) {
- this.status = status;
- }
-
- @Override
- public void addUnknownSchemaNode(final UnknownSchemaNodeBuilder unknownNode) {
- addedUnknownNodes.add(unknownNode);
- }
-
private final class FeatureDefinitionImpl implements FeatureDefinition {
private final QName qname;
private SchemaPath path;
return unknownNodes;
}
- private void setUnknownSchemaNodes(
- final List<UnknownSchemaNode> unknownNodes) {
+ private void setUnknownSchemaNodes(final List<UnknownSchemaNode> unknownNodes) {
if (unknownNodes != null) {
this.unknownNodes = unknownNodes;
}
@Override
public String toString() {
- StringBuilder sb = new StringBuilder(
- FeatureDefinitionImpl.class.getSimpleName());
+ StringBuilder sb = new StringBuilder(FeatureDefinitionImpl.class.getSimpleName());
sb.append("[name=" + qname + "]");
return sb.toString();
}
private String description;
private String reference;
private Status status = Status.CURRENT;
+ private boolean addedByUses;
private Set<DataSchemaNode> childNodes;
private final Set<DataSchemaNodeBuilder> addedChildNodes = new HashSet<DataSchemaNodeBuilder>();
public GroupingBuilderImpl(final QName qname, final int line) {
this.qname = qname;
- this.instance = new GroupingDefinitionImpl(qname);
+ instance = new GroupingDefinitionImpl(qname);
this.line = line;
}
+ public GroupingBuilderImpl(GroupingBuilder builder) {
+ qname = builder.getQName();
+ instance = new GroupingDefinitionImpl(qname);
+ line = builder.getLine();
+ schemaPath = builder.getPath();
+ description = builder.getDescription();
+ reference = builder.getReference();
+ status = builder.getStatus();
+ addedByUses = builder.isAddedByUses();
+ childNodes = builder.getChildNodes();
+ addedChildNodes.addAll(builder.getChildNodeBuilders());
+ groupings = builder.getGroupings();
+ addedGroupings.addAll(builder.getGroupingBuilders());
+ addedUsesNodes.addAll(builder.getUses());
+ addedUnknownNodes.addAll(builder.getUnknownNodes());
+ }
+
@Override
public GroupingDefinition build() {
if (!isBuilt) {
instance.setDescription(description);
instance.setReference(reference);
instance.setStatus(status);
+ instance.setAddedByUses(addedByUses);
// CHILD NODES
final Map<QName, DataSchemaNode> childs = new HashMap<QName, DataSchemaNode>();
- if(childNodes == null) {
+ if (childNodes == null) {
for (DataSchemaNodeBuilder node : addedChildNodes) {
childs.put(node.getQName(), node.build());
}
} else {
- for(DataSchemaNode node : childNodes) {
+ for (DataSchemaNode node : childNodes) {
childs.put(node.getQName(), node);
}
}
}
@Override
- public Set<TypeDefinitionBuilder> getTypeDefinitions() {
+ public Set<TypeDefinitionBuilder> getTypeDefinitionBuilders() {
return addedTypedefs;
}
this.status = status;
}
+ @Override
+ public boolean isAddedByUses() {
+ return addedByUses;
+ }
+
+ @Override
+ public void setAddedByUses(final boolean addedByUses) {
+ this.addedByUses = addedByUses;
+ }
+
@Override
public DataSchemaNodeBuilder getChildNode(String name) {
DataSchemaNodeBuilder result = null;
return result;
}
+ @Override
+ public Set<DataSchemaNode> getChildNodes() {
+ return childNodes;
+ }
+
@Override
public void addChildNode(final DataSchemaNodeBuilder childNode) {
addedChildNodes.add(childNode);
}
@Override
- public Set<DataSchemaNodeBuilder> getChildNodes() {
+ public Set<DataSchemaNodeBuilder> getChildNodeBuilders() {
return addedChildNodes;
}
}
@Override
- public Set<GroupingBuilder> getGroupings() {
+ public Set<GroupingDefinition> getGroupings() {
+ return Collections.emptySet();
+ }
+
+ @Override
+ public Set<GroupingBuilder> getGroupingBuilders() {
return addedGroupings;
}
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();
this.status = status;
}
+ @Override
+ public boolean isAddedByUses() {
+ return addedByUses;
+ }
+
+ private void setAddedByUses(final boolean addedByUses) {
+ this.addedByUses = addedByUses;
+ }
+
@Override
public Set<DataSchemaNode> getChildNodes() {
return new HashSet<DataSchemaNode>(childNodes.values());
import org.opendaylight.controller.yang.model.api.SchemaPath;
import org.opendaylight.controller.yang.model.api.Status;
import org.opendaylight.controller.yang.model.api.UnknownSchemaNode;
-import org.opendaylight.controller.yang.parser.builder.api.SchemaNodeBuilder;
+import org.opendaylight.controller.yang.parser.builder.api.AbstractSchemaNodeBuilder;
-public final class IdentitySchemaNodeBuilder implements SchemaNodeBuilder {
+public final class IdentitySchemaNodeBuilder extends AbstractSchemaNodeBuilder {
private boolean isBuilt;
private final IdentitySchemaNodeImpl instance;
- private final int line;
- private final QName qname;
- private SchemaPath schemaPath;
- private String description;
- private String reference;
- private Status status = Status.CURRENT;
private IdentitySchemaNodeBuilder baseIdentityBuilder;
private IdentitySchemaNode baseIdentity;
private String baseIdentityName;
- private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
IdentitySchemaNodeBuilder(final QName qname, final int line) {
- this.qname = qname;
- this.line = line;
+ super(qname, line);
instance = new IdentitySchemaNodeImpl(qname);
}
@Override
public IdentitySchemaNode build() {
- if(!isBuilt) {
- instance.setPath(schemaPath);
+ if (!isBuilt) {
+ instance.setPath(path);
instance.setDescription(description);
instance.setReference(reference);
instance.setStatus(status);
return instance;
}
- @Override
- public int getLine() {
- return line;
- }
-
- @Override
- public QName getQName() {
- return qname;
- }
-
- @Override
- public SchemaPath getPath() {
- return schemaPath;
- }
-
- @Override
- public void setPath(SchemaPath schemaPath) {
- this.schemaPath = schemaPath;
- }
-
- @Override
- public String getDescription() {
- return description;
- }
-
- @Override
- public void setDescription(final String description) {
- this.description = description;
- }
-
- @Override
- public String getReference() {
- return reference;
- }
-
- @Override
- public void setReference(final String reference) {
- this.reference = reference;
- }
-
- @Override
- public Status getStatus() {
- return status;
- }
-
- @Override
- public void setStatus(final Status status) {
- if (status != null) {
- this.status = status;
- }
- }
-
- @Override
- public void addUnknownSchemaNode(final UnknownSchemaNodeBuilder unknownNode) {
- addedUnknownNodes.add(unknownNode);
- }
-
public String getBaseIdentityName() {
return baseIdentityName;
}
import org.opendaylight.controller.yang.model.api.SchemaPath;
import org.opendaylight.controller.yang.model.api.Status;
import org.opendaylight.controller.yang.model.api.TypeDefinition;
+import org.opendaylight.controller.yang.model.api.UnknownSchemaNode;
import org.opendaylight.controller.yang.model.api.type.LengthConstraint;
import org.opendaylight.controller.yang.model.api.type.PatternConstraint;
import org.opendaylight.controller.yang.model.api.type.RangeConstraint;
* When build is called, types in builder form will be built and add to resolved
* types.
*/
-public final class IdentityrefTypeBuilder extends AbstractTypeAwareBuilder
- implements TypeDefinitionBuilder {
+public final class IdentityrefTypeBuilder extends AbstractTypeAwareBuilder implements TypeDefinitionBuilder {
private static final String NAME = "identityref";
private final int line;
private final SchemaPath schemaPath;
private QName baseQName;
- IdentityrefTypeBuilder(final String baseString,
- final SchemaPath schemaPath, final int line) {
+ IdentityrefTypeBuilder(final String baseString, final SchemaPath schemaPath, final int line) {
this.line = line;
this.baseString = baseString;
this.schemaPath = schemaPath;
throw new YangParseException(line, "Can not set status to " + NAME);
}
+ @Override
+ public boolean isAddedByUses() {
+ return false;
+ }
+
+ @Override
+ public void setAddedByUses(final boolean addedByUses) {
+ throw new YangParseException(line, "Identityref type can not be added by uses.");
+ }
+
+ @Override
+ public List<UnknownSchemaNode> getUnknownNodes() {
+ return Collections.emptyList();
+ }
+
@Override
public void addUnknownSchemaNode(final UnknownSchemaNodeBuilder unknownNode) {
- throw new YangParseException(line, "Can not add unknown node to "
- + NAME);
+ throw new YangParseException(line, "Can not add unknown node to " + NAME);
}
@Override
@Override
public void setFractionDigits(Integer fractionDigits) {
- throw new YangParseException(line, "Can not set fraction digits to "
- + NAME);
+ throw new YangParseException(line, "Can not set fraction digits to " + NAME);
}
@Override
- public List<UnknownSchemaNodeBuilder> getUnknownNodes() {
+ public List<UnknownSchemaNodeBuilder> getUnknownNodeBuilders() {
return Collections.emptyList();
}
@Override
public void setDefaultValue(Object defaultValue) {
- throw new YangParseException(line, "Can not set default value to "
- + NAME);
+ throw new YangParseException(line, "Can not set default value to " + NAME);
}
@Override
@Override
public String toString() {
- final StringBuilder result = new StringBuilder(
- IdentityrefTypeBuilder.class.getSimpleName() + "[");
+ final StringBuilder result = new StringBuilder(IdentityrefTypeBuilder.class.getSimpleName() + "[");
result.append(", base=" + baseQName);
result.append("]");
return result.toString();
import org.opendaylight.controller.yang.model.api.TypeDefinition;
import org.opendaylight.controller.yang.model.api.UnknownSchemaNode;
import org.opendaylight.controller.yang.parser.builder.api.AbstractTypeAwareBuilder;
+import org.opendaylight.controller.yang.parser.builder.api.ConfigNode;
import org.opendaylight.controller.yang.parser.builder.api.DataSchemaNodeBuilder;
+import org.opendaylight.controller.yang.parser.builder.api.GroupingMember;
-public final class LeafListSchemaNodeBuilder extends AbstractTypeAwareBuilder implements DataSchemaNodeBuilder {
+public final class LeafListSchemaNodeBuilder extends AbstractTypeAwareBuilder implements DataSchemaNodeBuilder,
+ GroupingMember, ConfigNode {
private boolean isBuilt;
private final LeafListSchemaNodeImpl instance;
private final int line;
private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
// DataSchemaNode args
private boolean augmenting;
- private boolean configuration;
+ private boolean addedByUses;
+ private Boolean configuration;
private final ConstraintsBuilder constraints;
// LeafListSchemaNode args
private boolean userOrdered;
- public LeafListSchemaNodeBuilder(final QName qname, final int line) {
+ public LeafListSchemaNodeBuilder(final QName qname, final SchemaPath schemaPath, final int line) {
this.qname = qname;
+ this.schemaPath = schemaPath;
this.line = line;
instance = new LeafListSchemaNodeImpl(qname);
constraints = new ConstraintsBuilder(line);
}
+ public LeafListSchemaNodeBuilder(final LeafListSchemaNodeBuilder b) {
+ qname = b.getQName();
+ line = b.getLine();
+ instance = new LeafListSchemaNodeImpl(qname);
+
+ type = b.getType();
+ typedef = b.getTypedef();
+
+ constraints = b.getConstraints();
+ schemaPath = b.getPath();
+ description = b.getDescription();
+ reference = b.getReference();
+ status = b.getStatus();
+ augmenting = b.isAugmenting();
+ addedByUses = b.isAddedByUses();
+ configuration = b.isConfiguration();
+ userOrdered = b.isUserOrdered();
+ unknownNodes = b.unknownNodes;
+ addedUnknownNodes.addAll(b.getUnknownNodes());
+ }
+
@Override
public LeafListSchemaNode build() {
if (!isBuilt) {
instance.setReference(reference);
instance.setStatus(status);
instance.setAugmenting(augmenting);
+ instance.setAddedByUses(addedByUses);
instance.setConfiguration(configuration);
instance.setUserOrdered(userOrdered);
this.augmenting = augmenting;
}
- public boolean isConfiguration() {
+ @Override
+ public boolean isAddedByUses() {
+ return addedByUses;
+ }
+
+ @Override
+ public void setAddedByUses(final boolean addedByUses) {
+ this.addedByUses = addedByUses;
+ }
+
+ public Boolean isConfiguration() {
return configuration;
}
@Override
- public void setConfiguration(boolean configuration) {
+ public void setConfiguration(Boolean configuration) {
this.configuration = configuration;
}
private String reference;
private Status status = Status.CURRENT;
private boolean augmenting;
+ private boolean addedByUses;
private boolean configuration;
private ConstraintDefinition constraintsDef;
private TypeDefinition<?> type;
this.augmenting = augmenting;
}
+ @Override
+ public boolean isAddedByUses() {
+ return addedByUses;
+ }
+
+ private void setAddedByUses(final boolean addedByUses) {
+ this.addedByUses = addedByUses;
+ }
+
@Override
public boolean isConfiguration() {
return configuration;
import org.opendaylight.controller.yang.model.api.TypeDefinition;
import org.opendaylight.controller.yang.model.api.UnknownSchemaNode;
import org.opendaylight.controller.yang.parser.builder.api.AbstractTypeAwareBuilder;
+import org.opendaylight.controller.yang.parser.builder.api.ConfigNode;
import org.opendaylight.controller.yang.parser.builder.api.DataSchemaNodeBuilder;
+import org.opendaylight.controller.yang.parser.builder.api.GroupingMember;
-public final class LeafSchemaNodeBuilder extends AbstractTypeAwareBuilder implements DataSchemaNodeBuilder {
+public final class LeafSchemaNodeBuilder extends AbstractTypeAwareBuilder implements DataSchemaNodeBuilder,
+ GroupingMember, ConfigNode {
private boolean isBuilt;
private final LeafSchemaNodeImpl instance;
private final int line;
private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
// DataSchemaNode args
private boolean augmenting;
- private boolean configuration;
+ private boolean addedByUses;
+ private Boolean configuration;
private final ConstraintsBuilder constraints;
// leaf args
private String defaultStr;
private String unitsStr;
- public LeafSchemaNodeBuilder(final QName qname, final int line) {
+ public LeafSchemaNodeBuilder(final QName qname, final SchemaPath schemaPath, final int line) {
this.qname = qname;
+ this.path = schemaPath;
this.line = line;
instance = new LeafSchemaNodeImpl(qname);
constraints = new ConstraintsBuilder(line);
}
+ public LeafSchemaNodeBuilder(final LeafSchemaNodeBuilder b) {
+ qname = b.getQName();
+ line = b.getLine();
+ instance = new LeafSchemaNodeImpl(qname);
+ constraints = b.getConstraints();
+ path = b.getPath();
+
+ type = b.getType();
+ typedef = b.getTypedef();
+
+ description = b.getDescription();
+ reference = b.getReference();
+ status = b.getStatus();
+ augmenting = b.isAugmenting();
+ addedByUses = b.isAddedByUses();
+ configuration = b.isConfiguration();
+ unknownNodes = b.unknownNodes;
+ addedUnknownNodes.addAll(b.getUnknownNodes());
+
+ defaultStr = b.getDefaultStr();
+ unitsStr = b.getUnits();
+ }
+
@Override
public LeafSchemaNode build() {
if (!isBuilt) {
instance.setReference(reference);
instance.setStatus(status);
instance.setAugmenting(augmenting);
+ instance.setAddedByUses(addedByUses);
instance.setConfiguration(configuration);
instance.setDefault(defaultStr);
instance.setUnits(unitsStr);
this.augmenting = augmenting;
}
- public boolean isConfiguration() {
+ @Override
+ public boolean isAddedByUses() {
+ return addedByUses;
+ }
+
+ @Override
+ public void setAddedByUses(final boolean addedByUses) {
+ this.addedByUses = addedByUses;
+ }
+
+ public Boolean isConfiguration() {
return configuration;
}
@Override
- public void setConfiguration(final boolean configuration) {
- instance.setConfiguration(configuration);
+ public void setConfiguration(final Boolean configuration) {
+ this.configuration = configuration;
}
public String getDefaultStr() {
private String reference;
private Status status = Status.CURRENT;
private boolean augmenting;
+ private boolean addedByUses;
private boolean configuration;
private ConstraintDefinition constraintsDef;
private TypeDefinition<?> type;
this.augmenting = augmenting;
}
+ @Override
+ public boolean isAddedByUses() {
+ return addedByUses;
+ }
+
+ private void setAddedByUses(final boolean addedByUses) {
+ this.addedByUses = addedByUses;
+ }
+
@Override
public boolean isConfiguration() {
return configuration;
import org.opendaylight.controller.yang.parser.builder.api.AbstractDataNodeContainerBuilder;
import org.opendaylight.controller.yang.parser.builder.api.AugmentationSchemaBuilder;
import org.opendaylight.controller.yang.parser.builder.api.AugmentationTargetBuilder;
+import org.opendaylight.controller.yang.parser.builder.api.ConfigNode;
import org.opendaylight.controller.yang.parser.builder.api.DataSchemaNodeBuilder;
import org.opendaylight.controller.yang.parser.builder.api.GroupingBuilder;
+import org.opendaylight.controller.yang.parser.builder.api.GroupingMember;
import org.opendaylight.controller.yang.parser.builder.api.TypeDefinitionAwareBuilder;
import org.opendaylight.controller.yang.parser.builder.api.TypeDefinitionBuilder;
import org.opendaylight.controller.yang.parser.builder.api.UsesNodeBuilder;
-public final class ListSchemaNodeBuilder extends AbstractDataNodeContainerBuilder
- implements DataSchemaNodeBuilder, AugmentationTargetBuilder,
- TypeDefinitionAwareBuilder {
+public final class ListSchemaNodeBuilder extends AbstractDataNodeContainerBuilder implements DataSchemaNodeBuilder,
+ AugmentationTargetBuilder, TypeDefinitionAwareBuilder, GroupingMember, ConfigNode {
private boolean isBuilt;
private final ListSchemaNodeImpl instance;
private final int line;
private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
// DataSchemaNode args
private boolean augmenting;
- private boolean configuration;
+ private boolean addedByUses;
+ private Boolean configuration;
private final ConstraintsBuilder constraints;
// DataNodeContainer args
private Set<TypeDefinition<?>> typedefs;
private List<QName> keyDefinition = Collections.emptyList();
private boolean userOrdered;
- public ListSchemaNodeBuilder(final QName qname, final int line) {
+ public ListSchemaNodeBuilder(final QName qname, final SchemaPath schemaPath, final int line) {
super(qname);
+ this.schemaPath = schemaPath;
this.line = line;
instance = new ListSchemaNodeImpl(qname);
constraints = new ConstraintsBuilder(line);
}
+ public ListSchemaNodeBuilder(final ListSchemaNodeBuilder b) {
+ super(b.getQName());
+ line = b.getLine();
+ instance = new ListSchemaNodeImpl(b.getQName());
+ constraints = b.getConstraints();
+ schemaPath = b.getPath();
+ description = b.getDescription();
+ reference = b.getReference();
+ status = b.getStatus();
+ augmenting = b.isAugmenting();
+ addedByUses = b.isAddedByUses();
+ configuration = b.isConfiguration();
+ keyDefinition = b.getKeyDefinition();
+ userOrdered = b.isUserOrdered();
+ childNodes = b.getChildNodes();
+ addedChildNodes.addAll(b.getChildNodeBuilders());
+ groupings = b.getGroupings();
+ addedGroupings.addAll(b.getGroupingBuilders());
+ typedefs = b.typedefs;
+ addedTypedefs.addAll(b.getTypeDefinitionBuilders());
+ usesNodes = b.usesNodes;
+ addedUsesNodes.addAll(b.getUsesNodes());
+ augmentations = b.augmentations;
+ addedAugmentations.addAll(b.getAugmentations());
+ unknownNodes = b.unknownNodes;
+ addedUnknownNodes.addAll(b.getUnknownNodes());
+ }
+
@Override
public ListSchemaNode build() {
if (!isBuilt) {
instance.setReference(reference);
instance.setStatus(status);
instance.setAugmenting(augmenting);
+ instance.setAddedByUses(addedByUses);
instance.setConfiguration(configuration);
instance.setUserOrdered(userOrdered);
// CHILD NODES
final Map<QName, DataSchemaNode> childs = new HashMap<QName, DataSchemaNode>();
- if(childNodes == null) {
+ if (childNodes == null) {
for (DataSchemaNodeBuilder node : addedChildNodes) {
childs.put(node.getQName(), node.build());
}
} else {
- for(DataSchemaNode node : childNodes) {
+ for (DataSchemaNode node : childNodes) {
childs.put(node.getQName(), node);
}
}
instance.setChildNodes(childs);
// TYPEDEFS
- if(typedefs == null) {
+ if (typedefs == null) {
typedefs = new HashSet<TypeDefinition<?>>();
for (TypeDefinitionBuilder entry : addedTypedefs) {
typedefs.add(entry.build());
instance.setTypeDefinitions(typedefs);
// USES
- if(usesNodes == null) {
+ if (usesNodes == null) {
usesNodes = new HashSet<UsesNode>();
for (UsesNodeBuilder builder : addedUsesNodes) {
usesNodes.add(builder.build());
instance.setUses(usesNodes);
// GROUPINGS
- if(groupings == null) {
+ if (groupings == null) {
groupings = new HashSet<GroupingDefinition>();
for (GroupingBuilder builder : addedGroupings) {
groupings.add(builder.build());
instance.setGroupings(groupings);
// AUGMENTATIONS
- if(augmentations == null) {
+ if (augmentations == null) {
augmentations = new HashSet<AugmentationSchema>();
for (AugmentationSchemaBuilder builder : addedAugmentations) {
augmentations.add(builder.build());
instance.setAvailableAugmentations(augmentations);
// UNKNOWN NODES
- if(unknownNodes == null) {
+ if (unknownNodes == null) {
unknownNodes = new ArrayList<UnknownSchemaNode>();
for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
unknownNodes.add(b.build());
}
@Override
- public Set<TypeDefinitionBuilder> getTypeDefinitions() {
+ public Set<TypeDefinitionBuilder> getTypeDefinitionBuilders() {
return addedTypedefs;
}
this.augmenting = augmenting;
}
- public boolean isConfiguration() {
+ @Override
+ public boolean isAddedByUses() {
+ return addedByUses;
+ }
+
+ @Override
+ public void setAddedByUses(final boolean addedByUses) {
+ this.addedByUses = addedByUses;
+ }
+
+ public Boolean isConfiguration() {
return configuration;
}
@Override
- public void setConfiguration(boolean configuration) {
+ public void setConfiguration(Boolean configuration) {
this.configuration = configuration;
}
this.unknownNodes = unknownNodes;
}
-
public final class ListSchemaNodeImpl implements ListSchemaNode {
private final QName qname;
private SchemaPath path;
private Status status = Status.CURRENT;
private List<QName> keyDefinition = Collections.emptyList();
private boolean augmenting;
+ private boolean addedByUses;
private boolean configuration;
private ConstraintDefinition constraints;
private Set<AugmentationSchema> augmentations = Collections.emptySet();
this.augmenting = augmenting;
}
+ @Override
+ public boolean isAddedByUses() {
+ return addedByUses;
+ }
+
+ private void setAddedByUses(final boolean addedByUses) {
+ this.addedByUses = addedByUses;
+ }
+
@Override
public boolean isConfiguration() {
return configuration;
return augmentations;
}
- private void setAvailableAugmentations(
- Set<AugmentationSchema> augmentations) {
+ private void setAvailableAugmentations(Set<AugmentationSchema> augmentations) {
if (augmentations != null) {
this.augmentations = augmentations;
}
@Override
public String toString() {
- StringBuilder sb = new StringBuilder(
- ListSchemaNodeImpl.class.getSimpleName());
+ StringBuilder sb = new StringBuilder(ListSchemaNodeImpl.class.getSimpleName());
sb.append("[");
sb.append("qname=" + qname);
sb.append(", path=" + path);
* module/modules, these dependencies must be resolved before module is built,
* otherwise result may not be valid.
*/
-public class ModuleBuilder implements Builder {
+public class ModuleBuilder implements DataNodeContainerBuilder {
private final ModuleImpl instance;
private final String name;
private URI namespace;
private final Map<List<String>, TypeDefinitionBuilder> addedTypedefs = new HashMap<List<String>, TypeDefinitionBuilder>();
private final Map<List<String>, UnionTypeBuilder> addedUnionTypes = new HashMap<List<String>, UnionTypeBuilder>();
private final List<ExtensionBuilder> addedExtensions = new ArrayList<ExtensionBuilder>();
- private final Map<List<String>, UnknownSchemaNodeBuilder> addedUnknownNodes = new HashMap<List<String>, UnknownSchemaNodeBuilder>();
+ private final Map<List<String>, List<UnknownSchemaNodeBuilder>> addedUnknownNodes = new HashMap<List<String>, List<UnknownSchemaNodeBuilder>>();
private final Map<List<String>, TypeAwareBuilder> dirtyNodes = new HashMap<List<String>, TypeAwareBuilder>();
return 0;
}
+ @Override
+ public QName getQName() {
+ return new QName(namespace, revision, prefix, name);
+ }
+
+ @Override
+ public SchemaPath getPath() {
+ return null;
+ }
+
+ @Override
+ public Set<TypeDefinitionBuilder> getTypeDefinitionBuilders() {
+ final Set<TypeDefinitionBuilder> typeDefinitions = new HashSet<TypeDefinitionBuilder>();
+ for (final Map.Entry<List<String>, TypeDefinitionBuilder> entry : addedTypedefs.entrySet()) {
+ final List<String> key = entry.getKey();
+ final TypeDefinitionBuilder typedefBuilder = entry.getValue();
+ if (key.size() == 2) {
+ typeDefinitions.add(typedefBuilder);
+
+ }
+ }
+ return typeDefinitions;
+ }
+
public void enterNode(final Builder node) {
actualPath.push(node);
}
}
}
+ public Builder getActualParent() {
+ if (actualPath.size() < 2) {
+ return null;
+ } else {
+ return actualPath.get(1);
+ }
+ }
+
public Builder getModuleNode(final List<String> path) {
return childNodes.get(path);
}
return addedGroupings.get(path);
}
+ @Override
+ public Set<GroupingDefinition> getGroupings() {
+ return Collections.emptySet();
+ }
+
+ @Override
+ public Set<GroupingBuilder> getGroupingBuilders() {
+ final Set<GroupingBuilder> result = new HashSet<GroupingBuilder>();
+ for (Map.Entry<List<String>, GroupingBuilder> entry : addedGroupings.entrySet()) {
+ if (entry.getKey().size() == 2) {
+ result.add(entry.getValue());
+ }
+ }
+ return result;
+ }
+
public Builder getModuleTypedef(final List<String> path) {
return addedTypedefs.get(path);
}
- public Set<DataSchemaNodeBuilder> getChildNodes() {
+ @Override
+ public Set<DataSchemaNode> getChildNodes() {
+ return Collections.emptySet();
+ }
+
+ public Set<DataSchemaNodeBuilder> getChildNodeBuilders() {
final Set<DataSchemaNodeBuilder> children = new HashSet<DataSchemaNodeBuilder>();
for (Map.Entry<List<String>, DataSchemaNodeBuilder> entry : childNodes.entrySet()) {
final List<String> path = entry.getKey();
return addedUsesNodes;
}
- public Set<UnknownSchemaNodeBuilder> getUnknownNodes() {
- return new HashSet<UnknownSchemaNodeBuilder>(addedUnknownNodes.values());
+ public List<UnknownSchemaNodeBuilder> getUnknownNodes() {
+ List<UnknownSchemaNodeBuilder> result = new ArrayList<UnknownSchemaNodeBuilder>();
+ for (List<UnknownSchemaNodeBuilder> entry : addedUnknownNodes.values()) {
+ result.addAll(entry);
+ }
+ return result;
}
public Set<TypeDefinitionBuilder> getModuleTypedefs() {
return builder;
}
- public ContainerSchemaNodeBuilder addContainerNode(final QName containerName, final List<String> parentPath,
- final int line) {
+ @Override
+ public void addChildNode(DataSchemaNodeBuilder child) {
+ final List<String> pathToChild = new ArrayList<String>();
+ for (QName qname : child.getPath().getPath()) {
+ pathToChild.add(qname.getLocalName());
+ }
+ if (childNodes.containsKey(pathToChild)) {
+ throw new YangParseException(this.name, child.getLine(), "Failed to add child node "
+ + child.getQName().getLocalName() + ": node already exists in context.");
+ }
+ childNodes.put(pathToChild, child);
+ }
+
+ public ContainerSchemaNodeBuilder addContainerNode(final SchemaPath schemaPath, final QName containerName,
+ final List<String> parentPath, final int line) {
final List<String> pathToNode = new ArrayList<String>(parentPath);
- final ContainerSchemaNodeBuilder containerBuilder = new ContainerSchemaNodeBuilder(containerName, line);
+ final ContainerSchemaNodeBuilder containerBuilder = new ContainerSchemaNodeBuilder(containerName, schemaPath, line);
updateParent(containerBuilder, line, "container");
pathToNode.add(containerName.getLocalName());
return containerBuilder;
}
- public ListSchemaNodeBuilder addListNode(final QName listName, final List<String> parentPath, final int line) {
+ public ListSchemaNodeBuilder addListNode(final SchemaPath schemaPath, final QName listName, final List<String> parentPath, final int line) {
final List<String> pathToNode = new ArrayList<String>(parentPath);
- final ListSchemaNodeBuilder listBuilder = new ListSchemaNodeBuilder(listName, line);
+ final ListSchemaNodeBuilder listBuilder = new ListSchemaNodeBuilder(listName, schemaPath, line);
updateParent(listBuilder, line, "list");
pathToNode.add(listName.getLocalName());
return listBuilder;
}
- public LeafSchemaNodeBuilder addLeafNode(final QName leafName, final List<String> parentPath, final int line) {
+ public LeafSchemaNodeBuilder addLeafNode(final SchemaPath schemaPath, final QName leafName, final List<String> parentPath, final int line) {
final List<String> pathToNode = new ArrayList<String>(parentPath);
- final LeafSchemaNodeBuilder leafBuilder = new LeafSchemaNodeBuilder(leafName, line);
+ final LeafSchemaNodeBuilder leafBuilder = new LeafSchemaNodeBuilder(leafName, schemaPath, line);
updateParent(leafBuilder, line, "leaf");
pathToNode.add(leafName.getLocalName());
return leafBuilder;
}
- public LeafListSchemaNodeBuilder addLeafListNode(final QName qname, final List<String> parentPath, final int line) {
+ public LeafListSchemaNodeBuilder addLeafListNode(final SchemaPath schemaPath, final QName qname, final List<String> parentPath, final int line) {
final List<String> pathToNode = new ArrayList<String>(parentPath);
- final LeafListSchemaNodeBuilder leafListBuilder = new LeafListSchemaNodeBuilder(qname, line);
+ final LeafListSchemaNodeBuilder leafListBuilder = new LeafListSchemaNodeBuilder(qname, schemaPath, line);
updateParent(leafListBuilder, line, "leaf-list");
pathToNode.add(qname.getLocalName());
return leafListBuilder;
}
+ @Override
+ public void addGrouping(GroupingBuilder groupingBuilder) {
+ final List<String> pathToGroup = new ArrayList<String>();
+ for (QName qname : groupingBuilder.getPath().getPath()) {
+ pathToGroup.add(qname.getLocalName());
+ }
+ if (addedGroupings.containsKey(pathToGroup)) {
+ throw new YangParseException(this.name, groupingBuilder.getLine(), "Failed to add grouping "
+ + groupingBuilder.getQName().getLocalName() + ": grouping already exists in context.");
+ }
+ addedGroupings.put(pathToGroup, groupingBuilder);
+ }
+
public GroupingBuilder addGrouping(final QName qname, final List<String> parentPath, final int line) {
final List<String> pathToGroup = new ArrayList<String>(parentPath);
final GroupingBuilder builder = new GroupingBuilderImpl(qname, line);
public AugmentationSchemaBuilder addAugment(final String name, final List<String> parentPath, final int line) {
final List<String> pathToAugment = new ArrayList<String>(parentPath);
- final AugmentationSchemaBuilder builder = new AugmentationSchemaBuilderImpl(name, line);
+ Builder parent = null;
+ if (!(actualPath.isEmpty())) {
+ parent = actualPath.getFirst();
+ }
+ final AugmentationSchemaBuilder builder = new AugmentationSchemaBuilderImpl(name, line, parent);
// augment can only be in 'module' or 'uses' statement
- if (!(actualPath.isEmpty())) {
- final Builder parent = actualPath.getFirst();
+ if (parent != null) {
if (parent instanceof UsesNodeBuilder) {
((UsesNodeBuilder) parent).addAugment(builder);
} else {
return builder;
}
+ @Override
+ public void addUsesNode(UsesNodeBuilder usesBuilder) {
+ final List<String> pathToTypedef = new ArrayList<String>();
+ for (QName qname : usesBuilder.getParent().getPath().getPath()) {
+ pathToTypedef.add(qname.getLocalName());
+ }
+ if (addedUsesNodes.containsKey(pathToTypedef)) {
+ throw new YangParseException(this.name, usesBuilder.getLine(), "Failed to add uses node "
+ + usesBuilder.getGroupingName() + ": uses already exists in context.");
+ }
+ addedUsesNodes.put(pathToTypedef, usesBuilder);
+ }
+
public UsesNodeBuilder addUsesNode(final String groupingPathStr, final List<String> parentPath, final int line) {
final List<String> pathToUses = new ArrayList<String>(parentPath);
- final UsesNodeBuilder usesBuilder = new UsesNodeBuilderImpl(groupingPathStr, line);
-
- if (!(actualPath.isEmpty())) {
- final Builder parent = actualPath.getFirst();
- if (parent instanceof DataNodeContainerBuilder) {
- if (parent instanceof AugmentationSchemaBuilder) {
- usesBuilder.setAugmenting(true);
- }
- ((DataNodeContainerBuilder) parent).addUsesNode(usesBuilder);
- } else {
- throw new YangParseException(name, line, "Unresolved parent of uses " + groupingPathStr);
+ Builder parent = null;
+ if (!actualPath.isEmpty()) {
+ parent = actualPath.getFirst();
+ }
+ if (parent != null && !(parent instanceof DataNodeContainerBuilder)) {
+ throw new YangParseException(name, line, "Unresolved parent of uses " + groupingPathStr);
+ }
+ final UsesNodeBuilder usesBuilder;
+ if (parent == null) {
+ usesBuilder = new UsesNodeBuilderImpl(groupingPathStr, line, this);
+ } else {
+ usesBuilder = new UsesNodeBuilderImpl(groupingPathStr, line, (DataNodeContainerBuilder) parent);
+ if (parent instanceof AugmentationSchemaBuilder) {
+ usesBuilder.setAugmenting(true);
}
+ ((DataNodeContainerBuilder) parent).addUsesNode(usesBuilder);
}
pathToUses.add(groupingPathStr);
return rpcBuilder;
}
- public ContainerSchemaNodeBuilder addRpcInput(final QName inputQName, final int line) {
+ public ContainerSchemaNodeBuilder addRpcInput(final SchemaPath schemaPath, final QName inputQName, final int line) {
final Builder parent = actualPath.getFirst();
if (!(parent instanceof RpcDefinitionBuilder)) {
throw new YangParseException(name, line, "input can be defined only in rpc statement");
}
final RpcDefinitionBuilder rpc = (RpcDefinitionBuilder) parent;
- final ContainerSchemaNodeBuilder inputBuilder = new ContainerSchemaNodeBuilder(inputQName, line);
+ final ContainerSchemaNodeBuilder inputBuilder = new ContainerSchemaNodeBuilder(inputQName, schemaPath, line);
rpc.setInput(inputBuilder);
return inputBuilder;
}
- public ContainerSchemaNodeBuilder addRpcOutput(final QName outputQName, final int line) {
+ public ContainerSchemaNodeBuilder addRpcOutput(final SchemaPath schemaPath, final QName outputQName, final int line) {
final Builder parent = actualPath.getFirst();
if (!(parent instanceof RpcDefinitionBuilder)) {
throw new YangParseException(name, line, "output can be defined only in rpc statement");
}
final RpcDefinitionBuilder rpc = (RpcDefinitionBuilder) parent;
- final ContainerSchemaNodeBuilder outputBuilder = new ContainerSchemaNodeBuilder(outputQName, line);
+ final ContainerSchemaNodeBuilder outputBuilder = new ContainerSchemaNodeBuilder(outputQName, schemaPath, line);
rpc.setOutput(outputBuilder);
return outputBuilder;
}
}
public ChoiceCaseBuilder addCase(final QName caseName, final List<String> parentPath, final int line) {
+ Builder parent = getActualNode();
+
final List<String> pathToCase = new ArrayList<String>(parentPath);
- final ChoiceCaseBuilder builder = new ChoiceCaseBuilder(caseName, line);
+ ChoiceCaseBuilder builder = null;
+ if (parent instanceof ChoiceBuilder) {
+ builder = new ChoiceCaseBuilder((ChoiceBuilder) parent, caseName, line);
+ } else {
+ builder = new ChoiceCaseBuilder(null, caseName, line);
+ }
if (actualPath.isEmpty()) {
throw new YangParseException(name, line, "'case' parent not found");
} else {
- final Builder parent = actualPath.getFirst();
if (parent instanceof ChoiceBuilder) {
((ChoiceBuilder) parent).addChildNode(builder);
} else if (parent instanceof AugmentationSchemaBuilder) {
return builder;
}
- public AnyXmlBuilder addAnyXml(final QName anyXmlName, final List<String> parentPath, final int line) {
+ public AnyXmlBuilder addAnyXml(final SchemaPath schemaPath, final QName anyXmlName, final List<String> parentPath, final int line) {
final List<String> pathToAnyXml = new ArrayList<String>(parentPath);
- final AnyXmlBuilder builder = new AnyXmlBuilder(anyXmlName, line);
+ final AnyXmlBuilder builder = new AnyXmlBuilder(anyXmlName, schemaPath, line);
updateParent(builder, line, "anyxml");
pathToAnyXml.add(anyXmlName.getLocalName());
return builder;
}
+ @Override
+ public void addTypedef(TypeDefinitionBuilder typedefBuilder) {
+ final List<String> pathToTypedef = new ArrayList<String>();
+ for (QName qname : typedefBuilder.getPath().getPath()) {
+ pathToTypedef.add(qname.getLocalName());
+ }
+ if (addedTypedefs.containsKey(pathToTypedef)) {
+ throw new YangParseException(this.name, typedefBuilder.getLine(), "Failed to add typedef "
+ + typedefBuilder.getQName().getLocalName() + ": typedef already exists in context.");
+ }
+ addedTypedefs.put(pathToTypedef, typedefBuilder);
+ }
+
public TypeDefinitionBuilderImpl addTypedef(final QName typeDefName, final List<String> parentPath, final int line) {
final List<String> pathToType = new ArrayList<String>(parentPath);
final TypeDefinitionBuilderImpl builder = new TypeDefinitionBuilderImpl(typeDefName, line);
return builder;
}
- public void addConfiguration(final boolean configuration, final List<String> parentPath, final int line) {
- if (actualPath.isEmpty()) {
- throw new YangParseException(name, line, "Parent node of config statement not found.");
+ @Override
+ public void addUnknownSchemaNode(UnknownSchemaNodeBuilder unknownNode) {
+ final List<String> unPath = new ArrayList<String>();
+ for (QName qname : unknownNode.getPath().getPath()) {
+ unPath.add(qname.getLocalName());
+ }
+
+ if (addedUnknownNodes.containsKey(unPath)) {
+ addedUnknownNodes.get(unPath).add(unknownNode);
} else {
- final Builder parent = actualPath.getFirst();
- if (parent instanceof DataSchemaNodeBuilder) {
- ((DataSchemaNodeBuilder) parent).setConfiguration(configuration);
- } else if (parent instanceof RefineHolder) {
- ((RefineHolder) parent).setConfig(configuration);
- } else if (parent instanceof DeviationBuilder) {
- // skip: set config to deviation (deviate stmt) not supported by
- // current api
- return;
- } else {
- throw new YangParseException(name, line, "Unresolved parent of config statement.");
- }
+ List<UnknownSchemaNodeBuilder> nodes = new ArrayList<UnknownSchemaNodeBuilder>();
+ nodes.add(unknownNode);
+ addedUnknownNodes.put(unPath, nodes);
}
}
}
final List<String> unPath = new ArrayList<String>(parentPath);
unPath.add(qname.getLocalName());
- addedUnknownNodes.put(unPath, builder);
+
+ if (addedUnknownNodes.containsKey(unPath)) {
+ addedUnknownNodes.get(unPath).add(builder);
+ } else {
+ List<UnknownSchemaNodeBuilder> nodes = new ArrayList<UnknownSchemaNodeBuilder>();
+ nodes.add(builder);
+ addedUnknownNodes.put(unPath, nodes);
+ }
return builder;
}
}
private List<UnknownSchemaNode> buildModuleUnknownNodes(
- final Map<List<String>, UnknownSchemaNodeBuilder> addedUnknownNodes) {
+ final Map<List<String>, List<UnknownSchemaNodeBuilder>> addedUnknownNodes) {
final List<UnknownSchemaNode> unknownNodes = new ArrayList<UnknownSchemaNode>();
- for (Map.Entry<List<String>, UnknownSchemaNodeBuilder> entry : addedUnknownNodes.entrySet()) {
+ for (Map.Entry<List<String>, List<UnknownSchemaNodeBuilder>> entry : addedUnknownNodes.entrySet()) {
final List<String> path = entry.getKey();
- final UnknownSchemaNodeBuilder child = entry.getValue();
- if (path.size() == 2) {
- final UnknownSchemaNode node = child.build();
- unknownNodes.add(node);
+ final List<UnknownSchemaNodeBuilder> child = entry.getValue();
+ for (UnknownSchemaNodeBuilder un : child) {
+ if (path.size() == 2) {
+ final UnknownSchemaNode node = un.build();
+ unknownNodes.add(node);
+ }
}
}
return unknownNodes;
import org.opendaylight.controller.yang.parser.builder.api.TypeDefinitionBuilder;
import org.opendaylight.controller.yang.parser.builder.api.UsesNodeBuilder;
-public final class NotificationBuilder extends AbstractDataNodeContainerBuilder
- implements TypeDefinitionAwareBuilder, SchemaNodeBuilder, AugmentationTargetBuilder {
+public final class NotificationBuilder extends AbstractDataNodeContainerBuilder implements TypeDefinitionAwareBuilder,
+ SchemaNodeBuilder, AugmentationTargetBuilder {
private boolean isBuilt;
private final NotificationDefinitionImpl instance;
private final int line;
instance.setUses(uses);
// AUGMENTATIONS
- if(augmentations == null) {
+ if (augmentations == null) {
augmentations = new HashSet<AugmentationSchema>();
for (AugmentationSchemaBuilder builder : addedAugmentations) {
augmentations.add(builder.build());
}
@Override
- public Set<TypeDefinitionBuilder> getTypeDefinitions() {
+ public Set<TypeDefinitionBuilder> getTypeDefinitionBuilders() {
return addedTypedefs;
}
@Override
public void setStatus(final Status status) {
- if(status != null) {
+ if (status != null) {
this.status = status;
}
}
return typeDefinitions;
}
- private void setTypeDefinitions(
- final Set<TypeDefinition<?>> typeDefinitions) {
+ private void setTypeDefinitions(final Set<TypeDefinition<?>> typeDefinitions) {
if (typeDefinitions != null) {
this.typeDefinitions = typeDefinitions;
}
return augmentations;
}
- private void setAvailableAugmentations(
- Set<AugmentationSchema> augmentations) {
+ private void setAvailableAugmentations(Set<AugmentationSchema> augmentations) {
if (augmentations != null) {
this.augmentations = augmentations;
}
return unknownNodes;
}
- private void setUnknownSchemaNodes(
- final List<UnknownSchemaNode> unknownNodes) {
+ private void setUnknownSchemaNodes(final List<UnknownSchemaNode> unknownNodes) {
if (unknownNodes != null) {
this.unknownNodes = unknownNodes;
}
@Override
public String toString() {
- StringBuilder sb = new StringBuilder(
- NotificationDefinitionImpl.class.getSimpleName());
+ StringBuilder sb = new StringBuilder(NotificationDefinitionImpl.class.getSimpleName());
sb.append("[qname=" + qname + ", path=" + path + "]");
return sb.toString();
}
import org.opendaylight.controller.yang.model.api.Status;
import org.opendaylight.controller.yang.model.api.TypeDefinition;
import org.opendaylight.controller.yang.model.api.UnknownSchemaNode;
+import org.opendaylight.controller.yang.parser.builder.api.AbstractSchemaNodeBuilder;
import org.opendaylight.controller.yang.parser.builder.api.GroupingBuilder;
-import org.opendaylight.controller.yang.parser.builder.api.SchemaNodeBuilder;
import org.opendaylight.controller.yang.parser.builder.api.TypeDefinitionAwareBuilder;
import org.opendaylight.controller.yang.parser.builder.api.TypeDefinitionBuilder;
-public final class RpcDefinitionBuilder implements SchemaNodeBuilder, TypeDefinitionAwareBuilder {
+public final class RpcDefinitionBuilder extends AbstractSchemaNodeBuilder implements TypeDefinitionAwareBuilder {
private boolean isBuilt;
private final RpcDefinitionImpl instance;
- private final int line;
- private final QName qname;
- private SchemaPath schemaPath;
- private String description;
- private String reference;
- private Status status = Status.CURRENT;
private ContainerSchemaNodeBuilder inputBuilder;
private ContainerSchemaNodeBuilder outputBuilder;
private final Set<TypeDefinitionBuilder> addedTypedefs = new HashSet<TypeDefinitionBuilder>();
private final Set<GroupingBuilder> addedGroupings = new HashSet<GroupingBuilder>();
- private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
RpcDefinitionBuilder(final QName qname, final int line) {
- this.qname = qname;
- this.line = line;
+ super(qname, line);
this.instance = new RpcDefinitionImpl(qname);
}
instance.setInput(input);
instance.setOutput(output);
- instance.setPath(schemaPath);
+ instance.setPath(path);
// TYPEDEFS
final Set<TypeDefinition<?>> typedefs = new HashSet<TypeDefinition<?>>();
return instance;
}
- @Override
- public int getLine() {
- return line;
- }
-
void setInput(final ContainerSchemaNodeBuilder inputBuilder) {
this.inputBuilder = inputBuilder;
}
addedGroupings.add(grouping);
}
- @Override
- public SchemaPath getPath() {
- return schemaPath;
- }
-
- @Override
- public void setPath(SchemaPath schemaPath) {
- this.schemaPath = schemaPath;
- }
-
- @Override
- public String getDescription() {
- return description;
- }
-
- @Override
- public void setDescription(final String description) {
- this.description = description;
- }
-
- @Override
- public String getReference() {
- return reference;
- }
-
- @Override
- public void setReference(String reference) {
- this.reference = reference;
- }
-
- @Override
- public Status getStatus() {
- return status;
- }
-
- @Override
- public void setStatus(final Status status) {
- if (status != null) {
- this.status = status;
- }
- }
-
- @Override
- public QName getQName() {
- return null;
- }
-
- @Override
- public void addUnknownSchemaNode(final UnknownSchemaNodeBuilder unknownNode) {
- addedUnknownNodes.add(unknownNode);
- }
-
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((qname == null) ? 0 : qname.hashCode());
- result = prime * result + ((schemaPath == null) ? 0 : schemaPath.hashCode());
+ result = prime * result + ((path == null) ? 0 : path.hashCode());
return result;
}
} else if (!other.qname.equals(this.qname)) {
return false;
}
- if (other.schemaPath == null) {
- if (this.schemaPath != null) {
+ if (other.path == null) {
+ if (this.path != null) {
return false;
}
- } else if (!other.schemaPath.equals(this.schemaPath)) {
+ } else if (!other.path.equals(this.path)) {
return false;
}
return true;
import org.opendaylight.controller.yang.parser.builder.api.TypeDefinitionBuilder;
import org.opendaylight.controller.yang.parser.util.YangParseException;
-public final class TypeDefinitionBuilderImpl extends AbstractTypeAwareBuilder
- implements TypeDefinitionBuilder {
+public final class TypeDefinitionBuilderImpl extends AbstractTypeAwareBuilder implements TypeDefinitionBuilder {
private final int line;
private final QName qname;
private SchemaPath schemaPath;
- private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
private List<UnknownSchemaNode> unknownNodes;
+ private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
private List<RangeConstraint> ranges = Collections.emptyList();
private List<LengthConstraint> lengths = Collections.emptyList();
private List<PatternConstraint> patterns = Collections.emptyList();
private Status status = Status.CURRENT;
private String units;
private Object defaultValue;
+ private boolean addedByUses;
public TypeDefinitionBuilderImpl(final QName qname, final int line) {
this.qname = qname;
this.line = line;
}
+ public TypeDefinitionBuilderImpl(TypeDefinitionBuilder tdb) {
+ qname = tdb.getQName();
+ line = tdb.getLine();
+ schemaPath = tdb.getPath();
+
+ type = tdb.getType();
+ typedef = tdb.getTypedef();
+
+ unknownNodes = tdb.getUnknownNodes();
+ for (UnknownSchemaNodeBuilder usnb : tdb.getUnknownNodeBuilders()) {
+ addedUnknownNodes.add(usnb);
+ }
+ ranges = tdb.getRanges();
+ lengths = tdb.getLengths();
+ patterns = tdb.getPatterns();
+ fractionDigits = tdb.getFractionDigits();
+
+ description = tdb.getDescription();
+ reference = tdb.getReference();
+ status = tdb.getStatus();
+ units = tdb.getUnits();
+ defaultValue = tdb.getDefaultValue();
+ addedByUses = tdb.isAddedByUses();
+ }
+
@Override
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() + "'.");
+ throw new YangParseException("Unresolved type: '" + qname.getLocalName() + "'.");
}
if (type == null || type instanceof UnknownType) {
type = typedef.build();
}
- typeBuilder = new ExtendedType.Builder(qname, type, description,
- reference, schemaPath);
+ 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);
}
}
+ @Override
+ public boolean isAddedByUses() {
+ return addedByUses;
+ }
+
+ @Override
+ public void setAddedByUses(final boolean addedByUses) {
+ this.addedByUses = addedByUses;
+ }
+
@Override
public String getUnits() {
return units;
}
@Override
- public List<UnknownSchemaNodeBuilder> getUnknownNodes() {
+ public List<UnknownSchemaNode> getUnknownNodes() {
+ return Collections.emptyList();
+ }
+
+ @Override
+ public List<UnknownSchemaNodeBuilder> getUnknownNodeBuilders() {
return addedUnknownNodes;
}
@Override
public String toString() {
- final StringBuilder result = new StringBuilder("TypedefBuilder["
- + qname.getLocalName());
+ final StringBuilder result = new StringBuilder("TypedefBuilder[" + qname.getLocalName());
result.append(", type=");
if (type == null) {
result.append(typedef);
import org.opendaylight.controller.yang.model.api.SchemaPath;
import org.opendaylight.controller.yang.model.api.Status;
import org.opendaylight.controller.yang.model.api.TypeDefinition;
+import org.opendaylight.controller.yang.model.api.UnknownSchemaNode;
import org.opendaylight.controller.yang.model.api.type.LengthConstraint;
import org.opendaylight.controller.yang.model.api.type.PatternConstraint;
import org.opendaylight.controller.yang.model.api.type.RangeConstraint;
* When build is called, types in builder form will be built and add to resolved
* types.
*/
-public final class UnionTypeBuilder extends AbstractTypeAwareBuilder implements
- TypeDefinitionBuilder {
+public final class UnionTypeBuilder extends AbstractTypeAwareBuilder implements TypeDefinitionBuilder {
private final static String NAME = "union";
private final int line;
throw new YangParseException(line, "Can not set status to " + NAME);
}
+ @Override
+ public boolean isAddedByUses() {
+ return false;
+ }
+
+ @Override
+ public void setAddedByUses(final boolean addedByUses) {
+ throw new YangParseException(line, "Union type can not be added by uses.");
+ }
+
+ @Override
+ public List<UnknownSchemaNode> getUnknownNodes() {
+ return Collections.emptyList();
+ }
+
@Override
public void addUnknownSchemaNode(final UnknownSchemaNodeBuilder unknownNode) {
- throw new YangParseException(line, "Can not add unknown node to "
- + NAME);
+ // not supported
}
@Override
@Override
public void setFractionDigits(Integer fractionDigits) {
- throw new YangParseException(line, "Can not set fraction digits to "
- + NAME);
+ throw new YangParseException(line, "Can not set fraction digits to " + NAME);
}
@Override
- public List<UnknownSchemaNodeBuilder> getUnknownNodes() {
+ public List<UnknownSchemaNodeBuilder> getUnknownNodeBuilders() {
return Collections.emptyList();
}
@Override
public void setDefaultValue(Object defaultValue) {
- throw new YangParseException(line, "Can not set default value to "
- + NAME);
+ throw new YangParseException(line, "Can not set default value to " + NAME);
}
@Override
@Override
public String toString() {
- final StringBuilder result = new StringBuilder(
- UnionTypeBuilder.class.getSimpleName() + "[");
+ final StringBuilder result = new StringBuilder(UnionTypeBuilder.class.getSimpleName() + "[");
result.append(", types=" + types);
result.append(", typedefs=" + typedefs);
result.append("]");
import org.opendaylight.controller.yang.model.api.SchemaPath;
import org.opendaylight.controller.yang.model.api.Status;
import org.opendaylight.controller.yang.model.api.UnknownSchemaNode;
-import org.opendaylight.controller.yang.parser.builder.api.SchemaNodeBuilder;
+import org.opendaylight.controller.yang.parser.builder.api.AbstractSchemaNodeBuilder;
-public final class UnknownSchemaNodeBuilder implements SchemaNodeBuilder {
+public final class UnknownSchemaNodeBuilder extends AbstractSchemaNodeBuilder {
private boolean isBuilt;
private final UnknownSchemaNodeImpl instance;
- private final int line;
- private final QName qname;
- private SchemaPath schemaPath;
- private String description;
- private String reference;
- private Status status = Status.CURRENT;
- private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
+ private boolean addedByUses;
+ private List<UnknownSchemaNode> unknownNodes;
private QName nodeType;
private String nodeParameter;
- UnknownSchemaNodeBuilder(final QName qname, final int line) {
- this.qname = qname;
- this.line = line;
+ public UnknownSchemaNodeBuilder(final QName qname, final int line) {
+ super(qname, line);
instance = new UnknownSchemaNodeImpl(qname);
}
+ public UnknownSchemaNodeBuilder(UnknownSchemaNodeBuilder b) {
+ super(b.getQName(), b.getLine());
+ instance = new UnknownSchemaNodeImpl(qname);
+ path = b.getPath();
+ description = b.getDescription();
+ reference = b.getReference();
+ status = b.getStatus();
+ addedByUses = b.isAddedByUses();
+ unknownNodes = b.unknownNodes;
+ addedUnknownNodes.addAll(b.addedUnknownNodes);
+ nodeType = b.getNodeType();
+ nodeParameter = b.getNodeParameter();
+ }
+
@Override
public UnknownSchemaNode build() {
if (!isBuilt) {
- instance.setPath(schemaPath);
+ instance.setPath(path);
instance.setNodeType(nodeType);
instance.setNodeParameter(nodeParameter);
instance.setDescription(description);
instance.setReference(reference);
instance.setStatus(status);
+ instance.setAddedByUses(addedByUses);
// UNKNOWN NODES
- final List<UnknownSchemaNode> unknownNodes = new ArrayList<UnknownSchemaNode>();
- for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
- unknownNodes.add(b.build());
+ if (unknownNodes == null) {
+ unknownNodes = new ArrayList<UnknownSchemaNode>();
+ for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
+ unknownNodes.add(b.build());
+ }
}
instance.setUnknownSchemaNodes(unknownNodes);
return instance;
}
- @Override
- public int getLine() {
- return line;
- }
-
- @Override
- public QName getQName() {
- return qname;
- }
-
- @Override
- public SchemaPath getPath() {
- return schemaPath;
- }
-
- @Override
- public void setPath(SchemaPath schemaPath) {
- this.schemaPath = schemaPath;
- }
-
- @Override
- public String getDescription() {
- return description;
+ public boolean isAddedByUses() {
+ return addedByUses;
}
- @Override
- public void setDescription(final String description) {
- this.description = description;
+ public void setAddedByUses(final boolean addedByUses) {
+ this.addedByUses = addedByUses;
}
- @Override
- public String getReference() {
- return reference;
- }
-
- @Override
- public void setReference(String reference) {
- this.reference = reference;
- }
-
- @Override
- public Status getStatus() {
- return status;
- }
-
- @Override
- public void setStatus(Status status) {
- if (status != null) {
- this.status = status;
- }
- }
-
- @Override
- public void addUnknownSchemaNode(final UnknownSchemaNodeBuilder unknownNode) {
- addedUnknownNodes.add(unknownNode);
+ public void setUnknownNodes(final List<UnknownSchemaNode> unknownNodes) {
+ this.unknownNodes = unknownNodes;
}
public QName getNodeType() {
private List<UnknownSchemaNode> unknownNodes = Collections.emptyList();
private QName nodeType;
private String nodeParameter;
+ private boolean addedByUses;
private UnknownSchemaNodeImpl(final QName qname) {
this.qname = qname;
}
}
+ @Override
+ public boolean isAddedByUses() {
+ return addedByUses;
+ }
+
+ private void setAddedByUses(final boolean addedByUses) {
+ this.addedByUses = addedByUses;
+ }
+
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
return unknownNodes;
private void setNodeParameter(final String nodeParameter) {
this.nodeParameter = nodeParameter;
}
+
+ @Override
+ public String toString() {
+ StringBuilder sb = new StringBuilder(UnknownSchemaNodeImpl.class.getSimpleName());
+ sb.append("[");
+ sb.append(qname);
+ sb.append("]");
+ return sb.toString();
+ }
}
}
import org.opendaylight.controller.yang.model.api.AugmentationSchema;\r
import org.opendaylight.controller.yang.model.api.SchemaNode;\r
import org.opendaylight.controller.yang.model.api.SchemaPath;\r
+import org.opendaylight.controller.yang.model.api.UnknownSchemaNode;\r
import org.opendaylight.controller.yang.model.api.UsesNode;\r
import org.opendaylight.controller.yang.parser.builder.api.AugmentationSchemaBuilder;\r
+import org.opendaylight.controller.yang.parser.builder.api.DataNodeContainerBuilder;\r
import org.opendaylight.controller.yang.parser.builder.api.SchemaNodeBuilder;\r
import org.opendaylight.controller.yang.parser.builder.api.UsesNodeBuilder;\r
import org.opendaylight.controller.yang.parser.util.RefineHolder;\r
private boolean isBuilt;\r
private UsesNodeImpl instance;\r
private final int line;\r
- private SchemaPath schemaPath;\r
+ private final DataNodeContainerBuilder parent;\r
private final String groupingName;\r
private SchemaPath groupingPath;\r
private boolean augmenting;\r
+ private boolean addedByUses;\r
private final Set<AugmentationSchemaBuilder> addedAugments = new HashSet<AugmentationSchemaBuilder>();\r
- private List<SchemaNodeBuilder> refineBuilders = new ArrayList<SchemaNodeBuilder>();\r
- private List<RefineHolder> refines = new ArrayList<RefineHolder>();\r
+ private final List<SchemaNodeBuilder> refineBuilders = new ArrayList<SchemaNodeBuilder>();\r
+ private final List<RefineHolder> refines = new ArrayList<RefineHolder>();\r
+ private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();\r
\r
- public UsesNodeBuilderImpl(final String groupingName, final int line) {\r
+ public UsesNodeBuilderImpl(final String groupingName, final int line, final DataNodeContainerBuilder parent) {\r
this.groupingName = groupingName;\r
this.line = line;\r
+ this.parent = parent;\r
+ }\r
+\r
+ public UsesNodeBuilderImpl(UsesNodeBuilder b) {\r
+ groupingName = b.getGroupingName();\r
+ line = b.getLine();\r
+ parent = b.getParent();\r
+ groupingPath = b.getGroupingPath();\r
+ augmenting = b.isAugmenting();\r
+ addedByUses = b.isAddedByUses();\r
+ addedAugments.addAll(b.getAugmentations());\r
+ refineBuilders.addAll(b.getRefineNodes());\r
+ refines.addAll(b.getRefines());\r
}\r
\r
@Override\r
if (!isBuilt) {\r
instance = new UsesNodeImpl(groupingPath);\r
instance.setAugmenting(augmenting);\r
+ instance.setAddedByUses(addedByUses);\r
\r
// AUGMENTATIONS\r
final Set<AugmentationSchema> augments = new HashSet<AugmentationSchema>();\r
}\r
instance.setRefines(refineNodes);\r
\r
+ // UNKNOWN NODES\r
+ List<UnknownSchemaNode> unknownNodes = new ArrayList<UnknownSchemaNode>();\r
+ for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {\r
+ unknownNodes.add(b.build());\r
+ }\r
+ instance.setUnknownSchemaNodes(unknownNodes);\r
+\r
isBuilt = true;\r
}\r
return instance;\r
}\r
\r
@Override\r
- public void setGroupingPath(SchemaPath groupingPath) {\r
- this.groupingPath = groupingPath;\r
+ public DataNodeContainerBuilder getParent() {\r
+ return parent;\r
}\r
\r
@Override\r
- public SchemaPath getPath() {\r
- return schemaPath;\r
+ public SchemaPath getGroupingPath() {\r
+ return groupingPath;\r
}\r
\r
@Override\r
- public void setPath(SchemaPath path) {\r
- this.schemaPath = path;\r
+ public void setGroupingPath(SchemaPath groupingPath) {\r
+ this.groupingPath = groupingPath;\r
}\r
\r
@Override\r
this.augmenting = augmenting;\r
}\r
\r
+ @Override\r
+ public boolean isAddedByUses() {\r
+ return addedByUses;\r
+ }\r
+\r
+ @Override\r
+ public void setAddedByUses(final boolean addedByUses) {\r
+ this.addedByUses = addedByUses;\r
+ }\r
+\r
@Override\r
public List<SchemaNodeBuilder> getRefineNodes() {\r
return refineBuilders;\r
refines.add(refine);\r
}\r
\r
+ public List<UnknownSchemaNodeBuilder> getUnknownNodes() {\r
+ return addedUnknownNodes;\r
+ }\r
+\r
+ @Override\r
+ public void addUnknownSchemaNode(UnknownSchemaNodeBuilder unknownNode) {\r
+ addedUnknownNodes.add(unknownNode);\r
+ }\r
\r
- private final class UsesNodeImpl implements UsesNode {\r
+ public final class UsesNodeImpl implements UsesNode {\r
private final SchemaPath groupingPath;\r
private Set<AugmentationSchema> augmentations = Collections.emptySet();\r
private boolean augmenting;\r
+ private boolean addedByUses;\r
private Map<SchemaPath, SchemaNode> refines = Collections.emptyMap();\r
+ private List<UnknownSchemaNode> unknownNodes = Collections.emptyList();\r
\r
private UsesNodeImpl(final SchemaPath groupingPath) {\r
this.groupingPath = groupingPath;\r
return augmentations;\r
}\r
\r
- private void setAugmentations(\r
- final Set<AugmentationSchema> augmentations) {\r
+ private void setAugmentations(final Set<AugmentationSchema> augmentations) {\r
if (augmentations != null) {\r
this.augmentations = augmentations;\r
}\r
this.augmenting = augmenting;\r
}\r
\r
+ @Override\r
+ public boolean isAddedByUses() {\r
+ return addedByUses;\r
+ }\r
+\r
+ private void setAddedByUses(final boolean addedByUses) {\r
+ this.addedByUses = addedByUses;\r
+ }\r
+\r
@Override\r
public Map<SchemaPath, SchemaNode> getRefines() {\r
return refines;\r
}\r
}\r
\r
+ public List<UnknownSchemaNode> getUnknownSchemaNodes() {\r
+ return unknownNodes;\r
+ }\r
+\r
+ private void setUnknownSchemaNodes(List<UnknownSchemaNode> unknownSchemaNodes) {\r
+ if (unknownSchemaNodes != null) {\r
+ this.unknownNodes = unknownSchemaNodes;\r
+ }\r
+ }\r
+\r
+ public UsesNodeBuilder toBuilder() {\r
+ return UsesNodeBuilderImpl.this;\r
+ }\r
+\r
@Override\r
public int hashCode() {\r
final int prime = 31;\r
int result = 1;\r
- result = prime * result\r
- + ((groupingPath == null) ? 0 : groupingPath.hashCode());\r
- result = prime * result\r
- + ((augmentations == null) ? 0 : augmentations.hashCode());\r
+ result = prime * result + ((groupingPath == null) ? 0 : groupingPath.hashCode());\r
+ result = prime * result + ((augmentations == null) ? 0 : augmentations.hashCode());\r
result = prime * result + (augmenting ? 1231 : 1237);\r
return result;\r
}\r
\r
@Override\r
public String toString() {\r
- StringBuilder sb = new StringBuilder(\r
- UsesNodeImpl.class.getSimpleName());\r
+ StringBuilder sb = new StringBuilder(UsesNodeImpl.class.getSimpleName());\r
sb.append("[groupingPath=" + groupingPath + "]");\r
return sb.toString();\r
}\r
import org.opendaylight.controller.antlrv4.code.gen.YangLexer;
import org.opendaylight.controller.antlrv4.code.gen.YangParser;
import org.opendaylight.controller.yang.common.QName;
+import org.opendaylight.controller.yang.model.api.AnyXmlSchemaNode;
+import org.opendaylight.controller.yang.model.api.ChoiceNode;
+import org.opendaylight.controller.yang.model.api.ContainerSchemaNode;
+import org.opendaylight.controller.yang.model.api.DataSchemaNode;
import org.opendaylight.controller.yang.model.api.GroupingDefinition;
import org.opendaylight.controller.yang.model.api.IdentitySchemaNode;
+import org.opendaylight.controller.yang.model.api.LeafListSchemaNode;
+import org.opendaylight.controller.yang.model.api.LeafSchemaNode;
+import org.opendaylight.controller.yang.model.api.ListSchemaNode;
import org.opendaylight.controller.yang.model.api.Module;
import org.opendaylight.controller.yang.model.api.SchemaContext;
import org.opendaylight.controller.yang.model.api.SchemaPath;
import org.opendaylight.controller.yang.model.api.TypeDefinition;
+import org.opendaylight.controller.yang.model.api.UnknownSchemaNode;
+import org.opendaylight.controller.yang.model.api.UsesNode;
import org.opendaylight.controller.yang.model.parser.api.YangModelParser;
import org.opendaylight.controller.yang.model.util.ExtendedType;
import org.opendaylight.controller.yang.model.util.IdentityrefType;
import org.opendaylight.controller.yang.parser.builder.api.AugmentationSchemaBuilder;
import org.opendaylight.controller.yang.parser.builder.api.Builder;
import org.opendaylight.controller.yang.parser.builder.api.DataNodeContainerBuilder;
+import org.opendaylight.controller.yang.parser.builder.api.DataSchemaNodeBuilder;
import org.opendaylight.controller.yang.parser.builder.api.GroupingBuilder;
+import org.opendaylight.controller.yang.parser.builder.api.GroupingMember;
import org.opendaylight.controller.yang.parser.builder.api.SchemaNodeBuilder;
import org.opendaylight.controller.yang.parser.builder.api.TypeAwareBuilder;
import org.opendaylight.controller.yang.parser.builder.api.TypeDefinitionBuilder;
import org.opendaylight.controller.yang.parser.builder.api.UsesNodeBuilder;
+import org.opendaylight.controller.yang.parser.builder.impl.AnyXmlBuilder;
+import org.opendaylight.controller.yang.parser.builder.impl.ChoiceBuilder;
+import org.opendaylight.controller.yang.parser.builder.impl.ContainerSchemaNodeBuilder;
+import org.opendaylight.controller.yang.parser.builder.impl.GroupingBuilderImpl;
import org.opendaylight.controller.yang.parser.builder.impl.IdentitySchemaNodeBuilder;
import org.opendaylight.controller.yang.parser.builder.impl.IdentityrefTypeBuilder;
+import org.opendaylight.controller.yang.parser.builder.impl.LeafListSchemaNodeBuilder;
+import org.opendaylight.controller.yang.parser.builder.impl.LeafSchemaNodeBuilder;
+import org.opendaylight.controller.yang.parser.builder.impl.ListSchemaNodeBuilder;
import org.opendaylight.controller.yang.parser.builder.impl.ModuleBuilder;
import org.opendaylight.controller.yang.parser.builder.impl.RpcDefinitionBuilder;
+import org.opendaylight.controller.yang.parser.builder.impl.TypeDefinitionBuilderImpl;
import org.opendaylight.controller.yang.parser.builder.impl.UnionTypeBuilder;
import org.opendaylight.controller.yang.parser.builder.impl.UnknownSchemaNodeBuilder;
+import org.opendaylight.controller.yang.parser.builder.impl.UsesNodeBuilderImpl;
+import org.opendaylight.controller.yang.parser.builder.impl.UsesNodeBuilderImpl.UsesNodeImpl;
import org.opendaylight.controller.yang.parser.util.ModuleDependencySort;
import org.opendaylight.controller.yang.parser.util.RefineHolder;
import org.opendaylight.controller.yang.parser.util.RefineUtils;
import com.google.common.collect.Sets;
public final class YangParserImpl implements YangModelParser {
-
private static final Logger logger = LoggerFactory.getLogger(YangParserImpl.class);
@Override
nodeToResolve.setTypedef(newType);
} else {
- if(nodeToResolve instanceof TypeDefinitionBuilder) {
- TypeDefinitionBuilder tdb = (TypeDefinitionBuilder)nodeToResolve;
- TypeConstraints tc = findConstraintsFromTypeBuilder(nodeToResolve, new TypeConstraints(module.getName(), nodeToResolve.getLine()), modules, module, context);
+ if (nodeToResolve instanceof TypeDefinitionBuilder) {
+ TypeDefinitionBuilder tdb = (TypeDefinitionBuilder) nodeToResolve;
+ TypeConstraints tc = findConstraintsFromTypeBuilder(nodeToResolve,
+ new TypeConstraints(module.getName(), nodeToResolve.getLine()), modules, module, context);
tdb.setLengths(tc.getLength());
tdb.setPatterns(tc.getPatterns());
tdb.setRanges(tc.getRange());
/**
* Go through all augment definitions and resolve them. This method works in
- * same way as {@link #resolveAugments(Map)} except that if target node is not
- * found in loaded modules, it search for target node in given context.
+ * same way as {@link #resolveAugments(Map)} except that if target node is
+ * not found in loaded modules, it search for target node in given context.
*
* @param modules
* all loaded modules
* SchemaContext containing already resolved modules
*/
private void resolveIdentitiesWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,
- final ModuleBuilder module, SchemaContext context) {
+ final ModuleBuilder module, final SchemaContext context) {
final Set<IdentitySchemaNodeBuilder> identities = module.getIdentities();
for (IdentitySchemaNodeBuilder identity : identities) {
final String baseIdentityName = identity.getBaseIdentityName();
private void resolveUsesRefine(final Map<String, TreeMap<Date, ModuleBuilder>> modules, final ModuleBuilder module) {
final Map<List<String>, UsesNodeBuilder> moduleUses = module.getUsesNodes();
for (Map.Entry<List<String>, UsesNodeBuilder> entry : moduleUses.entrySet()) {
+ // refine
final UsesNodeBuilder usesNode = entry.getValue();
final int line = usesNode.getLine();
final GroupingBuilder targetGrouping = getTargetGroupingFromModules(usesNode, modules, module);
for (RefineHolder refine : usesNode.getRefines()) {
final SchemaNodeBuilder nodeToRefine = RefineUtils.getRefineNodeFromGroupingBuilder(targetGrouping,
refine, module.getName());
+ if(nodeToRefine instanceof GroupingMember) {
+ ((GroupingMember)nodeToRefine).setAddedByUses(true);
+ }
RefineUtils.performRefine(nodeToRefine, refine, line);
usesNode.addRefineNode(nodeToRefine);
}
+
+ // child nodes
+ processUsesNode(usesNode, targetGrouping);
}
}
* SchemaContext containing already resolved modules
*/
private void resolveUsesRefineWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,
- final ModuleBuilder module, SchemaContext context) {
+ final ModuleBuilder module, final SchemaContext context) {
final Map<List<String>, UsesNodeBuilder> moduleUses = module.getUsesNodes();
for (Map.Entry<List<String>, UsesNodeBuilder> entry : moduleUses.entrySet()) {
final UsesNodeBuilder usesNode = entry.getValue();
for (RefineHolder refine : usesNode.getRefines()) {
final SchemaNodeBuilder nodeToRefine = RefineUtils.getRefineNodeFromGroupingDefinition(
targetGrouping, refine, module.getName());
+ if(nodeToRefine instanceof GroupingMember) {
+ ((GroupingMember)nodeToRefine).setAddedByUses(true);
+ }
RefineUtils.performRefine(nodeToRefine, refine, line);
usesNode.addRefineNode(nodeToRefine);
}
+
+ processUsesNode(usesNode, targetGrouping);
} else {
usesNode.setGroupingPath(targetGroupingBuilder.getPath());
for (RefineHolder refine : usesNode.getRefines()) {
final SchemaNodeBuilder nodeToRefine = RefineUtils.getRefineNodeFromGroupingBuilder(
targetGroupingBuilder, refine, module.getName());
+ if(nodeToRefine instanceof GroupingMember) {
+ ((GroupingMember)nodeToRefine).setAddedByUses(true);
+ }
RefineUtils.performRefine(nodeToRefine, refine, line);
usesNode.addRefineNode(nodeToRefine);
}
+
+ processUsesNode(usesNode, targetGroupingBuilder);
}
}
}
return null;
}
- List<QName> path = usesBuilder.getPath().getPath();
+ List<QName> path = usesBuilder.getParent().getPath().getPath();
GroupingBuilder result = null;
Set<GroupingBuilder> groupings = dependentModule.getModuleGroupings();
result = findGroupingBuilder(groupings, groupingName);
if (currentNode instanceof RpcDefinitionBuilder) {
groupings = ((RpcDefinitionBuilder) currentNode).getGroupings();
} else if (currentNode instanceof DataNodeContainerBuilder) {
- groupings = ((DataNodeContainerBuilder) currentNode).getGroupings();
+ groupings = ((DataNodeContainerBuilder) currentNode).getGroupingBuilders();
} else {
groupings = Collections.emptySet();
}
* @return grouping with given name if found, null otherwise
*/
private GroupingDefinition getTargetGroupingFromContext(final UsesNodeBuilder usesBuilder,
- final ModuleBuilder module, SchemaContext context) {
+ final ModuleBuilder module, final SchemaContext context) {
final int line = usesBuilder.getLine();
String groupingString = usesBuilder.getGroupingName();
String groupingPrefix;
return findGroupingDefinition(dependentModule.getGroupings(), groupingName);
}
+ /**
+ * Add nodes defined in target grouping to current context.
+ *
+ * @param usesNode
+ * @param targetGrouping
+ */
+ private void processUsesNode(final UsesNodeBuilder usesNode, final GroupingBuilder targetGrouping) {
+ List<SchemaNodeBuilder> refineNodes = usesNode.getRefineNodes();
+ DataNodeContainerBuilder parent = usesNode.getParent();
+ SchemaPath parentPath = parent.getPath();
+ for (DataSchemaNodeBuilder child : targetGrouping.getChildNodeBuilders()) {
+ // if node is refined, take it from refined nodes and continue
+ SchemaNodeBuilder refined = getRefined(child.getQName(), refineNodes);
+ if(refined != null) {
+ refined.setPath(createSchemaPath(parentPath, refined.getQName().getLocalName()));
+ parent.addChildNode((DataSchemaNodeBuilder)refined);
+ continue;
+ }
+
+ DataSchemaNodeBuilder newChild = null;
+ if (child instanceof AnyXmlBuilder) {
+ newChild = new AnyXmlBuilder((AnyXmlBuilder) child);
+ } else if (child instanceof ChoiceBuilder) {
+ newChild = new ChoiceBuilder((ChoiceBuilder) child);
+ } else if (child instanceof ContainerSchemaNodeBuilder) {
+ newChild = new ContainerSchemaNodeBuilder((ContainerSchemaNodeBuilder) child);
+ } else if (child instanceof LeafListSchemaNodeBuilder) {
+ newChild = new LeafListSchemaNodeBuilder((LeafListSchemaNodeBuilder) child);
+ } else if (child instanceof LeafSchemaNodeBuilder) {
+ newChild = new LeafSchemaNodeBuilder((LeafSchemaNodeBuilder) child);
+ } else if (child instanceof ListSchemaNodeBuilder) {
+ newChild = new ListSchemaNodeBuilder((ListSchemaNodeBuilder) child);
+ }
+
+ if (newChild instanceof GroupingMember) {
+ ((GroupingMember) newChild).setAddedByUses(true);
+ }
+ newChild.setPath(createSchemaPath(parentPath, newChild.getQName().getLocalName()));
+ parent.addChildNode(newChild);
+ }
+ for (GroupingBuilder g : targetGrouping.getGroupingBuilders()) {
+ GroupingBuilder newGrouping = new GroupingBuilderImpl(g);
+ newGrouping.setAddedByUses(true);
+ newGrouping.setPath(createSchemaPath(parentPath, newGrouping.getQName().getLocalName()));
+ parent.addGrouping(newGrouping);
+ }
+ for (TypeDefinitionBuilder td : targetGrouping.getTypeDefinitionBuilders()) {
+ TypeDefinitionBuilder newType = new TypeDefinitionBuilderImpl(td);
+ newType.setAddedByUses(true);
+ newType.setPath(createSchemaPath(parentPath, newType.getQName().getLocalName()));
+ parent.addTypedef(newType);
+ }
+ for (UsesNodeBuilder un : targetGrouping.getUses()) {
+ UsesNodeBuilder newUses = new UsesNodeBuilderImpl(un);
+ newUses.setAddedByUses(true);
+ // uses has not path
+ parent.addUsesNode(newUses);
+ }
+ for (UnknownSchemaNodeBuilder un : targetGrouping.getUnknownNodes()) {
+ UnknownSchemaNodeBuilder newUn = new UnknownSchemaNodeBuilder(un);
+ newUn.setAddedByUses(true);
+ newUn.setPath(createSchemaPath(parentPath, un.getQName().getLocalName()));
+ parent.addUnknownSchemaNode(newUn);
+ }
+ }
+
+ private void processUsesNode(final UsesNodeBuilder usesNode, final GroupingDefinition targetGrouping) {
+ final int line = usesNode.getLine();
+ List<SchemaNodeBuilder> refineNodes = usesNode.getRefineNodes();
+ DataNodeContainerBuilder parent = usesNode.getParent();
+ SchemaPath parentPath = parent.getPath();
+ for (DataSchemaNode child : targetGrouping.getChildNodes()) {
+ // if node is refined, take it from refined nodes and continue
+ SchemaNodeBuilder refined = getRefined(child.getQName(), refineNodes);
+ if(refined != null) {
+ refined.setPath(createSchemaPath(parentPath, refined.getQName().getLocalName()));
+ parent.addChildNode((DataSchemaNodeBuilder)refined);
+ continue;
+ }
+
+ DataSchemaNodeBuilder newChild = null;
+ if (child instanceof AnyXmlSchemaNode) {
+ newChild = createAnyXml((AnyXmlSchemaNode) child, line);
+ } else if (child instanceof ChoiceNode) {
+ newChild = createChoice((ChoiceNode) child, line);
+ } else if (child instanceof ContainerSchemaNode) {
+ newChild = createContainer((ContainerSchemaNode) child, line);
+ } else if (child instanceof LeafListSchemaNode) {
+ newChild = createLeafList((LeafListSchemaNode) child, line);
+ } else if (child instanceof LeafSchemaNode) {
+ newChild = createLeafBuilder((LeafSchemaNode) child, line);
+ } else if (child instanceof ListSchemaNode) {
+ newChild = createList((ListSchemaNode) child, line);
+ }
+
+ if (newChild instanceof GroupingMember) {
+ ((GroupingMember) newChild).setAddedByUses(true);
+ }
+ newChild.setPath(createSchemaPath(parentPath, newChild.getQName().getLocalName()));
+ parent.addChildNode(newChild);
+ }
+ for (GroupingDefinition g : targetGrouping.getGroupings()) {
+ GroupingBuilder newGrouping = createGrouping(g, line);
+ newGrouping.setAddedByUses(true);
+ newGrouping.setPath(createSchemaPath(parentPath, newGrouping.getQName().getLocalName()));
+ parent.addGrouping(newGrouping);
+ }
+ for (TypeDefinition<?> td : targetGrouping.getTypeDefinitions()) {
+ TypeDefinitionBuilder newType = createTypedef((ExtendedType) td, line);
+ newType.setAddedByUses(true);
+ newType.setPath(createSchemaPath(parentPath, newType.getQName().getLocalName()));
+ parent.addTypedef(newType);
+ }
+ for (UsesNode un : targetGrouping.getUses()) {
+ if (un instanceof UsesNodeImpl) {
+ UsesNodeBuilder newUses = new UsesNodeBuilderImpl(((UsesNodeImpl) un).toBuilder());
+ newUses.setAddedByUses(true);
+ // uses has not path
+ parent.addUsesNode(newUses);
+ }
+ }
+ for (UnknownSchemaNode un : targetGrouping.getUnknownSchemaNodes()) {
+ UnknownSchemaNodeBuilder newNode = createUnknownSchemaNode(un, line);
+ newNode.setAddedByUses(true);
+ newNode.setPath(createSchemaPath(parentPath, un.getQName().getLocalName()));
+ parent.addUnknownSchemaNode(newNode);
+ }
+ }
+
private QName findFullQName(final Map<String, TreeMap<Date, ModuleBuilder>> modules, final ModuleBuilder module,
final IdentityrefTypeBuilder idref) {
QName result = null;
import java.util.Stack;
import org.antlr.v4.runtime.tree.ParseTree;
-import org.opendaylight.controller.antlrv4.code.gen.YangParser;
+import org.opendaylight.controller.antlrv4.code.gen.*;
import org.opendaylight.controller.antlrv4.code.gen.YangParser.Argument_stmtContext;
import org.opendaylight.controller.antlrv4.code.gen.YangParser.Base_stmtContext;
import org.opendaylight.controller.antlrv4.code.gen.YangParser.Contact_stmtContext;
import org.opendaylight.controller.antlrv4.code.gen.YangParser.Units_stmtContext;
import org.opendaylight.controller.antlrv4.code.gen.YangParser.When_stmtContext;
import org.opendaylight.controller.antlrv4.code.gen.YangParser.Yang_version_stmtContext;
-import org.opendaylight.controller.antlrv4.code.gen.YangParserBaseListener;
import org.opendaylight.controller.yang.common.QName;
import org.opendaylight.controller.yang.model.api.SchemaPath;
import org.opendaylight.controller.yang.model.api.Status;
SchemaPath path = createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix);
moduleBuilder.addIdentityrefType(getIdentityrefBase(typeBody), actualPath, path, line);
} else {
- type = parseTypeBody(moduleName, typeName, typeBody, actualPath, namespace, revision,
+ type = parseTypeWithBody(moduleName, typeName, typeBody, actualPath, namespace, revision,
yangModelPrefix, moduleBuilder.getActualNode());
moduleBuilder.setType(type, actualPath);
}
}
} else {
- type = parseUnknownTypeBody(typeQName, typeBody, actualPath, namespace, revision, yangModelPrefix,
- moduleBuilder.getActualNode(), moduleBuilder);
- // mark parent node of this type statement as dirty
+ type = parseUnknownTypeWithBody(typeQName, typeBody, actualPath, namespace, revision, yangModelPrefix,
+ moduleBuilder.getActualNode());
+ // add parent node of this type statement to dirty nodes
moduleBuilder.addDirtyNode(actualPath);
moduleBuilder.setType(type, actualPath);
}
@Override
public void enterContainer_stmt(Container_stmtContext ctx) {
+ final int line = ctx.getStart().getLine();
final String containerName = stringFromNode(ctx);
QName containerQName = new QName(namespace, revision, yangModelPrefix, containerName);
- ContainerSchemaNodeBuilder builder = moduleBuilder.addContainerNode(containerQName, actualPath, ctx.getStart()
- .getLine());
+
+ SchemaPath path = createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix, containerName);
+
+ ContainerSchemaNodeBuilder builder = moduleBuilder.addContainerNode(path, containerQName, actualPath, line);
moduleBuilder.enterNode(builder);
updatePath(containerName);
- builder.setPath(createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix));
parseSchemaNodeArgs(ctx, builder);
parseConstraints(ctx, builder.getConstraints());
+ builder.setConfiguration(getConfig(ctx, moduleBuilder.getActualParent(), moduleName, line));
for (int i = 0; i < ctx.getChildCount(); ++i) {
final ParseTree childNode = ctx.getChild(i);
public void enterLeaf_stmt(Leaf_stmtContext ctx) {
final String leafName = stringFromNode(ctx);
QName leafQName = new QName(namespace, revision, yangModelPrefix, leafName);
- LeafSchemaNodeBuilder builder = moduleBuilder.addLeafNode(leafQName, actualPath, ctx.getStart().getLine());
+ SchemaPath schemaPath = createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix, leafName);
+
+ LeafSchemaNodeBuilder builder = moduleBuilder.addLeafNode(schemaPath, leafQName, actualPath, ctx.getStart().getLine());
moduleBuilder.enterNode(builder);
updatePath(leafName);
- builder.setPath(createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix));
parseSchemaNodeArgs(ctx, builder);
parseConstraints(ctx, builder.getConstraints());
+ builder.setConfiguration(getConfig(ctx, moduleBuilder.getActualParent(), moduleName, ctx.getStart().getLine()));
String defaultStr = null;
String unitsStr = null;
moduleBuilder.enterNode(builder);
updatePath(groupingPathStr);
- builder.setPath(createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix));
}
@Override
public void enterLeaf_list_stmt(Leaf_list_stmtContext ctx) {
final String leafListName = stringFromNode(ctx);
QName leafListQName = new QName(namespace, revision, yangModelPrefix, leafListName);
- LeafListSchemaNodeBuilder builder = moduleBuilder.addLeafListNode(leafListQName, actualPath, ctx.getStart()
+ SchemaPath schemaPath = createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix, leafListName);
+
+ LeafListSchemaNodeBuilder builder = moduleBuilder.addLeafListNode(schemaPath, leafListQName, actualPath, ctx.getStart()
.getLine());
moduleBuilder.enterNode(builder);
updatePath(leafListName);
- builder.setPath(createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix));
parseSchemaNodeArgs(ctx, builder);
parseConstraints(ctx, builder.getConstraints());
+ builder.setConfiguration(getConfig(ctx, moduleBuilder.getActualParent(), moduleName, ctx.getStart().getLine()));
for (int i = 0; i < ctx.getChildCount(); ++i) {
final ParseTree childNode = ctx.getChild(i);
@Override
public void enterList_stmt(List_stmtContext ctx) {
- final String containerName = stringFromNode(ctx);
- QName containerQName = new QName(namespace, revision, yangModelPrefix, containerName);
- ListSchemaNodeBuilder builder = moduleBuilder.addListNode(containerQName, actualPath, ctx.getStart().getLine());
+ final String listName = stringFromNode(ctx);
+ QName listQName = new QName(namespace, revision, yangModelPrefix, listName);
+ SchemaPath schemaPath = createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix, listName);
+
+ ListSchemaNodeBuilder builder = moduleBuilder.addListNode(schemaPath, listQName, actualPath, ctx.getStart().getLine());
moduleBuilder.enterNode(builder);
- updatePath(containerName);
+ updatePath(listName);
- builder.setPath(createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix));
parseSchemaNodeArgs(ctx, builder);
parseConstraints(ctx, builder.getConstraints());
+ builder.setConfiguration(getConfig(ctx, moduleBuilder.getActualParent(), moduleName, ctx.getStart().getLine()));
String keyDefinition = "";
for (int i = 0; i < ctx.getChildCount(); ++i) {
public void enterAnyxml_stmt(YangParser.Anyxml_stmtContext ctx) {
final String anyXmlName = stringFromNode(ctx);
QName anyXmlQName = new QName(namespace, revision, yangModelPrefix, anyXmlName);
- AnyXmlBuilder builder = moduleBuilder.addAnyXml(anyXmlQName, actualPath, ctx.getStart().getLine());
+ SchemaPath schemaPath = createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix, anyXmlName);
+
+ AnyXmlBuilder builder = moduleBuilder.addAnyXml(schemaPath, anyXmlQName, actualPath, ctx.getStart().getLine());
moduleBuilder.enterNode(builder);
updatePath(anyXmlName);
- builder.setPath(createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix));
parseSchemaNodeArgs(ctx, builder);
parseConstraints(ctx, builder.getConstraints());
+ builder.setConfiguration(getConfig(ctx, moduleBuilder.getActualParent(), moduleName, ctx.getStart().getLine()));
}
@Override
builder.setPath(createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix));
parseSchemaNodeArgs(ctx, builder);
parseConstraints(ctx, builder.getConstraints());
+ builder.setConfiguration(getConfig(ctx, moduleBuilder.getActualParent(), moduleName, ctx.getStart().getLine()));
// set 'default' case
for (int i = 0; i < ctx.getChildCount(); i++) {
public void enterInput_stmt(YangParser.Input_stmtContext ctx) {
final String input = "input";
QName rpcQName = new QName(namespace, revision, yangModelPrefix, input);
- ContainerSchemaNodeBuilder builder = moduleBuilder.addRpcInput(rpcQName, ctx.getStart().getLine());
+ SchemaPath path = createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix, input);
+
+ ContainerSchemaNodeBuilder builder = moduleBuilder.addRpcInput(path, rpcQName, ctx.getStart().getLine());
moduleBuilder.enterNode(builder);
updatePath(input);
- builder.setPath(createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix));
parseSchemaNodeArgs(ctx, builder);
parseConstraints(ctx, builder.getConstraints());
}
public void enterOutput_stmt(YangParser.Output_stmtContext ctx) {
final String output = "output";
QName rpcQName = new QName(namespace, revision, yangModelPrefix, output);
- ContainerSchemaNodeBuilder builder = moduleBuilder.addRpcOutput(rpcQName, ctx.getStart().getLine());
+ SchemaPath path = createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix, output);
+
+ ContainerSchemaNodeBuilder builder = moduleBuilder.addRpcOutput(path, rpcQName, ctx.getStart().getLine());
moduleBuilder.enterNode(builder);
updatePath(output);
- builder.setPath(createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix));
parseSchemaNodeArgs(ctx, builder);
parseConstraints(ctx, builder.getConstraints());
}
moduleBuilder.exitNode();
}
- @Override
- public void enterConfig_stmt(YangParser.Config_stmtContext ctx) {
- boolean configuration = parseConfig(ctx);
- moduleBuilder.addConfiguration(configuration, actualPath, ctx.getStart().getLine());
- }
-
@Override
public void enterIdentity_stmt(YangParser.Identity_stmtContext ctx) {
final String identityName = stringFromNode(ctx);
import org.opendaylight.controller.yang.common.QName;
import org.opendaylight.controller.yang.model.api.AnyXmlSchemaNode;
-import org.opendaylight.controller.yang.model.api.ChoiceCaseNode;
import org.opendaylight.controller.yang.model.api.ChoiceNode;
import org.opendaylight.controller.yang.model.api.ConstraintDefinition;
import org.opendaylight.controller.yang.model.api.ContainerSchemaNode;
import org.opendaylight.controller.yang.model.api.SchemaNode;
import org.opendaylight.controller.yang.model.api.SchemaPath;
import org.opendaylight.controller.yang.model.api.TypeDefinition;
+import org.opendaylight.controller.yang.model.api.UnknownSchemaNode;
import org.opendaylight.controller.yang.model.api.type.BinaryTypeDefinition;
import org.opendaylight.controller.yang.model.api.type.BitsTypeDefinition;
import org.opendaylight.controller.yang.model.api.type.BooleanTypeDefinition;
import org.opendaylight.controller.yang.parser.builder.api.DataNodeContainerBuilder;
import org.opendaylight.controller.yang.parser.builder.api.DataSchemaNodeBuilder;
import org.opendaylight.controller.yang.parser.builder.api.GroupingBuilder;
+import org.opendaylight.controller.yang.parser.builder.api.GroupingMember;
import org.opendaylight.controller.yang.parser.builder.api.SchemaNodeBuilder;
import org.opendaylight.controller.yang.parser.builder.api.TypeAwareBuilder;
import org.opendaylight.controller.yang.parser.builder.api.TypeDefinitionBuilder;
import org.opendaylight.controller.yang.parser.builder.impl.TypeDefinitionBuilderImpl;
import org.opendaylight.controller.yang.parser.builder.impl.UnionTypeBuilder;
import org.opendaylight.controller.yang.parser.builder.impl.UnknownSchemaNodeBuilder;
-import org.opendaylight.controller.yang.parser.builder.impl.UsesNodeBuilderImpl;
public final class ParserUtils {
private ParserUtils() {
}
+ /**
+ * Create new SchemaPath from given path and name.
+ *
+ * Append new qname to schema path created from name argument. New QName
+ * gets namespace, revision and prefix same as last qname in current schema
+ * path.
+ *
+ * @param schemaPath
+ * @param name
+ * @return
+ */
+ public static SchemaPath createSchemaPath(SchemaPath schemaPath, String name) {
+ List<QName> path = new ArrayList<QName>(schemaPath.getPath());
+ QName last = path.get(path.size() - 1);
+ QName newQName = new QName(last.getNamespace(), last.getRevision(), last.getPrefix(), name);
+ path.add(newQName);
+ return new SchemaPath(path, schemaPath.isAbsolute());
+ }
+
/**
* Get module import referenced by given prefix.
*
return new SchemaPath(path, absolute);
}
+ /**
+ * Check if node is present in refine nodes.
+ *
+ * @param nodeQName
+ * qname of node
+ * @param refineNodes
+ * collections of refined nodes
+ * @return true, if node with given qname was found, false otherwise
+ */
+ public static SchemaNodeBuilder getRefined(QName nodeQName, List<SchemaNodeBuilder> refineNodes) {
+ for (SchemaNodeBuilder rn : refineNodes) {
+ if (rn.getQName().equals(nodeQName)) {
+ return rn;
+ }
+ }
+ return null;
+ }
+
/**
* Pull restriction from type and add them to constraints.
*
Builder result = grouping.getChildNode(refineNodeName);
// search groupings
if (result == null) {
- Set<GroupingBuilder> grps = grouping.getGroupings();
+ Set<GroupingBuilder> grps = grouping.getGroupingBuilders();
for (GroupingBuilder gr : grps) {
if (gr.getQName().getLocalName().equals(refineNodeName)) {
result = gr;
}
// search typedefs
if (result == null) {
- Set<TypeDefinitionBuilder> typedefs = grouping.getTypeDefinitions();
+ Set<TypeDefinitionBuilder> typedefs = grouping.getTypeDefinitionBuilders();
for (TypeDefinitionBuilder typedef : typedefs) {
if (typedef.getQName().getLocalName().equals(refineNodeName)) {
result = typedef;
* augmentation target node
*/
public static void fillAugmentTarget(final AugmentationSchemaBuilder augment, final DataNodeContainerBuilder target) {
- for (DataSchemaNodeBuilder builder : augment.getChildNodes()) {
+ boolean usesAugment = augment.getParent() instanceof UsesNodeBuilder;
+ for (DataSchemaNodeBuilder builder : augment.getChildNodeBuilders()) {
builder.setAugmenting(true);
+ if (usesAugment) {
+ if (builder instanceof GroupingMember) {
+ ((GroupingMember) builder).setAddedByUses(true);
+ }
+ }
correctAugmentChildPath(builder, target.getPath());
target.addChildNode(builder);
}
* augmentation target choice node
*/
public static void fillAugmentTarget(final AugmentationSchemaBuilder augment, final ChoiceBuilder target) {
- for (DataSchemaNodeBuilder builder : augment.getChildNodes()) {
+ boolean usesAugment = augment.getParent() instanceof UsesNodeBuilder;
+ for (DataSchemaNodeBuilder builder : augment.getChildNodeBuilders()) {
builder.setAugmenting(true);
+ if (usesAugment) {
+ if (builder instanceof GroupingMember) {
+ ((GroupingMember) builder).setAddedByUses(true);
+ }
+ }
correctAugmentChildPath(builder, target.getPath());
target.addChildNode(builder);
}
// set correct path for all child nodes
if (childNode instanceof DataNodeContainerBuilder) {
DataNodeContainerBuilder dataNodeContainer = (DataNodeContainerBuilder) childNode;
- for (DataSchemaNodeBuilder child : dataNodeContainer.getChildNodes()) {
+ for (DataSchemaNodeBuilder child : dataNodeContainer.getChildNodeBuilders()) {
correctAugmentChildPath(child, childNode.getPath());
}
}
return new SchemaPath(newPath, schemaPath.isAbsolute());
}
- public static LeafSchemaNodeBuilder copyLeafBuilder(final LeafSchemaNodeBuilder old) {
- final LeafSchemaNodeBuilder copy = new LeafSchemaNodeBuilder(old.getQName(), old.getLine());
- final TypeDefinition<?> type = old.getType();
- if (type == null) {
- copy.setTypedef(old.getTypedef());
- } else {
- copy.setType(type);
- }
- copyDataSchemaNodeArgs(old, copy);
- copyConstraintsFromBuilder(old, copy);
- for (UnknownSchemaNodeBuilder unknown : old.getUnknownNodes()) {
- copy.addUnknownSchemaNode(unknown);
- }
- copy.setDefaultStr(old.getDefaultStr());
- copy.setUnits(old.getUnits());
- return copy;
- }
-
- public static ContainerSchemaNodeBuilder copyContainerBuilder(final ContainerSchemaNodeBuilder old) {
- final ContainerSchemaNodeBuilder copy = new ContainerSchemaNodeBuilder(old.getQName(), old.getLine());
- copyDataSchemaNodeArgs(old, copy);
- copyConstraintsFromBuilder(old, copy);
- for (UnknownSchemaNodeBuilder unknown : old.getUnknownNodes()) {
- copy.addUnknownSchemaNode(unknown);
- }
- for (DataSchemaNodeBuilder child : old.getChildNodes()) {
- copy.addChildNode(child);
- }
- for (GroupingBuilder grouping : old.getGroupings()) {
- copy.addGrouping(grouping);
- }
- for (TypeDefinitionBuilder typedef : old.getTypeDefinitions()) {
- copy.addTypedef(typedef);
- }
- for (AugmentationSchemaBuilder augment : old.getAugmentations()) {
- copy.addAugmentation(augment);
- }
- for (UsesNodeBuilder use : old.getUsesNodes()) {
- copy.addUsesNode(use);
- }
- copy.setPresence(old.isPresence());
- return copy;
- }
-
- public static ListSchemaNodeBuilder copyListBuilder(final ListSchemaNodeBuilder old) {
- final ListSchemaNodeBuilder copy = new ListSchemaNodeBuilder(old.getQName(), old.getLine());
- copyDataSchemaNodeArgs(old, copy);
- copyConstraintsFromBuilder(old, copy);
- for (UnknownSchemaNodeBuilder unknown : old.getUnknownNodes()) {
- copy.addUnknownSchemaNode(unknown);
- }
- for (DataSchemaNodeBuilder child : old.getChildNodes()) {
- copy.addChildNode(child);
- }
- for (GroupingBuilder grouping : old.getGroupings()) {
- copy.addGrouping(grouping);
- }
- for (TypeDefinitionBuilder typedef : old.getTypeDefinitions()) {
- copy.addTypedef(typedef);
- }
- for (AugmentationSchemaBuilder augment : old.getAugmentations()) {
- copy.addAugmentation(augment);
- }
- for (UsesNodeBuilder use : old.getUsesNodes()) {
- copy.addUsesNode(use);
- }
- copy.setUserOrdered(old.isUserOrdered());
- return copy;
- }
-
- public static LeafListSchemaNodeBuilder copyLeafListBuilder(final LeafListSchemaNodeBuilder old) {
- final LeafListSchemaNodeBuilder copy = new LeafListSchemaNodeBuilder(old.getQName(), old.getLine());
- copyDataSchemaNodeArgs(old, copy);
- copyConstraintsFromBuilder(old, copy);
- final TypeDefinition<?> type = old.getType();
- if (type == null) {
- copy.setTypedef(old.getTypedef());
- } else {
- copy.setType(type);
- }
- for (UnknownSchemaNodeBuilder unknown : old.getUnknownNodes()) {
- copy.addUnknownSchemaNode(unknown);
- }
- copy.setUserOrdered(old.isUserOrdered());
- return copy;
- }
-
- public static ChoiceBuilder copyChoiceBuilder(final ChoiceBuilder old) {
- final ChoiceBuilder copy = new ChoiceBuilder(old.getQName(), old.getLine());
- copyDataSchemaNodeArgs(old, copy);
- copyConstraintsFromBuilder(old, copy);
- for (ChoiceCaseBuilder caseBuilder : old.getCases()) {
- copy.addChildNode(caseBuilder);
- }
- for (UnknownSchemaNodeBuilder unknown : old.getUnknownNodes()) {
- copy.addUnknownSchemaNode(unknown);
- }
- copy.setDefaultCase(old.getDefaultCase());
- return copy;
- }
-
- public static AnyXmlBuilder copyAnyXmlBuilder(final AnyXmlBuilder old) {
- final AnyXmlBuilder copy = new AnyXmlBuilder(old.getQName(), old.getLine());
- copyDataSchemaNodeArgs(old, copy);
- copyConstraintsFromBuilder(old, copy);
- for (UnknownSchemaNodeBuilder unknown : old.getUnknownNodes()) {
- copy.addUnknownSchemaNode(unknown);
- }
- return copy;
- }
-
- public static GroupingBuilder copyGroupingBuilder(final GroupingBuilder old) {
- final GroupingBuilder copy = new GroupingBuilderImpl(old.getQName(), old.getLine());
- copy.setPath(old.getPath());
- for (DataSchemaNodeBuilder child : old.getChildNodes()) {
- copy.addChildNode(child);
- }
- for (GroupingBuilder grouping : old.getGroupings()) {
- copy.addGrouping(grouping);
- }
- for (TypeDefinitionBuilder typedef : old.getTypeDefinitions()) {
- copy.addTypedef(typedef);
- }
- for (UsesNodeBuilder use : old.getUses()) {
- copy.addUsesNode(use);
- }
- for (UnknownSchemaNodeBuilder unknown : old.getUnknownNodes()) {
- copy.addUnknownSchemaNode(unknown);
- }
- copy.setDescription(old.getDescription());
- copy.setReference(old.getReference());
- copy.setStatus(old.getStatus());
- return copy;
- }
-
- public static TypeDefinitionBuilderImpl copyTypedefBuilder(final TypeDefinitionBuilderImpl old) {
- final TypeDefinitionBuilderImpl copy = new TypeDefinitionBuilderImpl(old.getQName(), old.getLine());
- copy.setPath(old.getPath());
- copy.setDefaultValue(old.getDefaultValue());
- copy.setUnits(old.getUnits());
- copy.setDescription(old.getDescription());
- copy.setReference(old.getReference());
- copy.setStatus(old.getStatus());
-
- copy.setRanges(old.getRanges());
- copy.setLengths(old.getLengths());
- copy.setPatterns(old.getPatterns());
- copy.setFractionDigits(old.getFractionDigits());
-
- TypeDefinition<?> type = old.getType();
- if (type == null) {
- copy.setTypedef(old.getTypedef());
- } else {
- copy.setType(old.getType());
- }
- copy.setUnits(old.getUnits());
- for (UnknownSchemaNodeBuilder unknown : old.getUnknownNodes()) {
- copy.addUnknownSchemaNode(unknown);
- }
- return copy;
- }
-
- public static UsesNodeBuilder copyUsesNodeBuilder(final UsesNodeBuilder old) {
- final UsesNodeBuilder copy = new UsesNodeBuilderImpl(old.getGroupingName(), old.getLine());
- for (AugmentationSchemaBuilder augment : old.getAugmentations()) {
- copy.addAugment(augment);
- }
- copy.setAugmenting(old.isAugmenting());
- for (SchemaNodeBuilder refineNode : old.getRefineNodes()) {
- copy.addRefineNode(refineNode);
- }
- return copy;
- }
-
- private static void copyDataSchemaNodeArgs(final DataSchemaNodeBuilder oldBuilder,
- final DataSchemaNodeBuilder newBuilder) {
- newBuilder.setPath(oldBuilder.getPath());
- newBuilder.setDescription(oldBuilder.getDescription());
- newBuilder.setReference(oldBuilder.getReference());
- newBuilder.setStatus(oldBuilder.getStatus());
- newBuilder.setAugmenting(oldBuilder.isAugmenting());
- if (!(oldBuilder instanceof ChoiceCaseNode)) {
- newBuilder.setConfiguration(oldBuilder.isConfiguration());
- }
- }
-
- /**
- * Copy constraints from old builder to new builder.
- *
- * @param oldBuilder
- * @param newBuilder
- */
- private static void copyConstraintsFromBuilder(final DataSchemaNodeBuilder oldBuilder,
- final DataSchemaNodeBuilder newBuilder) {
- final ConstraintsBuilder oldConstraints = oldBuilder.getConstraints();
- final ConstraintsBuilder newConstraints = newBuilder.getConstraints();
- newConstraints.addWhenCondition(oldConstraints.getWhenCondition());
- for (MustDefinition must : oldConstraints.getMustDefinitions()) {
- newConstraints.addMustDefinition(must);
- }
- newConstraints.setMandatory(oldConstraints.isMandatory());
- newConstraints.setMinElements(oldConstraints.getMinElements());
- newConstraints.setMaxElements(oldConstraints.getMaxElements());
- }
-
/**
* Create LeafSchemaNodeBuilder from given LeafSchemaNode.
*
* @return builder object from leaf
*/
public static LeafSchemaNodeBuilder createLeafBuilder(LeafSchemaNode leaf, int line) {
- final LeafSchemaNodeBuilder builder = new LeafSchemaNodeBuilder(leaf.getQName(), line);
+ final LeafSchemaNodeBuilder builder = new LeafSchemaNodeBuilder(leaf.getQName(), leaf.getPath(), line);
convertDataSchemaNode(leaf, builder);
+ builder.setConfiguration(leaf.isConfiguration());
final TypeDefinition<?> type = leaf.getType();
builder.setType(type);
builder.setPath(leaf.getPath());
}
public static ContainerSchemaNodeBuilder createContainer(ContainerSchemaNode container, int line) {
- final ContainerSchemaNodeBuilder builder = new ContainerSchemaNodeBuilder(container.getQName(), line);
+ final ContainerSchemaNodeBuilder builder = new ContainerSchemaNodeBuilder(container.getQName(),
+ container.getPath(), line);
convertDataSchemaNode(container, builder);
+ builder.setConfiguration(container.isConfiguration());
builder.setUnknownNodes(container.getUnknownSchemaNodes());
builder.setChildNodes(container.getChildNodes());
builder.setGroupings(container.getGroupings());
}
public static ListSchemaNodeBuilder createList(ListSchemaNode list, int line) {
- ListSchemaNodeBuilder builder = new ListSchemaNodeBuilder(list.getQName(), line);
+ ListSchemaNodeBuilder builder = new ListSchemaNodeBuilder(list.getQName(), list.getPath(), line);
convertDataSchemaNode(list, builder);
+ builder.setConfiguration(list.isConfiguration());
builder.setUnknownNodes(list.getUnknownSchemaNodes());
builder.setTypedefs(list.getTypeDefinitions());
builder.setChildNodes(list.getChildNodes());
}
public static LeafListSchemaNodeBuilder createLeafList(LeafListSchemaNode leafList, int line) {
- final LeafListSchemaNodeBuilder builder = new LeafListSchemaNodeBuilder(leafList.getQName(), line);
+ final LeafListSchemaNodeBuilder builder = new LeafListSchemaNodeBuilder(leafList.getQName(),
+ leafList.getPath(), line);
convertDataSchemaNode(leafList, builder);
+ builder.setConfiguration(leafList.isConfiguration());
builder.setType(leafList.getType());
builder.setUnknownNodes(leafList.getUnknownSchemaNodes());
builder.setUserOrdered(leafList.isUserOrdered());
public static ChoiceBuilder createChoice(ChoiceNode choice, int line) {
final ChoiceBuilder builder = new ChoiceBuilder(choice.getQName(), line);
convertDataSchemaNode(choice, builder);
+ builder.setConfiguration(choice.isConfiguration());
builder.setCases(choice.getCases());
builder.setUnknownNodes(choice.getUnknownSchemaNodes());
builder.setDefaultCase(choice.getDefaultCase());
}
public static AnyXmlBuilder createAnyXml(AnyXmlSchemaNode anyxml, int line) {
- final AnyXmlBuilder builder = new AnyXmlBuilder(anyxml.getQName(), line);
+ final AnyXmlBuilder builder = new AnyXmlBuilder(anyxml.getQName(), anyxml.getPath(), line);
convertDataSchemaNode(anyxml, builder);
+ builder.setConfiguration(anyxml.isConfiguration());
builder.setUnknownNodes(anyxml.getUnknownSchemaNodes());
return builder;
}
return builder;
}
+ public static UnknownSchemaNodeBuilder createUnknownSchemaNode(UnknownSchemaNode grouping, int line) {
+ final UnknownSchemaNodeBuilder builder = new UnknownSchemaNodeBuilder(grouping.getQName(), line);
+ builder.setPath(grouping.getPath());
+ builder.setUnknownNodes(grouping.getUnknownSchemaNodes());
+ builder.setDescription(grouping.getDescription());
+ builder.setReference(grouping.getReference());
+ builder.setStatus(grouping.getStatus());
+ builder.setAddedByUses(grouping.isAddedByUses());
+ builder.setNodeType(grouping.getNodeType());
+ builder.setNodeParameter(grouping.getNodeParameter());
+ return builder;
+ }
+
/**
* Set DataSchemaNode arguments to builder object
*
builder.setReference(node.getReference());
builder.setStatus(node.getStatus());
builder.setAugmenting(node.isAugmenting());
- if (!(node instanceof ChoiceCaseNode)) {
- builder.setConfiguration(node.isConfiguration());
- }
copyConstraintsFromDefinition(node.getConstraints(), builder.getConstraints());
}
public static void processAugmentation(final AugmentationSchemaBuilder augmentBuilder, final List<QName> path,
final ModuleBuilder module, final QName qname, final ModuleBuilder dependentModuleBuilder) {
DataSchemaNodeBuilder currentParent = null;
- for (DataSchemaNodeBuilder child : dependentModuleBuilder.getChildNodes()) {
+ for (DataSchemaNodeBuilder child : dependentModuleBuilder.getChildNodeBuilders()) {
final QName childQName = child.getQName();
if (childQName.getLocalName().equals(qname.getLocalName())) {
currentParent = child;
for (int i = 1; i < path.size(); i++) {
final QName currentQName = path.get(i);
DataSchemaNodeBuilder newParent = null;
- for (DataSchemaNodeBuilder child : ((DataNodeContainerBuilder) currentParent).getChildNodes()) {
+ for (DataSchemaNodeBuilder child : ((DataNodeContainerBuilder) currentParent).getChildNodeBuilders()) {
final QName childQName = child.getQName();
if (childQName.getLocalName().equals(currentQName.getLocalName())) {
newParent = child;
if (currentNode instanceof RpcDefinitionBuilder) {
typedefs = ((RpcDefinitionBuilder) currentNode).getTypeDefinitions();
} else if (currentNode instanceof DataNodeContainerBuilder) {
- typedefs = ((DataNodeContainerBuilder) currentNode).getTypeDefinitions();
+ typedefs = ((DataNodeContainerBuilder) currentNode).getTypeDefinitionBuilders();
} else {
typedefs = Collections.emptySet();
}
import org.opendaylight.controller.yang.model.api.MustDefinition;
import org.opendaylight.controller.yang.parser.builder.api.Builder;
+import org.opendaylight.controller.yang.parser.builder.api.ConfigNode;
import org.opendaylight.controller.yang.parser.builder.impl.UnknownSchemaNodeBuilder;
-public final class RefineHolder implements Builder {
+public final class RefineHolder implements Builder, ConfigNode {
private final String name;
private final int line;
private String defaultStr;
this.reference = reference;
}
- public Boolean isConfig() {
+ @Override
+ public Boolean isConfiguration() {
return config;
}
- public void setConfig(final Boolean config) {
+ @Override
+ public void setConfiguration(final Boolean config) {
this.config = config;
}
import org.opendaylight.controller.yang.parser.builder.impl.AnyXmlBuilder;
import org.opendaylight.controller.yang.parser.builder.impl.ChoiceBuilder;
import org.opendaylight.controller.yang.parser.builder.impl.ContainerSchemaNodeBuilder;
+import org.opendaylight.controller.yang.parser.builder.impl.GroupingBuilderImpl;
import org.opendaylight.controller.yang.parser.builder.impl.LeafListSchemaNodeBuilder;
import org.opendaylight.controller.yang.parser.builder.impl.LeafSchemaNodeBuilder;
import org.opendaylight.controller.yang.parser.builder.impl.ListSchemaNodeBuilder;
Builder result = null;
final Builder lookedUpBuilder = findRefineTargetBuilder(targetGrouping, refine.getName());
if (lookedUpBuilder instanceof LeafSchemaNodeBuilder) {
- result = copyLeafBuilder((LeafSchemaNodeBuilder) lookedUpBuilder);
+ result = new LeafSchemaNodeBuilder((LeafSchemaNodeBuilder) lookedUpBuilder);
} else if (lookedUpBuilder instanceof ContainerSchemaNodeBuilder) {
- result = copyContainerBuilder((ContainerSchemaNodeBuilder) lookedUpBuilder);
+ result = new ContainerSchemaNodeBuilder((ContainerSchemaNodeBuilder) lookedUpBuilder);
} else if (lookedUpBuilder instanceof ListSchemaNodeBuilder) {
- result = copyListBuilder((ListSchemaNodeBuilder) lookedUpBuilder);
+ result = new ListSchemaNodeBuilder((ListSchemaNodeBuilder) lookedUpBuilder);
} else if (lookedUpBuilder instanceof LeafListSchemaNodeBuilder) {
- result = copyLeafListBuilder((LeafListSchemaNodeBuilder) lookedUpBuilder);
+ result = new LeafListSchemaNodeBuilder((LeafListSchemaNodeBuilder) lookedUpBuilder);
} else if (lookedUpBuilder instanceof ChoiceBuilder) {
- result = copyChoiceBuilder((ChoiceBuilder) lookedUpBuilder);
+ result = new ChoiceBuilder((ChoiceBuilder) lookedUpBuilder);
} else if (lookedUpBuilder instanceof AnyXmlBuilder) {
- result = copyAnyXmlBuilder((AnyXmlBuilder) lookedUpBuilder);
+ result = new AnyXmlBuilder((AnyXmlBuilder) lookedUpBuilder);
} else if (lookedUpBuilder instanceof GroupingBuilder) {
- result = copyGroupingBuilder((GroupingBuilder) lookedUpBuilder);
+ result = new GroupingBuilderImpl((GroupingBuilder) lookedUpBuilder);
} else if (lookedUpBuilder instanceof TypeDefinitionBuilder) {
- result = copyTypedefBuilder((TypeDefinitionBuilderImpl) lookedUpBuilder);
+ result = new TypeDefinitionBuilderImpl((TypeDefinitionBuilder) lookedUpBuilder);
} else {
throw new YangParseException(moduleName, refine.getLine(), "Target '" + refine.getName()
+ "' can not be refined");
}
}
- Boolean config = refine.isConfig();
+ Boolean config = refine.isConfiguration();
if (config != null) {
try {
- Method method = cls.getDeclaredMethod("setConfiguration", Boolean.TYPE);
+ Method method = cls.getDeclaredMethod("setConfiguration", Boolean.class);
method.invoke(node, config);
} catch (Exception e) {
throw new YangParseException(line, "Cannot refine config in " + cls.getName(), e);
import java.util.Stack;
import org.antlr.v4.runtime.tree.ParseTree;
-import org.opendaylight.controller.antlrv4.code.gen.YangParser;
+import org.opendaylight.controller.antlrv4.code.gen.*;
import org.opendaylight.controller.antlrv4.code.gen.YangParser.Argument_stmtContext;
import org.opendaylight.controller.antlrv4.code.gen.YangParser.Base_stmtContext;
import org.opendaylight.controller.antlrv4.code.gen.YangParser.Bit_stmtContext;
import org.opendaylight.controller.yang.model.util.Uint8;
import org.opendaylight.controller.yang.model.util.UnknownType;
import org.opendaylight.controller.yang.parser.builder.api.Builder;
+import org.opendaylight.controller.yang.parser.builder.api.ConfigNode;
import org.opendaylight.controller.yang.parser.builder.api.SchemaNodeBuilder;
import org.opendaylight.controller.yang.parser.builder.api.TypeDefinitionBuilder;
+import org.opendaylight.controller.yang.parser.builder.impl.ChoiceBuilder;
+import org.opendaylight.controller.yang.parser.builder.impl.ChoiceCaseBuilder;
import org.opendaylight.controller.yang.parser.builder.impl.ConstraintsBuilder;
-import org.opendaylight.controller.yang.parser.builder.impl.ModuleBuilder;
import org.opendaylight.controller.yang.parser.builder.impl.UnionTypeBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public final class YangModelBuilderUtil {
-
private static final Logger logger = LoggerFactory.getLogger(YangModelBuilderUtil.class);
private YangModelBuilderUtil() {
}
/**
- * Create SchemaPath object from given path list with namespace, revision
- * and prefix based on given values.
+ * Create SchemaPath from actualPath and names.
*
* @param actualPath
* current position in model
* @param namespace
* @param revision
* @param prefix
+ * @param names
* @return SchemaPath object.
*/
public static SchemaPath createActualSchemaPath(final List<String> actualPath, final URI namespace,
- final Date revision, final String prefix) {
+ final Date revision, final String prefix, final String... names) {
final List<QName> path = new ArrayList<QName>();
QName qname;
// start from index 1 - module name omited
qname = new QName(namespace, revision, prefix, actualPath.get(i));
path.add(qname);
}
+ for (String name : names) {
+ qname = new QName(namespace, revision, prefix, name);
+ path.add(qname);
+ }
return new SchemaPath(path, true);
}
}
/**
- * Parse orderedby statement.
+ * Parse 'ordered-by' statement.
+ *
+ * The 'ordered-by' statement defines whether the order of entries within a
+ * list are determined by the user or the system. The argument is one of the
+ * strings "system" or "user". If not present, order defaults to "system".
*
* @param childNode
* Ordered_by_stmtContext
- * @return true, if orderedby contains value 'user' or false otherwise
+ * @return true, if ordered-by contains value 'user', false otherwise
*/
public static boolean parseUserOrdered(Ordered_by_stmtContext childNode) {
boolean result = false;
return result;
}
+ public static Boolean getConfig(final ParseTree ctx, final Builder parent, final String moduleName, final int line) {
+ Boolean result = null;
+ // parse configuration statement
+ Boolean configuration = null;
+ for (int i = 0; i < ctx.getChildCount(); i++) {
+ ParseTree child = ctx.getChild(i);
+ if (child instanceof Config_stmtContext) {
+ configuration = parseConfig((Config_stmtContext) child);
+ break;
+ }
+ }
+
+ // If 'config' is not specified, the default is the same as the parent
+ // schema node's 'config' value
+ if (configuration == null) {
+ if (parent instanceof ConfigNode) {
+ Boolean parentConfig = ((ConfigNode) parent).isConfiguration();
+ // If the parent node is a rpc input or output, it can has
+ // config set to null
+ result = parentConfig == null ? true : parentConfig;
+ } else if (parent instanceof ChoiceCaseBuilder) {
+ // If the parent node is a 'case' node, the value is the same as
+ // the 'case' node's parent 'choice' node
+ ChoiceCaseBuilder choiceCase = (ChoiceCaseBuilder) parent;
+ ChoiceBuilder choice = choiceCase.getParent();
+ Boolean parentConfig = null;
+ if (choice == null) {
+ parentConfig = true;
+ } else {
+ parentConfig = choice.isConfiguration();
+ }
+ result = parentConfig;
+ } else {
+ result = true;
+ }
+ } else {
+ // Check first: if a node has 'config' set to 'false', no node
+ // underneath it can have 'config' set to 'true'
+ if (parent instanceof ConfigNode) {
+ Boolean parentConfig = ((ConfigNode) parent).isConfiguration();
+ if (parentConfig == false && configuration == true) {
+ throw new YangParseException(moduleName, line,
+ "Can not set 'config' to 'true' if parent node has 'config' set to 'false'");
+ }
+ }
+ result = configuration;
+ }
+
+ return result;
+ }
+
/**
- * Parse given config context and return true if it contains string 'true',
- * false otherwise.
+ * Parse config statement.
*
* @param ctx
* config context to parse.
* @return true if given context contains string 'true', false otherwise
*/
- public static boolean parseConfig(final Config_stmtContext ctx) {
- boolean result = false;
+ private static Boolean parseConfig(final Config_stmtContext ctx) {
+ Boolean result = null;
if (ctx != null) {
for (int i = 0; i < ctx.getChildCount(); ++i) {
final ParseTree configContext = ctx.getChild(i);
if ("true".equals(value)) {
result = true;
break;
+ } else if ("false".equals(value)) {
+ result = false;
+ break;
+ } else {
+ throw new YangParseException(ctx.getStart().getLine(),
+ "Failed to parse 'config' statement value: '" + value + "'.");
}
}
}
}
/**
- * Parse given type body and creates UnknownType definition.
+ * Parse type body and create UnknownType definition.
*
* @param typedefQName
* qname of current type
* @param ctx
* type body
+ * @param actualPath
+ * @param namespace
+ * @param revision
+ * @param prefix
+ * @param parent
* @return UnknownType object with constraints from parsed type body
*/
- public static TypeDefinition<?> parseUnknownTypeBody(QName typedefQName, Type_body_stmtsContext ctx,
- final List<String> actualPath, final URI namespace, final Date revision, final String prefix,
- Builder parent, ModuleBuilder moduleBuilder) {
+ public static TypeDefinition<?> parseUnknownTypeWithBody(final QName typedefQName,
+ final Type_body_stmtsContext ctx, final List<String> actualPath, final URI namespace, final Date revision,
+ final String prefix, final Builder parent) {
String typeName = typedefQName.getLocalName();
UnknownType.Builder unknownType = new UnknownType.Builder(typedefQName);
/**
* Create TypeDefinition object based on given type name and type body.
*
+ * @param moduleName
+ * current module name
* @param typeName
* name of type
* @param typeBody
- * type body
+ * type body context
* @param actualPath
* current path in schema
* @param namespace
* current revision
* @param prefix
* current prefix
+ * @param parent
+ * parent builder
* @return TypeDefinition object based on parsed values.
*/
- public static TypeDefinition<?> parseTypeBody(final String moduleName, final String typeName,
+ public static TypeDefinition<?> parseTypeWithBody(final String moduleName, final String typeName,
final Type_body_stmtsContext typeBody, final List<String> actualPath, final URI namespace,
- final Date revision, final String prefix, Builder parent) {
+ final Date revision, final String prefix, final Builder parent) {
TypeDefinition<?> baseType = null;
- List<RangeConstraint> rangeStatements = getRangeConstraints(typeBody);
Integer fractionDigits = getFractionDigits(typeBody);
List<LengthConstraint> lengthStatements = getLengthConstraints(typeBody);
List<PatternConstraint> patternStatements = getPatternConstraint(typeBody);
- List<EnumTypeDefinition.EnumPair> enumConstants = getEnumConstants(typeBody, actualPath, namespace, revision,
- prefix);
+ List<RangeConstraint> rangeStatements = getRangeConstraints(typeBody);
TypeConstraints constraints = new TypeConstraints(moduleName, typeBody.getStart().getLine());
constraints.addFractionDigits(fractionDigits);
constraints.addRanges(uintType.getRangeStatements());
baseType = uintType;
} else if ("enumeration".equals(typeName)) {
+ List<EnumTypeDefinition.EnumPair> enumConstants = getEnumConstants(typeBody, actualPath, namespace,
+ revision, prefix);
return new EnumerationType(baseTypePathFinal, enumConstants);
} else if ("string".equals(typeName)) {
StringTypeDefinition stringType = new StringType(baseTypePath);
}
/**
- * Parse given context and find require-instance value.
+ * Parse type body statement and find require-instance value.
*
* @param ctx
- * type body
+ * type body context
* @return require-instance value
*/
private static boolean isRequireInstance(Type_body_stmtsContext ctx) {
}
/**
- * Parse given context and find leafref path.
+ * Parse type body statement and find leafref path.
*
* @param ctx
- * type body
+ * type body context
* @return leafref path as String
*/
private static String parseLeafrefPath(Type_body_stmtsContext ctx) {
}
/**
- * Internal helper method for parsing Must_stmtContext.
+ * Internal helper method for parsing must statement.
*
* @param ctx
* Must_stmtContext
}
/**
- * Parse given tree and set constraints to given builder.
+ * Parse given context and set constraints to constraints builder.
*
* @param ctx
- * context to search
+ * context to parse
* @param constraints
* ConstraintsBuilder to fill
*/
String reference = stringFromNode(refineArg);
refine.setReference(reference);
} else if (refineArg instanceof Config_stmtContext) {
- boolean config = parseConfig((Config_stmtContext) refineArg);
- refine.setConfig(config);
+ Boolean config = parseConfig((Config_stmtContext) refineArg);
+ refine.setConfiguration(config);
}
}
}
--- /dev/null
+/*
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.controller.yang.parser.impl;
+
+import static org.junit.Assert.*;
+
+import java.io.FileNotFoundException;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.opendaylight.controller.yang.model.api.AnyXmlSchemaNode;
+import org.opendaylight.controller.yang.model.api.ChoiceNode;
+import org.opendaylight.controller.yang.model.api.ContainerSchemaNode;
+import org.opendaylight.controller.yang.model.api.DataSchemaNode;
+import org.opendaylight.controller.yang.model.api.GroupingDefinition;
+import org.opendaylight.controller.yang.model.api.LeafSchemaNode;
+import org.opendaylight.controller.yang.model.api.ListSchemaNode;
+import org.opendaylight.controller.yang.model.api.Module;
+import org.opendaylight.controller.yang.model.api.MustDefinition;
+import org.opendaylight.controller.yang.model.api.SchemaNode;
+import org.opendaylight.controller.yang.model.api.SchemaPath;
+import org.opendaylight.controller.yang.model.api.TypeDefinition;
+import org.opendaylight.controller.yang.model.api.UnknownSchemaNode;
+import org.opendaylight.controller.yang.model.api.UsesNode;
+import org.opendaylight.controller.yang.model.util.ExtendedType;
+
+public class GroupingTest {
+ private Set<Module> modules;
+
+ @Before
+ public void init() throws FileNotFoundException {
+ modules = TestUtils.loadModules(getClass().getResource("/model").getPath());
+ assertEquals(3, modules.size());
+ }
+
+ @Test
+ public void testRefine() {
+ Module testModule = TestUtils.findModule(modules, "types2");
+
+ ContainerSchemaNode peer = (ContainerSchemaNode) testModule.getDataChildByName("peer");
+ ContainerSchemaNode destination = (ContainerSchemaNode) peer.getDataChildByName("destination");
+ Set<UsesNode> usesNodes = destination.getUses();
+ assertEquals(1, usesNodes.size());
+ UsesNode usesNode = usesNodes.iterator().next();
+ Map<SchemaPath, SchemaNode> refines = usesNode.getRefines();
+ assertEquals(5, refines.size());
+
+ LeafSchemaNode refineLeaf = null;
+ ContainerSchemaNode refineContainer = null;
+ ListSchemaNode refineList = null;
+ GroupingDefinition refineGrouping = null;
+ TypeDefinition<?> typedef = null;
+ for (Map.Entry<SchemaPath, SchemaNode> entry : refines.entrySet()) {
+ SchemaNode value = entry.getValue();
+ if (value instanceof LeafSchemaNode) {
+ refineLeaf = (LeafSchemaNode) value;
+ } else if (value instanceof ContainerSchemaNode) {
+ refineContainer = (ContainerSchemaNode) value;
+ } else if (value instanceof ListSchemaNode) {
+ refineList = (ListSchemaNode) value;
+ } else if (value instanceof GroupingDefinition) {
+ refineGrouping = (GroupingDefinition) value;
+ } else if (value instanceof TypeDefinition<?>) {
+ typedef = (TypeDefinition<?>) value;
+ }
+ }
+
+ // leaf address
+ assertNotNull(refineLeaf);
+ assertEquals("address", refineLeaf.getQName().getLocalName());
+ assertEquals("IP address of target node", refineLeaf.getDescription());
+ assertEquals("address reference added by refine", refineLeaf.getReference());
+ assertFalse(refineLeaf.isConfiguration());
+ assertTrue(refineLeaf.getConstraints().isMandatory());
+ Set<MustDefinition> leafMustConstraints = refineLeaf.getConstraints().getMustConstraints();
+ assertEquals(1, leafMustConstraints.size());
+ MustDefinition leafMust = leafMustConstraints.iterator().next();
+ assertEquals("\"ifType != 'ethernet' or (ifType = 'ethernet' and ifMTU = 1500)\"", leafMust.toString());
+
+ // container port
+ assertNotNull(refineContainer);
+ Set<MustDefinition> mustConstraints = refineContainer.getConstraints().getMustConstraints();
+ assertTrue(mustConstraints.isEmpty());
+ assertEquals("description of port defined by refine", refineContainer.getDescription());
+ assertEquals("port reference added by refine", refineContainer.getReference());
+ assertFalse(refineContainer.isConfiguration());
+ assertTrue(refineContainer.isPresenceContainer());
+
+ // list addresses
+ assertNotNull(refineList);
+ assertEquals("description of addresses defined by refine", refineList.getDescription());
+ assertEquals("addresses reference added by refine", refineList.getReference());
+ assertFalse(refineList.isConfiguration());
+ assertEquals(2, (int) refineList.getConstraints().getMinElements());
+ assertEquals(12, (int) refineList.getConstraints().getMaxElements());
+
+ // grouping target-inner
+ assertNotNull(refineGrouping);
+ Set<DataSchemaNode> refineGroupingChildren = refineGrouping.getChildNodes();
+ assertEquals(1, refineGroupingChildren.size());
+ LeafSchemaNode refineGroupingLeaf = (LeafSchemaNode) refineGroupingChildren.iterator().next();
+ assertEquals("inner-grouping-id", refineGroupingLeaf.getQName().getLocalName());
+ assertEquals("new target-inner grouping description", refineGrouping.getDescription());
+
+ // typedef group-type
+ assertNotNull(typedef);
+ assertEquals("new group-type description", typedef.getDescription());
+ assertEquals("new group-type reference", typedef.getReference());
+ assertTrue(typedef.getBaseType() instanceof ExtendedType);
+ }
+
+ @Test
+ public void testGrouping() {
+ Module testModule = TestUtils.findModule(modules, "types2");
+ Set<GroupingDefinition> groupings = testModule.getGroupings();
+ assertEquals(1, groupings.size());
+ GroupingDefinition grouping = groupings.iterator().next();
+ Set<DataSchemaNode> children = grouping.getChildNodes();
+ assertEquals(5, children.size());
+ }
+
+ @Test
+ public void testUses() {
+ // suffix _u = added by uses
+ // suffix _g = defined in grouping
+
+ Module testModule = TestUtils.findModule(modules, "types2");
+
+ // get grouping
+ Set<GroupingDefinition> groupings = testModule.getGroupings();
+ assertEquals(1, groupings.size());
+ GroupingDefinition grouping = groupings.iterator().next();
+
+ // get node containing uses
+ ContainerSchemaNode peer = (ContainerSchemaNode) testModule.getDataChildByName("peer");
+ ContainerSchemaNode destination = (ContainerSchemaNode) peer.getDataChildByName("destination");
+
+ // check uses
+ Set<UsesNode> uses = destination.getUses();
+ assertEquals(1, uses.size());
+
+ // check uses process
+ AnyXmlSchemaNode data_u = (AnyXmlSchemaNode) destination.getDataChildByName("data");
+ assertNotNull(data_u);
+ assertTrue(data_u.isAddedByUses());
+
+ AnyXmlSchemaNode data_g = (AnyXmlSchemaNode) grouping.getDataChildByName("data");
+ assertNotNull(data_g);
+ assertFalse(data_g.isAddedByUses());
+ assertFalse(data_u.equals(data_g));
+
+ ChoiceNode how_u = (ChoiceNode) destination.getDataChildByName("how");
+ assertNotNull(how_u);
+ assertTrue(how_u.isAddedByUses());
+
+ ChoiceNode how_g = (ChoiceNode) grouping.getDataChildByName("how");
+ assertNotNull(how_g);
+ assertFalse(how_g.isAddedByUses());
+ assertFalse(how_u.equals(how_g));
+
+ LeafSchemaNode address_u = (LeafSchemaNode) destination.getDataChildByName("address");
+ assertNotNull(address_u);
+ assertEquals("1.2.3.4", address_u.getDefault());
+ assertEquals("IP address of target node", address_u.getDescription());
+ assertEquals("address reference added by refine", address_u.getReference());
+ assertFalse(address_u.isConfiguration());
+ assertTrue(address_u.isAddedByUses());
+
+ LeafSchemaNode address_g = (LeafSchemaNode) grouping.getDataChildByName("address");
+ assertNotNull(address_g);
+ assertFalse(address_g.isAddedByUses());
+ assertNull(address_g.getDefault());
+ assertEquals("Target IP address", address_g.getDescription());
+ assertNull(address_g.getReference());
+ assertTrue(address_g.isConfiguration());
+ assertFalse(address_u.equals(address_g));
+
+ ContainerSchemaNode port_u = (ContainerSchemaNode) destination.getDataChildByName("port");
+ assertNotNull(port_u);
+ assertTrue(port_u.isAddedByUses());
+
+ ContainerSchemaNode port_g = (ContainerSchemaNode) grouping.getDataChildByName("port");
+ assertNotNull(port_g);
+ assertFalse(port_g.isAddedByUses());
+ assertFalse(port_u.equals(port_g));
+
+ ListSchemaNode addresses_u = (ListSchemaNode) destination.getDataChildByName("addresses");
+ assertNotNull(addresses_u);
+ assertTrue(addresses_u.isAddedByUses());
+
+ ListSchemaNode addresses_g = (ListSchemaNode) grouping.getDataChildByName("addresses");
+ assertNotNull(addresses_g);
+ assertFalse(addresses_g.isAddedByUses());
+ assertFalse(addresses_u.equals(addresses_g));
+
+ // grouping defined by 'uses'
+ Set<GroupingDefinition> groupings_u = destination.getGroupings();
+ assertEquals(1, groupings_u.size());
+ GroupingDefinition grouping_u = groupings_u.iterator().next();
+ assertTrue(grouping_u.isAddedByUses());
+
+ // grouping defined in 'grouping' node
+ Set<GroupingDefinition> groupings_g = grouping.getGroupings();
+ assertEquals(1, groupings_g.size());
+ GroupingDefinition grouping_g = groupings_g.iterator().next();
+ assertFalse(grouping_g.isAddedByUses());
+ assertFalse(grouping_u.equals(grouping_g));
+
+ List<UnknownSchemaNode> nodes_u = destination.getUnknownSchemaNodes();
+ assertEquals(1, nodes_u.size());
+ UnknownSchemaNode node_u = nodes_u.get(0);
+ assertTrue(node_u.isAddedByUses());
+
+ List<UnknownSchemaNode> nodes_g = grouping.getUnknownSchemaNodes();
+ assertEquals(1, nodes_g.size());
+ UnknownSchemaNode node_g = nodes_g.get(0);
+ assertFalse(node_g.isAddedByUses());
+ assertFalse(node_u.equals(node_g));
+ }
+
+}
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
-import java.util.Map;
import java.util.Set;
import org.junit.Before;
import org.opendaylight.controller.yang.model.api.ChoiceNode;
import org.opendaylight.controller.yang.model.api.ConstraintDefinition;
import org.opendaylight.controller.yang.model.api.ContainerSchemaNode;
-import org.opendaylight.controller.yang.model.api.DataSchemaNode;
import org.opendaylight.controller.yang.model.api.Deviation;
import org.opendaylight.controller.yang.model.api.Deviation.Deviate;
import org.opendaylight.controller.yang.model.api.ExtensionDefinition;
import org.opendaylight.controller.yang.model.api.FeatureDefinition;
-import org.opendaylight.controller.yang.model.api.GroupingDefinition;
import org.opendaylight.controller.yang.model.api.LeafListSchemaNode;
import org.opendaylight.controller.yang.model.api.LeafSchemaNode;
import org.opendaylight.controller.yang.model.api.ListSchemaNode;
import org.opendaylight.controller.yang.model.api.Module;
import org.opendaylight.controller.yang.model.api.ModuleImport;
-import org.opendaylight.controller.yang.model.api.MustDefinition;
import org.opendaylight.controller.yang.model.api.NotificationDefinition;
import org.opendaylight.controller.yang.model.api.RpcDefinition;
-import org.opendaylight.controller.yang.model.api.SchemaNode;
import org.opendaylight.controller.yang.model.api.SchemaPath;
import org.opendaylight.controller.yang.model.api.Status;
import org.opendaylight.controller.yang.model.api.TypeDefinition;
import org.opendaylight.controller.yang.model.api.UnknownSchemaNode;
-import org.opendaylight.controller.yang.model.api.UsesNode;
import org.opendaylight.controller.yang.model.api.type.LengthConstraint;
import org.opendaylight.controller.yang.model.api.type.PatternConstraint;
import org.opendaylight.controller.yang.model.api.type.RangeConstraint;
public class YangParserTest {
private final DateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
-
private Set<Module> modules;
@Before
assertEquals(0, interfaces.getUnknownSchemaNodes().size());
// test DataSchemaNode args
assertFalse(interfaces.isAugmenting());
- assertFalse(interfaces.isConfiguration());
+ assertTrue(interfaces.isConfiguration());
ConstraintDefinition constraints = interfaces.getConstraints();
assertNull(constraints.getWhenCondition());
assertEquals(0, constraints.getMustConstraints().size());
assertEquals(0, ifEntry.getUnknownSchemaNodes().size());
// test DataSchemaNode args
assertFalse(ifEntry.isAugmenting());
- assertFalse(ifEntry.isConfiguration());
+ assertTrue(ifEntry.isConfiguration());
ConstraintDefinition constraints = ifEntry.getConstraints();
assertNull(constraints.getWhenCondition());
assertEquals(0, constraints.getMustConstraints().size());
assertEquals(100L, range.getMax());
}
- @Test
- public void testRefine() {
- Module testModule = TestUtils.findModule(modules, "types2");
-
- ContainerSchemaNode peer = (ContainerSchemaNode) testModule.getDataChildByName("peer");
- ContainerSchemaNode destination = (ContainerSchemaNode) peer.getDataChildByName("destination");
- Set<UsesNode> usesNodes = destination.getUses();
- assertEquals(1, usesNodes.size());
- UsesNode usesNode = usesNodes.iterator().next();
- Map<SchemaPath, SchemaNode> refines = usesNode.getRefines();
- assertEquals(5, refines.size());
-
- LeafSchemaNode refineLeaf = null;
- ContainerSchemaNode refineContainer = null;
- ListSchemaNode refineList = null;
- GroupingDefinition refineGrouping = null;
- TypeDefinition<?> typedef = null;
- for (Map.Entry<SchemaPath, SchemaNode> entry : refines.entrySet()) {
- SchemaNode value = entry.getValue();
- if (value instanceof LeafSchemaNode) {
- refineLeaf = (LeafSchemaNode) value;
- } else if (value instanceof ContainerSchemaNode) {
- refineContainer = (ContainerSchemaNode) value;
- } else if (value instanceof ListSchemaNode) {
- refineList = (ListSchemaNode) value;
- } else if (value instanceof GroupingDefinition) {
- refineGrouping = (GroupingDefinition) value;
- } else if (value instanceof TypeDefinition<?>) {
- typedef = (TypeDefinition<?>) value;
- }
- }
-
- // leaf address
- assertNotNull(refineLeaf);
- assertEquals("address", refineLeaf.getQName().getLocalName());
- assertEquals("description of address defined by refine", refineLeaf.getDescription());
- assertEquals("address reference added by refine", refineLeaf.getReference());
- assertFalse(refineLeaf.isConfiguration());
- assertTrue(refineLeaf.getConstraints().isMandatory());
- Set<MustDefinition> leafMustConstraints = refineLeaf.getConstraints().getMustConstraints();
- assertEquals(1, leafMustConstraints.size());
- MustDefinition leafMust = leafMustConstraints.iterator().next();
- assertEquals("\"ifType != 'ethernet' or (ifType = 'ethernet' and ifMTU = 1500)\"", leafMust.toString());
-
- // container port
- assertNotNull(refineContainer);
- Set<MustDefinition> mustConstraints = refineContainer.getConstraints().getMustConstraints();
- assertTrue(mustConstraints.isEmpty());
- assertEquals("description of port defined by refine", refineContainer.getDescription());
- assertEquals("port reference added by refine", refineContainer.getReference());
- assertFalse(refineContainer.isConfiguration());
- assertTrue(refineContainer.isPresenceContainer());
-
- // list addresses
- assertNotNull(refineList);
- assertEquals("description of addresses defined by refine", refineList.getDescription());
- assertEquals("addresses reference added by refine", refineList.getReference());
- assertFalse(refineList.isConfiguration());
- assertEquals(2, (int) refineList.getConstraints().getMinElements());
- assertEquals(12, (int) refineList.getConstraints().getMaxElements());
-
- // grouping target-inner
- assertNotNull(refineGrouping);
- Set<DataSchemaNode> refineGroupingChildren = refineGrouping.getChildNodes();
- assertEquals(1, refineGroupingChildren.size());
- LeafSchemaNode refineGroupingLeaf = (LeafSchemaNode) refineGroupingChildren.iterator().next();
- assertEquals("inner-grouping-id", refineGroupingLeaf.getQName().getLocalName());
- assertEquals("new target-inner grouping description", refineGrouping.getDescription());
-
- // typedef group-type
- assertNotNull(typedef);
- assertEquals("new group-type description", typedef.getDescription());
- assertEquals("new group-type reference", typedef.getReference());
- assertTrue(typedef.getBaseType() instanceof ExtendedType);
- }
-
@Test
public void testChoice() {
Module testModule = TestUtils.findModule(modules, "types1");
ContainerSchemaNode peer = (ContainerSchemaNode) testModule.getDataChildByName("transfer");
ChoiceNode how = (ChoiceNode) peer.getDataChildByName("how");
Set<ChoiceCaseNode> cases = how.getCases();
- assertEquals(3, cases.size());
+ assertEquals(5, cases.size());
+ ChoiceCaseNode input = null;
+ ChoiceCaseNode output = null;
+ for(ChoiceCaseNode caseNode : cases) {
+ if("input".equals(caseNode.getQName().getLocalName())) {
+ input = caseNode;
+ } else if("output".equals(caseNode.getQName().getLocalName())) {
+ output = caseNode;
+ }
+ }
+ assertNotNull(input);
+ assertNotNull(input.getPath());
+ assertNotNull(output);
+ assertNotNull(output.getPath());
}
@Test
assertNotNull(output.getDataChildByName("data"));
}
- @Test
- public void testGrouping() {
- Module testModule = TestUtils.findModule(modules, "types2");
- Set<GroupingDefinition> groupings = testModule.getGroupings();
- assertEquals(1, groupings.size());
- GroupingDefinition grouping = groupings.iterator().next();
- Set<DataSchemaNode> children = grouping.getChildNodes();
- assertEquals(5, children.size());
- }
-
@Test
public void testAugmentNodesTypesSchemaPath() throws Exception {
Module testModule = TestUtils.findModule(modules, "types1");
import org.junit.Test;
import org.opendaylight.controller.yang.common.QName;
+import org.opendaylight.controller.yang.model.api.AnyXmlSchemaNode;
+import org.opendaylight.controller.yang.model.api.ChoiceNode;
import org.opendaylight.controller.yang.model.api.ContainerSchemaNode;
import org.opendaylight.controller.yang.model.api.DataSchemaNode;
import org.opendaylight.controller.yang.model.api.GroupingDefinition;
RangeConstraint range = ranges.get(0);
assertEquals(0L, range.getMin());
assertEquals(63L, range.getMax());
+ }
+ @Test
+ public void testUsesFromContext() throws Exception {
+ SchemaContext context = null;
+ try (InputStream stream = new FileInputStream(getClass().getResource("/model/testfile2.yang").getPath())) {
+ context = parser.resolveSchemaContext(TestUtils.loadModules(Lists.newArrayList(stream)));
+ }
+ Module testModule = null;
+ try (InputStream stream = new FileInputStream(getClass().getResource("/context-test/test2.yang").getPath())) {
+ testModule = TestUtils.loadModuleWithContext(stream, context);
+ }
+ assertNotNull(testModule);
+
+ // suffix _u = added by uses
+ // suffix _g = defined in grouping from context
+
+ // get grouping
+ Module contextModule = context.findModuleByNamespace(URI.create("urn:simple.types.data.demo"));
+ assertNotNull(contextModule);
+ Set<GroupingDefinition> groupings = contextModule.getGroupings();
+ assertEquals(1, groupings.size());
+ GroupingDefinition grouping = groupings.iterator().next();
+
+ // get node containing uses
+ ContainerSchemaNode peer = (ContainerSchemaNode)testModule.getDataChildByName("peer");
+ ContainerSchemaNode destination = (ContainerSchemaNode)peer.getDataChildByName("destination");
+
+ // check uses
+ Set<UsesNode> uses = destination.getUses();
+ assertEquals(1, uses.size());
+
+ // check uses process
+ AnyXmlSchemaNode data_u = (AnyXmlSchemaNode)destination.getDataChildByName("data");
+ assertNotNull(data_u);
+ assertTrue(data_u.isAddedByUses());
+
+ AnyXmlSchemaNode data_g = (AnyXmlSchemaNode)grouping.getDataChildByName("data");
+ assertNotNull(data_g);
+ assertFalse(data_g.isAddedByUses());
+ assertFalse(data_u.equals(data_g));
+
+ ChoiceNode how_u = (ChoiceNode)destination.getDataChildByName("how");
+ assertNotNull(how_u);
+ assertTrue(how_u.isAddedByUses());
+
+ ChoiceNode how_g = (ChoiceNode)grouping.getDataChildByName("how");
+ assertNotNull(how_g);
+ assertFalse(how_g.isAddedByUses());
+ assertFalse(how_u.equals(how_g));
+
+ LeafSchemaNode address_u = (LeafSchemaNode)destination.getDataChildByName("address");
+ assertNotNull(address_u);
+ assertTrue(address_u.isAddedByUses());
+
+ LeafSchemaNode address_g = (LeafSchemaNode)grouping.getDataChildByName("address");
+ assertNotNull(address_g);
+ assertFalse(address_g.isAddedByUses());
+ assertFalse(address_u.equals(address_g));
+
+ ContainerSchemaNode port_u = (ContainerSchemaNode)destination.getDataChildByName("port");
+ assertNotNull(port_u);
+ assertTrue(port_u.isAddedByUses());
+
+ ContainerSchemaNode port_g = (ContainerSchemaNode)grouping.getDataChildByName("port");
+ assertNotNull(port_g);
+ assertFalse(port_g.isAddedByUses());
+ assertFalse(port_u.equals(port_g));
+
+ ListSchemaNode addresses_u = (ListSchemaNode)destination.getDataChildByName("addresses");
+ assertNotNull(addresses_u);
+ assertTrue(addresses_u.isAddedByUses());
+
+ ListSchemaNode addresses_g = (ListSchemaNode)grouping.getDataChildByName("addresses");
+ assertNotNull(addresses_g);
+ assertFalse(addresses_g.isAddedByUses());
+ assertFalse(addresses_u.equals(addresses_g));
+
+ // grouping defined by 'uses'
+ Set<GroupingDefinition> groupings_u = destination.getGroupings();
+ assertEquals(1, groupings_u.size());
+ GroupingDefinition grouping_u = groupings_u.iterator().next();
+ assertTrue(grouping_u.isAddedByUses());
+
+ // grouping defined in 'grouping' node
+ Set<GroupingDefinition> groupings_g = grouping.getGroupings();
+ assertEquals(1, groupings_g.size());
+ GroupingDefinition grouping_g = groupings_g.iterator().next();
+ assertFalse(grouping_g.isAddedByUses());
+ assertFalse(grouping_u.equals(grouping_g));
+
+ List<UnknownSchemaNode> nodes_u = destination.getUnknownSchemaNodes();
+ assertEquals(1, nodes_u.size());
+ UnknownSchemaNode node_u = nodes_u.get(0);
+ assertTrue(node_u.isAddedByUses());
+
+ List<UnknownSchemaNode> nodes_g = grouping.getUnknownSchemaNodes();
+ assertEquals(1, nodes_g.size());
+ UnknownSchemaNode node_g = nodes_g.get(0);
+ assertFalse(node_g.isAddedByUses());
+ assertFalse(node_u.equals(node_g));
}
@Test
- public void testUsesGroupingFromContext() throws Exception {
+ public void testUsesRefineFromContext() throws Exception {
SchemaContext context = null;
try (InputStream stream = new FileInputStream(getClass().getResource("/model/testfile2.yang").getPath())) {
context = parser.resolveSchemaContext(TestUtils.loadModules(Lists.newArrayList(stream)));
container transfer {
choice how {
default interval;
+ container input {
+ }
+ list output {
+ leaf id {
+ type string;
+ }
+ }
case interval {
leaf interval {
type uint16;
revision "2013-02-27" {
reference " WILL BE DEFINED LATER";
}
-
+
typedef my-base-int32-type {
type int32 {
range "2..20";
units "mile";
default "11";
}
-
+
typedef my-custom-string {
type string {
pattern "[a-k]*";
length "5..11";
}
}
-
+
typedef my-string-type {
type my-custom-string {
length "6..10";
range "10..20";
}
}
-
+
typedef my-int-type2 {
type my-int-type {
range "12..18";
}
}
-
+
typedef my-int-type-ext {
type my-int-type2 {
range "14..16";
}
}
-
+
typedef my-decimal-type {
type decimal64 {
fraction-digits 6;
}
}
-
+
typedef my-decimal-type-ext {
type decimal64 {
fraction-digits 5;
path "/interface/name";
}
}
-
+
leaf name {
type string;
}
-
+
leaf count {
type int8 {
range "1..10";
}
}
-
+
leaf nested-type-leaf {
type my-type1;
}
-
+
extension c-define {
description
"Takes as argument a name string.
yin-element "true";
}
}
-
+
container system {
leaf user {
type string;
}
}
-
+
grouping target {
anyxml data {
config true;
typedef group-type {
type my-decimal-type;
}
+
+ opendaylight;
}
container peer {
uses target {
refine address {
default "1.2.3.4";
- description "description of address defined by refine";
+ description "IP address of target node";
reference "address reference added by refine";
config false;
mandatory true;
}
}
}
-
+
container interfaces {
list ifEntry {
key "ifIndex";
type uint32;
units minutes;
}
-
+
leaf ifMtu {
type int32;
}
-
+
min-elements 1;
max-elements 11;
}
/**\r
* Returns <code>true</code> if the data node was added by augmentation,\r
* otherwise returns <code>false</code>\r
- * \r
+ *\r
* @return <code>true</code> if the data node was added by augmentation,\r
* otherwise returns <code>false</code>\r
*/\r
boolean isAugmenting();\r
\r
+ /**\r
+ * Returns <code>true</code> if the data node was added by uses statement,\r
+ * otherwise returns <code>false</code>\r
+ *\r
+ * @return <code>true</code> if the data node was added by uses statement,\r
+ * otherwise returns <code>false</code>\r
+ */\r
+ boolean isAddedByUses();\r
+\r
/**\r
* Returns <code>true</code> if the data represents configuration data,\r
* otherwise returns <code>false</code>\r
- * \r
+ *\r
* @return <code>true</code> if the data represents configuration data,\r
* otherwise returns <code>false</code>\r
*/\r
\r
/**\r
* Returns the constraints associated with Data Schema Node\r
- * \r
+ *\r
* @return the constraints associated with Data Schema Node\r
*/\r
ConstraintDefinition getConstraints();\r
*/\r
public interface GroupingDefinition extends DataNodeContainer, SchemaNode {\r
\r
+ boolean isAddedByUses();\r
+\r
}\r
public interface UnknownSchemaNode extends SchemaNode {
QName getNodeType();
+
String getNodeParameter();
+ boolean isAddedByUses();
+
}
*/\r
boolean isAugmenting();\r
\r
+ boolean isAddedByUses();\r
+\r
/**\r
* Some of the properties of each node in the grouping can be refined with\r
* the "refine" statement.\r
private Status status;
private String units;
private Object defaultValue;
+ private boolean addedByUses;
public static class Builder {
private final QName typeName;
private Status status = Status.CURRENT;
private String units = "";
private Object defaultValue = null;
+ private boolean addedByUses;
private List<RangeConstraint> ranges = Collections.emptyList();
private List<LengthConstraint> lengths = Collections.emptyList();
return this;
}
+ public Builder addedByUses(final boolean addedByUses) {
+ this.addedByUses = addedByUses;
+ return this;
+ }
+
public Builder unknownSchemaNodes(
final List<UnknownSchemaNode> unknownSchemaNodes) {
this.unknownSchemaNodes = unknownSchemaNodes;
this.status = builder.status;
this.units = builder.units;
this.defaultValue = builder.defaultValue;
+ this.addedByUses = builder.addedByUses;
this.ranges = builder.ranges;
this.lengths = builder.lengths;
return defaultValue;
}
+ public boolean isAddedByUses() {
+ return addedByUses;
+ }
+
@Override
public QName getQName() {
return typeName;
/*
- * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
package org.opendaylight.controller.yang.model.util;
import java.util.Collections;
import org.opendaylight.controller.yang.model.api.type.InstanceIdentifierTypeDefinition;
/**
- * The <code>default</code> implementation of Instance Identifier Type Definition interface.
+ * The <code>default</code> implementation of Instance Identifier Type
+ * Definition interface.
*
* @see InstanceIdentifierTypeDefinition
*/
public final class InstanceIdentifier implements InstanceIdentifierTypeDefinition {
- private static final QName name = BaseTypes
- .constructQName("instance-identifier");
- private static final String description = "The instance-identifier built-in type is used to " +
- "uniquely identify a particular instance node in the data tree.";
+ private static final QName name = BaseTypes.constructQName("instance-identifier");
+ private static final String description = "The instance-identifier built-in type is used to "
+ + "uniquely identify a particular instance node in the data tree.";
private static final String reference = "https://tools.ietf.org/html/rfc6020#section-9.13";
private final transient SchemaPath path;
private final RevisionAwareXPath xpath;
private final String units = "";
private final InstanceIdentifierTypeDefinition baseType;
- private final boolean requireInstance;
+ private boolean requireInstance = true;
+
+ public InstanceIdentifier(final SchemaPath path, final RevisionAwareXPath xpath) {
+ super();
+ this.path = path;
+ this.xpath = xpath;
+ this.baseType = this;
+ }
- public InstanceIdentifier(final SchemaPath path, RevisionAwareXPath xpath, boolean requireInstance) {
+ public InstanceIdentifier(final SchemaPath path, final RevisionAwareXPath xpath, final boolean requireInstance) {
super();
this.path = path;
this.xpath = xpath;
/*
* (non-Javadoc)
*
- * @see org.opendaylight.controller.yang.model.api.TypeDefinition#getBaseType()
+ * @see
+ * org.opendaylight.controller.yang.model.api.TypeDefinition#getBaseType()
*/
@Override
public InstanceIdentifierTypeDefinition getBaseType() {
/*
* (non-Javadoc)
*
- * @see org.opendaylight.controller.yang.model.api.TypeDefinition#getDefaultValue()
+ * @see
+ * org.opendaylight.controller.yang.model.api.TypeDefinition#getDefaultValue
+ * ()
*/
@Override
public Object getDefaultValue() {
/*
* (non-Javadoc)
*
- * @see org.opendaylight.controller.yang.model.api.SchemaNode#getDescription()
+ * @see
+ * org.opendaylight.controller.yang.model.api.SchemaNode#getDescription()
*/
@Override
public String getDescription() {
/*
* (non-Javadoc)
*
- * @see org.opendaylight.controller.yang.model.api.SchemaNode#getExtensionSchemaNodes()
+ * @see
+ * org.opendaylight.controller.yang.model.api.SchemaNode#getExtensionSchemaNodes
+ * ()
*/
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
/*
* (non-Javadoc)
*
- * @see org.opendaylight.controller.yang.model.api.type.InstanceIdentifierTypeDefinition#
- * getPathStatement()
+ * @see org.opendaylight.controller.yang.model.api.type.
+ * InstanceIdentifierTypeDefinition# getPathStatement()
*/
@Override
public RevisionAwareXPath getPathStatement() {
/*
* (non-Javadoc)
*
- * @see org.opendaylight.controller.yang.model.api.type.InstanceIdentifierTypeDefinition#
- * requireInstance()
+ * @see org.opendaylight.controller.yang.model.api.type.
+ * InstanceIdentifierTypeDefinition# requireInstance()
*/
@Override
public boolean requireInstance() {
Code Review / controller.git / commitdiff