*/
package org.opendaylight.yangtools.yang.parser.builder.impl;
-import java.util.*;
+import java.util.List;
-import org.opendaylight.yangtools.yang.model.api.*;
+import org.opendaylight.yangtools.yang.model.api.Deviation;
import org.opendaylight.yangtools.yang.model.api.Deviation.Deviate;
+import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.parser.builder.api.AbstractBuilder;
-import org.opendaylight.yangtools.yang.parser.util.*;
+import org.opendaylight.yangtools.yang.parser.util.ParserUtils;
+import org.opendaylight.yangtools.yang.parser.util.YangParseException;
+
+import com.google.common.collect.ImmutableList;
public final class DeviationBuilder extends AbstractBuilder {
- private boolean isBuilt;
- private final DeviationImpl instance;
+ private DeviationImpl instance;
private final String targetPathStr;
private SchemaPath targetPath;
+ private Deviate deviate;
+ private String reference;
DeviationBuilder(final String moduleName, final int line, final String targetPathStr) {
super(moduleName, line);
}
this.targetPathStr = targetPathStr;
this.targetPath = ParserUtils.parseXPathString(targetPathStr);
- instance = new DeviationImpl();
}
@Override
public Deviation build() {
if (targetPath == null) {
- throw new YangParseException(moduleName, line, "Unresolved deviation target");
+ throw new YangParseException(getModuleName(), getLine(), "Unresolved deviation target");
}
- if (!isBuilt) {
- instance.setTargetPath(targetPath);
+ if (instance != null) {
+ return instance;
+ }
- // UNKNOWN NODES
- for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
- unknownNodes.add(b.build());
- }
- Collections.sort(unknownNodes, Comparators.SCHEMA_NODE_COMP);
- instance.addUnknownSchemaNodes(unknownNodes);
+ instance = new DeviationImpl();
+ instance.targetPath = targetPath;
+ instance.deviate = deviate;
+ instance.reference = reference;
- isBuilt = true;
+ // UNKNOWN NODES
+ for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
+ unknownNodes.add(b.build());
}
+ instance.unknownNodes = ImmutableList.copyOf(unknownNodes);
return instance;
}
public void setDeviate(final String deviate) {
if ("not-supported".equals(deviate)) {
- instance.setDeviate(Deviate.NOT_SUPPORTED);
+ this.deviate = Deviate.NOT_SUPPORTED;
} else if ("add".equals(deviate)) {
- instance.setDeviate(Deviate.ADD);
+ this.deviate = Deviate.ADD;
} else if ("replace".equals(deviate)) {
- instance.setDeviate(Deviate.REPLACE);
+ this.deviate = Deviate.REPLACE;
} else if ("delete".equals(deviate)) {
- instance.setDeviate(Deviate.DELETE);
+ this.deviate = Deviate.DELETE;
} else {
- throw new YangParseException(moduleName, line, "Unsupported type of 'deviate' statement: " + deviate);
+ throw new YangParseException(getModuleName(), getLine(), "Unsupported type of 'deviate' statement: " + deviate);
}
}
public void setReference(final String reference) {
- instance.reference = reference;
+ this.reference = reference;
}
@Override
return "deviation " + targetPathStr;
}
- private final class DeviationImpl implements Deviation {
+ private static final class DeviationImpl implements Deviation {
private SchemaPath targetPath;
private Deviate deviate;
private String reference;
- private final List<UnknownSchemaNode> unknownNodes = new ArrayList<>();
+ private ImmutableList<UnknownSchemaNode> unknownNodes;
private DeviationImpl() {
}
return targetPath;
}
- private void setTargetPath(final SchemaPath targetPath) {
- this.targetPath = targetPath;
- }
-
@Override
public Deviate getDeviate() {
return deviate;
}
- private void setDeviate(final Deviate deviate) {
- this.deviate = deviate;
- }
-
@Override
public String getReference() {
return reference;
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
- return Collections.unmodifiableList(unknownNodes);
- }
-
- private void addUnknownSchemaNodes(List<UnknownSchemaNode> unknownSchemaNodes) {
- if (unknownSchemaNodes != null) {
- this.unknownNodes.addAll(unknownSchemaNodes);
- }
+ return unknownNodes;
}
@Override