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%2FChoiceBuilder.java;h=f4aabb19445df58cf9cf8fd4ee1832244c9fab06;hb=dc40f7a41a29cbaee3f00acc19b1ef1b94391d41;hp=9b68ec19ea36221f571cdc84d48ec0ae955936fa;hpb=dcedede24f6a7cc24520306abf5622f179033144;p=yangtools.git diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/builder/impl/ChoiceBuilder.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/builder/impl/ChoiceBuilder.java index 9b68ec19ea..f4aabb1944 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/builder/impl/ChoiceBuilder.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/builder/impl/ChoiceBuilder.java @@ -7,10 +7,7 @@ */ package org.opendaylight.yangtools.yang.parser.builder.impl; -import java.net.URI; import java.util.ArrayList; -import java.util.Collections; -import java.util.Date; import java.util.HashSet; import java.util.List; import java.util.Set; @@ -22,95 +19,119 @@ import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode; import org.opendaylight.yangtools.yang.model.api.ChoiceNode; import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition; import org.opendaylight.yangtools.yang.model.api.DataSchemaNode; +import org.opendaylight.yangtools.yang.model.api.DerivableSchemaNode; import org.opendaylight.yangtools.yang.model.api.SchemaPath; import org.opendaylight.yangtools.yang.model.api.Status; import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode; -import org.opendaylight.yangtools.yang.parser.builder.api.AbstractSchemaNodeBuilder; import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder; import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationTargetBuilder; +import org.opendaylight.yangtools.yang.parser.builder.api.ConstraintsBuilder; import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder; -import org.opendaylight.yangtools.yang.parser.util.Comparators; -import org.opendaylight.yangtools.yang.parser.util.ParserUtils; +import org.opendaylight.yangtools.yang.parser.builder.api.SchemaNodeBuilder; +import org.opendaylight.yangtools.yang.parser.builder.api.UnknownSchemaNodeBuilder; +import org.opendaylight.yangtools.yang.parser.builder.util.AbstractSchemaNodeBuilder; +import org.opendaylight.yangtools.yang.parser.builder.util.Comparators; import org.opendaylight.yangtools.yang.parser.util.YangParseException; +import com.google.common.base.Optional; +import com.google.common.base.Preconditions; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableSet; + public final class ChoiceBuilder extends AbstractSchemaNodeBuilder implements DataSchemaNodeBuilder, - AugmentationTargetBuilder { - private boolean isBuilt; - private final ChoiceNodeImpl instance; +AugmentationTargetBuilder { + private ChoiceNodeImpl instance; + // DataSchemaNode args + private boolean augmenting; + private boolean addedByUses; + private boolean configuration; + private ChoiceNode originalNode; + private ChoiceBuilder originalBuilder; private final ConstraintsBuilder constraints; // AugmentationTarget args - private final List augmentations = new ArrayList<>(); + private final Set augmentations = new HashSet<>(); private final List augmentationBuilders = new ArrayList<>(); // ChoiceNode args - private Set cases = new TreeSet<>(Comparators.SCHEMA_NODE_COMP); private final Set caseBuilders = new HashSet<>(); private String defaultCase; public ChoiceBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path) { super(moduleName, line, qname); this.schemaPath = path; - instance = new ChoiceNodeImpl(qname, path); - constraints = new ConstraintsBuilder(moduleName, line); + constraints = new ConstraintsBuilderImpl(moduleName, line); } public ChoiceBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path, final ChoiceNode base) { super(moduleName, line, qname); this.schemaPath = path; - instance = new ChoiceNodeImpl(qname, path); - constraints = new ConstraintsBuilder(moduleName, line, base.getConstraints()); - - instance.description = base.getDescription(); - instance.reference = base.getReference(); - instance.status = base.getStatus(); - instance.augmenting = base.isAugmenting(); - instance.addedByUses = base.isAddedByUses(); - instance.configuration = base.isConfiguration(); - instance.constraints = base.getConstraints(); - instance.augmentations.addAll(base.getAvailableAugmentations()); - - URI ns = qname.getNamespace(); - Date rev = qname.getRevision(); - String pref = qname.getPrefix(); - Set wrapped = ParserUtils.wrapChildNodes(moduleName, line, new HashSet( - base.getCases()), path, ns, rev, pref); + constraints = new ConstraintsBuilderImpl(moduleName, line, base.getConstraints()); + + description = base.getDescription(); + reference = base.getReference(); + status = base.getStatus(); + augmenting = base.isAugmenting(); + addedByUses = base.isAddedByUses(); + originalNode = base; + configuration = base.isConfiguration(); + augmentations.addAll(base.getAvailableAugmentations()); + + Set wrapped = BuilderUtils.wrapChildNodes(moduleName, line, new HashSet( + base.getCases()), path, qname); for (DataSchemaNodeBuilder wrap : wrapped) { if (wrap instanceof ChoiceCaseBuilder) { caseBuilders.add((ChoiceCaseBuilder) wrap); } } - instance.unknownNodes.addAll(base.getUnknownSchemaNodes()); + addedUnknownNodes.addAll(BuilderUtils.wrapUnknownNodes(moduleName, line, base.getUnknownSchemaNodes(), path, + qname)); } @Override public ChoiceNode build() { - if (!isBuilt) { - instance.setConstraints(constraints.build()); - instance.setDefaultCase(defaultCase); + if (instance != null) { + return instance; + } - // CASES - for (ChoiceCaseBuilder caseBuilder : caseBuilders) { - cases.add(caseBuilder.build()); - } - instance.addCases(cases); + instance = new ChoiceNodeImpl(qname, schemaPath); - // AUGMENTATIONS - for (AugmentationSchemaBuilder builder : augmentationBuilders) { - augmentations.add(builder.build()); - } - instance.addAvailableAugmentations(new HashSet<>(augmentations)); + instance.description = description; + instance.reference = reference; + instance.status = status; + instance.augmenting = augmenting; + instance.addedByUses = addedByUses; + instance.configuration = configuration; - // UNKNOWN NODES - for (UnknownSchemaNodeBuilder b : addedUnknownNodes) { - unknownNodes.add(b.build()); - } - Collections.sort(unknownNodes, Comparators.SCHEMA_NODE_COMP); - instance.addUnknownSchemaNodes(unknownNodes); + instance.constraints = constraints.toInstance(); + instance.defaultCase = defaultCase; + + // ORIGINAL NODE + if (originalNode == null && originalBuilder != null) { + originalNode = originalBuilder.build(); + } + instance.original = originalNode; + + // CASES + final Set cases = new TreeSet<>(Comparators.SCHEMA_NODE_COMP); + for (ChoiceCaseBuilder caseBuilder : caseBuilders) { + cases.add(caseBuilder.build()); + } + instance.cases = ImmutableSet.copyOf(cases); + + // AUGMENTATIONS + for (AugmentationSchemaBuilder builder : augmentationBuilders) { + augmentations.add(builder.build()); + } + instance.augmentations = ImmutableSet.copyOf(augmentations); - isBuilt = true; + // UNKNOWN NODES + for (UnknownSchemaNodeBuilder b : addedUnknownNodes) { + unknownNodes.add(b.build()); } + instance.unknownNodes = ImmutableList.copyOf(unknownNodes); + return instance; } @@ -118,16 +139,6 @@ public final class ChoiceBuilder extends AbstractSchemaNodeBuilder implements Da return caseBuilders; } - @Override - public SchemaPath getPath() { - return instance.path; - } - - @Override - public void setPath(SchemaPath path) { - instance.path = path; - } - /** * Get case by name. * @@ -135,7 +146,7 @@ public final class ChoiceBuilder extends AbstractSchemaNodeBuilder implements Da * name of case to search * @return case with given name if present, null otherwise */ - public ChoiceCaseBuilder getCaseNodeByName(String caseName) { + public ChoiceCaseBuilder getCaseNodeByName(final String caseName) { for (ChoiceCaseBuilder addedCase : caseBuilders) { if (addedCase.getQName().getLocalName().equals(caseName)) { return addedCase; @@ -153,15 +164,15 @@ public final class ChoiceBuilder extends AbstractSchemaNodeBuilder implements Da * @param caseNode * case node */ - public void addCase(DataSchemaNodeBuilder caseNode) { + public void addCase(final DataSchemaNodeBuilder caseNode) { QName caseQName = caseNode.getQName(); String caseName = caseQName.getLocalName(); - for (ChoiceCaseBuilder addedCase : caseBuilders) { - if (addedCase.getQName().getLocalName().equals(caseName)) { + for (ChoiceCaseBuilder existingCase : caseBuilders) { + if (existingCase.getQName().getLocalName().equals(caseName)) { throw new YangParseException(caseNode.getModuleName(), caseNode.getLine(), "Can not add '" + caseNode - + "' to node '" + qname.getLocalName() + "' in module '" + moduleName - + "': case with same name already declared at line " + addedCase.getLine()); + + "' to node '" + qname.getLocalName() + "' in module '" + getModuleName() + + "': case with same name already declared at line " + existingCase.getLine()); } } @@ -176,7 +187,7 @@ public final class ChoiceBuilder extends AbstractSchemaNodeBuilder implements Da caseBuilder.setAugmenting(true); caseNode.setAugmenting(false); } - SchemaPath newPath = ParserUtils.createSchemaPath(caseNode.getPath(), caseQName); + SchemaPath newPath = caseNode.getPath().createChild(caseQName); caseNode.setPath(newPath); caseBuilder.addChildNode(caseNode); caseBuilders.add(caseBuilder); @@ -184,65 +195,44 @@ public final class ChoiceBuilder extends AbstractSchemaNodeBuilder implements Da } @Override - public String getDescription() { - return instance.description; - } - - @Override - public void setDescription(final String description) { - instance.description = description; - } - - @Override - public String getReference() { - return instance.reference; - } - - @Override - public void setReference(final String reference) { - instance.reference = reference; - } - - @Override - public Status getStatus() { - return instance.status; + public boolean isAugmenting() { + return augmenting; } @Override - public void setStatus(Status status) { - if (status != null) { - instance.status = status; - } + public void setAugmenting(final boolean augmenting) { + this.augmenting = augmenting; } @Override - public boolean isAugmenting() { - return instance.augmenting; + public boolean isAddedByUses() { + return addedByUses; } @Override - public void setAugmenting(boolean augmenting) { - instance.augmenting = augmenting; + public void setAddedByUses(final boolean addedByUses) { + this.addedByUses = addedByUses; } @Override - public boolean isAddedByUses() { - return instance.addedByUses; + public ChoiceBuilder getOriginal() { + return originalBuilder; } @Override - public void setAddedByUses(final boolean addedByUses) { - instance.addedByUses = addedByUses; + public void setOriginal(final SchemaNodeBuilder builder) { + Preconditions.checkArgument(builder instanceof ChoiceBuilder, "Original of choice cannot be " + builder); + this.originalBuilder = (ChoiceBuilder) builder; } @Override - public Boolean isConfiguration() { - return instance.configuration; + public boolean isConfiguration() { + return configuration; } @Override - public void setConfiguration(Boolean configuration) { - instance.configuration = configuration; + public void setConfiguration(final boolean configuration) { + this.configuration = configuration; } @Override @@ -251,7 +241,7 @@ public final class ChoiceBuilder extends AbstractSchemaNodeBuilder implements Da } @Override - public void addAugmentation(AugmentationSchemaBuilder augment) { + public void addAugmentation(final AugmentationSchemaBuilder augment) { augmentationBuilders.add(augment); } @@ -263,7 +253,7 @@ public final class ChoiceBuilder extends AbstractSchemaNodeBuilder implements Da return defaultCase; } - public void setDefaultCase(String defaultCase) { + public void setDefaultCase(final String defaultCase) { this.defaultCase = defaultCase; } @@ -276,7 +266,7 @@ public final class ChoiceBuilder extends AbstractSchemaNodeBuilder implements Da } @Override - public boolean equals(Object obj) { + public boolean equals(final Object obj) { if (this == obj) { return true; } @@ -294,11 +284,11 @@ public final class ChoiceBuilder extends AbstractSchemaNodeBuilder implements Da } else if (!schemaPath.equals(other.schemaPath)) { return false; } - if (parentBuilder == null) { - if (other.parentBuilder != null) { + if (getParent() == null) { + if (other.getParent() != null) { return false; } - } else if (!parentBuilder.equals(other.parentBuilder)) { + } else if (!getParent().equals(other.getParent())) { return false; } return true; @@ -309,22 +299,23 @@ public final class ChoiceBuilder extends AbstractSchemaNodeBuilder implements Da return "choice " + qname.getLocalName(); } - private static final class ChoiceNodeImpl implements ChoiceNode { + private static final class ChoiceNodeImpl implements ChoiceNode, DerivableSchemaNode { private final QName qname; - private SchemaPath path; + private final SchemaPath path; private String description; private String reference; - private Status status = Status.CURRENT; + private Status status; private boolean augmenting; private boolean addedByUses; + private ChoiceNode original; private boolean configuration; private ConstraintDefinition constraints; - private final Set cases = new HashSet<>(); - private final Set augmentations = new HashSet<>(); - private final List unknownNodes = new ArrayList<>(); + private ImmutableSet cases; + private ImmutableSet augmentations; + private ImmutableList unknownNodes; private String defaultCase; - private ChoiceNodeImpl(QName qname, SchemaPath path) { + private ChoiceNodeImpl(final QName qname, final SchemaPath path) { this.qname = qname; this.path = path; } @@ -364,6 +355,11 @@ public final class ChoiceBuilder extends AbstractSchemaNodeBuilder implements Da return addedByUses; } + @Override + public Optional getOriginal() { + return Optional.fromNullable(original); + } + @Override public boolean isConfiguration() { return configuration; @@ -374,35 +370,19 @@ public final class ChoiceBuilder extends AbstractSchemaNodeBuilder implements Da return constraints; } - private void setConstraints(ConstraintDefinition constraints) { - this.constraints = constraints; - } - @Override public Set getAvailableAugmentations() { - return Collections.unmodifiableSet(augmentations); - } - - private void addAvailableAugmentations(Set availableAugmentations) { - if (availableAugmentations != null) { - this.augmentations.addAll(availableAugmentations); - } + return augmentations; } @Override public List getUnknownSchemaNodes() { - return Collections.unmodifiableList(unknownNodes); - } - - private void addUnknownSchemaNodes(List unknownSchemaNodes) { - if (unknownSchemaNodes != null) { - this.unknownNodes.addAll(unknownSchemaNodes); - } + return unknownNodes; } @Override public Set getCases() { - return Collections.unmodifiableSet(cases); + return cases; } @Override @@ -432,21 +412,11 @@ public final class ChoiceBuilder extends AbstractSchemaNodeBuilder implements Da return null; } - private void addCases(Set cases) { - if (cases != null) { - this.cases.addAll(cases); - } - } - @Override public String getDefaultCase() { return defaultCase; } - private void setDefaultCase(String defaultCase) { - this.defaultCase = defaultCase; - } - @Override public int hashCode() { final int prime = 31; @@ -457,7 +427,7 @@ public final class ChoiceBuilder extends AbstractSchemaNodeBuilder implements Da } @Override - public boolean equals(Object obj) { + public boolean equals(final Object obj) { if (this == obj) { return true; } @@ -489,10 +459,11 @@ public final class ChoiceBuilder extends AbstractSchemaNodeBuilder implements Da public String toString() { StringBuilder sb = new StringBuilder(ChoiceNodeImpl.class.getSimpleName()); sb.append("["); - sb.append("qname=" + qname); + sb.append("qname=").append(qname); sb.append("]"); return sb.toString(); } + } }