X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=yang%2Fyang-parser-impl%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fyangtools%2Fyang%2Fparser%2Fbuilder%2Fimpl%2FAugmentationSchemaBuilderImpl.java;h=3b75d1190cab0ccd863bf60c9883e9483e0f099d;hb=d50b1bfe8ba708d57fe6428cdd39d87853a4e779;hp=0ef1e4eba962bf6bb3f79f425496239a8b679ba8;hpb=e5fb69f742a7a98f4767e630b819051d6d7d9153;p=yangtools.git diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/builder/impl/AugmentationSchemaBuilderImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/builder/impl/AugmentationSchemaBuilderImpl.java index 0ef1e4eba9..3b75d1190c 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/builder/impl/AugmentationSchemaBuilderImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/builder/impl/AugmentationSchemaBuilderImpl.java @@ -7,19 +7,22 @@ */ package org.opendaylight.yangtools.yang.parser.builder.impl; +import com.google.common.base.Optional; +import com.google.common.base.Preconditions; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableSet; +import java.net.URI; import java.util.ArrayList; import java.util.Collections; -import java.util.HashMap; -import java.util.HashSet; +import java.util.Date; +import java.util.Iterator; import java.util.List; -import java.util.Map; import java.util.Set; -import java.util.TreeSet; - import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.model.api.AugmentationSchema; import org.opendaylight.yangtools.yang.model.api.DataSchemaNode; import org.opendaylight.yangtools.yang.model.api.GroupingDefinition; +import org.opendaylight.yangtools.yang.model.api.NamespaceRevisionAware; import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath; import org.opendaylight.yangtools.yang.model.api.SchemaPath; import org.opendaylight.yangtools.yang.model.api.Status; @@ -29,32 +32,36 @@ import org.opendaylight.yangtools.yang.model.api.UsesNode; import org.opendaylight.yangtools.yang.model.util.RevisionAwareXPathImpl; import org.opendaylight.yangtools.yang.parser.builder.api.AbstractDataNodeContainerBuilder; import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder; +import org.opendaylight.yangtools.yang.parser.builder.api.Builder; import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder; import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder; import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder; import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder; -import org.opendaylight.yangtools.yang.parser.util.Comparators; import org.opendaylight.yangtools.yang.parser.util.ParserUtils; import org.opendaylight.yangtools.yang.parser.util.YangParseException; public final class AugmentationSchemaBuilderImpl extends AbstractDataNodeContainerBuilder implements AugmentationSchemaBuilder { - private boolean built; - private final AugmentationSchemaImpl instance; - + private final int order; + private AugmentationSchemaImpl instance; private String whenCondition; + private String description; + private String reference; + private Status status = Status.CURRENT; + private final String augmentTargetStr; - private SchemaPath targetPath; + private final SchemaPath targetPath; private SchemaPath targetNodeSchemaPath; private boolean resolved; + private AugmentationSchemaBuilder copyOf; - public AugmentationSchemaBuilderImpl(final String moduleName, final int line, final String augmentTargetStr) { + public AugmentationSchemaBuilderImpl(final String moduleName, final int line, final String augmentTargetStr, int order) { super(moduleName, line, null); + this.order = order; this.augmentTargetStr = augmentTargetStr; targetPath = ParserUtils.parseXPathString(augmentTargetStr); - instance = new AugmentationSchemaImpl(targetPath); } @Override @@ -68,7 +75,7 @@ public final class AugmentationSchemaBuilderImpl extends AbstractDataNodeContain } @Override - public void addGrouping(GroupingBuilder grouping) { + public void addGrouping(final GroupingBuilder grouping) { throw new YangParseException(moduleName, line, "augment can not contains grouping statement"); } @@ -79,39 +86,65 @@ public final class AugmentationSchemaBuilderImpl extends AbstractDataNodeContain @Override public AugmentationSchema build() { - if (!built) { - instance.setTargetPath(targetNodeSchemaPath); + if (instance != null) { + return instance; + } - RevisionAwareXPath whenStmt; - if (whenCondition == null) { - whenStmt = null; - } else { - whenStmt = new RevisionAwareXPathImpl(whenCondition, false); - } - instance.setWhenCondition(whenStmt); + instance = new AugmentationSchemaImpl(targetPath, order); - // CHILD NODES - for (DataSchemaNodeBuilder node : addedChildNodes) { - DataSchemaNode child = node.build(); - childNodes.put(child.getQName(), child); - } - instance.addChildNodes(childNodes); + instance.description = description; + instance.reference = reference; + instance.status = status; - // USES - for (UsesNodeBuilder builder : addedUsesNodes) { - usesNodes.add(builder.build()); - } - instance.addUses(usesNodes); + Builder parent = getParent(); + if (parent instanceof ModuleBuilder) { + ModuleBuilder moduleBuilder = (ModuleBuilder) parent; + instance.namespace = moduleBuilder.getNamespace(); + instance.revision = moduleBuilder.getRevision(); + } - // UNKNOWN NODES - for (UnknownSchemaNodeBuilder b : addedUnknownNodes) { - unknownNodes.add(b.build()); + if (parent instanceof UsesNodeBuilder) { + ModuleBuilder mb = ParserUtils.getParentModule(this); + List newPath = new ArrayList<>(); + List parsedPath = targetPath.getPath(); + for (QName name : parsedPath) { + newPath.add(new QName(mb.getNamespace(), mb.getRevision(), name.getPrefix(), name.getLocalName())); } - Collections.sort(unknownNodes, Comparators.SCHEMA_NODE_COMP); - instance.addUnknownSchemaNodes(unknownNodes); + instance.targetPath = SchemaPath.create(newPath, false); + } else { + instance.targetPath = targetNodeSchemaPath; + } + + if (copyOf != null) { + instance.setCopyOf(copyOf.build()); + } + + RevisionAwareXPath whenStmt; + if (whenCondition == null) { + whenStmt = null; + } else { + whenStmt = new RevisionAwareXPathImpl(whenCondition, false); + } + instance.whenCondition = whenStmt; + + // CHILD NODES + for (DataSchemaNodeBuilder node : addedChildNodes) { + childNodes.add(node.build()); + } + instance.childNodes = ImmutableSet.copyOf(childNodes); + + // USES + for (UsesNodeBuilder builder : addedUsesNodes) { + usesNodes.add(builder.build()); + } + instance.uses = ImmutableSet.copyOf(usesNodes); - built = true; + // UNKNOWN NODES + for (UnknownSchemaNodeBuilder b : addedUnknownNodes) { + unknownNodes.add(b.build()); } + instance.unknownNodes = ImmutableList.copyOf(unknownNodes); + return instance; } @@ -121,15 +154,17 @@ public final class AugmentationSchemaBuilderImpl extends AbstractDataNodeContain } @Override - public void setResolved(boolean resolved) { + public void setResolved(final boolean resolved) { this.resolved = resolved; } + @Override public String getWhenCondition() { return whenCondition; } - public void addWhenCondition(String whenCondition) { + @Override + public void addWhenCondition(final String whenCondition) { this.whenCondition = whenCondition; } @@ -139,40 +174,38 @@ public final class AugmentationSchemaBuilderImpl extends AbstractDataNodeContain } @Override - public void addTypedef(TypeDefinitionBuilder type) { + public void addTypedef(final TypeDefinitionBuilder type) { throw new YangParseException(moduleName, line, "Augmentation can not contains typedef statement."); } @Override public String getDescription() { - return instance.description; + return description; } @Override public void setDescription(final String description) { - instance.description = description; + this.description = description; } @Override public String getReference() { - return instance.reference; + return reference; } @Override public void setReference(final String reference) { - instance.reference = reference; + this.reference = reference; } @Override public Status getStatus() { - return instance.status; + return status; } @Override - public void setStatus(Status status) { - if (status != null) { - instance.status = status; - } + public void setStatus(final Status status) { + this.status = Preconditions.checkNotNull(status, "status cannot be null"); } @Override @@ -191,10 +224,15 @@ public final class AugmentationSchemaBuilderImpl extends AbstractDataNodeContain } @Override - public void setTargetNodeSchemaPath(SchemaPath path) { + public void setTargetNodeSchemaPath(final SchemaPath path) { this.targetNodeSchemaPath = path; } + @Override + public int getOrder() { + return order; + } + @Override public int hashCode() { final int prime = 17; @@ -206,7 +244,7 @@ public final class AugmentationSchemaBuilderImpl extends AbstractDataNodeContain } @Override - public boolean equals(Object obj) { + public boolean equals(final Object obj) { if (this == obj) { return true; } @@ -241,31 +279,48 @@ public final class AugmentationSchemaBuilderImpl extends AbstractDataNodeContain return true; } + @Override public String toString() { return "augment " + augmentTargetStr; } - private final class AugmentationSchemaImpl implements AugmentationSchema { + public void setCopyOf(final AugmentationSchemaBuilder old) { + copyOf = old; + } + + private static final class AugmentationSchemaImpl implements AugmentationSchema, NamespaceRevisionAware, + Comparable { + private final int order; private SchemaPath targetPath; private RevisionAwareXPath whenCondition; - private final Map childNodes = new HashMap<>(); - private final Set uses = new HashSet<>(); + private ImmutableSet childNodes; + private ImmutableSet uses; private String description; private String reference; private Status status; - private final List unknownNodes = new ArrayList<>(); - private AugmentationSchemaImpl(SchemaPath targetPath) { + private URI namespace; + private Date revision; + private ImmutableList unknownNodes; + private AugmentationSchema copyOf; + + public AugmentationSchemaImpl(final SchemaPath targetPath, final int order) { this.targetPath = targetPath; + this.order = order; + } + + public void setCopyOf(final AugmentationSchema build) { + this.copyOf = build; } @Override - public SchemaPath getTargetPath() { - return targetPath; + public Optional getOriginalDefinition() { + return Optional.fromNullable(this.copyOf); } - private void setTargetPath(SchemaPath path) { - this.targetPath = path; + @Override + public SchemaPath getTargetPath() { + return targetPath; } @Override @@ -273,21 +328,9 @@ public final class AugmentationSchemaBuilderImpl extends AbstractDataNodeContain return whenCondition; } - private void setWhenCondition(RevisionAwareXPath whenCondition) { - this.whenCondition = whenCondition; - } - @Override public Set getChildNodes() { - final Set result = new TreeSet(Comparators.SCHEMA_NODE_COMP); - result.addAll(childNodes.values()); - return Collections.unmodifiableSet(result); - } - - private void addChildNodes(Map childNodes) { - if (childNodes != null) { - this.childNodes.putAll(childNodes); - } + return childNodes; } /** @@ -301,13 +344,7 @@ public final class AugmentationSchemaBuilderImpl extends AbstractDataNodeContain @Override public Set getUses() { - return Collections.unmodifiableSet(uses); - } - - private void addUses(Set uses) { - if (uses != null) { - this.uses.addAll(uses); - } + return uses; } /** @@ -336,30 +373,27 @@ public final class AugmentationSchemaBuilderImpl extends AbstractDataNodeContain @Override public List getUnknownSchemaNodes() { - return Collections.unmodifiableList(unknownNodes); + return unknownNodes; } - private void addUnknownSchemaNodes(List unknownSchemaNodes) { - if (unknownSchemaNodes != null) { - this.unknownNodes.addAll(unknownSchemaNodes); - } + @Override + public DataSchemaNode getDataChildByName(final QName name) { + return getChildNode(childNodes, name); } @Override - public DataSchemaNode getDataChildByName(QName name) { - return childNodes.get(name); + public DataSchemaNode getDataChildByName(final String name) { + return getChildNode(childNodes, name); } @Override - public DataSchemaNode getDataChildByName(String name) { - DataSchemaNode result = null; - for (Map.Entry entry : childNodes.entrySet()) { - if (entry.getKey().getLocalName().equals(name)) { - result = entry.getValue(); - break; - } - } - return result; + public URI getNamespace() { + return namespace; + } + + @Override + public Date getRevision() { + return revision; } @Override @@ -373,7 +407,7 @@ public final class AugmentationSchemaBuilderImpl extends AbstractDataNodeContain } @Override - public boolean equals(Object obj) { + public boolean equals(final Object obj) { if (this == obj) { return true; } @@ -417,6 +451,26 @@ public final class AugmentationSchemaBuilderImpl extends AbstractDataNodeContain sb.append("]"); return sb.toString(); } + + @Override + public int compareTo(AugmentationSchemaImpl o) { + Iterator thisIt = this.targetPath.getPath().iterator(); + Iterator otherIt = o.getTargetPath().getPath().iterator(); + while (thisIt.hasNext()) { + if (otherIt.hasNext()) { + int comp = thisIt.next().compareTo(otherIt.next()); + if (comp != 0) { + return comp; + } + } else { + return 1; + } + } + if (otherIt.hasNext()) { + return -1; + } + return this.order - o.order; + } } }