Removed unused methods from UsesNodeBuilder.
Signed-off-by: Martin Vitez <mvitez@cisco.com>
*/
public interface UsesNodeBuilder extends GroupingMember, Builder {
+ /**
+ * Get parent of this uses node. Since uses can be defined only under on of
+ * module, container, list, case, grouping, input, output, notification or
+ * augment, return type is DataNodeContainerBuilder.
+ */
DataNodeContainerBuilder getParent();
- String getGroupingName();
-
+ /**
+ * Get grouping path as string.
+ *
+ * @return grouping path as String
+ */
+ String getGroupingPathAsString();
+
+ /**
+ * Get grouping path.
+ *
+ * @return grouping path as SchemaPath
+ */
SchemaPath getGroupingPath();
+ /**
+ * Get grouping definition.
+ *
+ * @return GroupingDefinition if present, null otherwise
+ */
GroupingDefinition getGroupingDefinition();
+ /**
+ * Set grouping definition.
+ *
+ * @param groupingDefinition
+ * GroupingDefinition object
+ */
void setGroupingDefinition(GroupingDefinition groupingDefinition);
+ /**
+ * Get grouping builder.
+ *
+ * @return GroupingBuilder if present, null otherwise
+ */
GroupingBuilder getGroupingBuilder();
+ /**
+ * Set grouping builder.
+ *
+ * @param grouping
+ * GroupingBuilder object
+ */
void setGrouping(GroupingBuilder grouping);
+ /**
+ * Get augmentations defined in this uses node.
+ *
+ * @return set of augmentations defined in this node
+ */
Set<AugmentationSchemaBuilder> getAugmentations();
+ /**
+ * Add augment builder.
+ *
+ * @param builder
+ * new builder of augment statement
+ */
void addAugment(AugmentationSchemaBuilder builder);
- boolean isAugmenting();
-
- void setAugmenting(boolean augmenting);
-
+ /**
+ * Get refine statements.
+ *
+ * @return list of RefineHolder objects
+ */
List<RefineHolder> getRefines();
+ /**
+ * Get refined nodes.
+ *
+ * @return List of refined SchemaNodeBuilder objects
+ */
List<SchemaNodeBuilder> getRefineNodes();
+ /**
+ * Add refine statement.
+ *
+ * @param refine
+ * new RefineHolder object
+ */
void addRefine(RefineHolder refine);
+ /**
+ * Add refine node.
+ *
+ * @param refineNode
+ * refined DataSchemaNodeBuilder object
+ */
void addRefineNode(DataSchemaNodeBuilder refineNode);
+ /**
+ * Build new UsesNode object.
+ */
UsesNode build();
+ /**
+ * Get child nodes defined in target grouping.
+ *
+ * @return set of DataSchemaNodeBuilder objects
+ */
Set<DataSchemaNodeBuilder> getTargetChildren();
+ /**
+ * Set reference to target grouping child nodes.
+ *
+ * @param targetChildren
+ * set of child nodes defined in target grouping
+ */
void setTargetChildren(Set<DataSchemaNodeBuilder> targetChildren);
+ /**
+ * Get groupings defined in target grouping.
+ *
+ * @return set of GroupingBuilder objects
+ */
Set<GroupingBuilder> getTargetGroupings();
+ /**
+ * Set reference to target grouping groupings.
+ *
+ * @param targetGroupings
+ * set of groupings defined in target grouping
+ */
void setTargetGroupings(Set<GroupingBuilder> targetGroupings);
+ /**
+ * Get type definitions defined in target grouping.
+ *
+ * @return set of typedefs defined in target grouping
+ */
Set<TypeDefinitionBuilder> getTargetTypedefs();
+ /**
+ * Set reference to target grouping typedefs.
+ *
+ * @param targetTypedefs
+ * set of typedefs defined in target grouping
+ */
void setTargetTypedefs(Set<TypeDefinitionBuilder> targetTypedefs);
+ /**
+ * Get unknown nodes defined in target grouping.
+ *
+ * @return list of unknown nodes defined in target grouping
+ */
List<UnknownSchemaNodeBuilder> getTargetUnknownNodes();
+ /**
+ * Set reference to target grouping unknown nodes.
+ *
+ * @param targetUnknownNodes
+ * list of unknown nodes defined in target grouping.
+ */
void setTargetUnknownNodes(List<UnknownSchemaNodeBuilder> targetUnknownNodes);
+ /**
+ *
+ * @return true, if this object was built based on another UsesNodeBuilder,
+ * false otherwise
+ */
boolean isCopy();
+ /**
+ *
+ * @return true, if target grouping objects was loaded already, false
+ * otherwise
+ */
boolean isDataCollected();
+ /**
+ * Set if target grouping objects was loaded already.
+ *
+ * @param dataCollected
+ */
void setDataCollected(boolean dataCollected);
- boolean isParentUpdated();
-
- void setParentUpdated(boolean parentUpdated);
-
}
if (!(parent instanceof DataNodeContainerBuilder)) {
throw new YangParseException(name, line, "Unresolved parent of uses '" + groupingPathStr + "'.");
}
- if (parent instanceof AugmentationSchemaBuilder) {
- usesBuilder.setAugmenting(true);
- }
((DataNodeContainerBuilder) parent).addUsesNode(usesBuilder);
}
allUsesNodes.add(usesBuilder);
private SchemaPath groupingPath;\r
private GroupingDefinition groupingDefinition;\r
private GroupingBuilder groupingBuilder;\r
- private boolean augmenting;\r
private boolean addedByUses;\r
private final Set<AugmentationSchemaBuilder> addedAugments = new HashSet<AugmentationSchemaBuilder>();\r
private final List<SchemaNodeBuilder> refineBuilders = new ArrayList<SchemaNodeBuilder>();\r
\r
private final boolean isCopy;\r
private boolean dataCollected;\r
- private boolean parentUpdated;\r
\r
@Override\r
public boolean isCopy() {\r
this.dataCollected = dataCollected;\r
}\r
\r
- @Override\r
- public boolean isParentUpdated() {\r
- return parentUpdated;\r
- }\r
-\r
- @Override\r
- public void setParentUpdated(boolean parentUpdated) {\r
- this.parentUpdated = parentUpdated;\r
- }\r
-\r
public UsesNodeBuilderImpl(final String moduleName, final int line, final String groupingName) {\r
super(moduleName, line);\r
this.groupingName = groupingName;\r
public UsesNode build() {\r
if (!isBuilt) {\r
instance = new UsesNodeImpl(groupingPath);\r
- instance.setAugmenting(augmenting);\r
instance.setAddedByUses(addedByUses);\r
\r
// AUGMENTATIONS\r
@Override\r
public void setParent(Builder parent) {\r
if (!(parent instanceof DataNodeContainerBuilder)) {\r
- throw new YangParseException(moduleName, line, "Unresolved parent of uses '" + groupingName + "'.");\r
+ throw new YangParseException(moduleName, line,\r
+ "Parent of 'uses' has to be instance of DataNodeContainerBuilder, but was: '" + parent + "'.");\r
}\r
this.parent = (DataNodeContainerBuilder) parent;\r
}\r
}\r
\r
@Override\r
- public String getGroupingName() {\r
+ public String getGroupingPathAsString() {\r
return groupingName;\r
}\r
\r
addedAugments.add(augmentBuilder);\r
}\r
\r
- @Override\r
- public boolean isAugmenting() {\r
- return augmenting;\r
- }\r
-\r
- @Override\r
- public void setAugmenting(final boolean augmenting) {\r
- this.augmenting = augmenting;\r
- }\r
-\r
@Override\r
public boolean isAddedByUses() {\r
return addedByUses;\r
final int prime = 31;\r
int result = 1;\r
result = prime * result + ((groupingName == null) ? 0 : groupingName.hashCode());\r
+ result = prime * result + ((parent == null) ? 0 : parent.hashCode());\r
+ result = prime * result + ((refines == null) ? 0 : refines.hashCode());\r
return result;\r
}\r
\r
return false;\r
} else if (!groupingName.equals(other.groupingName))\r
return false;\r
-\r
if (parent == null) {\r
if (other.parent != null)\r
return false;\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
@Override\r
public boolean isAugmenting() {\r
- return augmenting;\r
- }\r
-\r
- private void setAugmenting(final boolean augmenting) {\r
- this.augmenting = augmenting;\r
+ return false;\r
}\r
\r
@Override\r
int result = 1;\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
} else if (!augmentations.equals(other.augmentations)) {\r
return false;\r
}\r
- if (augmenting != other.augmenting) {\r
- return false;\r
- }\r
return true;\r
}\r
\r
if (targetGroupingBuilder == null) {
if (context == null) {
throw new YangParseException(module.getName(), usesNode.getLine(), "Referenced grouping '"
- + usesNode.getGroupingName() + "' not found.");
+ + usesNode.getGroupingPathAsString() + "' not found.");
} else {
GroupingDefinition targetGroupingDefinition = GroupingUtils.getTargetGroupingFromContext(usesNode,
module, context);
}
}
- // new cycle is must because in collecting data process new uses could
+ // new loop is must because in collecting data process new uses could
// be created
final List<UsesNodeBuilder> allModulesUses = new ArrayList<>();
for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
}
}
- // new cycle is must because in collecting data process new uses could
+ // new loop is must because in collecting data process new uses could
// be created
final List<UsesNodeBuilder> allModulesUses = new ArrayList<>();
for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
public class CopyUtils {
+ private CopyUtils() {
+ }
+
/**
* Create copy of DataSchemaNodeBuilder with new parent. If updateQName is
* true, qname of node will be corrected based on new parent.
static UsesNodeBuilder copyUses(UsesNodeBuilder old, Builder newParent) {
UsesNodeBuilder copy = new UsesNodeBuilderImpl(newParent.getModuleName(), newParent.getLine(),
- old.getGroupingName(), true);
+ old.getGroupingPathAsString(), true);
copy.setParent(newParent);
copy.setGroupingDefinition(old.getGroupingDefinition());
copy.setGrouping(old.getGroupingBuilder());
- copy.setAugmenting(old.isAugmenting());
copy.setAddedByUses(old.isAddedByUses());
copy.getAugmentations().addAll(old.getAugmentations());
copy.getRefineNodes().addAll(old.getRefineNodes());
*/
package org.opendaylight.yangtools.yang.parser.util;
-import static org.opendaylight.yangtools.yang.parser.util.ParserUtils.createSchemaPath;
-
import java.net.URI;
import java.util.ArrayList;
import java.util.Date;
public class GroupingUtils {
+ private GroupingUtils() {
+ }
+
/**
* Search given modules for grouping by name defined in uses node.
*
public static GroupingBuilder getTargetGroupingFromModules(final UsesNodeBuilder usesBuilder,
final Map<String, TreeMap<Date, ModuleBuilder>> modules, final ModuleBuilder module) {
final int line = usesBuilder.getLine();
- final String groupingString = usesBuilder.getGroupingName();
+ final String groupingString = usesBuilder.getGroupingPathAsString();
String groupingPrefix;
String groupingName;
public static GroupingDefinition getTargetGroupingFromContext(final UsesNodeBuilder usesBuilder,
final ModuleBuilder module, final SchemaContext context) {
final int line = usesBuilder.getLine();
- String groupingString = usesBuilder.getGroupingName();
+ String groupingString = usesBuilder.getGroupingPathAsString();
String groupingPrefix;
String groupingName;
}
}
+ /**
+ * Read data defined in target grouping builder, make a copy and add them to
+ * uses node builder.
+ *
+ * @param usesNode
+ * uses node builder
+ */
public static void collectUsesData(UsesNodeBuilder usesNode) {
- usesNode.setTargetChildren(collectUsesChildNodes(usesNode));
- usesNode.setTargetTypedefs(collectUsesTypedefs(usesNode));
- usesNode.setTargetGroupings(collectUsesGroupings(usesNode));
- usesNode.setTargetUnknownNodes(collectUsesUnknownNodes(usesNode));
+ usesNode.setTargetChildren(collectTargetChildNodes(usesNode));
+ usesNode.setTargetTypedefs(collectTargetTypedefs(usesNode));
+ usesNode.setTargetGroupings(collectTargetGroupings(usesNode));
+ usesNode.setTargetUnknownNodes(collectTargetUnknownNodes(usesNode));
usesNode.setDataCollected(true);
}
- private static Set<DataSchemaNodeBuilder> collectUsesChildNodes(UsesNodeBuilder usesNode) {
+ /**
+ * Read child nodes defined in target grouping and make a copy of them.
+ *
+ * @param usesNode
+ * @return copy of child nodes defined in uses target grouping
+ */
+ private static Set<DataSchemaNodeBuilder> collectTargetChildNodes(UsesNodeBuilder usesNode) {
final GroupingBuilder target = usesNode.getGroupingBuilder();
Set<DataSchemaNodeBuilder> childNodes = target.getChildNodeBuilders();
Set<DataSchemaNodeBuilder> copies = new HashSet<>();
copies.add(CopyUtils.copy(childNode, usesNode.getParent(), true));
}
for (UsesNodeBuilder targetUses : target.getUsesNodes()) {
- copies.addAll(collectUsesChildNodes(targetUses));
+ copies.addAll(collectTargetChildNodes(targetUses));
}
return copies;
}
- private static Set<TypeDefinitionBuilder> collectUsesTypedefs(UsesNodeBuilder usesNode) {
+ /**
+ * Read typedefs defined in target grouping and make a copy of them.
+ *
+ * @param usesNode
+ * @return copy of typedefs defined in uses target grouping
+ */
+ private static Set<TypeDefinitionBuilder> collectTargetTypedefs(UsesNodeBuilder usesNode) {
final GroupingBuilder target = usesNode.getGroupingBuilder();
Set<TypeDefinitionBuilder> typedefs = target.getTypeDefinitionBuilders();
Set<TypeDefinitionBuilder> copies = new HashSet<>();
copies.add(CopyUtils.copy(typedef, usesNode.getParent(), true));
}
for (UsesNodeBuilder targetUses : target.getUsesNodes()) {
- copies.addAll(collectUsesTypedefs(targetUses));
+ copies.addAll(collectTargetTypedefs(targetUses));
}
return copies;
}
- private static Set<GroupingBuilder> collectUsesGroupings(UsesNodeBuilder usesNode) {
+ /**
+ * Read groupings defined in target grouping and make a copy of them.
+ *
+ * @param usesNode
+ * @return copy of groupings defined in uses target grouping
+ */
+ private static Set<GroupingBuilder> collectTargetGroupings(UsesNodeBuilder usesNode) {
final GroupingBuilder target = usesNode.getGroupingBuilder();
Set<GroupingBuilder> groupings = target.getGroupingBuilders();
Set<GroupingBuilder> copies = new HashSet<>();
copies.add(CopyUtils.copy(grouping, usesNode.getParent(), true));
}
for (UsesNodeBuilder targetUses : target.getUsesNodes()) {
- copies.addAll(collectUsesGroupings(targetUses));
+ copies.addAll(collectTargetGroupings(targetUses));
}
return copies;
}
- private static List<UnknownSchemaNodeBuilder> collectUsesUnknownNodes(UsesNodeBuilder usesNode) {
+ /**
+ * Read unknown nodes defined in target grouping and make a copy of them.
+ *
+ * @param usesNode
+ * @return copy of unknown nodes defined in uses target grouping
+ */
+ private static List<UnknownSchemaNodeBuilder> collectTargetUnknownNodes(UsesNodeBuilder usesNode) {
final GroupingBuilder target = usesNode.getGroupingBuilder();
List<UnknownSchemaNodeBuilder> unknownNodes = target.getUnknownNodeBuilders();
List<UnknownSchemaNodeBuilder> copies = new ArrayList<>();
copies.add(CopyUtils.copy(unknownNode, usesNode.getParent(), true));
}
for (UsesNodeBuilder targetUses : target.getUsesNodes()) {
- copies.addAll(collectUsesUnknownNodes(targetUses));
+ copies.addAll(collectTargetUnknownNodes(targetUses));
}
return copies;
}
+ /**
+ * Read data defined in target grouping definition, make a copy and add them
+ * to uses node builder.
+ *
+ * @param usesNode
+ * uses node builder
+ */
public static void collectUsesDataFromContext(UsesNodeBuilder usesNode) {
DataNodeContainerBuilder parent = usesNode.getParent();
URI namespace = parent.getQName().getNamespace();
Date revision = parent.getQName().getRevision();
String prefix = parent.getQName().getPrefix();
- String moduleName = parent.getModuleName();
+ String moduleName = parent.getModuleName();
int line = parent.getLine();
// child nodes
((GroupingMember) newChild).setAddedByUses(true);
}
- newChild.setPath(createSchemaPath(parent.getPath(), newQName));
newChildren.add(newChild);
}
}
QName newQName = new QName(namespace, revision, prefix, g.getQName().getLocalName());
GroupingBuilder newGrouping = CopyUtils.createGrouping(g, newQName, moduleName, line);
newGrouping.setAddedByUses(true);
- newGrouping.setPath(createSchemaPath(parent.getPath(), newQName));
newGroupings.add(newGrouping);
}
usesNode.setTargetGroupings(newGroupings);
QName newQName = new QName(namespace, revision, prefix, td.getQName().getLocalName());
TypeDefinitionBuilder newType = CopyUtils.createTypedef((ExtendedType) td, newQName, moduleName, line);
newType.setAddedByUses(true);
- newType.setPath(createSchemaPath(parent.getPath(), newQName));
newTypedefs.add(newType);
}
usesNode.setTargetTypedefs(newTypedefs);
QName newQName = new QName(namespace, revision, prefix, un.getQName().getLocalName());
UnknownSchemaNodeBuilder newNode = CopyUtils.createUnknownSchemaNode(un, newQName, moduleName, line);
newNode.setAddedByUses(true);
- newNode.setPath(createSchemaPath(parent.getPath(), newQName));
newUnknownNodes.add(newNode);
}
usesNode.setTargetUnknownNodes(newUnknownNodes);
usesNode.setDataCollected(true);
}
+ /**
+ * Fix schema path of all nodes which were defined by this usesNode.
+ *
+ * @param usesNode
+ */
public static void fixUsesNodesPath(UsesNodeBuilder usesNode) {
DataNodeContainerBuilder parent = usesNode.getParent();
}
}
+ /**
+ * Create new schema path of node based on parent node schema path.
+ *
+ * @param node
+ * node to correct
+ * @param parentSchemaPath
+ * schema path of node parent
+ */
static void correctNodePath(final SchemaNodeBuilder node, final SchemaPath parentSchemaPath) {
// set correct path
List<QName> targetNodePath = new ArrayList<QName>(parentSchemaPath.getPath());
* parent of first node in path
* @param path
* path to augment target
- * @return true if augment process succeed, false otherwise
+ * @return true if augmentation process succeed, false otherwise
*/
public static boolean processAugmentation(final AugmentationSchemaBuilder augment, final Builder firstNodeParent,
final List<QName> path) {
return true;
}
+ /**
+ * Find node with given name in uses target.
+ *
+ * @param localName
+ * name of node to find
+ * @param uses
+ * uses node which target grouping should be searched
+ * @return node with given name if found, null otherwise
+ */
private static DataSchemaNodeBuilder findNodeInUses(String localName, UsesNodeBuilder uses) {
GroupingBuilder target = uses.getGroupingBuilder();
for (DataSchemaNodeBuilder child : target.getChildNodeBuilders()) {
* @return builder of module where this node is defined
*/
public static ModuleBuilder getParentModule(Builder node) {
- if(node instanceof ModuleBuilder) {
- return (ModuleBuilder)node;
+ if (node instanceof ModuleBuilder) {
+ return (ModuleBuilder) node;
}
Builder parent = node.getParent();
Code Review / yangtools.git / commitdiff