protected abstract T thisInstance();
@Override
- public GeneratedTOBuilder addEnclosingTransferObject(String name) {
+ public GeneratedTOBuilder addEnclosingTransferObject(final String name) {
if (name == null) {
throw new IllegalArgumentException("Name for Enclosing Generated Transfer Object cannot be null!");
}
}
@Override
- public T addComment(String comment) {
+ public T addComment(final String comment) {
this.comment = comment;
return thisInstance();
}
}
@Override
- public T setAbstract(boolean isAbstract) {
+ public T setAbstract(final boolean isAbstract) {
this.isAbstract = isAbstract;
return thisInstance();
}
@Override
- public T addImplementsType(Type genType) {
+ public T addImplementsType(final Type genType) {
if (genType == null) {
throw new IllegalArgumentException("Type cannot be null");
}
}
@Override
- public Constant addConstant(Type type, String name, Object value) {
+ public Constant addConstant(final Type type, final String name, final Object value) {
if (type == null) {
throw new IllegalArgumentException("Returning Type for Constant cannot be null!");
}
}
@Override
- public EnumBuilder addEnumeration(String name) {
+ public EnumBuilder addEnumeration(final String name) {
if (name == null) {
throw new IllegalArgumentException("Name of enumeration cannot be null!");
}
}
@Override
- public MethodSignatureBuilder addMethod(String name) {
+ public MethodSignatureBuilder addMethod(final String name) {
if (name == null) {
throw new IllegalArgumentException("Name of method cannot be null!");
}
}
@Override
- public boolean containsMethod(String name) {
+ public boolean containsMethod(final String name) {
if (name == null) {
throw new IllegalArgumentException("Parameter name can't be null");
}
}
@Override
- public GeneratedPropertyBuilder addProperty(String name) {
+ public GeneratedPropertyBuilder addProperty(final String name) {
final GeneratedPropertyBuilder builder = new GeneratedPropertyBuilderImpl(name);
builder.setAccessModifier(AccessModifier.PUBLIC);
properties.add(builder);
}
@Override
- public boolean containsProperty(String name) {
+ public boolean containsProperty(final String name) {
if (name == null) {
throw new IllegalArgumentException("Parameter name can't be null");
}
}
@Override
- public boolean equals(Object obj) {
+ public boolean equals(final Object obj) {
if (this == obj) {
return true;
}
if (getClass() != obj.getClass()) {
return false;
}
- AbstractGeneratedTypeBuilder<T> other = (AbstractGeneratedTypeBuilder<T>) obj;
+ AbstractGeneratedTypeBuilder<?> other = (AbstractGeneratedTypeBuilder<?>) obj;
if (getName() == null) {
if (other.getName() != null) {
return false;
«generateFields(false)»
+ «generateAugmentField(true)»
+
«generateConstructorsFromIfcs(type)»
«generateMethodFieldsFrom(type)»
«generateFields(true)»
+ «generateAugmentField(false)»
+
«generateConstructor»
«generateGetters(true)»
/**
* Generate constructor with argument of given type.
*/
- def private generateConstructorFromIfc(Type impl) '''
+ def private Object generateConstructorFromIfc(Type impl) '''
«IF (impl instanceof GeneratedType)»
«val implType = impl as GeneratedType»
«ENDIF»
'''
- def private printConstructorPropertySetter(Type implementedIfc) '''
+ def private Object printConstructorPropertySetter(Type implementedIfc) '''
«IF (implementedIfc instanceof GeneratedType && !(implementedIfc instanceof GeneratedTransferObject))»
«val ifc = implementedIfc as GeneratedType»
«FOR getter : ifc.methodDefinitions»
private«IF _final» final«ENDIF» «f.returnType.importedName» «f.fieldName»;
«ENDFOR»
«ENDIF»
+ '''
+
+ def private generateAugmentField(boolean init) '''
«IF augmentField != null»
- private «Map.importedName»<Class<? extends «augmentField.returnType.importedName»>, «augmentField.returnType.importedName»> «augmentField.name» = new «HashMap.importedName»<>();
+ private final «Map.importedName»<Class<? extends «augmentField.returnType.importedName»>, «augmentField.returnType.importedName»> «augmentField.name»«IF init» = new «HashMap.importedName»<>()«ENDIF»;
«ENDIF»
'''
this.«field.fieldName» = builder.«field.getterMethodName»();
«ENDFOR»
«IF augmentField != null»
- this.«augmentField.name».putAll(builder.«augmentField.name»);
+ switch (builder.«augmentField.name».size()) {
+ case 0:
+ this.«augmentField.name» = «Collections.importedName».emptyMap();
+ break;
+ case 1:
+ final «Map.importedName».Entry<Class<? extends «augmentField.returnType.importedName»>, «augmentField.returnType.importedName»> e = builder.«augmentField.name».entrySet().iterator().next();
+ this.«augmentField.name» = «Collections.importedName».<Class<? extends «augmentField.returnType.importedName»>, «augmentField.returnType.importedName»>singletonMap(e.getKey(), e.getValue());
+ break;
+ default :
+ this.«augmentField.name» = new «HashMap.importedName»<>(builder.«augmentField.name»);
+ }
«ENDIF»
}
'''
import java.util.Date;
import java.util.LinkedList;
import java.util.List;
+import java.util.Set;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.*;
+import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
+import org.opendaylight.yangtools.yang.model.api.AugmentationTarget;
+import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
+import org.opendaylight.yangtools.yang.model.api.ChoiceNode;
+import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
+import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
+import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.Module;
+import org.opendaylight.yangtools.yang.model.api.ModuleImport;
+import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
+import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath;
+import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
+import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.SchemaNode;
+import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.model.api.UsesNode;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import com.google.common.base.Preconditions;
-import java.util.Set;
-
/**
* The Schema Context Util contains support methods for searching through Schema
* Context modules for specified schema nodes via Schema Path or Revision Aware
* instantiable.
*
*/
-public class SchemaContextUtil {
+public final class SchemaContextUtil {
+ private static final Logger LOG = LoggerFactory.getLogger(SchemaContextUtil.class);
private SchemaContextUtil() {
}
* @return SchemaNode from the end of the Schema Path or <code>null</code>
* if the Node is not present.
*/
- public static SchemaNode findDataSchemaNode(SchemaContext context, SchemaPath schemaPath) {
+ public static SchemaNode findDataSchemaNode(final SchemaContext context, final SchemaPath schemaPath) {
Preconditions.checkArgument(context != null, "Schema Context reference cannot be NULL");
Preconditions.checkArgument(schemaPath != null, "Schema Path reference cannot be NULL");
- List<QName> prefixedPath = (schemaPath.getPath());
- if (prefixedPath != null) {
- return findNodeInSchemaContext(context, prefixedPath);
+
+ final List<QName> prefixedPath = (schemaPath.getPath());
+ if (prefixedPath == null) {
+ LOG.debug("Schema path {} has null path", schemaPath);
+ return null;
}
- return null;
+
+ LOG.trace("Looking for path {} in context {}", schemaPath, context);
+ return findNodeInSchemaContext(context, prefixedPath);
}
/**
* Non-conditional Revision Aware XPath, or <code>null</code> if the
* DataSchemaNode is not present in Schema Context.
*/
- public static SchemaNode findDataSchemaNode(SchemaContext context, Module module, RevisionAwareXPath nonCondXPath) {
+ public static SchemaNode findDataSchemaNode(final SchemaContext context, final Module module, final RevisionAwareXPath nonCondXPath) {
Preconditions.checkArgument(context != null, "Schema Context reference cannot be NULL");
Preconditions.checkArgument(module != null, "Module reference cannot be NULL");
Preconditions.checkArgument(nonCondXPath != null, "Non Conditional Revision Aware XPath cannot be NULL");
String strXPath = nonCondXPath.toString();
if (strXPath != null) {
- if (strXPath.contains("[")) {
- throw new IllegalArgumentException("Revision Aware XPath cannot contains condition");
- }
+ Preconditions.checkArgument(strXPath.indexOf('[') == -1, "Revision Aware XPath may not contain a condition");
if (nonCondXPath.isAbsolute()) {
List<QName> qnamedPath = xpathToQNamePath(context, module, strXPath);
if (qnamedPath != null) {
* given relative Revision Aware XPath, otherwise will return
* <code>null</code>.
*/
- public static SchemaNode findDataSchemaNodeForRelativeXPath(SchemaContext context, Module module,
- SchemaNode actualSchemaNode, RevisionAwareXPath relativeXPath) {
+ public static SchemaNode findDataSchemaNodeForRelativeXPath(final SchemaContext context, final Module module,
+ final SchemaNode actualSchemaNode, final RevisionAwareXPath relativeXPath) {
Preconditions.checkArgument(context != null, "Schema Context reference cannot be NULL");
Preconditions.checkArgument(module != null, "Module reference cannot be NULL");
Preconditions.checkArgument(actualSchemaNode != null, "Actual Schema Node reference cannot be NULL");
* Schema Node is NOT present, the method will returns
* <code>null</code>
*/
- public static Module findParentModule(SchemaContext context, SchemaNode schemaNode) {
+ public static Module findParentModule(final SchemaContext context, final SchemaNode schemaNode) {
Preconditions.checkArgument(context != null, "Schema Context reference cannot be NULL!");
Preconditions.checkArgument(schemaNode != null, "Schema Node cannot be NULL!");
Preconditions.checkState(schemaNode.getPath() != null, "Schema Path for Schema Node is not "
return context.findModuleByNamespaceAndRevision(qname.getNamespace(), qname.getRevision());
}
- public static SchemaNode findNodeInSchemaContext(SchemaContext context, List<QName> path) {
- QName current = path.get(0);
- Module module = context.findModuleByNamespaceAndRevision(current.getNamespace(), current.getRevision());
- if (module == null)
+ public static SchemaNode findNodeInSchemaContext(final SchemaContext context, final List<QName> path) {
+ final QName current = path.get(0);
+
+ LOG.trace("Looking up module {} in context {}", current, path);
+ final Module module = context.findModuleByNamespaceAndRevision(current.getNamespace(), current.getRevision());
+ if (module == null) {
+ LOG.debug("Module {} not found", current);
return null;
+ }
+
return findNodeInModule(module, path);
}
- public static GroupingDefinition findGrouping(SchemaContext context, Module module, List<QName> path) {
+ public static GroupingDefinition findGrouping(final SchemaContext context, final Module module, final List<QName> path) {
QName first = path.get(0);
Module m = context.findModuleByNamespace(first.getNamespace()).iterator().next();
DataNodeContainer currentParent = m;
found = true;
currentParent = node;
}
- if (!found) {
- throw new IllegalArgumentException("Failed to find referenced grouping: " + path + "("
- + qname.getLocalName() + ")");
- }
+
+ Preconditions.checkArgument(found, "Failed to find referenced grouping: %s(%s)", path, qname.getLocalName());
}
return (GroupingDefinition) currentParent;
}
- private static SchemaNode findNodeInModule(Module module, List<QName> path) {
- QName current = path.get(0);
- SchemaNode node = module.getDataChildByName(current);
- if (node != null)
- return findNode((DataSchemaNode) node, nextLevel(path));
- node = getRpcByName(module, current);
- if (node != null)
- return findNodeInRpc((RpcDefinition) node, nextLevel(path));
- node = getNotificationByName(module, current);
- if (node != null)
- return findNodeInNotification((NotificationDefinition) node, nextLevel(path));
- node = getGroupingByName(module, current);
- if (node != null)
- return findNodeInGrouping((GroupingDefinition) node, nextLevel(path));
- return node;
+ private static SchemaNode findNodeInModule(final Module module, final List<QName> path) {
+ final QName current = path.get(0);
+
+ LOG.trace("Looking for data container {} in module {}", current, module);
+ SchemaNode parent = module.getDataChildByName(current);
+ if (parent != null) {
+ final SchemaNode ret = findNode((DataSchemaNode) parent, nextLevel(path));
+ if (ret != null) {
+ return ret;
+ }
+ }
+
+ LOG.trace("Looking for RPC {} in module {}", current, module);
+ parent = getRpcByName(module, current);
+ if (parent != null) {
+ final SchemaNode ret = findNodeInRpc((RpcDefinition) parent, nextLevel(path));
+ if (ret != null) {
+ return ret;
+ }
+ }
+
+ LOG.trace("Looking for notification {} in module {}", current, module);
+ parent = getNotificationByName(module, current);
+ if (parent != null) {
+ final SchemaNode ret = findNodeInNotification((NotificationDefinition) parent, nextLevel(path));
+ if (ret != null) {
+ return ret;
+ }
+ }
+
+ LOG.trace("Looking for grouping {} in module {}", current, module);
+ parent = getGroupingByName(module, current);
+ if (parent != null) {
+ final SchemaNode ret = findNodeInGrouping((GroupingDefinition) parent, nextLevel(path));
+ if (ret != null) {
+ return ret;
+ }
+ }
+
+ LOG.debug("No node matching {} found in module {}", path, module);
+ return null;
}
- private static SchemaNode findNodeInGrouping(GroupingDefinition grouping, List<QName> path) {
- if (path.isEmpty())
+ private static SchemaNode findNodeInGrouping(final GroupingDefinition grouping, final List<QName> path) {
+ if (path.isEmpty()) {
+ LOG.debug("Found grouping {}", grouping);
return grouping;
- QName current = path.get(0);
- DataSchemaNode node = grouping.getDataChildByName(current);
- if (node != null)
- return findNode(node, nextLevel(path));
- return null;
+ }
+
+ LOG.trace("Looking for path {} in grouping {}", path, grouping);
+ final QName current = path.get(0);
+ final DataSchemaNode node = grouping.getDataChildByName(current);
+ if (node == null) {
+ LOG.debug("No node matching {} found in grouping {}", current, grouping);
+ return null;
+ }
+
+ return findNode(node, nextLevel(path));
}
- private static SchemaNode findNodeInRpc(RpcDefinition rpc, List<QName> path) {
- if (path.isEmpty())
+ private static SchemaNode findNodeInRpc(final RpcDefinition rpc, final List<QName> path) {
+ if (path.isEmpty()) {
+ LOG.debug("Found RPC {}", rpc);
return rpc;
- QName current = path.get(0);
+ }
+
+ LOG.trace("Looking for path {} in rpc {}", path, rpc);
+ final QName current = path.get(0);
switch (current.getLocalName()) {
case "input":
return findNode(rpc.getInput(), nextLevel(path));
case "output":
return findNode(rpc.getOutput(), nextLevel(path));
+ default:
+ LOG.debug("Invalid component {} of path {} in RPC {}", current, path, rpc);
+ return null;
}
- return null;
}
- private static SchemaNode findNodeInNotification(NotificationDefinition rpc, List<QName> path) {
- if (path.isEmpty())
- return rpc;
- QName current = path.get(0);
- DataSchemaNode node = rpc.getDataChildByName(current);
- if (node != null)
- return findNode(node, nextLevel(path));
- return null;
+ private static SchemaNode findNodeInNotification(final NotificationDefinition ntf, final List<QName> path) {
+ if (path.isEmpty()) {
+ LOG.debug("Found notification {}", ntf);
+ return ntf;
+ }
+
+ LOG.trace("Looking for path {} in notification {}", path, ntf);
+ final QName current = path.get(0);
+ DataSchemaNode node = ntf.getDataChildByName(current);
+ if (node == null) {
+ LOG.debug("No node matching {} found in notification {}", current, ntf);
+ return null;
+ }
+
+ return findNode(node, nextLevel(path));
}
- private static SchemaNode findNode(ChoiceNode parent, List<QName> path) {
- if (path.isEmpty())
+ private static SchemaNode findNode(final ChoiceNode parent, final List<QName> path) {
+ if (path.isEmpty()) {
return parent;
+ }
QName current = path.get(0);
ChoiceCaseNode node = parent.getCaseNodeByName(current);
- if (node != null)
+ if (node != null) {
return findNodeInCase(node, nextLevel(path));
+ }
return null;
}
- private static SchemaNode findNode(ContainerSchemaNode parent, List<QName> path) {
- if (path.isEmpty())
+ private static SchemaNode findNode(final ContainerSchemaNode parent, final List<QName> path) {
+ if (path.isEmpty()) {
return parent;
- QName current = path.get(0);
- DataSchemaNode node = parent.getDataChildByName(current);
- if (node != null)
- return findNode(node, nextLevel(path));
- return null;
+ }
+
+ final QName current = path.get(0);
+ final DataSchemaNode node = parent.getDataChildByName(current);
+ if (node == null) {
+ LOG.debug("Failed to find {} in parent {}", path, parent);
+ return null;
+ }
+
+ return findNode(node, nextLevel(path));
}
- private static SchemaNode findNode(ListSchemaNode parent, List<QName> path) {
- if (path.isEmpty())
+ private static SchemaNode findNode(final ListSchemaNode parent, final List<QName> path) {
+ if (path.isEmpty()) {
return parent;
+ }
+
QName current = path.get(0);
DataSchemaNode node = parent.getDataChildByName(current);
- if (node != null)
- return findNode(node, nextLevel(path));
- return null;
+ if (node == null) {
+ LOG.debug("Failed to find {} in parent {}", path, parent);
+ return null;
+ }
+ return findNode(node, nextLevel(path));
}
- private static SchemaNode findNode(DataSchemaNode parent, List<QName> path) {
- SchemaNode result = null;
- if (path.isEmpty()) {
- result = parent;
- } else {
+ private static SchemaNode findNode(final DataSchemaNode parent, final List<QName> path) {
+ final SchemaNode node;
+ if (!path.isEmpty()) {
if (parent instanceof ContainerSchemaNode) {
- result = findNode((ContainerSchemaNode) parent, path);
+ node = findNode((ContainerSchemaNode) parent, path);
} else if (parent instanceof ListSchemaNode) {
- result = findNode((ListSchemaNode) parent, path);
+ node = findNode((ListSchemaNode) parent, path);
} else if (parent instanceof ChoiceNode) {
- result = findNode((ChoiceNode) parent, path);
+ node = findNode((ChoiceNode) parent, path);
} else {
- throw new IllegalArgumentException("Path nesting violation");
+ throw new IllegalArgumentException(
+ String.format("Path nesting violation in parent %s path %s", parent, path));
}
+ } else {
+ node = parent;
}
- return result;
+
+ if (node == null) {
+ LOG.debug("Failed to find {} in parent {}", path, parent);
+ return null;
+ }
+ return node;
}
- public static SchemaNode findNodeInCase(ChoiceCaseNode parent, List<QName> path) {
- if (path.isEmpty())
+ public static SchemaNode findNodeInCase(final ChoiceCaseNode parent, final List<QName> path) {
+ if (path.isEmpty()) {
return parent;
+ }
+
QName current = path.get(0);
DataSchemaNode node = parent.getDataChildByName(current);
- if (node != null)
- return findNode(node, nextLevel(path));
- return null;
+ if (node == null) {
+ LOG.debug("Failed to find {} in parent {}", path, parent);
+ return null;
+ }
+ return findNode(node, nextLevel(path));
}
- public static RpcDefinition getRpcByName(Module module, QName name) {
+ public static RpcDefinition getRpcByName(final Module module, final QName name) {
for (RpcDefinition rpc : module.getRpcs()) {
if (rpc.getQName().equals(name)) {
return rpc;
return null;
}
- private static List<QName> nextLevel(List<QName> path) {
+ private static List<QName> nextLevel(final List<QName> path) {
return path.subList(1, path.size());
}
- public static NotificationDefinition getNotificationByName(Module module, QName name) {
+ public static NotificationDefinition getNotificationByName(final Module module, final QName name) {
for (NotificationDefinition notification : module.getNotifications()) {
if (notification.getQName().equals(name)) {
return notification;
return null;
}
- public static GroupingDefinition getGroupingByName(Module module, QName name) {
+ public static GroupingDefinition getGroupingByName(final Module module, final QName name) {
for (GroupingDefinition grouping : module.getGroupings()) {
if (grouping.getQName().equals(name)) {
return grouping;
* @param node
* @return
*/
- public static DataSchemaNode findOriginal(DataSchemaNode node, SchemaContext ctx) {
+ public static DataSchemaNode findOriginal(final DataSchemaNode node, final SchemaContext ctx) {
DataSchemaNode result = findCorrectTargetFromGrouping(node, ctx);
if (result == null) {
result = findCorrectTargetFromAugment(node, ctx);
return result;
}
- private static DataSchemaNode findCorrectTargetFromGrouping(DataSchemaNode node, SchemaContext ctx) {
+ private static DataSchemaNode findCorrectTargetFromGrouping(final DataSchemaNode node, final SchemaContext ctx) {
if (node.getPath().getPath().size() == 1) {
// uses is under module statement
Module m = findParentModule(ctx, node);
for (UsesNode u : m.getUses()) {
SchemaNode targetGrouping = findNodeInSchemaContext(ctx, u.getGroupingPath().getPath());
if (!(targetGrouping instanceof GroupingDefinition)) {
- throw new IllegalArgumentException("Failed to generate code for augment in " + u);
+ throw new IllegalArgumentException(String.format("Failed to generate code for augment in %s", u));
}
GroupingDefinition gr = (GroupingDefinition) targetGrouping;
result = gr.getDataChildByName(node.getQName().getLocalName());
}
}
- private static DataSchemaNode findCorrectTargetFromAugment(DataSchemaNode node, SchemaContext ctx) {
+ private static DataSchemaNode findCorrectTargetFromAugment(final DataSchemaNode node, final SchemaContext ctx) {
if (!node.isAugmenting()) {
return null;
}
}
}
- private static DataSchemaNode getResultFromUses(UsesNode u, String currentName, SchemaContext ctx) {
+ private static DataSchemaNode getResultFromUses(final UsesNode u, final String currentName, final SchemaContext ctx) {
SchemaNode targetGrouping = findNodeInSchemaContext(ctx, u.getGroupingPath().getPath());
- if (!(targetGrouping instanceof GroupingDefinition)) {
- throw new IllegalArgumentException("Failed to generate code for augment in " + u);
- }
+
+ Preconditions.checkArgument(targetGrouping instanceof GroupingDefinition,
+ "Failed to generate code for augment in %s", u);
GroupingDefinition gr = (GroupingDefinition) targetGrouping;
return gr.getDataChildByName(currentName);
}
- private static Module getParentModule(SchemaNode node, SchemaContext ctx) {
+ private static Module getParentModule(final SchemaNode node, final SchemaContext ctx) {
QName qname = node.getPath().getPath().get(0);
URI namespace = qname.getNamespace();
Date revision = qname.getRevision();
return ctx.findModuleByNamespaceAndRevision(namespace, revision);
}
- private static DataSchemaNode getTargetNode(List<QName> tmpPath, DataSchemaNode node, SchemaContext ctx) {
+ private static DataSchemaNode getTargetNode(final List<QName> tmpPath, final DataSchemaNode node, final SchemaContext ctx) {
DataSchemaNode result = node;
if (tmpPath.size() == 1) {
if (result != null && result.isAddedByUses()) {
}
}
- private static AugmentationSchema findNodeInAugment(Collection<AugmentationSchema> augments, QName name) {
+ private static AugmentationSchema findNodeInAugment(final Collection<AugmentationSchema> augments, final QName name) {
for (AugmentationSchema augment : augments) {
DataSchemaNode node = augment.getDataChildByName(name);
if (node != null) {
return null;
}
- private static DataSchemaNode findCorrectTargetFromAugmentGrouping(DataSchemaNode node,
- AugmentationSchema parentNode, List<SchemaNode> dataTree, SchemaContext ctx) {
+ private static DataSchemaNode findCorrectTargetFromAugmentGrouping(final DataSchemaNode node,
+ final AugmentationSchema parentNode, final List<SchemaNode> dataTree, final SchemaContext ctx) {
DataSchemaNode result = null;
QName currentName = node.getQName();
* XPath String
* @return return a list of QName
*/
- private static List<QName> xpathToQNamePath(SchemaContext context, Module parentModule, String xpath) {
+ private static List<QName> xpathToQNamePath(final SchemaContext context, final Module parentModule, final String xpath) {
Preconditions.checkArgument(context != null, "Schema Context reference cannot be NULL");
Preconditions.checkArgument(parentModule != null, "Parent Module reference cannot be NULL");
Preconditions.checkArgument(xpath != null, "XPath string reference cannot be NULL");
* Prefixed Path Part string
* @return QName from prefixed Path Part String.
*/
- private static QName stringPathPartToQName(SchemaContext context, Module parentModule, String prefixedPathPart) {
+ private static QName stringPathPartToQName(final SchemaContext context, final Module parentModule, final String prefixedPathPart) {
Preconditions.checkArgument(context != null, "Schema Context reference cannot be NULL");
Preconditions.checkArgument(parentModule != null, "Parent Module reference cannot be NULL");
Preconditions.checkArgument(prefixedPathPart != null, "Prefixed Path Part cannot be NULL!");
if (prefixedPathPart.contains(":")) {
String[] prefixedName = prefixedPathPart.split(":");
Module module = resolveModuleForPrefix(context, parentModule, prefixedName[0]);
- if (module == null) {
- throw new IllegalArgumentException("Failed to resolve xpath: no module found for prefix "
- + prefixedName[0] + " in module " + parentModule.getName());
- } else {
- return new QName(module.getNamespace(), module.getRevision(), prefixedName[1]);
- }
+ Preconditions.checkArgument(module != null, "Failed to resolve xpath: no module found for prefix %s in module %s",
+ prefixedName[0], parentModule.getName());
+ return new QName(module.getNamespace(), module.getRevision(), prefixedName[1]);
} else {
return new QName(parentModule.getNamespace(), parentModule.getRevision(), prefixedPathPart);
}
* @return Module for given prefix in specified Schema Context if is
* present, otherwise returns <code>null</code>
*/
- private static Module resolveModuleForPrefix(SchemaContext context, Module module, String prefix) {
+ private static Module resolveModuleForPrefix(final SchemaContext context, final Module module, final String prefix) {
Preconditions.checkArgument(context != null, "Schema Context reference cannot be NULL");
Preconditions.checkArgument(module != null, "Module reference cannot be NULL");
Preconditions.checkArgument(prefix != null, "Prefix string cannot be NULL");
* Schema Path for Leafref
* @return list of QName
*/
- private static List<QName> resolveRelativeXPath(SchemaContext context, Module module,
- RevisionAwareXPath relativeXPath, SchemaNode leafrefParentNode) {
+ private static List<QName> resolveRelativeXPath(final SchemaContext context, final Module module,
+ final RevisionAwareXPath relativeXPath, final SchemaNode leafrefParentNode) {
Preconditions.checkArgument(context != null, "Schema Context reference cannot be NULL");
Preconditions.checkArgument(module != null, "Module reference cannot be NULL");
Preconditions.checkArgument(relativeXPath != null, "Non Conditional Revision Aware XPath cannot be NULL");
* Basic implementation of DataNodeContainerBuilder.
*/
public abstract class AbstractDataNodeContainerBuilder extends AbstractBuilder implements DataNodeContainerBuilder {
- protected QName qname;
+ protected final QName qname;
- protected final Set<DataSchemaNode> childNodes = new HashSet<>();
+ protected final Set<DataSchemaNode> childNodes = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
protected final Set<DataSchemaNodeBuilder> addedChildNodes = new HashSet<>();
protected final Set<GroupingDefinition> groupings = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
return groupings;
}
+ @Override
public Set<GroupingBuilder> getGroupingBuilders() {
return addedGroupings;
}
*/
package org.opendaylight.yangtools.yang.parser.builder.api;
-import java.util.List;
-
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.Status;
+
+import com.google.common.base.Preconditions;
/**
* Basic implementation of SchemaNodeBuilder.
public abstract class AbstractSchemaNodeBuilder extends AbstractBuilder implements SchemaNodeBuilder {
protected final QName qname;
protected SchemaPath schemaPath;
+ protected String description;
+ protected String reference;
+ protected Status status = Status.CURRENT;
protected AbstractSchemaNodeBuilder(final String moduleName, final int line, final QName qname) {
super(moduleName, line);
this.qname = qname;
}
+ @Override
+ public QName getQName() {
+ return qname;
+ }
+
+ @Override
+ public SchemaPath getPath() {
+ return schemaPath;
+ }
+
+ @Override
+ public void setPath(final SchemaPath path) {
+ this.schemaPath = path;
+ }
+
+ @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(Status status) {
+ this.status = Preconditions.checkNotNull(status, "status cannot be null");
+ }
+
@Override
public int hashCode() {
final int prime = 31;
return true;
}
- @Override
- public QName getQName() {
- return qname;
- }
-
- public void setUnknownNodes(List<UnknownSchemaNode> unknownNodes) {
- this.unknownNodes.addAll(unknownNodes);
- }
-
}
*/
SchemaPath getPath();
+ /**
+ * Set path to this node.
+ *
+ * @param path
+ */
+ void setPath(SchemaPath path);
+
/**
* Get description of this node.
*
*/
package org.opendaylight.yangtools.yang.parser.builder.impl;
-import java.util.ArrayList;
-import java.util.Collections;
import java.util.List;
import org.opendaylight.yangtools.yang.common.QName;
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.DataSchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.util.Comparators;
+
+import com.google.common.collect.ImmutableList;
public final class AnyXmlBuilder extends AbstractSchemaNodeBuilder implements DataSchemaNodeBuilder {
- private boolean built;
- private final AnyXmlSchemaNodeImpl instance;
+ private AnyXmlSchemaNodeImpl instance;
+
+ private boolean augmenting;
+ private boolean addedByUses;
+ private boolean configuration;
+
private final ConstraintsBuilder constraints;
public AnyXmlBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path) {
super(moduleName, line, qname);
this.schemaPath = path;
- instance = new AnyXmlSchemaNodeImpl(qname, schemaPath);
constraints = new ConstraintsBuilder(moduleName, line);
}
final AnyXmlSchemaNode base) {
super(moduleName, line, qname);
this.schemaPath = path;
- this.instance = new AnyXmlSchemaNodeImpl(qname, schemaPath);
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.constraintsDef = base.getConstraints();
- instance.unknownNodes.addAll(base.getUnknownSchemaNodes());
+ description = base.getDescription();
+ reference = base.getReference();
+ status = base.getStatus();
+ augmenting = base.isAugmenting();
+ addedByUses = base.isAddedByUses();
+ configuration = base.isConfiguration();
+ unknownNodes.addAll(base.getUnknownSchemaNodes());
}
@Override
public AnyXmlSchemaNode build() {
- if (!built) {
- instance.setConstraints(constraints.build());
-
- // UNKNOWN NODES
- for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
- unknownNodes.add(b.build());
- }
- Collections.sort(unknownNodes, Comparators.SCHEMA_NODE_COMP);
- instance.setUnknownSchemaNodes(unknownNodes);
-
- built = true;
+ if (instance != null) {
+ return instance;
}
- return instance;
- }
-
- @Override
- public SchemaPath getPath() {
- return instance.path;
- }
- @Override
- public void setPath(SchemaPath path) {
- instance.path = path;
- }
-
- @Override
- public ConstraintsBuilder getConstraints() {
- return constraints;
- }
-
- @Override
- public String getDescription() {
- return instance.description;
- }
+ instance = new AnyXmlSchemaNodeImpl(qname, schemaPath);
- @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;
- }
+ instance.status = status;
+ instance.augmenting = augmenting;
+ instance.addedByUses = addedByUses;
+ instance.configuration = configuration;
- @Override
- public Status getStatus() {
- return instance.status;
- }
+ instance.constraintsDef = constraints.build();
- @Override
- public void setStatus(Status status) {
- if (status != null) {
- instance.status = status;
+ // UNKNOWN NODES
+ for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
+ unknownNodes.add(b.build());
}
+ instance.unknownNodes = ImmutableList.copyOf(unknownNodes);
+
+ return instance;
}
- public List<UnknownSchemaNodeBuilder> getUnknownNodes() {
- return addedUnknownNodes;
+ @Override
+ public ConstraintsBuilder getConstraints() {
+ return constraints;
}
@Override
public boolean isAugmenting() {
- return instance.augmenting;
+ return augmenting;
}
@Override
public void setAugmenting(final boolean augmenting) {
- instance.augmenting = augmenting;
+ this.augmenting = augmenting;
}
@Override
public boolean isAddedByUses() {
- return instance.addedByUses;
+ return addedByUses;
}
@Override
public void setAddedByUses(final boolean addedByUses) {
- instance.addedByUses = addedByUses;
+ this.addedByUses = addedByUses;
}
@Override
public boolean isConfiguration() {
- return instance.configuration;
+ return configuration;
}
@Override
public void setConfiguration(final boolean configuration) {
- instance.configuration = configuration;
+ this.configuration = configuration;
}
@Override
private static final class AnyXmlSchemaNodeImpl implements AnyXmlSchemaNode {
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 configuration;
private ConstraintDefinition constraintsDef;
private boolean augmenting;
private boolean addedByUses;
- private final List<UnknownSchemaNode> unknownNodes = new ArrayList<>();
+ private ImmutableList<UnknownSchemaNode> unknownNodes;
private AnyXmlSchemaNodeImpl(final QName qname, final SchemaPath path) {
this.qname = qname;
return constraintsDef;
}
- private void setConstraints(ConstraintDefinition constraintsDef) {
- this.constraintsDef = constraintsDef;
- }
-
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
- return Collections.unmodifiableList(unknownNodes);
- }
-
- private void setUnknownSchemaNodes(List<UnknownSchemaNode> unknownNodes) {
- if (unknownNodes != null) {
- this.unknownNodes.addAll(unknownNodes);
- }
+ return unknownNodes;
}
@Override
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
-import java.util.HashSet;
import java.util.List;
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.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;
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 AugmentationSchemaBuilderImpl extends AbstractDataNodeContainerBuilder implements
AugmentationSchemaBuilder {
- private boolean built;
- private final AugmentationSchemaImpl instance;
-
+ private AugmentationSchemaImpl instance;
private String whenCondition;
+ private String description;
+ private String reference;
+ private Status status = Status.CURRENT;
+
private final String augmentTargetStr;
private final SchemaPath targetPath;
private SchemaPath targetNodeSchemaPath;
super(moduleName, line, null);
this.augmentTargetStr = augmentTargetStr;
targetPath = ParserUtils.parseXPathString(augmentTargetStr);
- instance = new AugmentationSchemaImpl(targetPath);
}
@Override
@Override
public AugmentationSchema build() {
- if (!built) {
+ if (instance != null) {
+ return instance;
+ }
- Builder parent = getParent();
- if(parent instanceof ModuleBuilder) {
- ModuleBuilder moduleBuilder = (ModuleBuilder) parent;
- instance.setNamespace(moduleBuilder.getNamespace());
- instance.setRevision(moduleBuilder.getRevision());
- }
+ instance = new AugmentationSchemaImpl(targetPath);
- if (parent instanceof UsesNodeBuilder) {
- ModuleBuilder mb = ParserUtils.getParentModule(this);
- List<QName> newPath = new ArrayList<>();
- List<QName> parsedPath = targetPath.getPath();
- for (QName name : parsedPath) {
- newPath.add(new QName(mb.getNamespace(), mb.getRevision(), name.getPrefix(), name.getLocalName()));
- }
- instance.setTargetPath(new SchemaPath(newPath, false));
- } else {
- instance.setTargetPath(targetNodeSchemaPath);
- }
+ instance.description = description;
+ instance.reference = reference;
+ instance.status = status;
- if(copyOf != null) {
- instance.setCopyOf(copyOf.build());
- }
+ Builder parent = getParent();
+ if (parent instanceof ModuleBuilder) {
+ ModuleBuilder moduleBuilder = (ModuleBuilder) parent;
+ instance.namespace = moduleBuilder.getNamespace();
+ instance.revision = moduleBuilder.getRevision();
+ }
- RevisionAwareXPath whenStmt;
- if (whenCondition == null) {
- whenStmt = null;
- } else {
- whenStmt = new RevisionAwareXPathImpl(whenCondition, false);
+ if (parent instanceof UsesNodeBuilder) {
+ ModuleBuilder mb = ParserUtils.getParentModule(this);
+ List<QName> newPath = new ArrayList<>();
+ List<QName> parsedPath = targetPath.getPath();
+ for (QName name : parsedPath) {
+ newPath.add(new QName(mb.getNamespace(), mb.getRevision(), name.getPrefix(), name.getLocalName()));
}
- instance.setWhenCondition(whenStmt);
+ instance.targetPath = new SchemaPath(newPath, false);
+ } else {
+ instance.targetPath = targetNodeSchemaPath;
+ }
- // CHILD NODES
- for (DataSchemaNodeBuilder node : addedChildNodes) {
- DataSchemaNode child = node.build();
- childNodes.add(child);
- }
- instance.addChildNodes(childNodes);
+ if (copyOf != null) {
+ instance.setCopyOf(copyOf.build());
+ }
- // USES
- for (UsesNodeBuilder builder : addedUsesNodes) {
- usesNodes.add(builder.build());
- }
- instance.addUses(usesNodes);
+ RevisionAwareXPath whenStmt;
+ if (whenCondition == null) {
+ whenStmt = null;
+ } else {
+ whenStmt = new RevisionAwareXPathImpl(whenCondition, false);
+ }
+ instance.whenCondition = whenStmt;
- // UNKNOWN NODES
- for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
- unknownNodes.add(b.build());
- }
- Collections.sort(unknownNodes, Comparators.SCHEMA_NODE_COMP);
- instance.addUnknownSchemaNodes(unknownNodes);
+ // 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;
}
@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(final Status status) {
- if (status != null) {
- instance.status = status;
- }
+ public void setStatus(Status status) {
+ this.status = Preconditions.checkNotNull(status, "status cannot be null");
}
@Override
private static final class AugmentationSchemaImpl implements AugmentationSchema, NamespaceRevisionAware {
private SchemaPath targetPath;
private RevisionAwareXPath whenCondition;
- private final Set<DataSchemaNode> childNodes = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
- private final Set<UsesNode> uses = new HashSet<>();
+ private ImmutableSet<DataSchemaNode> childNodes;
+ private ImmutableSet<UsesNode> uses;
private String description;
private String reference;
private Status status;
private URI namespace;
private Date revision;
- private final List<UnknownSchemaNode> unknownNodes = new ArrayList<>();
+ private ImmutableList<UnknownSchemaNode> unknownNodes;
private AugmentationSchema copyOf;
private AugmentationSchemaImpl(final SchemaPath targetPath) {
public Optional<AugmentationSchema> getOriginalDefinition() {
return Optional.fromNullable(this.copyOf);
}
+
@Override
public SchemaPath getTargetPath() {
return targetPath;
}
- private void setTargetPath(final SchemaPath path) {
- this.targetPath = path;
- }
-
@Override
public RevisionAwareXPath getWhenCondition() {
return whenCondition;
}
- private void setWhenCondition(final RevisionAwareXPath whenCondition) {
- this.whenCondition = whenCondition;
- }
-
@Override
public Set<DataSchemaNode> getChildNodes() {
- return Collections.unmodifiableSet(childNodes);
- }
-
- private void addChildNodes(final Set<DataSchemaNode> childNodes) {
- if (childNodes != null) {
- this.childNodes.addAll(childNodes);
- }
+ return childNodes;
}
/**
@Override
public Set<UsesNode> getUses() {
- return Collections.unmodifiableSet(uses);
- }
-
- private void addUses(final Set<UsesNode> uses) {
- if (uses != null) {
- this.uses.addAll(uses);
- }
+ return uses;
}
/**
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
- return Collections.unmodifiableList(unknownNodes);
- }
-
- private void addUnknownSchemaNodes(final List<UnknownSchemaNode> unknownSchemaNodes) {
- if (unknownSchemaNodes != null) {
- this.unknownNodes.addAll(unknownSchemaNodes);
- }
+ return unknownNodes;
}
@Override
return namespace;
}
- protected void setNamespace(final URI namespace) {
- this.namespace = namespace;
- }
-
@Override
public Date getRevision() {
return revision;
}
- protected void setRevision(final Date revision) {
- this.revision = revision;
- }
-
@Override
public int hashCode() {
final int prime = 17;
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 org.opendaylight.yangtools.yang.parser.util.ParserUtils;
import org.opendaylight.yangtools.yang.parser.util.YangParseException;
+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;
+ private ChoiceNodeImpl instance;
+
// DataSchemaNode args
+ private boolean augmenting;
+ private boolean addedByUses;
+ private boolean configuration;
private final ConstraintsBuilder constraints;
// AugmentationTarget args
+ private final Set<AugmentationSchema> augmentations = new HashSet<>();
private final List<AugmentationSchemaBuilder> augmentationBuilders = new ArrayList<>();
// ChoiceNode args
private final Set<ChoiceCaseBuilder> caseBuilders = new HashSet<>();
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);
}
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());
+ description = base.getDescription();
+ reference = base.getReference();
+ status = base.getStatus();
+ augmenting = base.isAugmenting();
+ addedByUses = base.isAddedByUses();
+ configuration = base.isConfiguration();
+ augmentations.addAll(base.getAvailableAugmentations());
URI ns = qname.getNamespace();
Date rev = qname.getRevision();
}
}
- instance.unknownNodes.addAll(base.getUnknownSchemaNodes());
+ addedUnknownNodes.addAll(ParserUtils.wrapUnknownNodes(moduleName, line, base.getUnknownSchemaNodes(), path, ns,
+ rev, pref));
}
@Override
public ChoiceNode build() {
- if (!isBuilt) {
- instance.setConstraints(constraints.build());
- instance.setDefaultCase(defaultCase);
-
- // CASES
- final Set<ChoiceCaseNode> cases = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
- for (ChoiceCaseBuilder caseBuilder : caseBuilders) {
- cases.add(caseBuilder.build());
- }
- instance.addCases(cases);
+ if (instance != null) {
+ return instance;
+ }
- // AUGMENTATIONS
- final Set<AugmentationSchema> augmentations = new HashSet<>();
- for (AugmentationSchemaBuilder builder : augmentationBuilders) {
- augmentations.add(builder.build());
- }
- instance.addAvailableAugmentations(augmentations);
+ instance = new ChoiceNodeImpl(qname, schemaPath);
- // UNKNOWN NODES
- for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
- unknownNodes.add(b.build());
- }
- Collections.sort(unknownNodes, Comparators.SCHEMA_NODE_COMP);
- instance.addUnknownSchemaNodes(unknownNodes);
+ instance.description = description;
+ instance.reference = reference;
+ instance.status = status;
+ instance.augmenting = augmenting;
+ instance.addedByUses = addedByUses;
+ instance.configuration = configuration;
+
+ instance.constraints = constraints.build();
+ instance.defaultCase = defaultCase;
+
+ // CASES
+ final Set<ChoiceCaseNode> 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;
}
return caseBuilders;
}
- @Override
- public SchemaPath getPath() {
- return instance.path;
- }
-
- @Override
- public void setPath(final SchemaPath path) {
- instance.path = path;
- }
-
/**
* Get case by name.
*
}
}
- @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;
- }
-
- @Override
- public void setStatus(final Status status) {
- if (status != null) {
- instance.status = status;
- }
- }
-
@Override
public boolean isAugmenting() {
- return instance.augmenting;
+ return augmenting;
}
@Override
public void setAugmenting(final boolean augmenting) {
- instance.augmenting = augmenting;
+ this.augmenting = augmenting;
}
@Override
public boolean isAddedByUses() {
- return instance.addedByUses;
+ return addedByUses;
}
@Override
public void setAddedByUses(final boolean addedByUses) {
- instance.addedByUses = addedByUses;
+ this.addedByUses = addedByUses;
}
@Override
public boolean isConfiguration() {
- return instance.configuration;
+ return configuration;
}
@Override
public void setConfiguration(final boolean configuration) {
- instance.configuration = configuration;
+ this.configuration = configuration;
}
@Override
private static final class ChoiceNodeImpl implements ChoiceNode {
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 boolean configuration;
private ConstraintDefinition constraints;
- private final Set<ChoiceCaseNode> cases = new HashSet<>();
- private final Set<AugmentationSchema> augmentations = new HashSet<>();
- private final List<UnknownSchemaNode> unknownNodes = new ArrayList<>();
+ private ImmutableSet<ChoiceCaseNode> cases;
+ private ImmutableSet<AugmentationSchema> augmentations;
+ private ImmutableList<UnknownSchemaNode> unknownNodes;
private String defaultCase;
private ChoiceNodeImpl(final QName qname, final SchemaPath path) {
return constraints;
}
- private void setConstraints(final ConstraintDefinition constraints) {
- this.constraints = constraints;
- }
-
@Override
public Set<AugmentationSchema> getAvailableAugmentations() {
- return Collections.unmodifiableSet(augmentations);
- }
-
- private void addAvailableAugmentations(final Set<AugmentationSchema> availableAugmentations) {
- if (availableAugmentations != null) {
- this.augmentations.addAll(availableAugmentations);
- }
+ return augmentations;
}
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
- return Collections.unmodifiableList(unknownNodes);
- }
-
- private void addUnknownSchemaNodes(final List<UnknownSchemaNode> unknownSchemaNodes) {
- if (unknownSchemaNodes != null) {
- this.unknownNodes.addAll(unknownSchemaNodes);
- }
+ return unknownNodes;
}
@Override
public Set<ChoiceCaseNode> getCases() {
- return Collections.unmodifiableSet(cases);
+ return cases;
}
@Override
return null;
}
- private void addCases(final Set<ChoiceCaseNode> cases) {
- if (cases != null) {
- this.cases.addAll(cases);
- }
- }
-
@Override
public String getDefaultCase() {
return defaultCase;
}
- private void setDefaultCase(final String defaultCase) {
- this.defaultCase = defaultCase;
- }
-
@Override
public int hashCode() {
final int prime = 31;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
-import java.util.HashSet;
import java.util.List;
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.parser.builder.api.DataSchemaNodeBuilder;
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;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+
public final class ChoiceCaseBuilder extends AbstractDataNodeContainerBuilder implements DataSchemaNodeBuilder,
AugmentationTargetBuilder {
- private boolean isBuilt;
- private final ChoiceCaseNodeImpl instance;
+ private ChoiceCaseNodeImpl instance;
// SchemaNode args
- private final SchemaPath schemaPath;
+ private SchemaPath schemaPath;
+ private String description;
+ private String reference;
+ private Status status = Status.CURRENT;
+ // DataSchemaNode args
+ private boolean augmenting;
+ private boolean addedByUses;
private final ConstraintsBuilder constraints;
// AugmentationTarget args
+ private final List<AugmentationSchema> augmentations = new ArrayList<>();
private final List<AugmentationSchemaBuilder> augmentationBuilders = new ArrayList<>();
public ChoiceCaseBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path) {
super(moduleName, line, qname);
this.schemaPath = path;
- instance = new ChoiceCaseNodeImpl(qname, path);
constraints = new ConstraintsBuilder(moduleName, line);
}
- public ChoiceCaseBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path, final ChoiceCaseNode base) {
+ public ChoiceCaseBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path,
+ final ChoiceCaseNode base) {
super(moduleName, line, qname);
this.schemaPath = path;
- instance = new ChoiceCaseNodeImpl(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.constraints = base.getConstraints();
- instance.augmentations.addAll(base.getAvailableAugmentations());
+ description = base.getDescription();
+ reference = base.getReference();
+ status = base.getStatus();
+ augmenting = base.isAugmenting();
+ addedByUses = base.isAddedByUses();
URI ns = qname.getNamespace();
Date rev = qname.getRevision();
String pref = qname.getPrefix();
addedChildNodes.addAll(ParserUtils.wrapChildNodes(moduleName, line, base.getChildNodes(), path, ns, rev, pref));
addedGroupings.addAll(ParserUtils.wrapGroupings(moduleName, line, base.getGroupings(), path, ns, rev, pref));
+ addedUnknownNodes.addAll(ParserUtils.wrapUnknownNodes(moduleName, line, base.getUnknownSchemaNodes(), path, ns,
+ rev, pref));
- instance.uses.addAll(base.getUses());
- instance.unknownNodes.addAll(base.getUnknownSchemaNodes());
+ augmentations.addAll(base.getAvailableAugmentations());
+ usesNodes.addAll(base.getUses());
}
@Override
public ChoiceCaseNode build() {
- if (!isBuilt) {
- instance.setConstraints(constraints.build());
+ if (instance != null) {
+ return instance;
+ }
- // CHILD NODES
- for (DataSchemaNodeBuilder node : addedChildNodes) {
- childNodes.add(node.build());
- }
- instance.addChildNodes(childNodes);
+ instance = new ChoiceCaseNodeImpl(qname, schemaPath);
- // USES
- for (UsesNodeBuilder builder : addedUsesNodes) {
- usesNodes.add(builder.build());
- }
- instance.addUses(usesNodes);
+ instance.description = description;
+ instance.reference = reference;
+ instance.status = status;
+ instance.augmenting = augmenting;
+ instance.addedByUses = addedByUses;
- // UNKNOWN NODES
- for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
- unknownNodes.add(b.build());
- }
- Collections.sort(unknownNodes, Comparators.SCHEMA_NODE_COMP);
- instance.addUnknownSchemaNodes(unknownNodes);
+ instance.constraints = constraints.build();
- // AUGMENTATIONS
- final Set<AugmentationSchema> augmentations = new HashSet<>();
- for (AugmentationSchemaBuilder builder : augmentationBuilders) {
- augmentations.add(builder.build());
- }
- instance.addAvailableAugmentations(augmentations);
+ // CHILD NODES
+ for (DataSchemaNodeBuilder node : addedChildNodes) {
+ childNodes.add(node.build());
+ }
+ instance.childNodes = ImmutableSet.copyOf(childNodes);
- isBuilt = true;
+ // USES
+ for (UsesNodeBuilder builder : addedUsesNodes) {
+ usesNodes.add(builder.build());
}
+ instance.uses = ImmutableSet.copyOf(usesNodes);
+
+ // UNKNOWN NODES
+ for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
+ unknownNodes.add(b.build());
+ }
+ instance.unknownNodes = ImmutableList.copyOf(unknownNodes);
+
+ // AUGMENTATIONS
+ for (AugmentationSchemaBuilder builder : augmentationBuilders) {
+ augmentations.add(builder.build());
+ }
+ instance.augmentations = ImmutableSet.copyOf(augmentations);
return instance;
}
-
@Override
public SchemaPath getPath() {
- return instance.path;
+ return schemaPath;
}
@Override
public void setPath(final SchemaPath path) {
- instance.path = path;
+ this.schemaPath = path;
}
@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(final Status status) {
- if (status != null) {
- instance.status = status;
- }
+ public void setStatus(Status status) {
+ this.status = Preconditions.checkNotNull(status, "status cannot be null");
}
@Override
public boolean isAugmenting() {
- return instance.augmenting;
+ return augmenting;
}
@Override
public void setAugmenting(final boolean augmenting) {
- instance.augmenting = augmenting;
+ this.augmenting = augmenting;
}
@Override
public boolean isAddedByUses() {
- return instance.addedByUses;
+ return addedByUses;
}
@Override
public void setAddedByUses(final boolean addedByUses) {
- instance.addedByUses = addedByUses;
+ this.addedByUses = addedByUses;
}
@Override
private static final class ChoiceCaseNodeImpl implements ChoiceCaseNode {
private final QName qname;
- private SchemaPath path;
+ private final SchemaPath path;
private String description;
private String reference;
private Status status = Status.CURRENT;
private boolean augmenting;
private boolean addedByUses;
private ConstraintDefinition constraints;
- private final Set<DataSchemaNode> childNodes = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
- private final Set<AugmentationSchema> augmentations = new HashSet<>();
- private final Set<UsesNode> uses = new HashSet<>();
- private final List<UnknownSchemaNode> unknownNodes = new ArrayList<>();
+ private ImmutableSet<DataSchemaNode> childNodes;
+ private ImmutableSet<AugmentationSchema> augmentations;
+ private ImmutableSet<UsesNode> uses;
+ private ImmutableList<UnknownSchemaNode> unknownNodes;
private ChoiceCaseNodeImpl(final QName qname, final SchemaPath path) {
this.qname = qname;
return constraints;
}
- private void setConstraints(final ConstraintDefinition constraints) {
- this.constraints = constraints;
- }
-
@Override
public boolean isAugmenting() {
return augmenting;
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
- return Collections.unmodifiableList(unknownNodes);
- }
-
- private void addUnknownSchemaNodes(final List<UnknownSchemaNode> unknownNodes) {
- if (unknownNodes != null) {
- this.unknownNodes.addAll(unknownNodes);
- }
+ return unknownNodes;
}
/**
@Override
public Set<DataSchemaNode> getChildNodes() {
- return Collections.unmodifiableSet(childNodes);
- }
-
- private void addChildNodes(final Set<DataSchemaNode> childNodes) {
- if (childNodes != null) {
- this.childNodes.addAll(childNodes);
- }
+ return childNodes;
}
@Override
@Override
public Set<UsesNode> getUses() {
- return Collections.unmodifiableSet(uses);
- }
-
- private void addUses(final Set<UsesNode> uses) {
- if (uses != null) {
- this.uses.addAll(uses);
- }
+ return uses;
}
@Override
public Set<AugmentationSchema> getAvailableAugmentations() {
- return Collections.unmodifiableSet(augmentations);
- }
-
- private void addAvailableAugmentations(final Set<AugmentationSchema> augmentations) {
- if (augmentations != null) {
- this.augmentations.addAll(augmentations);
- }
+ return augmentations;
}
@Override
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;
-import java.util.TreeSet;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.*;
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;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+
public final class ContainerSchemaNodeBuilder extends AbstractDataNodeContainerBuilder implements
AugmentationTargetBuilder, DataSchemaNodeBuilder {
- private boolean isBuilt;
- private final ContainerSchemaNodeImpl instance;
-
- private final SchemaPath path;
+ private ContainerSchemaNodeImpl instance;
+ private boolean presence;
+ // SchemaNode args
+ private SchemaPath path;
+ private String description;
+ private String reference;
+ private Status status = Status.CURRENT;
// DataSchemaNode args
+ private boolean augmenting;
+ private boolean addedByUses;
+ private boolean configuration;
private final ConstraintsBuilder constraints;
// AugmentationTarget args
+ private final List<AugmentationSchema> augmentations = new ArrayList<>();
private final List<AugmentationSchemaBuilder> augmentationBuilders = new ArrayList<>();
public ContainerSchemaNodeBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path) {
super(moduleName, line, qname);
this.path = path;
- this.instance = new ContainerSchemaNodeImpl(qname, path);
this.constraints = new ConstraintsBuilder(moduleName, line);
}
final SchemaPath path, final ContainerSchemaNode base) {
super(moduleName, line, qname);
this.path = path;
- instance = new ContainerSchemaNodeImpl(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());
+ description = base.getDescription();
+ reference = base.getReference();
+ status = base.getStatus();
+ augmenting = base.isAugmenting();
+ addedByUses = base.isAddedByUses();
+ configuration = base.isConfiguration();
+ presence = base.isPresenceContainer();
URI ns = qname.getNamespace();
Date rev = qname.getRevision();
addedUnknownNodes.addAll(ParserUtils.wrapUnknownNodes(moduleName, line, base.getUnknownSchemaNodes(), path, ns,
rev, pref));
- instance.uses.addAll(base.getUses());
- instance.presence = base.isPresenceContainer();
- instance.configuration = base.isConfiguration();
- instance.configuration = base.isConfiguration();
+ augmentations.addAll(base.getAvailableAugmentations());
+ usesNodes.addAll(base.getUses());
}
@Override
public ContainerSchemaNode build() {
- if (!isBuilt) {
- // USES
- for (UsesNodeBuilder builder : addedUsesNodes) {
- usesNodes.add(builder.build());
- }
- instance.addUses(usesNodes);
+ if (instance != null) {
+ return instance;
+ }
- // CHILD NODES
- for (DataSchemaNodeBuilder node : addedChildNodes) {
- childNodes.add(node.build());
- }
- instance.addChildNodes(childNodes);
+ instance = new ContainerSchemaNodeImpl(qname, path);
- // GROUPINGS
- for (GroupingBuilder builder : addedGroupings) {
- groupings.add(builder.build());
- }
- instance.addGroupings(groupings);
+ instance.description = description;
+ instance.reference = reference;
+ instance.status = status;
+ instance.augmenting = augmenting;
+ instance.addedByUses = addedByUses;
+ instance.configuration = configuration;
+ instance.constraints = constraints.build();
+ instance.presence = presence;
- // TYPEDEFS
- for (TypeDefinitionBuilder entry : addedTypedefs) {
- typedefs.add(entry.build());
- }
- instance.addTypeDefinitions(typedefs);
+ // CHILD NODES
+ for (DataSchemaNodeBuilder node : addedChildNodes) {
+ childNodes.add(node.build());
+ }
+ instance.childNodes = ImmutableSet.copyOf(childNodes);
- // AUGMENTATIONS
- final List<AugmentationSchema> augmentations = new ArrayList<>();
- for (AugmentationSchemaBuilder builder : augmentationBuilders) {
- augmentations.add(builder.build());
- }
- instance.addAvailableAugmentations(new HashSet<>(augmentations));
+ // GROUPINGS
+ for (GroupingBuilder builder : addedGroupings) {
+ groupings.add(builder.build());
+ }
+ instance.groupings = ImmutableSet.copyOf(groupings);
- // UNKNOWN NODES
- for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
- unknownNodes.add(b.build());
- }
- Collections.sort(unknownNodes, Comparators.SCHEMA_NODE_COMP);
- instance.addUnknownSchemaNodes(unknownNodes);
+ // TYPEDEFS
+ for (TypeDefinitionBuilder entry : addedTypedefs) {
+ typedefs.add(entry.build());
+ }
+ instance.typeDefinitions = ImmutableSet.copyOf(typedefs);
- if (constraints != null) {
- instance.setConstraints(constraints.build());
- }
+ // USES
+ for (UsesNodeBuilder builder : addedUsesNodes) {
+ usesNodes.add(builder.build());
+ }
+ instance.uses = ImmutableSet.copyOf(usesNodes);
+
+ // 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;
}
@Override
public SchemaPath getPath() {
- return instance.path;
+ return path;
}
@Override
public void setPath(SchemaPath path) {
- instance.path = path;
+ this.path = path;
}
@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;
- }
+ this.status = Preconditions.checkNotNull(status, "status cannot be null");
}
@Override
public boolean isAugmenting() {
- return instance.augmenting;
+ return augmenting;
}
@Override
public void setAugmenting(boolean augmenting) {
- instance.augmenting = augmenting;
+ this.augmenting = augmenting;
}
@Override
public boolean isAddedByUses() {
- return instance.addedByUses;
+ return addedByUses;
}
@Override
public void setAddedByUses(final boolean addedByUses) {
- instance.addedByUses = addedByUses;
+ this.addedByUses = addedByUses;
}
@Override
public boolean isConfiguration() {
- return instance.configuration;
+ return configuration;
}
@Override
public void setConfiguration(boolean configuration) {
- instance.configuration = configuration;
+ this.configuration = configuration;
}
@Override
}
public boolean isPresence() {
- return instance.presence;
+ return presence;
}
public void setPresence(boolean presence) {
- instance.presence = presence;
+ this.presence = presence;
}
@Override
private static final class ContainerSchemaNodeImpl implements ContainerSchemaNode {
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 boolean configuration;
private ConstraintDefinition constraints;
- private final Set<AugmentationSchema> augmentations = new HashSet<>();
- private final Set<DataSchemaNode> childNodes = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
- private final Set<GroupingDefinition> groupings = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
- private final Set<TypeDefinition<?>> typeDefinitions = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
- private final Set<UsesNode> uses = new HashSet<>();
- private final List<UnknownSchemaNode> unknownNodes = new ArrayList<>();
+
+ private ImmutableSet<AugmentationSchema> augmentations;
+ private ImmutableSet<DataSchemaNode> childNodes;
+ private ImmutableSet<GroupingDefinition> groupings;
+ private ImmutableSet<TypeDefinition<?>> typeDefinitions;
+ private ImmutableSet<UsesNode> uses;
+ private ImmutableList<UnknownSchemaNode> unknownNodes;
+
private boolean presence;
private ContainerSchemaNodeImpl(QName qname, SchemaPath path) {
return constraints;
}
- private void setConstraints(ConstraintDefinition constraints) {
- this.constraints = constraints;
- }
-
@Override
public Set<AugmentationSchema> getAvailableAugmentations() {
- return Collections.unmodifiableSet(augmentations);
- }
-
- private void addAvailableAugmentations(Set<AugmentationSchema> augmentations) {
- if (augmentations != null) {
- this.augmentations.addAll(augmentations);
- }
+ return augmentations;
}
@Override
public Set<DataSchemaNode> getChildNodes() {
- return Collections.unmodifiableSet(childNodes);
- }
-
- private void addChildNodes(Set<DataSchemaNode> childNodes) {
- if (childNodes != null) {
- this.childNodes.addAll(childNodes);
- }
+ return childNodes;
}
@Override
public Set<GroupingDefinition> getGroupings() {
- return Collections.unmodifiableSet(groupings);
- }
-
- private void addGroupings(Set<GroupingDefinition> groupings) {
- if (groupings != null) {
- this.groupings.addAll(groupings);
- }
+ return groupings;
}
@Override
@Override
public Set<UsesNode> getUses() {
- return Collections.unmodifiableSet(uses);
- }
-
- private void addUses(Set<UsesNode> uses) {
- if (uses != null) {
- this.uses.addAll(uses);
- }
+ return uses;
}
@Override
@Override
public Set<TypeDefinition<?>> getTypeDefinitions() {
- return Collections.unmodifiableSet(typeDefinitions);
- }
-
- private void addTypeDefinitions(Set<TypeDefinition<?>> typeDefinitions) {
- if (typeDefinitions != null) {
- this.typeDefinitions.addAll(typeDefinitions);
- }
+ return typeDefinitions;
}
@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
import org.opendaylight.yangtools.yang.parser.builder.api.AbstractBuilder;
import org.opendaylight.yangtools.yang.parser.util.*;
+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
throw new YangParseException(moduleName, line, "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);
}
}
public void setReference(final String reference) {
- instance.reference = reference;
+ this.reference = reference;
}
@Override
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
*/
package org.opendaylight.yangtools.yang.parser.builder.impl;
-import java.util.ArrayList;
-import java.util.Collections;
import java.util.List;
import org.opendaylight.yangtools.yang.common.QName;
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.util.Comparators;
+
+import com.google.common.collect.ImmutableList;
public final class ExtensionBuilder extends AbstractSchemaNodeBuilder {
- private boolean isBuilt;
- private final ExtensionDefinitionImpl instance;
+ private ExtensionDefinitionImpl instance;
+ private String argument;
+ private boolean yin;
ExtensionBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path) {
super(moduleName, line, qname);
this.schemaPath = path;
- instance = new ExtensionDefinitionImpl(qname, path);
}
@Override
public ExtensionDefinition build() {
- if (!isBuilt) {
- // UNKNOWN NODES
- for (UnknownSchemaNodeBuilder un : addedUnknownNodes) {
- unknownNodes.add(un.build());
- }
- Collections.sort(unknownNodes, Comparators.SCHEMA_NODE_COMP);
- instance.addUnknownSchemaNodes(unknownNodes);
-
- isBuilt = true;
+ if (instance != null) {
+ return instance;
}
- return instance;
- }
-
- @Override
- public SchemaPath getPath() {
- return instance.schemaPath;
- }
-
- @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;
- }
+ instance = new ExtensionDefinitionImpl(qname, schemaPath);
+ instance.argument = argument;
+ instance.yin = yin;
- @Override
- public void setStatus(Status status) {
- if (status != null) {
- instance.status = status;
+ // UNKNOWN NODES
+ for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
+ unknownNodes.add(b.build());
}
+ instance.unknownNodes = ImmutableList.copyOf(unknownNodes);
+
+ return instance;
}
public void setYinElement(boolean yin) {
- instance.yin = yin;
+ this.yin = yin;
}
public void setArgument(String argument) {
- instance.argument = argument;
+ this.argument = argument;
}
@Override
private final SchemaPath schemaPath;
private String description;
private String reference;
- private Status status = Status.CURRENT;
- private final List<UnknownSchemaNode> unknownNodes = new ArrayList<>();
+ private Status status;
+ private ImmutableList<UnknownSchemaNode> unknownNodes;
private boolean yin;
private ExtensionDefinitionImpl(QName qname, SchemaPath path) {
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
- return Collections.unmodifiableList(unknownNodes);
- }
-
- private void addUnknownSchemaNodes(List<UnknownSchemaNode> unknownNodes) {
- if (unknownNodes != null) {
- this.unknownNodes.addAll(unknownNodes);
- }
+ return unknownNodes;
}
@Override
*/
package org.opendaylight.yangtools.yang.parser.builder.impl;
-import java.util.ArrayList;
-import java.util.Collections;
import java.util.List;
import org.opendaylight.yangtools.yang.common.QName;
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.util.Comparators;
+
+import com.google.common.collect.ImmutableList;
public final class FeatureBuilder extends AbstractSchemaNodeBuilder {
- private boolean isBuilt;
- private final FeatureDefinitionImpl instance;
+ private FeatureDefinitionImpl instance;
FeatureBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path) {
super(moduleName, line, qname);
this.schemaPath = path;
- instance = new FeatureDefinitionImpl(qname, path);
}
@Override
public FeatureDefinitionImpl build() {
- if (!isBuilt) {
- // UNKNOWN NODES
- for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
- unknownNodes.add(b.build());
- }
- Collections.sort(unknownNodes, Comparators.SCHEMA_NODE_COMP);
- instance.addUnknownSchemaNodes(unknownNodes);
-
- isBuilt = true;
+ if (instance != null) {
+ return instance;
}
- return instance;
- }
-
- @Override
- public SchemaPath getPath() {
- return instance.path;
- }
-
- @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;
- }
+ instance = new FeatureDefinitionImpl(qname, schemaPath);
- @Override
- public void setStatus(Status status) {
- if (status != null) {
- instance.status = status;
+ // UNKNOWN NODES
+ for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
+ unknownNodes.add(b.build());
}
+ instance.unknownNodes = ImmutableList.copyOf(unknownNodes);
+
+ return instance;
}
@Override
private final SchemaPath path;
private String description;
private String reference;
- private Status status = Status.CURRENT;
- private final List<UnknownSchemaNode> unknownNodes = new ArrayList<>();
+ private Status status;
+ private ImmutableList<UnknownSchemaNode> unknownNodes;
private FeatureDefinitionImpl(final QName qname, final SchemaPath path) {
this.qname = qname;
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
- return Collections.unmodifiableList(unknownNodes);
- }
-
- private void addUnknownSchemaNodes(final List<UnknownSchemaNode> unknownNodes) {
- if (unknownNodes != null) {
- this.unknownNodes.addAll(unknownNodes);
- }
+ return unknownNodes;
}
@Override
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;
-import java.util.TreeSet;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
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.CopyUtils;
import org.opendaylight.yangtools.yang.parser.util.ParserUtils;
import org.opendaylight.yangtools.yang.parser.util.YangParseException;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+
public final class GroupingBuilderImpl extends AbstractDataNodeContainerBuilder implements GroupingBuilder {
- private boolean isBuilt;
- private final GroupingDefinitionImpl instance;
+ private GroupingDefinitionImpl instance;
+ // SchemaNode args
private SchemaPath schemaPath;
+ private String description;
+ private String reference;
+ private Status status = Status.CURRENT;
+ // DataSchemaNode args
+ private boolean addedByUses;
public GroupingBuilderImpl(final String moduleName, final int line, final QName qname, final SchemaPath path) {
super(moduleName, line, qname);
schemaPath = path;
- instance = new GroupingDefinitionImpl(qname, path);
}
- public GroupingBuilderImpl(final String moduleName, final int line, final QName qname, final SchemaPath path, final GroupingDefinition base) {
+ public GroupingBuilderImpl(final String moduleName, final int line, final QName qname, final SchemaPath path,
+ final GroupingDefinition base) {
super(moduleName, line, base.getQName());
schemaPath = path;
- instance = new GroupingDefinitionImpl(qname, path);
- instance.description = base.getDescription();
- instance.reference = base.getReference();
- instance.status = base.getStatus();
- instance.addedByUses = base.isAddedByUses();
+ description = base.getDescription();
+ reference = base.getReference();
+ status = base.getStatus();
+ addedByUses = base.isAddedByUses();
URI ns = qname.getNamespace();
Date rev = qname.getRevision();
addedUnknownNodes.addAll(ParserUtils.wrapUnknownNodes(moduleName, line, base.getUnknownSchemaNodes(), path, ns,
rev, pref));
- instance.uses.addAll(base.getUses());
+ usesNodes.addAll(base.getUses());
}
@Override
public GroupingDefinition build() {
- if (!isBuilt) {
- // CHILD NODES
- for (DataSchemaNodeBuilder node : addedChildNodes) {
- childNodes.add(node.build());
- }
- instance.addChildNodes(childNodes);
+ if (instance != null) {
+ return instance;
+ }
- // GROUPINGS
- for (GroupingBuilder builder : addedGroupings) {
- groupings.add(builder.build());
- }
- instance.addGroupings(groupings);
+ instance = new GroupingDefinitionImpl(qname, schemaPath);
- // TYPEDEFS
- for (TypeDefinitionBuilder entry : addedTypedefs) {
- typedefs.add(entry.build());
- }
- instance.addTypeDefinitions(typedefs);
+ instance.description = description;
+ instance.reference = reference;
+ instance.status = status;
+ instance.addedByUses = addedByUses;
- // USES
- for (UsesNodeBuilder builder : addedUsesNodes) {
- usesNodes.add(builder.build());
- }
- instance.addUses(usesNodes);
+ // CHILD NODES
+ for (DataSchemaNodeBuilder node : addedChildNodes) {
+ childNodes.add(node.build());
+ }
+ instance.childNodes = ImmutableSet.copyOf(childNodes);
- // UNKNOWN NODES
- for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
- unknownNodes.add(b.build());
- }
- Collections.sort(unknownNodes, Comparators.SCHEMA_NODE_COMP);
- instance.addUnknownSchemaNodes(unknownNodes);
+ // GROUPINGS
+ for (GroupingBuilder builder : addedGroupings) {
+ groupings.add(builder.build());
+ }
+ instance.groupings = ImmutableSet.copyOf(groupings);
+
+ // TYPEDEFS
+ for (TypeDefinitionBuilder entry : addedTypedefs) {
+ typedefs.add(entry.build());
+ }
+ instance.typeDefinitions = ImmutableSet.copyOf(typedefs);
- isBuilt = true;
+ // USES
+ for (UsesNodeBuilder builder : addedUsesNodes) {
+ usesNodes.add(builder.build());
}
+ instance.uses = ImmutableSet.copyOf(usesNodes);
+
+ // UNKNOWN NODES
+ for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
+ unknownNodes.add(b.build());
+ }
+ instance.unknownNodes = ImmutableList.copyOf(unknownNodes);
return instance;
}
return schemaPath;
}
+ @Override
+ public void setPath(final SchemaPath path) {
+ this.schemaPath = path;
+ }
+
@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;
- }
+ this.status = Preconditions.checkNotNull(status, "status cannot be null");
}
@Override
public boolean isAddedByUses() {
- return instance.addedByUses;
+ return addedByUses;
}
@Override
public void setAddedByUses(final boolean addedByUses) {
- instance.addedByUses = addedByUses;
+ this.addedByUses = addedByUses;
}
@Override
return true;
}
-
private static final class GroupingDefinitionImpl implements GroupingDefinition {
private final QName qname;
private final SchemaPath path;
private String reference;
private Status status;
private boolean addedByUses;
- private final Set<DataSchemaNode> childNodes = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
- private final Set<GroupingDefinition> groupings = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
- private final Set<TypeDefinition<?>> typeDefinitions = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
- private final Set<UsesNode> uses = new HashSet<>();
- private final List<UnknownSchemaNode> unknownNodes = new ArrayList<>();
+ private ImmutableSet<DataSchemaNode> childNodes;
+ private ImmutableSet<GroupingDefinition> groupings;
+ private ImmutableSet<TypeDefinition<?>> typeDefinitions;
+ private ImmutableSet<UsesNode> uses;
+ private ImmutableList<UnknownSchemaNode> unknownNodes;
private GroupingDefinitionImpl(final QName qname, final SchemaPath path) {
this.qname = qname;
@Override
public Set<DataSchemaNode> getChildNodes() {
- return Collections.unmodifiableSet(childNodes);
- }
-
- private void addChildNodes(Set<DataSchemaNode> childNodes) {
- if (childNodes != null) {
- this.childNodes.addAll(childNodes);
- }
+ return childNodes;
}
@Override
public Set<GroupingDefinition> getGroupings() {
- return Collections.unmodifiableSet(groupings);
- }
-
- private void addGroupings(Set<GroupingDefinition> groupings) {
- if (groupings != null) {
- this.groupings.addAll(groupings);
- }
+ return groupings;
}
@Override
public Set<UsesNode> getUses() {
- return Collections.unmodifiableSet(uses);
- }
-
- private void addUses(Set<UsesNode> uses) {
- if (uses != null) {
- this.uses.addAll(uses);
- }
+ return uses;
}
@Override
public Set<TypeDefinition<?>> getTypeDefinitions() {
- return Collections.unmodifiableSet(typeDefinitions);
- }
-
- private void addTypeDefinitions(Set<TypeDefinition<?>> typeDefinitions) {
- if (typeDefinitions != null) {
- this.typeDefinitions.addAll(typeDefinitions);
- }
+ return typeDefinitions;
}
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
- return Collections.unmodifiableList(unknownNodes);
- }
-
- private void addUnknownSchemaNodes(List<UnknownSchemaNode> unknownNodes) {
- if (unknownNodes != null) {
- this.unknownNodes.addAll(unknownNodes);
- }
+ return unknownNodes;
}
@Override
*/
package org.opendaylight.yangtools.yang.parser.builder.impl;
-import java.util.*;
-
+import com.google.common.collect.ImmutableList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.*;
+import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
+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.util.Comparators;
public final class IdentitySchemaNodeBuilder extends AbstractSchemaNodeBuilder {
- private boolean isBuilt;
- private final IdentitySchemaNodeImpl instance;
+ private IdentitySchemaNodeImpl instance;
private IdentitySchemaNode baseIdentity;
private IdentitySchemaNodeBuilder baseIdentityBuilder;
private final Set<IdentitySchemaNode> derivedIdentities = new HashSet<>();
IdentitySchemaNodeBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path) {
super(moduleName, line, qname);
- this.schemaPath = path;
- instance = new IdentitySchemaNodeImpl(qname, path, derivedIdentities);
+ schemaPath = path;
}
IdentitySchemaNodeBuilder(final String moduleName, IdentitySchemaNode base) {
schemaPath = base.getPath();
derivedIdentities.addAll(base.getDerivedIdentities());
unknownNodes.addAll(base.getUnknownSchemaNodes());
- instance = new IdentitySchemaNodeImpl(qname, schemaPath, derivedIdentities);
}
@Override
public IdentitySchemaNode build() {
- if (!isBuilt) {
- if(baseIdentityBuilder != null) {
- baseIdentityBuilder.addDerivedIdentity(instance);
- baseIdentity = baseIdentityBuilder.build();
- }
- instance.setBaseIdentity(baseIdentity);
-
- // UNKNOWN NODES
- for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
- unknownNodes.add(b.build());
- }
- Collections.sort(unknownNodes, Comparators.SCHEMA_NODE_COMP);
- instance.addUnknownSchemaNodes(unknownNodes);
-
- isBuilt = true;
+ if (instance != null) {
+ return instance;
}
- return instance;
- }
-
- @Override
- public SchemaPath getPath() {
- return instance.path;
- }
-
- @Override
- public String getDescription() {
- return instance.description;
- }
+ instance = new IdentitySchemaNodeImpl(qname, schemaPath, derivedIdentities);
- @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;
- }
+ instance.status = status;
- @Override
- public Status getStatus() {
- return instance.status;
- }
+ if (baseIdentityBuilder != null) {
+ baseIdentityBuilder.addDerivedIdentity(instance);
+ baseIdentity = baseIdentityBuilder.build();
+ }
+ instance.baseIdentity = baseIdentity;
- @Override
- public void setStatus(Status status) {
- if (status != null) {
- instance.status = status;
+ // UNKNOWN NODES
+ for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
+ unknownNodes.add(b.build());
}
+ instance.unknownNodes = ImmutableList.copyOf(unknownNodes);
+
+ return instance;
}
public String getBaseIdentityName() {
private final Set<IdentitySchemaNode> derivedIdentities;
private String description;
private String reference;
- private Status status = Status.CURRENT;
- private final List<UnknownSchemaNode> unknownNodes = new ArrayList<>();
+ private Status status;
+ private ImmutableList<UnknownSchemaNode> unknownNodes;
- private IdentitySchemaNodeImpl(final QName qname, final SchemaPath path, final Set<IdentitySchemaNode> derivedIdentities) {
+ private IdentitySchemaNodeImpl(final QName qname, final SchemaPath path,
+ final Set<IdentitySchemaNode> derivedIdentities) {
this.qname = qname;
this.path = path;
this.derivedIdentities = derivedIdentities;
return baseIdentity;
}
- private void setBaseIdentity(final IdentitySchemaNode baseIdentity) {
- this.baseIdentity = baseIdentity;
- }
-
@Override
public Set<IdentitySchemaNode> getDerivedIdentities() {
return Collections.unmodifiableSet(derivedIdentities);
@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
private static final String NAME = "identityref";
private final String baseString;
- private final SchemaPath schemaPath;
+ private SchemaPath schemaPath;
private IdentitySchemaNodeBuilder baseIdentity;
public IdentityrefTypeBuilder(final String moduleName, final int line, final String baseString,
return schemaPath;
}
+ @Override
+ public void setPath(SchemaPath path) {
+ this.schemaPath = path;
+ }
+
@Override
public String getDescription() {
return null;
*/
package org.opendaylight.yangtools.yang.parser.builder.impl;
-import java.util.ArrayList;
-import java.util.Collections;
import java.util.List;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.parser.builder.api.AbstractTypeAwareBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.util.Comparators;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
public final class LeafListSchemaNodeBuilder extends AbstractTypeAwareBuilder implements DataSchemaNodeBuilder {
- private boolean isBuilt;
- private final LeafListSchemaNodeImpl instance;
+ private LeafListSchemaNodeImpl instance;
+ private boolean userOrdered;
// SchemaNode args
private SchemaPath schemaPath;
+ private String description;
+ private String reference;
+ private Status status = Status.CURRENT;
// DataSchemaNode args
+ private boolean augmenting;
+ private boolean addedByUses;
+ private boolean configuration;
private final ConstraintsBuilder constraints;
public LeafListSchemaNodeBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path) {
super(moduleName, line, qname);
this.schemaPath = path;
- instance = new LeafListSchemaNodeImpl(qname, path);
constraints = new ConstraintsBuilder(moduleName, line);
}
- public LeafListSchemaNodeBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path, final LeafListSchemaNode base) {
+ public LeafListSchemaNodeBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path,
+ final LeafListSchemaNode base) {
super(moduleName, line, qname);
schemaPath = path;
- instance = new LeafListSchemaNodeImpl(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.constraintsDef = base.getConstraints();
+ description = base.getDescription();
+ reference = base.getReference();
+ status = base.getStatus();
+ augmenting = base.isAugmenting();
+ addedByUses = base.isAddedByUses();
+ configuration = base.isConfiguration();
this.type = base.getType();
- instance.userOrdered = base.isUserOrdered();
- instance.unknownNodes.addAll(base.getUnknownSchemaNodes());
+ userOrdered = base.isUserOrdered();
+ unknownNodes.addAll(base.getUnknownSchemaNodes());
}
@Override
public LeafListSchemaNode build() {
- if (!isBuilt) {
- instance.setConstraints(constraints.build());
+ if (instance != null) {
+ return instance;
+ }
- if (type == null) {
- instance.setType(typedef.build());
- } else {
- instance.setType(type);
- }
+ instance = new LeafListSchemaNodeImpl(qname, schemaPath);
- // UNKNOWN NODES
- for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
- unknownNodes.add(b.build());
- }
- Collections.sort(unknownNodes, Comparators.SCHEMA_NODE_COMP);
- instance.addUnknownSchemaNodes(unknownNodes);
+ instance.description = description;
+ instance.reference = reference;
+ instance.status = status;
+ instance.augmenting = augmenting;
+ instance.addedByUses = addedByUses;
+ instance.configuration = configuration;
+ instance.constraintsDef = constraints.build();
+ instance.userOrdered = userOrdered;
- isBuilt = true;
+ if (type == null) {
+ instance.type = typedef.build();
+ } else {
+ instance.type = type;
}
+
+ // UNKNOWN NODES
+ for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
+ unknownNodes.add(b.build());
+ }
+ instance.unknownNodes = ImmutableList.copyOf(unknownNodes);
+
return instance;
}
@Override
public void setPath(SchemaPath path) {
- instance.path = path;
+ this.schemaPath = path;
}
@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;
- }
+ this.status = Preconditions.checkNotNull(status, "status cannot be null");
}
@Override
public boolean isAugmenting() {
- return instance.augmenting;
+ return augmenting;
}
@Override
public void setAugmenting(boolean augmenting) {
- instance.augmenting = augmenting;
+ this.augmenting = augmenting;
}
@Override
public boolean isAddedByUses() {
- return instance.addedByUses;
+ return addedByUses;
}
@Override
public void setAddedByUses(final boolean addedByUses) {
- instance.addedByUses = addedByUses;
+ this.addedByUses = addedByUses;
}
@Override
public boolean isConfiguration() {
- return instance.configuration;
+ return configuration;
}
@Override
public void setConfiguration(boolean configuration) {
- instance.configuration = configuration;
+ this.configuration = configuration;
}
@Override
}
public boolean isUserOrdered() {
- return instance.userOrdered;
+ return userOrdered;
}
public void setUserOrdered(final boolean userOrdered) {
- instance.userOrdered = userOrdered;
+ this.userOrdered = userOrdered;
}
@Override
private static final class LeafListSchemaNodeImpl implements LeafListSchemaNode {
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 boolean configuration;
private ConstraintDefinition constraintsDef;
private TypeDefinition<?> type;
private boolean userOrdered;
- private final List<UnknownSchemaNode> unknownNodes = new ArrayList<>();
+ private ImmutableList<UnknownSchemaNode> unknownNodes;
private LeafListSchemaNodeImpl(final QName qname, final SchemaPath path) {
this.qname = qname;
return constraintsDef;
}
- private void setConstraints(ConstraintDefinition constraintsDef) {
- this.constraintsDef = constraintsDef;
- }
-
@Override
public TypeDefinition<?> getType() {
return type;
}
- public void setType(TypeDefinition<? extends TypeDefinition<?>> type) {
- this.type = type;
- }
-
@Override
public boolean isUserOrdered() {
return userOrdered;
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
- return Collections.unmodifiableList(unknownNodes);
- }
-
- private void addUnknownSchemaNodes(List<UnknownSchemaNode> unknownNodes) {
- if (unknownNodes != null) {
- this.unknownNodes.addAll(unknownNodes);
- }
+ return unknownNodes;
}
@Override
*/
package org.opendaylight.yangtools.yang.parser.builder.impl;
-import java.util.ArrayList;
-import java.util.Collections;
import java.util.List;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.parser.builder.api.AbstractTypeAwareBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.util.Comparators;
import org.opendaylight.yangtools.yang.parser.util.YangParseException;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+
public final class LeafSchemaNodeBuilder extends AbstractTypeAwareBuilder implements DataSchemaNodeBuilder {
- private boolean isBuilt;
- private final LeafSchemaNodeImpl instance;
+ private LeafSchemaNodeImpl instance;
+ private String defaultStr;
+ private String unitsStr;
// SchemaNode args
private SchemaPath schemaPath;
+ private String description;
+ private String reference;
+ private Status status = Status.CURRENT;
// DataSchemaNode args
+ private boolean augmenting;
+ private boolean addedByUses;
+ private boolean configuration;
private final ConstraintsBuilder constraints;
public LeafSchemaNodeBuilder(final String moduleName, final int line, final QName qname, final SchemaPath schemaPath) {
super(moduleName, line, qname);
this.schemaPath = schemaPath;
- instance = new LeafSchemaNodeImpl(qname, schemaPath);
constraints = new ConstraintsBuilder(moduleName, line);
}
public LeafSchemaNodeBuilder(String moduleName, int line, QName qname, SchemaPath path, LeafSchemaNode base) {
super(moduleName, line, qname);
this.schemaPath = path;
- instance = new LeafSchemaNodeImpl(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.constraintsDef = base.getConstraints();
+ description = base.getDescription();
+ reference = base.getReference();
+ status = base.getStatus();
+ augmenting = base.isAugmenting();
+ addedByUses = base.isAddedByUses();
+ configuration = base.isConfiguration();
this.type = base.getType();
- instance.unknownNodes.addAll(base.getUnknownSchemaNodes());
- instance.defaultStr = base.getDefault();
- instance.unitsStr = base.getUnits();
+ unknownNodes.addAll(base.getUnknownSchemaNodes());
+
+ defaultStr = base.getDefault();
+ unitsStr = base.getUnits();
}
@Override
public LeafSchemaNode build() {
- if (!isBuilt) {
- instance.setConstraints(constraints.build());
+ if (instance != null) {
+ return instance;
+ }
- if (type == null && typedef == null) {
- throw new YangParseException(moduleName, line, "Failed to resolve leaf type.");
- }
+ instance = new LeafSchemaNodeImpl(qname, schemaPath);
- // TYPE
- if (type == null) {
- instance.setType(typedef.build());
- } else {
- instance.setType(type);
- }
+ instance.description = description;
+ instance.reference = reference;
+ instance.status = status;
+ instance.augmenting = augmenting;
+ instance.addedByUses = addedByUses;
+ instance.configuration = configuration;
+ instance.constraintsDef = constraints.build();
+ instance.defaultStr = defaultStr;
+ instance.unitsStr = unitsStr;
- // UNKNOWN NODES
- for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
- unknownNodes.add(b.build());
- }
- Collections.sort(unknownNodes, Comparators.SCHEMA_NODE_COMP);
- instance.addUnknownSchemaNodes(unknownNodes);
+ if (type == null && typedef == null) {
+ throw new YangParseException(moduleName, line, "Failed to resolve leaf type.");
+ }
+
+ // TYPE
+ if (type == null) {
+ instance.type = typedef.build();
+ } else {
+ instance.type = type;
+ }
- isBuilt = true;
+ // UNKNOWN NODES
+ for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
+ unknownNodes.add(b.build());
}
+ instance.unknownNodes = ImmutableList.copyOf(unknownNodes);
+
return instance;
}
-
@Override
public SchemaPath getPath() {
return schemaPath;
@Override
public void setPath(SchemaPath path) {
- instance.path = path;
+ this.schemaPath = path;
}
@Override
@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;
- }
+ this.status = Preconditions.checkNotNull(status, "status cannot be null");
}
@Override
public boolean isAugmenting() {
- return instance.augmenting;
+ return augmenting;
}
@Override
public void setAugmenting(final boolean augmenting) {
- instance.augmenting = augmenting;
+ this.augmenting = augmenting;
}
@Override
public boolean isAddedByUses() {
- return instance.addedByUses;
+ return addedByUses;
}
@Override
public void setAddedByUses(final boolean addedByUses) {
- instance.addedByUses = addedByUses;
+ this.addedByUses = addedByUses;
}
@Override
public boolean isConfiguration() {
- return instance.configuration;
+ return configuration;
}
@Override
public void setConfiguration(final boolean configuration) {
- instance.configuration = configuration;
+ this.configuration = configuration;
}
public String getDefaultStr() {
- return instance.defaultStr;
+ return defaultStr;
}
public void setDefaultStr(String defaultStr) {
- instance.defaultStr = defaultStr;
+ this.defaultStr = defaultStr;
}
public String getUnits() {
- return instance.unitsStr;
+ return unitsStr;
}
public void setUnits(String unitsStr) {
- instance.unitsStr = unitsStr;
+ this.unitsStr = unitsStr;
}
@Override
private static final class LeafSchemaNodeImpl implements LeafSchemaNode {
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 boolean configuration;
private ConstraintDefinition constraintsDef;
private TypeDefinition<?> type;
- private final List<UnknownSchemaNode> unknownNodes = new ArrayList<>();
+ private ImmutableList<UnknownSchemaNode> unknownNodes;
private String defaultStr;
private String unitsStr;
return constraintsDef;
}
- private void setConstraints(ConstraintDefinition constraintsDef) {
- this.constraintsDef = constraintsDef;
- }
-
@Override
public TypeDefinition<?> getType() {
return type;
}
- private void setType(TypeDefinition<? extends TypeDefinition<?>> type) {
- this.type = type;
- }
-
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
- return Collections.unmodifiableList(unknownNodes);
- }
-
- private void addUnknownSchemaNodes(List<UnknownSchemaNode> unknownNodes) {
- if (unknownNodes != null) {
- this.unknownNodes.addAll(unknownNodes);
- }
+ return unknownNodes;
}
@Override
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;
-import java.util.TreeSet;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
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;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+
public final class ListSchemaNodeBuilder extends AbstractDataNodeContainerBuilder implements DataSchemaNodeBuilder,
AugmentationTargetBuilder {
- private boolean isBuilt;
- private final ListSchemaNodeImpl instance;
+ private ListSchemaNodeImpl instance;
+ private boolean userOrdered;
private List<String> keys;
+ private List<QName> keyDefinition;
// SchemaNode args
- private final SchemaPath schemaPath;
+ private SchemaPath schemaPath;
+ private String description;
+ private String reference;
+ private Status status = Status.CURRENT;
// DataSchemaNode args
+ private boolean augmenting;
+ private boolean addedByUses;
+ private boolean configuration;
private final ConstraintsBuilder constraints;
// AugmentationTarget args
+ private final List<AugmentationSchema> augmentations = new ArrayList<>();
private final List<AugmentationSchemaBuilder> augmentationBuilders = new ArrayList<>();
-
public ListSchemaNodeBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path) {
super(moduleName, line, qname);
this.schemaPath = path;
- instance = new ListSchemaNodeImpl(qname, path);
constraints = new ConstraintsBuilder(moduleName, line);
}
- public ListSchemaNodeBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path, final ListSchemaNode base) {
+ public ListSchemaNodeBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path,
+ final ListSchemaNode base) {
super(moduleName, line, qname);
schemaPath = path;
- instance = new ListSchemaNodeImpl(qname, path);
constraints = new ConstraintsBuilder(moduleName, line, base.getConstraints());
- instance.keyDefinition = base.getKeyDefinition();
- instance.userOrdered = base.isUserOrdered();
+ keyDefinition = ImmutableList.copyOf(base.getKeyDefinition());
+ userOrdered = base.isUserOrdered();
- 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());
+ description = base.getDescription();
+ reference = base.getReference();
+ status = base.getStatus();
+ augmenting = base.isAugmenting();
+ addedByUses = base.isAddedByUses();
+ configuration = base.isConfiguration();
URI ns = qname.getNamespace();
Date rev = qname.getRevision();
addedUnknownNodes.addAll(ParserUtils.wrapUnknownNodes(moduleName, line, base.getUnknownSchemaNodes(), path, ns,
rev, pref));
- instance.uses.addAll(base.getUses());
+ augmentations.addAll(base.getAvailableAugmentations());
+ usesNodes.addAll(base.getUses());
}
@Override
public ListSchemaNode build() {
- if (!isBuilt) {
- // CHILD NODES
- for (DataSchemaNodeBuilder node : addedChildNodes) {
- childNodes.add(node.build());
- }
- instance.addChildNodes(childNodes);
-
- // KEY
- if (keys == null) {
- instance.keyDefinition = Collections.<QName> emptyList();
- } else {
- List<QName> qnames = new ArrayList<>();
- for (String key : keys) {
- qnames.add(instance.getDataChildByName(key).getQName());
- }
- instance.keyDefinition = qnames;
- }
+ if (instance != null) {
+ return instance;
+ }
- // TYPEDEFS
- for (TypeDefinitionBuilder entry : addedTypedefs) {
- typedefs.add(entry.build());
- }
- instance.addTypeDefinitions(typedefs);
+ instance = new ListSchemaNodeImpl(qname, schemaPath);
- // USES
- for (UsesNodeBuilder builder : addedUsesNodes) {
- usesNodes.add(builder.build());
- }
- instance.addUses(usesNodes);
+ instance.description = description;
+ instance.reference = reference;
+ instance.status = status;
+ instance.augmenting = augmenting;
+ instance.addedByUses = addedByUses;
+ instance.configuration = configuration;
+ instance.constraints = constraints.build();
+ instance.userOrdered = userOrdered;
- // GROUPINGS
- for (GroupingBuilder builder : addedGroupings) {
- groupings.add(builder.build());
- }
- instance.addGroupings(groupings);
+ // CHILD NODES
+ for (DataSchemaNodeBuilder node : addedChildNodes) {
+ childNodes.add(node.build());
+ }
+ instance.childNodes = ImmutableSet.copyOf(childNodes);
- // AUGMENTATIONS
- final Set<AugmentationSchema> augmentations = new HashSet<>();
- for (AugmentationSchemaBuilder builder : augmentationBuilders) {
- augmentations.add(builder.build());
+ // KEY
+ if (keys == null) {
+ instance.keyDefinition = ImmutableList.of();
+ } else {
+ keyDefinition = new ArrayList<>();
+ for (String key : keys) {
+ keyDefinition.add(instance.getDataChildByName(key).getQName());
}
- instance.addAvailableAugmentations(augmentations);
+ instance.keyDefinition = ImmutableList.copyOf(keyDefinition);
+ }
- // UNKNOWN NODES
- for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
- unknownNodes.add(b.build());
- }
- Collections.sort(unknownNodes, Comparators.SCHEMA_NODE_COMP);
- instance.addUnknownSchemaNodes(unknownNodes);
+ // GROUPINGS
+ for (GroupingBuilder builder : addedGroupings) {
+ groupings.add(builder.build());
+ }
+ instance.groupings = ImmutableSet.copyOf(groupings);
- instance.setConstraints(constraints.build());
+ // TYPEDEFS
+ for (TypeDefinitionBuilder entry : addedTypedefs) {
+ typedefs.add(entry.build());
+ }
+ instance.typeDefinitions = ImmutableSet.copyOf(typedefs);
- isBuilt = true;
+ // USES
+ for (UsesNodeBuilder builder : addedUsesNodes) {
+ usesNodes.add(builder.build());
}
+ instance.uses = ImmutableSet.copyOf(usesNodes);
+
+ // AUGMENTATIONS
+ for (AugmentationSchemaBuilder builder : augmentationBuilders) {
+ augmentations.add(builder.build());
+ }
+ instance.augmentations = ImmutableSet.copyOf(augmentations);
+
+ // UNKNOWN NODES
+ for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
+ unknownNodes.add(b.build());
+ }
+ instance.unknownNodes = ImmutableList.copyOf(unknownNodes);
+
return instance;
}
@Override
public SchemaPath getPath() {
- return instance.path;
+ return schemaPath;
}
@Override
- public void setPath(final SchemaPath path) {
- instance.path = path;
+ public void setPath(SchemaPath path) {
+ this.schemaPath = path;
}
@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(final Status status) {
- if (status != null) {
- instance.status = status;
- }
+ public void setStatus(Status status) {
+ this.status = Preconditions.checkNotNull(status, "status cannot be null");
}
@Override
@Override
public boolean isAugmenting() {
- return instance.augmenting;
+ return augmenting;
}
@Override
- public void setAugmenting(final boolean augmenting) {
- instance.augmenting = augmenting;
+ public void setAugmenting(boolean augmenting) {
+ this.augmenting = augmenting;
}
@Override
public boolean isAddedByUses() {
- return instance.addedByUses;
+ return addedByUses;
}
@Override
public void setAddedByUses(final boolean addedByUses) {
- instance.addedByUses = addedByUses;
+ this.addedByUses = addedByUses;
}
@Override
public boolean isConfiguration() {
- return instance.configuration;
+ return configuration;
}
@Override
- public void setConfiguration(final boolean configuration) {
- instance.configuration = configuration;
+ public void setConfiguration(boolean configuration) {
+ this.configuration = configuration;
}
@Override
}
public boolean isUserOrdered() {
- return instance.userOrdered;
+ return userOrdered;
}
public void setUserOrdered(final boolean userOrdered) {
- instance.userOrdered = userOrdered;
+ this.userOrdered = userOrdered;
}
@Override
private static final class ListSchemaNodeImpl implements ListSchemaNode {
private final QName qname;
- private SchemaPath path;
+ private final SchemaPath path;
private String description;
private String reference;
- private Status status = Status.CURRENT;
- private List<QName> keyDefinition = Collections.emptyList();
+ private Status status;
+ private ImmutableList<QName> keyDefinition;
private boolean augmenting;
private boolean addedByUses;
private boolean configuration;
private ConstraintDefinition constraints;
- private final Set<AugmentationSchema> augmentations = new HashSet<>();
- private final Set<DataSchemaNode> childNodes = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
- private final Set<TypeDefinition<?>> typeDefinitions = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
- private final Set<GroupingDefinition> groupings = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
- private final Set<UsesNode> uses = new HashSet<>();
+ private ImmutableSet<AugmentationSchema> augmentations;
+ private ImmutableSet<DataSchemaNode> childNodes;
+ private ImmutableSet<GroupingDefinition> groupings;
+ private ImmutableSet<TypeDefinition<?>> typeDefinitions;
+ private ImmutableSet<UsesNode> uses;
+ private ImmutableList<UnknownSchemaNode> unknownNodes;
private boolean userOrdered;
- private final List<UnknownSchemaNode> unknownNodes = new ArrayList<>();
private ListSchemaNodeImpl(final QName qname, final SchemaPath path) {
this.qname = qname;
return constraints;
}
- private void setConstraints(final ConstraintDefinition constraints) {
- this.constraints = constraints;
- }
-
@Override
public Set<AugmentationSchema> getAvailableAugmentations() {
- return Collections.unmodifiableSet(augmentations);
- }
-
- private void addAvailableAugmentations(final Set<AugmentationSchema> augmentations) {
- if (augmentations != null) {
- this.augmentations.addAll(augmentations);
- }
+ return augmentations;
}
@Override
public Set<DataSchemaNode> getChildNodes() {
- return Collections.unmodifiableSet(childNodes);
- }
-
- private void addChildNodes(final Set<DataSchemaNode> childNodes) {
- if (childNodes != null) {
- this.childNodes.addAll(childNodes);
- }
+ return childNodes;
}
@Override
public Set<GroupingDefinition> getGroupings() {
- return Collections.unmodifiableSet(groupings);
- }
-
- private void addGroupings(final Set<GroupingDefinition> groupings) {
- if (groupings != null) {
- this.groupings.addAll(groupings);
- }
+ return groupings;
}
@Override
public Set<TypeDefinition<?>> getTypeDefinitions() {
- return Collections.unmodifiableSet(typeDefinitions);
- }
-
- private void addTypeDefinitions(final Set<TypeDefinition<?>> typeDefinitions) {
- if (typeDefinitions != null) {
- this.typeDefinitions.addAll(typeDefinitions);
- }
+ return typeDefinitions;
}
@Override
public Set<UsesNode> getUses() {
- return Collections.unmodifiableSet(uses);
- }
-
- private void addUses(final Set<UsesNode> uses) {
- if (uses != null) {
- this.uses.addAll(uses);
- }
+ return uses;
}
@Override
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
- return Collections.unmodifiableList(unknownNodes);
- }
-
- private void addUnknownSchemaNodes(final List<UnknownSchemaNode> unknownNodes) {
- if (unknownNodes != null) {
- this.unknownNodes.addAll(unknownNodes);
- }
+ return unknownNodes;
}
@Override
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;
-import java.util.TreeSet;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
import org.opendaylight.yangtools.yang.parser.builder.api.SchemaNodeBuilder;
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;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+
public final class NotificationBuilder extends AbstractDataNodeContainerBuilder implements SchemaNodeBuilder,
AugmentationTargetBuilder {
- private boolean isBuilt;
- private final NotificationDefinitionImpl instance;
- private final SchemaPath schemaPath;
+ private NotificationDefinitionImpl instance;
+ // SchemaNode args
+ private SchemaPath schemaPath;
+ private String description;
+ private String reference;
+ private Status status = Status.CURRENT;
+ // AugmentationTarget args
+ private final List<AugmentationSchema> augmentations = new ArrayList<>();
private final List<AugmentationSchemaBuilder> augmentationBuilders = new ArrayList<>();
NotificationBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path) {
super(moduleName, line, qname);
this.schemaPath = path;
- instance = new NotificationDefinitionImpl(qname, path);
}
NotificationBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path, final NotificationDefinition base) {
super(moduleName, line, qname);
this.schemaPath = path;
- instance = new NotificationDefinitionImpl(qname, path);
- instance.description = base.getDescription();
- instance.reference = base.getReference();
- instance.status = base.getStatus();
- instance.augmentations.addAll(base.getAvailableAugmentations());
+ description = base.getDescription();
+ reference = base.getReference();
+ status = base.getStatus();
URI ns = qname.getNamespace();
Date rev = qname.getRevision();
String pref = qname.getPrefix();
addedChildNodes.addAll(ParserUtils.wrapChildNodes(moduleName, line, base.getChildNodes(), path, ns, rev, pref));
addedGroupings.addAll(ParserUtils.wrapGroupings(moduleName, line, base.getGroupings(), path, ns, rev, pref));
+ addedTypedefs.addAll(ParserUtils.wrapTypedefs(moduleName, line, base, path, ns, rev, pref));
+ addedUnknownNodes.addAll(ParserUtils.wrapUnknownNodes(moduleName, line, base.getUnknownSchemaNodes(), path, ns,
+ rev, pref));
- instance.groupings.addAll(base.getGroupings());
- instance.typeDefinitions.addAll(base.getTypeDefinitions());
- instance.uses.addAll(base.getUses());
- instance.unknownNodes.addAll(base.getUnknownSchemaNodes());
+ augmentations.addAll(base.getAvailableAugmentations());
+ usesNodes.addAll(base.getUses());
}
@Override
if (!(parentBuilder instanceof ModuleBuilder)) {
throw new YangParseException(moduleName, line, "Notification can be defined only under module (was " + parentBuilder + ")");
}
- if (!isBuilt) {
- // CHILD NODES
- for (DataSchemaNodeBuilder node : addedChildNodes) {
- childNodes.add(node.build());
- }
- instance.setChildNodes(childNodes);
+ if (instance != null) {
+ return instance;
+ }
- // GROUPINGS
- for (GroupingBuilder builder : addedGroupings) {
- groupings.add(builder.build());
- }
- instance.setGroupings(groupings);
+ instance = new NotificationDefinitionImpl(qname, schemaPath);
- // TYPEDEFS
- for (TypeDefinitionBuilder entry : addedTypedefs) {
- typedefs.add(entry.build());
- }
- instance.setTypeDefinitions(typedefs);
+ instance.description = description;
+ instance.reference = reference;
+ instance.status = status;
- // USES
- for (UsesNodeBuilder builder : addedUsesNodes) {
- usesNodes.add(builder.build());
- }
- instance.setUses(usesNodes);
+ // CHILD NODES
+ for (DataSchemaNodeBuilder node : addedChildNodes) {
+ childNodes.add(node.build());
+ }
+ instance.childNodes = ImmutableSet.copyOf(childNodes);
- // AUGMENTATIONS
- final Set<AugmentationSchema> augmentations = new HashSet<>();
- for (AugmentationSchemaBuilder builder : augmentationBuilders) {
- augmentations.add(builder.build());
- }
- instance.setAvailableAugmentations(augmentations);
+ // GROUPINGS
+ for (GroupingBuilder builder : addedGroupings) {
+ groupings.add(builder.build());
+ }
+ instance.groupings = ImmutableSet.copyOf(groupings);
- // UNKNOWN NODES
- for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
- unknownNodes.add(b.build());
- }
- Collections.sort(unknownNodes, Comparators.SCHEMA_NODE_COMP);
- instance.setUnknownSchemaNodes(unknownNodes);
+ // TYPEDEFS
+ for (TypeDefinitionBuilder entry : addedTypedefs) {
+ typedefs.add(entry.build());
+ }
+ instance.typeDefinitions = ImmutableSet.copyOf(typedefs);
+
+ // USES
+ for (UsesNodeBuilder builder : addedUsesNodes) {
+ usesNodes.add(builder.build());
+ }
+ instance.uses = ImmutableSet.copyOf(usesNodes);
+
+ // 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;
}
return schemaPath;
}
+ @Override
+ public void setPath(SchemaPath path) {
+ this.schemaPath = path;
+ }
+
@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(final Status status) {
- if (status != null) {
- instance.status = status;
- }
+ public void setStatus(Status status) {
+ this.status = Preconditions.checkNotNull(status, "status cannot be null");
}
@Override
private final SchemaPath path;
private String description;
private String reference;
- private Status status = Status.CURRENT;
- private final Set<DataSchemaNode> childNodes = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
- private final Set<GroupingDefinition> groupings = new HashSet<>();
- private final Set<TypeDefinition<?>> typeDefinitions = new HashSet<>();
- private final Set<UsesNode> uses = new HashSet<>();
- private final Set<AugmentationSchema> augmentations = new HashSet<>();
- private final List<UnknownSchemaNode> unknownNodes = new ArrayList<>();
+ private Status status;
+ private ImmutableSet<AugmentationSchema> augmentations;
+ private ImmutableSet<DataSchemaNode> childNodes;
+ private ImmutableSet<GroupingDefinition> groupings;
+ private ImmutableSet<TypeDefinition<?>> typeDefinitions;
+ private ImmutableSet<UsesNode> uses;
+ private ImmutableList<UnknownSchemaNode> unknownNodes;
private NotificationDefinitionImpl(final QName qname, final SchemaPath path) {
this.qname = qname;
@Override
public Set<DataSchemaNode> getChildNodes() {
- return Collections.unmodifiableSet(childNodes);
- }
-
- private void setChildNodes(final Set<DataSchemaNode> childNodes) {
- if (childNodes != null) {
- this.childNodes.addAll(childNodes);
- }
+ return childNodes;
}
@Override
public Set<GroupingDefinition> getGroupings() {
- return Collections.unmodifiableSet(groupings);
- }
-
- private void setGroupings(final Set<GroupingDefinition> groupings) {
- if (groupings != null) {
- this.groupings.addAll(groupings);
- }
+ return groupings;
}
@Override
public Set<UsesNode> getUses() {
- return Collections.unmodifiableSet(uses);
- }
-
- private void setUses(final Set<UsesNode> uses) {
- if (uses != null) {
- this.uses.addAll(uses);
- }
+ return uses;
}
@Override
public Set<TypeDefinition<?>> getTypeDefinitions() {
- return Collections.unmodifiableSet(typeDefinitions);
- }
-
- private void setTypeDefinitions(final Set<TypeDefinition<?>> typeDefinitions) {
- if (typeDefinitions != null) {
- this.typeDefinitions.addAll(typeDefinitions);
- }
+ return typeDefinitions;
}
@Override
public Set<AugmentationSchema> getAvailableAugmentations() {
- return Collections.unmodifiableSet(augmentations);
- }
-
- private void setAvailableAugmentations(final Set<AugmentationSchema> augmentations) {
- if (augmentations != null) {
- this.augmentations.addAll(augmentations);
- }
+ return augmentations;
}
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
- return Collections.unmodifiableList(unknownNodes);
- }
-
- private void setUnknownSchemaNodes(final List<UnknownSchemaNode> unknownNodes) {
- if (unknownNodes != null) {
- this.unknownNodes.addAll(unknownNodes);
- }
+ return unknownNodes;
}
@Override
*/
package org.opendaylight.yangtools.yang.parser.builder.impl;
-import java.util.ArrayList;
-import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
import org.opendaylight.yangtools.yang.parser.util.Comparators;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+
public final class RpcDefinitionBuilder extends AbstractSchemaNodeBuilder {
- private boolean isBuilt;
- private final RpcDefinitionImpl instance;
+ private RpcDefinitionImpl instance;
private ContainerSchemaNodeBuilder inputBuilder;
private ContainerSchemaNodeBuilder outputBuilder;
private final Set<TypeDefinitionBuilder> addedTypedefs = new HashSet<>();
RpcDefinitionBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path) {
super(moduleName, line, qname);
this.schemaPath = path;
- this.instance = new RpcDefinitionImpl(qname, path);
}
@Override
public RpcDefinition build() {
- if (!isBuilt) {
- final ContainerSchemaNode input = inputBuilder == null ? null : inputBuilder.build();
- final ContainerSchemaNode output = outputBuilder == null ? null : outputBuilder.build();
- instance.setInput(input);
- instance.setOutput(output);
-
- // TYPEDEFS
- final Set<TypeDefinition<?>> typedefs = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
- for (TypeDefinitionBuilder entry : addedTypedefs) {
- typedefs.add(entry.build());
- }
- instance.setTypeDefinitions(typedefs);
-
- // GROUPINGS
- final Set<GroupingDefinition> groupings = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
- for (GroupingBuilder entry : addedGroupings) {
- groupings.add(entry.build());
- }
- instance.setGroupings(groupings);
-
- // UNKNOWN NODES
- for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
- unknownNodes.add(b.build());
- }
- Collections.sort(unknownNodes, Comparators.SCHEMA_NODE_COMP);
- instance.setUnknownSchemaNodes(unknownNodes);
-
- isBuilt = true;
+ if (instance != null) {
+ return instance;
}
- return instance;
- }
- @Override
- public SchemaPath getPath() {
- return instance.path;
- }
+ instance = new RpcDefinitionImpl(qname, schemaPath);
- @Override
- public String getDescription() {
- return instance.description;
- }
+ final ContainerSchemaNode input = inputBuilder == null ? null : inputBuilder.build();
+ final ContainerSchemaNode output = outputBuilder == null ? null : outputBuilder.build();
+ instance.setInput(input);
+ instance.setOutput(output);
- @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;
- }
+ instance.status = status;
- @Override
- public Status getStatus() {
- return instance.status;
- }
+ // TYPEDEFS
+ final Set<TypeDefinition<?>> typedefs = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
+ for (TypeDefinitionBuilder entry : addedTypedefs) {
+ typedefs.add(entry.build());
+ }
+ instance.typeDefinitions = ImmutableSet.copyOf(typedefs);
- @Override
- public void setStatus(final Status status) {
- if (status != null) {
- instance.status = status;
+ // GROUPINGS
+ final Set<GroupingDefinition> groupings = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
+ for (GroupingBuilder builder : addedGroupings) {
+ groupings.add(builder.build());
+ }
+ instance.groupings = ImmutableSet.copyOf(groupings);
+
+ // UNKNOWN NODES
+ for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
+ unknownNodes.add(b.build());
}
+ instance.unknownNodes = ImmutableList.copyOf(unknownNodes);
+
+ return instance;
}
void setInput(final ContainerSchemaNodeBuilder inputBuilder) {
private Status status;
private ContainerSchemaNode input;
private ContainerSchemaNode output;
- private final Set<TypeDefinition<?>> typeDefinitions = new HashSet<>();
- private final Set<GroupingDefinition> groupings = new HashSet<>();
- private final List<UnknownSchemaNode> unknownNodes = new ArrayList<>();
+ private ImmutableSet<TypeDefinition<?>> typeDefinitions;
+ private ImmutableSet<GroupingDefinition> groupings;
+ private ImmutableList<UnknownSchemaNode> unknownNodes;
private RpcDefinitionImpl(final QName qname, final SchemaPath path) {
this.qname = qname;
@Override
public Set<TypeDefinition<?>> getTypeDefinitions() {
- return Collections.unmodifiableSet(typeDefinitions);
- }
-
- private void setTypeDefinitions(final Set<TypeDefinition<?>> typeDefinitions) {
- this.typeDefinitions.addAll(typeDefinitions);
+ return typeDefinitions;
}
@Override
public Set<GroupingDefinition> getGroupings() {
- return Collections.unmodifiableSet(groupings);
- }
-
- private void setGroupings(final Set<GroupingDefinition> groupings) {
- this.groupings.addAll(groupings);
+ return groupings;
}
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
- return Collections.unmodifiableList(unknownNodes);
- }
-
- private void setUnknownSchemaNodes(final List<UnknownSchemaNode> unknownNodes) {
- if (unknownNodes != null) {
- this.unknownNodes.addAll(unknownNodes);
- }
+ return unknownNodes;
}
@Override
import org.opendaylight.yangtools.yang.parser.util.YangParseException;
public final class TypeDefinitionBuilderImpl extends AbstractTypeAwareBuilder implements TypeDefinitionBuilder {
- private final SchemaPath schemaPath;
+ private SchemaPath schemaPath;
private List<RangeConstraint> ranges = Collections.emptyList();
private List<LengthConstraint> lengths = Collections.emptyList();
private List<PatternConstraint> patterns = Collections.emptyList();
return schemaPath;
}
+ @Override
+ public void setPath(SchemaPath path) {
+ this.schemaPath = path;
+ }
+
@Override
public String getDescription() {
return description;
return BaseTypes.schemaPath(QNAME);
}
+ @Override
+ public void setPath(SchemaPath path) {
+ throw new YangParseException(moduleName, line, "Can not set path to " + NAME);
+ }
+
@Override
public String getDescription() {
return null;
package org.opendaylight.yangtools.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 org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.SchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.util.Comparators;
import org.opendaylight.yangtools.yang.parser.util.RefineHolder;
import org.opendaylight.yangtools.yang.parser.util.YangParseException;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+
public final class UsesNodeBuilderImpl extends AbstractBuilder implements UsesNodeBuilder {
- private boolean isBuilt;
private UsesNodeImpl instance;
private DataNodeContainerBuilder parentBuilder;
private final String groupingPathString;
private boolean addedByUses;
private boolean augmenting;
private boolean resolved;
- private final Set<AugmentationSchemaBuilder> addedAugments = new HashSet<>();
+ private final Set<AugmentationSchemaBuilder> augmentationBuilders = new HashSet<>();
private final List<SchemaNodeBuilder> refineBuilders = new ArrayList<>();
private final List<RefineHolder> refines = new ArrayList<>();
-
public UsesNodeBuilderImpl(final String moduleName, final int line, final String groupingName) {
super(moduleName, line);
this.groupingPathString = groupingName;
@Override
public UsesNode build() {
- if (!isBuilt) {
- instance = new UsesNodeImpl(groupingPath);
- instance.setAddedByUses(addedByUses);
-
- // AUGMENTATIONS
- final Set<AugmentationSchema> augments = new HashSet<>();
- for (AugmentationSchemaBuilder builder : addedAugments) {
- augments.add(builder.build());
- }
- instance.setAugmentations(augments);
+ if (instance != null) {
+ return instance;
+ }
- // REFINES
- final Map<SchemaPath, SchemaNode> refineNodes = new HashMap<>();
- for (SchemaNodeBuilder refineBuilder : refineBuilders) {
- SchemaNode refineNode = refineBuilder.build();
- refineNodes.put(refineNode.getPath(), refineNode);
- }
- instance.setRefines(refineNodes);
+ instance = new UsesNodeImpl(groupingPath);
+ instance.setAddedByUses(addedByUses);
- // UNKNOWN NODES
- for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
- unknownNodes.add(b.build());
- }
- Collections.sort(unknownNodes, Comparators.SCHEMA_NODE_COMP);
- instance.addUnknownSchemaNodes(unknownNodes);
+ // AUGMENTATIONS
+ final Set<AugmentationSchema> augments = new HashSet<>();
+ for (AugmentationSchemaBuilder builder : augmentationBuilders) {
+ augments.add(builder.build());
+ }
+ instance.augmentations = ImmutableSet.copyOf(augments);
+
+ // REFINES
+ final Map<SchemaPath, SchemaNode> refineNodes = new HashMap<>();
+ for (SchemaNodeBuilder refineBuilder : refineBuilders) {
+ SchemaNode refineNode = refineBuilder.build();
+ refineNodes.put(refineNode.getPath(), refineNode);
+ }
+ instance.refines = ImmutableMap.copyOf(refineNodes);
- isBuilt = true;
+ // UNKNOWN NODES
+ for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
+ unknownNodes.add(b.build());
}
+ instance.unknownNodes = ImmutableList.copyOf(unknownNodes);
return instance;
}
@Override
public Set<AugmentationSchemaBuilder> getAugmentations() {
- return addedAugments;
+ return augmentationBuilders;
}
@Override
public void addAugment(final AugmentationSchemaBuilder augmentBuilder) {
- addedAugments.add(augmentBuilder);
+ augmentationBuilders.add(augmentBuilder);
}
@Override
public boolean isAddedByUses() {
return addedByUses;
}
+
@Override
public void setAddedByUses(final boolean addedByUses) {
this.addedByUses = addedByUses;
private static final class UsesNodeImpl implements UsesNode {
private final SchemaPath groupingPath;
- private Set<AugmentationSchema> augmentations = Collections.emptySet();
+ private ImmutableSet<AugmentationSchema> augmentations;
private boolean addedByUses;
- private Map<SchemaPath, SchemaNode> refines = Collections.emptyMap();
- private final List<UnknownSchemaNode> unknownNodes = new ArrayList<>();
+ private ImmutableMap<SchemaPath, SchemaNode> refines;
+ private ImmutableList<UnknownSchemaNode> unknownNodes;
private UsesNodeImpl(final SchemaPath groupingPath) {
this.groupingPath = groupingPath;
return augmentations;
}
- private void setAugmentations(final Set<AugmentationSchema> augmentations) {
- if (augmentations != null) {
- this.augmentations = augmentations;
- }
- }
-
@Override
public boolean isAugmenting() {
return false;
return refines;
}
- private void setRefines(final Map<SchemaPath, SchemaNode> refines) {
- if (refines != null) {
- this.refines = refines;
- }
- }
-
- private void addUnknownSchemaNodes(final List<UnknownSchemaNode> unknownSchemaNodes) {
- if (unknownSchemaNodes != null) {
- this.unknownNodes.addAll(unknownSchemaNodes);
- }
+ @SuppressWarnings("unused")
+ public List<UnknownSchemaNode> getUnknownSchemaNodes() {
+ return unknownNodes;
}
@Override
Code Review / yangtools.git / commitdiff