package org.opendaylight.yangtools.yang.parser.builder.api;
import java.util.List;
-
import org.opendaylight.yangtools.concepts.Mutable;
/**
package org.opendaylight.yangtools.yang.parser.builder.api;
import java.util.Set;
-
import org.opendaylight.yangtools.concepts.Builder;
import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition;
import org.opendaylight.yangtools.yang.model.api.MustDefinition;
package org.opendaylight.yangtools.yang.parser.builder.api;
import java.util.Set;
-
import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
/**
package org.opendaylight.yangtools.yang.parser.builder.api;
import java.util.List;
-
import org.opendaylight.yangtools.yang.model.api.MustDefinition;
/**
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.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint;
import java.util.List;
import java.util.Set;
-
import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.UsesNode;
*/
package org.opendaylight.yangtools.yang.parser.builder.impl;
+import com.google.common.collect.ImmutableList;
import java.util.List;
-
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition;
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.DataSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.ConstraintsBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.UnknownSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.util.AbstractSchemaNodeBuilder;
-import com.google.common.collect.ImmutableList;
-
public final class AnyXmlBuilder extends AbstractSchemaNodeBuilder implements DataSchemaNodeBuilder {
private AnyXmlSchemaNodeImpl instance;
public String toString() {
StringBuilder sb = new StringBuilder(AnyXmlSchemaNodeImpl.class.getSimpleName());
sb.append("[");
- sb.append("qname=" + qname);
- sb.append(", path=" + path);
+ sb.append("qname=").append(qname);
+ sb.append(", path=").append(path);
sb.append("]");
return sb.toString();
}
*/
package org.opendaylight.yangtools.yang.parser.builder.impl;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.base.Optional;
+import com.google.common.collect.ImmutableList;
import java.net.URI;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
-
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
import org.opendaylight.yangtools.yang.parser.builder.util.AbstractDocumentedDataNodeContainer;
import org.opendaylight.yangtools.yang.parser.builder.util.AbstractDocumentedDataNodeContainerBuilder;
-import com.google.common.base.Optional;
-import com.google.common.collect.ImmutableList;
-
public final class AugmentationSchemaBuilderImpl extends AbstractDocumentedDataNodeContainerBuilder implements
AugmentationSchemaBuilder {
private final int order;
} else if (!whenCondition.equals(other.whenCondition)) {
return false;
}
- if (other.getChildNodeBuilders() == null) {
- if (other.getChildNodeBuilders() != null) {
- return false;
- }
- } else if (!getChildNodeBuilders().equals(other.getChildNodeBuilders())) {
+ if (!getChildNodeBuilders().equals(other.getChildNodeBuilders())) {
return false;
}
return true;
int result = 1;
result = prime * result + ((targetPath == null) ? 0 : targetPath.hashCode());
result = prime * result + ((whenCondition == null) ? 0 : whenCondition.hashCode());
- result = getChildNodes().hashCode();
+ result = prime * result + getChildNodes().hashCode();
return result;
}
public String toString() {
StringBuilder sb = new StringBuilder(AugmentationSchemaImpl.class.getSimpleName());
sb.append("[");
- sb.append("targetPath=" + targetPath);
- sb.append(", when=" + whenCondition);
+ sb.append("targetPath=").append(targetPath);
+ sb.append(", when=").append(whenCondition);
sb.append("]");
return sb.toString();
}
@Override
public int compareTo(final AugmentationSchemaImpl o) {
+ checkNotNull(o);
Iterator<QName> thisIt = this.targetPath.getPathFromRoot().iterator();
Iterator<QName> otherIt = o.getTargetPath().getPathFromRoot().iterator();
while (thisIt.hasNext()) {
* prefix associated with import
* @return ModuleImport based on given prefix
*/
- public static ModuleImport getModuleImport(final ModuleBuilder builder, final String prefix) {
+ private static ModuleImport getModuleImport(final ModuleBuilder builder, final String prefix) {
for (ModuleImport mi : builder.getModuleImports()) {
if (mi.getPrefix().equals(prefix)) {
return mi;
*/
public static ModuleBuilder findModuleFromBuilders(final Map<String, TreeMap<Date, ModuleBuilder>> modules,
final ModuleBuilder module, final String prefix, final int line) {
- ModuleBuilder dependentModule = null;
- Date dependentModuleRevision = null;
+ ModuleBuilder dependentModule;
+ Date dependentModuleRevision;
if (prefix == null) {
dependentModule = module;
}
}
- Module result = null;
+ Module result;
if (dependentModuleRevision == null) {
result = modulesByRevision.get(modulesByRevision.firstKey());
} else {
public static SchemaPath parseXPathString(final String xpathString) {
final boolean absolute = xpathString.indexOf('/') == 0;
- final List<QName> path = new ArrayList<QName>();
+ final List<QName> path = new ArrayList<>();
for (String pathElement : SLASH_SPLITTER.split(xpathString)) {
if (pathElement.length() > 0) {
final Iterator<String> it = COLON_SPLITTER.split(pathElement).iterator();
* @param config
* new config value
*/
- public static void setNodeConfig(final DataSchemaNodeBuilder node, final Boolean config) {
+ private static void setNodeConfig(final DataSchemaNodeBuilder node, final Boolean config) {
if (node instanceof ContainerSchemaNodeBuilder || node instanceof LeafSchemaNodeBuilder
|| node instanceof LeafListSchemaNodeBuilder || node instanceof ListSchemaNodeBuilder
|| node instanceof ChoiceBuilder || node instanceof AnyXmlBuilder) {
while (!(parent instanceof ModuleBuilder)) {
parent = parent.getParent();
}
- Preconditions.checkState(parent instanceof ModuleBuilder);
ModuleBuilder parentModule = (ModuleBuilder) parent;
if (parentModule.isSubmodule()) {
parentModule = parentModule.getParent();
*/
package org.opendaylight.yangtools.yang.parser.builder.impl;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
import java.net.URI;
import java.util.ArrayList;
import java.util.Date;
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.model.api.ChoiceCaseNode;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationTargetBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.ConstraintsBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.UnknownSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.util.AbstractSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.util.Comparators;
import org.opendaylight.yangtools.yang.parser.util.YangParseException;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableSet;
-
public final class ChoiceBuilder extends AbstractSchemaNodeBuilder implements DataSchemaNodeBuilder,
AugmentationTargetBuilder {
private ChoiceNodeImpl instance;
public String toString() {
StringBuilder sb = new StringBuilder(ChoiceNodeImpl.class.getSimpleName());
sb.append("[");
- sb.append("qname=" + qname);
+ sb.append("qname=").append(qname);
sb.append("]");
return sb.toString();
}
*/
package org.opendaylight.yangtools.yang.parser.builder.impl;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
import java.net.URI;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Set;
-
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
import org.opendaylight.yangtools.yang.parser.builder.util.AbstractDocumentedDataNodeContainerBuilder;
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 AbstractDocumentedDataNodeContainerBuilder implements DataSchemaNodeBuilder,
AugmentationTargetBuilder {
private ChoiceCaseNodeImpl instance;
*/
package org.opendaylight.yangtools.yang.parser.builder.impl;
+import com.google.common.collect.ImmutableSet;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
-
import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition;
import org.opendaylight.yangtools.yang.model.api.MustDefinition;
import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath;
import org.opendaylight.yangtools.yang.model.util.RevisionAwareXPathImpl;
import org.opendaylight.yangtools.yang.parser.builder.api.ConstraintsBuilder;
-import com.google.common.collect.ImmutableSet;
-
public final class ConstraintsBuilderImpl implements ConstraintsBuilder {
private static final ConstraintDefinitionImpl EMPTY_CONSTRAINT = new ConstraintDefinitionImpl();
private static final ConstraintDefinitionImpl EMPTY_MANDATORY_CONSTRAINT;
public ConstraintsBuilderImpl(final String moduleName, final int line) {
this.moduleName = moduleName;
this.line = line;
- mustDefinitions = new HashSet<MustDefinition>();
+ mustDefinitions = new HashSet<>();
}
ConstraintsBuilderImpl(final ConstraintsBuilder b) {
this.moduleName = b.getModuleName();
this.line = b.getLine();
- mustDefinitions = new HashSet<MustDefinition>(b.getMustDefinitions());
+ mustDefinitions = new HashSet<>(b.getMustDefinitions());
whenCondition = b.getWhenCondition();
mandatory = b.isMandatory();
min = b.getMinElements();
this.moduleName = moduleName;
this.line = line;
whenStmt = base.getWhenCondition();
- mustDefinitions = new HashSet<MustDefinition>(base.getMustConstraints());
+ mustDefinitions = new HashSet<>(base.getMustConstraints());
mandatory = base.isMandatory();
min = base.getMinElements();
max = base.getMaxElements();
public String toString() {
StringBuilder sb = new StringBuilder(ConstraintDefinitionImpl.class.getSimpleName());
sb.append("[");
- sb.append("whenCondition=" + whenCondition);
- sb.append(", mustConstraints=" + mustConstraints);
- sb.append(", mandatory=" + mandatory);
- sb.append(", minElements=" + minElements);
- sb.append(", maxElements=" + maxElements);
+ sb.append("whenCondition=").append(whenCondition);
+ sb.append(", mustConstraints=").append(mustConstraints);
+ sb.append(", mandatory=").append(mandatory);
+ sb.append(", minElements=").append(minElements);
+ sb.append(", maxElements=").append(maxElements);
sb.append("]");
return sb.toString();
}
*/
package org.opendaylight.yangtools.yang.parser.builder.impl;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
-
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition;
import org.opendaylight.yangtools.yang.parser.builder.util.AbstractDocumentedDataNodeContainer;
import org.opendaylight.yangtools.yang.parser.builder.util.AbstractDocumentedDataNodeContainerBuilder;
-import com.google.common.base.Preconditions;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableSet;
-
public final class ContainerSchemaNodeBuilder extends AbstractDocumentedDataNodeContainerBuilder implements
AugmentationTargetBuilder, DataSchemaNodeBuilder {
private ContainerSchemaNodeImpl instance;
package org.opendaylight.yangtools.yang.parser.builder.impl;
import java.util.ArrayList;
-
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
return copy;
}
- public static LeafListSchemaNodeBuilder copy(final LeafListSchemaNodeBuilder old, final Builder newParent, final boolean updateQName) {
+ private static LeafListSchemaNodeBuilder copy(final LeafListSchemaNodeBuilder old, final Builder newParent, final boolean updateQName) {
DataBean data = getdata(old, newParent, updateQName);
QName newQName = data.qname;
SchemaPath newSchemaPath = data.schemaPath;
*/
package org.opendaylight.yangtools.yang.parser.builder.impl;
+import com.google.common.collect.ImmutableList;
import java.util.List;
-
import org.opendaylight.yangtools.yang.model.api.Deviation;
import org.opendaylight.yangtools.yang.model.api.Deviation.Deviate;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.parser.builder.util.AbstractBuilder;
import org.opendaylight.yangtools.yang.parser.util.YangParseException;
-import com.google.common.collect.ImmutableList;
-
public final class DeviationBuilder extends AbstractBuilder {
private DeviationImpl instance;
private final String targetPathStr;
public String toString() {
StringBuilder sb = new StringBuilder(DeviationImpl.class.getSimpleName());
sb.append("[");
- sb.append("targetPath=" + targetPath);
- sb.append(", deviate=" + deviate);
- sb.append(", reference=" + reference);
+ sb.append("targetPath=").append(targetPath);
+ sb.append(", deviate=").append(deviate);
+ sb.append(", reference=").append(reference);
sb.append("]");
return sb.toString();
}
*/
package org.opendaylight.yangtools.yang.parser.builder.impl;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
import java.util.List;
-
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.parser.builder.api.UnknownSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.util.AbstractSchemaNodeBuilder;
-import com.google.common.base.Preconditions;
-import com.google.common.collect.ImmutableList;
-
public final class ExtensionBuilderImpl extends AbstractSchemaNodeBuilder implements ExtensionBuilder {
private ExtensionDefinitionImpl instance;
private String argument;
public String toString() {
StringBuilder sb = new StringBuilder(ExtensionDefinitionImpl.class.getSimpleName());
sb.append("[");
- sb.append("argument=" + argument);
- sb.append(", qname=" + qname);
- sb.append(", schemaPath=" + schemaPath);
- sb.append(", extensionSchemaNodes=" + unknownNodes);
- sb.append(", yin=" + yin);
+ sb.append("argument=").append(argument);
+ sb.append(", qname=").append(qname);
+ sb.append(", schemaPath=").append(schemaPath);
+ sb.append(", extensionSchemaNodes=").append(unknownNodes);
+ sb.append(", yin=").append(yin);
sb.append("]");
return sb.toString();
}
*/
package org.opendaylight.yangtools.yang.parser.builder.impl;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
import java.util.List;
-
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.FeatureDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.parser.builder.api.UnknownSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.util.AbstractSchemaNodeBuilder;
-import com.google.common.base.Preconditions;
-import com.google.common.collect.ImmutableList;
-
public final class FeatureBuilder extends AbstractSchemaNodeBuilder {
private FeatureDefinitionImpl instance;
@Override
public String toString() {
StringBuilder sb = new StringBuilder(FeatureDefinitionImpl.class.getSimpleName());
- sb.append("[name=" + qname + "]");
+ sb.append("[name=").append(qname).append("]");
return sb.toString();
}
}
*/
package org.opendaylight.yangtools.yang.parser.builder.impl;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
import java.net.URI;
import java.util.Date;
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.GroupingDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.parser.builder.util.AbstractDocumentedDataNodeContainer;
import org.opendaylight.yangtools.yang.parser.builder.util.AbstractDocumentedDataNodeContainerBuilder;
-import com.google.common.base.Preconditions;
-import com.google.common.collect.ImmutableList;
-
public final class GroupingBuilderImpl extends AbstractDocumentedDataNodeContainerBuilder implements GroupingBuilder {
private GroupingDefinitionImpl instance;
// SchemaNode args
public String toString() {
StringBuilder sb = new StringBuilder(GroupingDefinitionImpl.class.getSimpleName());
sb.append("[");
- sb.append("qname=" + qname);
+ sb.append("qname=").append(qname);
sb.append("]");
return sb.toString();
}
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
-
import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
}
ModuleBuilder dependentModule;
+
if(groupingPrefix == null) {
dependentModule = module;
- }
- if (groupingPrefix.equals(module.getPrefix())) {
+ } else if (groupingPrefix.equals(module.getPrefix())) {
dependentModule = module;
} else {
dependentModule = BuilderUtils.findModuleFromBuilders(modules, module, groupingPrefix, line);
* name of grouping
* @return grouping with given name if present in collection, null otherwise
*/
- public static GroupingBuilder findGroupingBuilder(final Set<GroupingBuilder> groupings, final String name) {
+ private static GroupingBuilder findGroupingBuilder(final Set<GroupingBuilder> groupings, final String name) {
for (GroupingBuilder grouping : groupings) {
if (grouping.getQName().getLocalName().equals(name)) {
return grouping;
* name of grouping
* @return grouping with given name if present in collection, null otherwise
*/
- public static GroupingDefinition findGroupingDefinition(final Set<GroupingDefinition> groupings, final String name) {
+ private static GroupingDefinition findGroupingDefinition(final Set<GroupingDefinition> groupings, final String name) {
for (GroupingDefinition grouping : groupings) {
if (grouping.getQName().getLocalName().equals(name)) {
return grouping;
*/
package org.opendaylight.yangtools.yang.parser.builder.impl;
+import com.google.common.base.Preconditions;
+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.IdentitySchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.parser.builder.api.UnknownSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.util.AbstractSchemaNodeBuilder;
-import com.google.common.base.Preconditions;
-import com.google.common.collect.ImmutableList;
-
public final class IdentitySchemaNodeBuilder extends AbstractSchemaNodeBuilder {
private IdentitySchemaNodeImpl instance;
private IdentitySchemaNode baseIdentity;
this.baseIdentityBuilder = baseType;
}
- public void addDerivedIdentity(final IdentitySchemaNode derivedIdentity) {
+ void addDerivedIdentity(final IdentitySchemaNode derivedIdentity) {
if (derivedIdentity != null) {
derivedIdentities.add(derivedIdentity);
}
public String toString() {
StringBuilder sb = new StringBuilder(IdentitySchemaNodeImpl.class.getSimpleName());
sb.append("[");
- sb.append("base=" + baseIdentity);
- sb.append(", qname=" + qname);
+ sb.append("base=").append(baseIdentity);
+ sb.append(", qname=").append(qname);
sb.append("]");
return sb.toString();
}
*/
package org.opendaylight.yangtools.yang.parser.builder.impl;
+import com.google.common.base.Preconditions;
import java.util.Collections;
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.Status;
import org.opendaylight.yangtools.yang.parser.builder.util.AbstractTypeAwareBuilder;
import org.opendaylight.yangtools.yang.parser.util.YangParseException;
-import com.google.common.base.Preconditions;
-
/**
* Builder for YANG identityref type.
*/
*/
package org.opendaylight.yangtools.yang.parser.builder.impl;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
import java.util.List;
-
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition;
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
import org.opendaylight.yangtools.yang.parser.builder.api.UnknownSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.util.AbstractTypeAwareBuilder;
-import com.google.common.base.Preconditions;
-import com.google.common.collect.ImmutableList;
-
public final class LeafListSchemaNodeBuilder extends AbstractTypeAwareBuilder implements DataSchemaNodeBuilder {
private LeafListSchemaNodeImpl instance;
private boolean userOrdered;
*/
package org.opendaylight.yangtools.yang.parser.builder.impl;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
import java.util.List;
-
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.parser.builder.util.AbstractTypeAwareBuilder;
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 LeafSchemaNodeImpl instance;
private String defaultStr;
public String toString() {
StringBuilder sb = new StringBuilder(LeafSchemaNodeImpl.class.getSimpleName());
sb.append("[");
- sb.append("qname=" + qname);
- sb.append(", path=" + path);
+ sb.append("qname=").append(qname);
+ sb.append(", path=").append(path);
sb.append("]");
return sb.toString();
}
*/
package org.opendaylight.yangtools.yang.parser.builder.impl;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
import java.net.URI;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Set;
-
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition;
import org.opendaylight.yangtools.yang.parser.builder.util.AbstractDocumentedDataNodeContainer;
import org.opendaylight.yangtools.yang.parser.builder.util.AbstractDocumentedDataNodeContainerBuilder;
-import com.google.common.base.Preconditions;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableSet;
-
public final class ListSchemaNodeBuilder extends AbstractDocumentedDataNodeContainerBuilder implements DataSchemaNodeBuilder,
AugmentationTargetBuilder {
private ListSchemaNodeImpl instance;
import java.io.InputStream;
import java.net.URI;
import java.util.ArrayList;
-import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.Deque;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;
-
import org.apache.commons.io.IOUtils;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
private final Deque<Builder> actualPath = new LinkedList<>();
private final Set<TypeAwareBuilder> dirtyNodes = new HashSet<>();
- final Set<ModuleImport> imports = new HashSet<ModuleImport>();
+ final Set<ModuleImport> imports = new HashSet<>();
private final Set<AugmentationSchema> augments = new LinkedHashSet<>();
private final List<AugmentationSchemaBuilder> augmentBuilders = new ArrayList<>();
addedUnknownNodes.add(builder);
} else {
if (parent instanceof SchemaNodeBuilder) {
- ((SchemaNodeBuilder) parent).addUnknownNodeBuilder(builder);
+ parent.addUnknownNodeBuilder(builder);
} else if (parent instanceof DataNodeContainerBuilder) {
- ((DataNodeContainerBuilder) parent).addUnknownNodeBuilder(builder);
+ parent.addUnknownNodeBuilder(builder);
} else if (parent instanceof RefineHolderImpl) {
- ((RefineHolderImpl) parent).addUnknownNodeBuilder(builder);
+ parent.addUnknownNodeBuilder(builder);
} else {
throw new YangParseException(name, line, "Unresolved parent of unknown node '" + qname.getLocalName()
+ "'");
}
private ModuleImport createModuleImport(final String moduleName, final Date revision, final String prefix) {
- final ModuleImport moduleImport = new ModuleImportImpl(moduleName, revision, prefix);
- return moduleImport;
+ return new ModuleImportImpl(moduleName, revision, prefix);
}
private void raiseYangParserException(final String cantAddType, final String type, final String name,
package org.opendaylight.yangtools.yang.parser.builder.impl;
-import com.google.common.base.Optional;
-import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier;
+import static com.google.common.base.Preconditions.checkNotNull;
+import com.google.common.base.Optional;
import java.net.URI;
import java.util.Date;
-
-import static com.google.common.base.Preconditions.checkNotNull;
+import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier;
/**
* ModuleIdentifier that can be used for indexing/searching by name.
super(builder);
this.name = checkNotNull(name, "Missing name");
this.sourcePath = sourcePath; //TODO: can this be nullable?
- this.imports = ImmutableSet.<ModuleImport> copyOf(builder.imports);
+ this.imports = ImmutableSet.copyOf(builder.imports);
this.namespace = builder.getNamespace();
this.prefix = builder.getPrefix();
this.revision = builder.getRevision() == null ? Optional.<Date>absent():
public String toString() {
StringBuilder sb = new StringBuilder(ModuleImpl.class.getSimpleName());
sb.append("[");
- sb.append("name=" + name);
- sb.append(", namespace=" + namespace);
- sb.append(", revision=" + revision);
- sb.append(", prefix=" + prefix);
- sb.append(", yangVersion=" + yangVersion);
+ sb.append("name=").append(name);
+ sb.append(", namespace=").append(namespace);
+ sb.append(", revision=").append(revision);
+ sb.append(", prefix=").append(prefix);
+ sb.append(", yangVersion=").append(yangVersion);
sb.append("]");
return sb.toString();
}
*/
package org.opendaylight.yangtools.yang.parser.builder.impl;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
import java.net.URI;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Set;
-
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
import org.opendaylight.yangtools.yang.parser.builder.util.AbstractDocumentedDataNodeContainerBuilder;
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 AbstractDocumentedDataNodeContainerBuilder implements SchemaNodeBuilder,
AugmentationTargetBuilder {
private NotificationDefinitionImpl instance;
@Override
public String toString() {
StringBuilder sb = new StringBuilder(NotificationDefinitionImpl.class.getSimpleName());
- sb.append("[qname=" + qname + ", path=" + path + "]");
+ sb.append("[qname=").append(qname).append(", path=").append(path).append("]");
return sb.toString();
}
}
package org.opendaylight.yangtools.yang.parser.builder.impl;
import java.util.List;
-
import org.opendaylight.yangtools.yang.model.api.MustDefinition;
import org.opendaylight.yangtools.yang.parser.builder.api.Builder;
import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
private RefineUtils() {
}
- public static void refineLeaf(final LeafSchemaNodeBuilder leaf, final RefineBuilder refine) {
+ private static void refineLeaf(final LeafSchemaNodeBuilder leaf, final RefineBuilder refine) {
String defaultStr = refine.getDefaultStr();
Boolean mandatory = refine.isMandatory();
MustDefinition must = refine.getMust();
}
}
- public static void refineContainer(final ContainerSchemaNodeBuilder container, final RefineBuilder refine) {
+ private static void refineContainer(final ContainerSchemaNodeBuilder container, final RefineBuilder refine) {
Boolean presence = refine.isPresence();
MustDefinition must = refine.getMust();
List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodes();
}
}
- public static void refineList(final ListSchemaNodeBuilder list, final RefineBuilder refine) {
+ private static void refineList(final ListSchemaNodeBuilder list, final RefineBuilder refine) {
MustDefinition must = refine.getMust();
Integer min = refine.getMinElements();
Integer max = refine.getMaxElements();
private static void refineDefault(final Builder node, final RefineBuilder refine) {
final String moduleName = refine.getModuleName();
final int line = refine.getLine();
- Class<? extends Builder> cls = node.getClass();
final DocumentedNodeBuilder documentedNode;
*/
package org.opendaylight.yangtools.yang.parser.builder.impl;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
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.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
import org.opendaylight.yangtools.yang.parser.builder.util.AbstractSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.util.Comparators;
-import com.google.common.base.Preconditions;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableSet;
-
public final class RpcDefinitionBuilder extends AbstractSchemaNodeBuilder {
private RpcDefinitionImpl instance;
private ContainerSchemaNodeBuilder inputBuilder;
*/
package org.opendaylight.yangtools.yang.parser.builder.impl;
+import com.google.common.base.Preconditions;
import java.util.Collections;
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.Status;
import org.opendaylight.yangtools.yang.parser.builder.util.Comparators;
import org.opendaylight.yangtools.yang.parser.util.YangParseException;
-import com.google.common.base.Preconditions;
-
public final class TypeDefinitionBuilderImpl extends AbstractTypeAwareBuilder implements TypeDefinitionBuilder {
private SchemaPath schemaPath;
private List<RangeConstraint> ranges = Collections.emptyList();
this.units = base.getUnits();
this.defaultValue = base.getDefaultValue();
- ExtendedType ext = base;
- this.addedByUses = ext.isAddedByUses();
- this.ranges = ext.getRangeConstraints();
- this.lengths = ext.getLengthConstraints();
- this.patterns = ext.getPatternConstraints();
- this.fractionDigits = ext.getFractionDigits();
+ this.addedByUses = base.isAddedByUses();
+ this.ranges = base.getRangeConstraints();
+ this.lengths = base.getLengthConstraints();
+ this.patterns = base.getPatternConstraints();
+ this.fractionDigits = base.getFractionDigits();
this.unknownNodes.addAll(base.getUnknownSchemaNodes());
}
@Override
public TypeDefinition<? extends TypeDefinition<?>> build() {
- TypeDefinition<?> result = null;
- ExtendedType.Builder typeBuilder = null;
+ TypeDefinition<?> result;
+ ExtendedType.Builder typeBuilder;
if ((type == null || type instanceof UnknownType) && typedef == null) {
throw new YangParseException("Unresolved type: '" + qname.getLocalName() + "'.");
}
import static org.opendaylight.yangtools.yang.parser.builder.impl.BuilderUtils.findModuleFromBuilders;
import static org.opendaylight.yangtools.yang.parser.builder.impl.BuilderUtils.findModuleFromContext;
-import java.util.*;
-
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.*;
-import org.opendaylight.yangtools.yang.model.api.type.*;
+import org.opendaylight.yangtools.yang.model.api.Module;
+import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.type.BinaryTypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.type.DecimalTypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.type.IntegerTypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.type.StringTypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.type.UnsignedIntegerTypeDefinition;
import org.opendaylight.yangtools.yang.model.util.ExtendedType;
import org.opendaylight.yangtools.yang.model.util.UnknownType;
-import org.opendaylight.yangtools.yang.parser.builder.api.*;
-import org.opendaylight.yangtools.yang.parser.builder.impl.*;
+import org.opendaylight.yangtools.yang.parser.builder.api.Builder;
+import org.opendaylight.yangtools.yang.parser.builder.api.DataNodeContainerBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.TypeAwareBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
import org.opendaylight.yangtools.yang.parser.util.TypeConstraints;
import org.opendaylight.yangtools.yang.parser.util.YangParseException;
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.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
public UnionTypeBuilder(final String moduleName, final int line) {
super(moduleName, line, BaseTypes.constructQName(NAME));
- types = new ArrayList<TypeDefinition<?>>();
- typedefs = new ArrayList<TypeDefinitionBuilder>();
+ types = new ArrayList<>();
+ typedefs = new ArrayList<>();
}
public List<TypeDefinition<?>> getTypes() {
*/
package org.opendaylight.yangtools.yang.parser.builder.impl;
+import com.google.common.base.Preconditions;
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.ExtensionDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.parser.builder.util.AbstractSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.util.Comparators;
-import com.google.common.base.Preconditions;
-
public final class UnknownSchemaNodeBuilderImpl extends AbstractSchemaNodeBuilder implements UnknownSchemaNodeBuilder {
private boolean isBuilt;
private final UnknownSchemaNodeImpl instance;
*/
package org.opendaylight.yangtools.yang.parser.builder.impl;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
-
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.parser.builder.util.AbstractBuilder;
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 UsesNodeImpl instance;
private DataNodeContainerBuilder parentBuilder;
*/
package org.opendaylight.yangtools.yang.parser.builder.util;
+import com.google.common.base.Preconditions;
import java.util.ArrayList;
import java.util.List;
-
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.parser.builder.api.Builder;
import org.opendaylight.yangtools.yang.parser.builder.api.UnknownSchemaNodeBuilder;
-import com.google.common.base.Preconditions;
-
/**
* Base helper implementation of Builders for Yang Model elements.
*
private Builder parentBuilder;
protected final List<UnknownSchemaNode> unknownNodes = new ArrayList<>();
- protected final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
+ protected final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<>();
private boolean sealed;
protected AbstractBuilder(final String moduleName, final int line) {
addedUnknownNodes.add(unknownNode);
}
- protected void seal() {
+ void seal() {
checkNotSealed();
sealed = true;
}
Preconditions.checkState(!sealed, "Builder is sealed. No further modifications allowed");
}
- protected boolean isSealed() {
+ boolean isSealed() {
return sealed;
}
public abstract class AbstractDocumentedDataNodeContainer extends AbstractDocumentedNode implements DataNodeContainer {
- protected final Map<QName, DataSchemaNode> childNodes;
+ private final Map<QName, DataSchemaNode> childNodes;
private final Set<GroupingDefinition> groupings;
private final Set<UsesNode> uses;
private final Set<TypeDefinition<?>> typeDefinitions;
public abstract class AbstractDocumentedDataNodeContainerBuilder extends AbstractDocumentedNodeBuilder implements DataNodeContainerBuilder {
protected final QName qname;
- protected final Map<QName, DataSchemaNode> childNodes = new TreeMap<>();
+ private final Map<QName, DataSchemaNode> childNodes = new TreeMap<>();
private final Set<DataSchemaNodeBuilder> addedChildNodes = new HashSet<>();
private final Set<GroupingDefinition> groupings = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
this.qname = qname;
}
- public AbstractDocumentedDataNodeContainerBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path, final DataNodeContainer base) {
+ protected AbstractDocumentedDataNodeContainerBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path, final DataNodeContainer base) {
super(moduleName, line);
this.qname = qname;
package org.opendaylight.yangtools.yang.parser.builder.util;
+import com.google.common.base.Preconditions;
import org.opendaylight.yangtools.yang.model.api.DocumentedNode;
import org.opendaylight.yangtools.yang.model.api.Status;
-import com.google.common.base.Preconditions;
-
public abstract class AbstractDocumentedNode implements DocumentedNode {
private final String description;
private final String reference;
private final Status status;
- protected AbstractDocumentedNode(final AbstractDocumentedNodeBuilder builder) {
+ AbstractDocumentedNode(final AbstractDocumentedNodeBuilder builder) {
Preconditions.checkArgument(builder.isSealed(), "Builder must be sealed.");
this.description = builder.getDescription();
this.reference = builder.getReference();
*/
package org.opendaylight.yangtools.yang.parser.builder.util;
+import com.google.common.base.Preconditions;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.parser.builder.api.SchemaNodeBuilder;
-import com.google.common.base.Preconditions;
-
/**
* Basic implementation of SchemaNodeBuilder.
*/
protected TypeDefinition<?> type;
protected TypeDefinitionBuilder typedef;
- public AbstractTypeAwareBuilder(final String moduleName, final int line, final QName qname) {
+ protected AbstractTypeAwareBuilder(final String moduleName, final int line, final QName qname) {
super(moduleName, line);
this.qname = qname;
}
package org.opendaylight.yangtools.yang.parser.builder.util;
import java.util.Comparator;
-
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
*/
package org.opendaylight.yangtools.yang.parser.impl;
+import static java.lang.String.format;
+
+import com.google.common.collect.Sets;
import java.text.ParseException;
import java.util.Date;
import java.util.List;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
-
import org.antlr.v4.runtime.ParserRuleContext;
import org.antlr.v4.runtime.tree.ParseTree;
import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Yang_version_stmtContext;
import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
import org.opendaylight.yangtools.yang.parser.util.YangValidationException;
-import com.google.common.collect.Sets;
-
/**
* Reusable checks of basic constraints on yang statements
*/
* Check if only one module or submodule is present in session(one yang
* file)
*/
- static void checkOnlyOneModulePresent(final String moduleName, final String globalId) {
+ static void checkIsModuleIdNull(final String globalId) {
if (globalId != null) {
ValidationUtil.ex(ValidationUtil.f("Multiple (sub)modules per file"));
}
}
}
- private static Pattern prefixedIdentifierPattern = Pattern.compile("(.+):(.+)");
+ private static final Pattern prefixedIdentifierPattern = Pattern.compile("(.+):(.+)");
static void checkPrefixedIdentifier(final ParseTree statement) {
checkPrefixedIdentifierInternal(statement, ValidationUtil.getName(statement));
String getMessage();
}
- static void checkPresentChildOfTypeInternal(final ParseTree parent, final Set<Class<? extends ParseTree>> expectedChildType,
- final MessageProvider message, final boolean atMostOne) {
+ private static void checkPresentChildOfTypeInternal(final ParseTree parent, final Set<Class<? extends ParseTree>> expectedChildType,
+ final MessageProvider message, final boolean atMostOne) {
if (!checkPresentChildOfTypeSafe(parent, expectedChildType, atMostOne)) {
String str = atMostOne ? "(Expected exactly one statement) " + message.getMessage() : message.getMessage();
ValidationUtil.ex(str);
final boolean atMostOne) {
// Construct message in checkPresentChildOfTypeInternal only if
- // validaiton fails, not in advance
+ // validation fails, not in advance
MessageProvider message = new MessageProvider() {
@Override
ValidationUtil.getSimpleStatementName(parent.getClass()), ValidationUtil.getName(parent));
String root = ValidationUtil.getRootParentName(parent);
- message = parent.equals(ValidationUtil.getRootParentName(parent)) ? message : ValidationUtil.f(
- "(In (sub)module:%s) %s", root, message);
+ message = format("(In (sub)module:%s) %s", root, message);
return message;
}
};
ValidationUtil.getSimpleStatementName(parent.getClass()), ValidationUtil.getName(parent));
String root = ValidationUtil.getRootParentName(parent);
- message = parent.equals(ValidationUtil.getRootParentName(parent)) ? message : ValidationUtil.f(
- "(In (sub)module:%s) %s", root, message);
+ message = format("(In (sub)module:%s) %s", root, message);
return message;
}
- };
+ }
static void checkPresentChildOfTypes(final ParseTree parent,
final Set<Class<? extends ParseTree>> expectedChildTypes, final boolean atMostOne) {
// Construct message in checkPresentChildOfTypeInternal only if
- // validaiton fails, not in advance
+ // validation fails, not in advance
MessageProvider message = new MessageProviderForSetOfChildTypes(expectedChildTypes, parent);
checkPresentChildOfTypeInternal(parent, expectedChildTypes, message, atMostOne);
}
- static boolean checkPresentChildOfTypeSafe(final ParseTree parent, final Set<Class<? extends ParseTree>> expectedChildType,
- final boolean atMostOne) {
+ private static boolean checkPresentChildOfTypeSafe(final ParseTree parent, final Set<Class<? extends ParseTree>> expectedChildType,
+ final boolean atMostOne) {
int foundChildrenOfType = ValidationUtil.countPresentChildrenOfType(parent, expectedChildType);
- return atMostOne ? foundChildrenOfType == 1 ? true : false : foundChildrenOfType != 0 ? true : false;
+ return atMostOne ? foundChildrenOfType == 1 : foundChildrenOfType != 0;
}
- static boolean checkPresentChildOfTypeSafe(final ParseTree parent, final Class<? extends ParseTree> expectedChildType,
- final boolean atMostOne) {
+ private static boolean checkPresentChildOfTypeSafe(final ParseTree parent, final Class<? extends ParseTree> expectedChildType,
+ final boolean atMostOne) {
int foundChildrenOfType = ValidationUtil.countPresentChildrenOfType(parent, expectedChildType);
- return atMostOne ? foundChildrenOfType == 1 ? true : false : foundChildrenOfType != 0 ? true : false;
+ return atMostOne ? foundChildrenOfType == 1 : foundChildrenOfType != 0;
}
static List<String> getAndCheckUniqueKeys(final ParseTree ctx) {
*/
package org.opendaylight.yangtools.yang.parser.impl;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
-
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.DataNodeContainerBuilder;
import org.opendaylight.yangtools.yang.parser.util.TopologicalSort;
import org.opendaylight.yangtools.yang.parser.util.TopologicalSort.Node;
-import com.google.common.collect.Maps;
-import com.google.common.collect.Sets;
-
public final class GroupingSort {
private GroupingSort() {
throw new UnsupportedOperationException("Utility class should not be instantiated");
throw new IllegalArgumentException("Set of Type Definitions " + "cannot be NULL!");
}
- final List<GroupingBuilder> resultGroupingDefinitions = new ArrayList<GroupingBuilder>();
+ final List<GroupingBuilder> resultGroupingDefinitions = new ArrayList<>();
final Set<Node> unsorted = groupingDefinitionsToNodes(groupingDefinitions);
final List<Node> sortedNodes = TopologicalSort.sort(unsorted);
for (Node node : sortedNodes) {
import static com.google.common.base.Preconditions.checkState;
+import com.google.common.base.Optional;
import java.math.BigDecimal;
import java.net.URI;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Stack;
-
import org.antlr.v4.runtime.ParserRuleContext;
import org.antlr.v4.runtime.tree.ParseTree;
import org.antlr.v4.runtime.tree.TerminalNode;
import org.opendaylight.yangtools.yang.model.util.Uint8;
import org.opendaylight.yangtools.yang.model.util.UnknownType;
import org.opendaylight.yangtools.yang.parser.builder.api.Builder;
-import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.ConstraintsBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.RefineBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.SchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-
public final class ParserListenerUtils {
private static final Logger LOG = LoggerFactory.getLogger(ParserListenerUtils.class);
return result;
}
- public static String stringFromStringContext(final StringContext context) {
+ private static String stringFromStringContext(final StringContext context) {
StringBuilder str = new StringBuilder();
for (TerminalNode stringNode : context.STRING()) {
String result = stringNode.getText();
while (current != null && !(current instanceof Module_stmtContext)) {
current = current.getParent();
}
- if (current instanceof Module_stmtContext) {
+ if (current != null) {
Module_stmtContext module = (Module_stmtContext) current;
for (int i = 0; i < module.getChildCount(); i++) {
if (module.getChild(i) instanceof StringContext) {
private static boolean getParentConfig(final Builder node) {
Builder parent = node.getParent();
- boolean config = false;
+ boolean config;
if (parent instanceof ChoiceCaseBuilder) {
parent = parent.getParent();
* Must_stmtContext
* @return MustDefinition object based on parsed context
*/
- public static MustDefinition parseMust(final YangParser.Must_stmtContext ctx) {
+ private static MustDefinition parseMust(final YangParser.Must_stmtContext ctx) {
StringBuilder mustText = new StringBuilder();
String description = null;
String reference = null;
*/
package org.opendaylight.yangtools.yang.parser.impl;
+import com.google.common.base.Optional;
+import com.google.common.base.Supplier;
import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ImmutableSetMultimap;
+import com.google.common.collect.Multimaps;
+import com.google.common.collect.SetMultimap;
import java.net.URI;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
-
import javax.annotation.concurrent.Immutable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
import org.opendaylight.yangtools.yang.model.api.UsesNode;
import org.opendaylight.yangtools.yang.parser.util.ModuleDependencySort;
-import com.google.common.base.Optional;
-import com.google.common.base.Supplier;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.ImmutableSetMultimap;
-import com.google.common.collect.Multimaps;
-import com.google.common.collect.SetMultimap;
-
@Immutable
final class SchemaContextImpl implements SchemaContext {
private static final Supplier<HashSet<Module>> URI_SET_SUPPLIER = new Supplier<HashSet<Module>>() {
@Override
public Set<DataSchemaNode> getDataDefinitions() {
- final Set<DataSchemaNode> dataDefs = new HashSet<DataSchemaNode>();
+ final Set<DataSchemaNode> dataDefs = new HashSet<>();
for (Module m : modules) {
dataDefs.addAll(m.getChildNodes());
}
@Override
public Set<NotificationDefinition> getNotifications() {
- final Set<NotificationDefinition> notifications = new HashSet<NotificationDefinition>();
+ final Set<NotificationDefinition> notifications = new HashSet<>();
for (Module m : modules) {
notifications.addAll(m.getNotifications());
}
@Override
public Set<RpcDefinition> getOperations() {
- final Set<RpcDefinition> rpcs = new HashSet<RpcDefinition>();
+ final Set<RpcDefinition> rpcs = new HashSet<>();
for (Module m : modules) {
rpcs.addAll(m.getRpcs());
}
@Override
public Set<ExtensionDefinition> getExtensions() {
- final Set<ExtensionDefinition> extensions = new HashSet<ExtensionDefinition>();
+ final Set<ExtensionDefinition> extensions = new HashSet<>();
for (Module m : modules) {
extensions.addAll(m.getExtensionSchemaNodes());
}
if (revision == null) {
// FIXME: The ordering of modules in Multimap could just guarantee this...
- TreeMap<Date, Module> map = new TreeMap<Date, Module>();
+ TreeMap<Date, Module> map = new TreeMap<>();
for (Module module : modules) {
map.put(module.getRevision(), module);
}
String maybeSource = identifiersToSources.get(moduleIdentifier);
return Optional.fromNullable(maybeSource);
}
+
+ @Override
+ public String toString() {
+ return "SchemaContextImpl{" +
+ "modules=" + modules +
+ '}';
+ }
}
import java.util.HashSet;
import java.util.List;
import java.util.Set;
-
import org.antlr.v4.runtime.tree.ParseTree;
import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Module_stmtContext;
import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Submodule_stmtContext;
}
static Set<String> getDuplicates(Collection<String> keyList) {
- Set<String> all = new HashSet<String>();
- Set<String> duplicates = new HashSet<String>();
+ Set<String> all = new HashSet<>();
+ Set<String> duplicates = new HashSet<>();
for (String key : keyList) {
if (!all.add(key)) {
import java.util.ArrayList;
import java.util.List;
-
import org.antlr.v4.runtime.BaseErrorListener;
import org.antlr.v4.runtime.Parser;
import org.antlr.v4.runtime.RecognitionException;
*/
package org.opendaylight.yangtools.yang.parser.impl;
+import com.google.common.collect.Sets;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.HashSet;
import java.util.Set;
-
import org.antlr.v4.runtime.tree.ParseTree;
import org.opendaylight.yangtools.antlrv4.code.gen.YangParser;
import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Anyxml_stmtContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.collect.Sets;
-
/**
* Validation listener that validates yang statements according to RFC-6020.
* This validator expects only one module or submodule per file and performs
BasicValidations.checkPresentChildOfType(ctx, Module_header_stmtsContext.class, true);
String moduleName = ValidationUtil.getName(ctx);
- BasicValidations.checkOnlyOneModulePresent(moduleName, globalModuleId);
+ BasicValidations.checkIsModuleIdNull(globalModuleId);
globalModuleId = moduleName;
}
BasicValidations.checkPresentChildOfType(ctx, Submodule_header_stmtsContext.class, true);
String submoduleName = ValidationUtil.getName(ctx);
- BasicValidations.checkOnlyOneModulePresent(submoduleName, globalModuleId);
+ BasicValidations.checkIsModuleIdNull(globalModuleId);
globalModuleId = submoduleName;
}
package org.opendaylight.yangtools.yang.parser.impl;
import java.util.Collection;
-
import org.antlr.v4.runtime.tree.ParseTree;
import org.antlr.v4.runtime.tree.ParseTreeWalker;
import org.opendaylight.yangtools.yang.parser.util.YangValidationException;
}
Collection<ByteSource> sources = BuilderUtils.filesToByteSources(yangFiles);
- SchemaContext result = parseSources(sources, context);
- return result;
+ return parseSources(sources, context);
}
@Override
private Map<ByteSource, ModuleBuilder> resolveSources(final Collection<ByteSource> streams)
throws IOException, YangSyntaxErrorException {
Map<ByteSource, ModuleBuilder> builders = parseSourcesToBuilders(streams);
- Map<ByteSource, ModuleBuilder> result = resolveSubmodules(builders);
- return result;
+ return resolveSubmodules(builders);
}
private Map<ByteSource, ModuleBuilder> parseSourcesToBuilders(final Collection<ByteSource> sources)
*/
private ModuleBuilder findTargetModule(final QName qname, final ModuleBuilder module,
final Map<String, TreeMap<Date, ModuleBuilder>> modules, final SchemaContext context, final int line) {
- ModuleBuilder targetModule = null;
+ ModuleBuilder targetModule;
String prefix = qname.getPrefix();
if (prefix == null || prefix.equals("")) {
private ModuleBuilder findTargetModule(final String prefix, final ModuleBuilder module,
final Map<String, TreeMap<Date, ModuleBuilder>> modules, final SchemaContext context, final int line) {
- ModuleBuilder targetModule = null;
+ ModuleBuilder targetModule;
if (prefix == null || prefix.equals("")) {
targetModule = module;
DataNodeContainerBuilder parent = usesNode.getParent();
ModuleBuilder module = BuilderUtils.getParentModule(parent);
SchemaPath parentPath;
- URI ns = null;
- Date rev = null;
- String pref = null;
+ URI ns;
+ Date rev;
+ String pref;
if (parent instanceof AugmentationSchemaBuilder || parent instanceof ModuleBuilder) {
ns = module.getNamespace();
rev = module.getRevision();
if (parent instanceof AugmentationSchemaBuilder) {
parentPath = ((AugmentationSchemaBuilder) parent).getTargetNodeSchemaPath();
} else {
- parentPath = ((ModuleBuilder) parent).getPath();
+ parentPath = parent.getPath();
}
} else {
- ns = ((DataSchemaNodeBuilder) parent).getQName().getNamespace();
- rev = ((DataSchemaNodeBuilder) parent).getQName().getRevision();
- pref = ((DataSchemaNodeBuilder) parent).getQName().getPrefix();
- parentPath = ((DataSchemaNodeBuilder) parent).getPath();
+ ns = parent.getQName().getNamespace();
+ rev = parent.getQName().getRevision();
+ pref = parent.getQName().getPrefix();
+ parentPath = parent.getPath();
}
GroupingDefinition gd = usesNode.getGroupingDefinition();
import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.parseYinValue;
import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.stringFromNode;
+import com.google.common.base.Strings;
import java.net.URI;
import java.text.DateFormat;
import java.text.ParseException;
import java.util.Date;
import java.util.List;
import java.util.Stack;
-
import org.antlr.v4.runtime.tree.ParseTree;
import org.opendaylight.yangtools.antlrv4.code.gen.YangParser;
import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Argument_stmtContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Strings;
-
public final class YangParserListenerImpl extends YangParserBaseListener {
private static final Logger LOGGER = LoggerFactory.getLogger(YangParserListenerImpl.class);
private static final String AUGMENT_STR = "augment";
@Override
public void exitModule_stmt(final YangParser.Module_stmtContext ctx) {
- exitLog("module", "");
+ exitLog("module");
actualPath.pop();
}
}
@Override public void exitSubmodule_stmt(final YangParser.Submodule_stmtContext ctx) {
- exitLog("submodule", "");
+ exitLog("submodule");
actualPath.pop();
}
@Override
public void exitModule_header_stmts(final Module_header_stmtsContext ctx) {
- exitLog("module_header", "");
+ exitLog("module_header");
}
@Override
@Override
public void exitMeta_stmts(final YangParser.Meta_stmtsContext ctx) {
- exitLog("meta_stmt", "");
+ exitLog("meta_stmt");
}
@Override
@Override
public void exitRevision_stmts(final Revision_stmtsContext ctx) {
- exitLog("revisions", "");
+ exitLog("revisions");
}
private void updateRevisionForRevisionStatement(final ParseTree treeNode) {
@Override
public void exitImport_stmt(final Import_stmtContext ctx) {
- exitLog("import", "");
+ exitLog("import");
}
@Override
@Override
public void exitAugment_stmt(final YangParser.Augment_stmtContext ctx) {
moduleBuilder.exitNode();
- exitLog(AUGMENT_STR, "");
+ exitLog(AUGMENT_STR);
actualPath.pop();
}
final QName typeQName = parseQName(typeName);
- TypeDefinition<?> type = null;
+ TypeDefinition<?> type;
Type_body_stmtsContext typeBody = null;
for (int i = 0; i < ctx.getChildCount(); i++) {
if (ctx.getChild(i) instanceof Type_body_stmtsContext) {
@Override
public void exitUses_stmt(final YangParser.Uses_stmtContext ctx) {
moduleBuilder.exitNode();
- exitLog("uses", "");
+ exitLog("uses");
}
@Override
@Override
public void exitUses_augment_stmt(final YangParser.Uses_augment_stmtContext ctx) {
moduleBuilder.exitNode();
- exitLog(AUGMENT_STR, "");
+ exitLog(AUGMENT_STR);
actualPath.pop();
}
@Override
public void exitRefine_stmt(final YangParser.Refine_stmtContext ctx) {
moduleBuilder.exitNode();
- exitLog("refine", "");
+ exitLog("refine");
}
@Override
@Override
public void exitDeviation_stmt(final YangParser.Deviation_stmtContext ctx) {
moduleBuilder.exitNode();
- exitLog("deviation", "");
+ exitLog("deviation");
}
@Override
LOGGER.trace("entering {} {} ({})", p1, p2, line);
}
- private void exitLog(final String p1, final String p2) {
- LOGGER.trace("exiting {} {}", p1, p2);
+ private void exitLog(final String p1) {
+ LOGGER.trace("exiting {}", p1);
}
private void exitLog(final String p1, final QName p2) {
nodeType = new QName(namespace, revision, splittedElement[0], splittedElement[1]);
}
- QName qname = null;
+ QName qname;
try {
if (!Strings.isNullOrEmpty(nodeParameter)) {
String[] splittedName = nodeParameter.split(":");
import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.getArgumentString;
import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.getFirstContext;
+import com.google.common.base.Optional;
+import com.google.common.collect.ImmutableSet;
import java.io.InputStream;
import java.util.Date;
import java.util.List;
-
import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Belongs_to_stmtContext;
import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Import_stmtContext;
import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Include_stmtContext;
import org.opendaylight.yangtools.yang.model.api.ModuleImport;
import org.opendaylight.yangtools.yang.parser.impl.YangParserImpl;
-import com.google.common.base.Optional;
-import com.google.common.collect.ImmutableSet;
-
/**
* Helper transfer object which holds basic and dependency information for YANG
* model.
private final ImmutableSet<ModuleImport> moduleImports;
private final ImmutableSet<ModuleImport> dependencies;
- protected YangModelDependencyInfo(final String name, final String formattedRevision,
- final ImmutableSet<ModuleImport> imports, final ImmutableSet<ModuleImport> includes) {
+ YangModelDependencyInfo(final String name, final String formattedRevision,
+ final ImmutableSet<ModuleImport> imports, final ImmutableSet<ModuleImport> includes) {
this.name = name;
this.formattedRevision = formattedRevision;
this.revision = QName.parseRevision(formattedRevision);
*
* @return revision
*/
- public Date getRevision() {
+ Date getRevision() {
return revision;
}
import static com.google.common.base.Preconditions.checkNotNull;
+import com.google.common.base.Optional;
+import com.google.common.collect.ImmutableMultimap;
+import com.google.common.collect.ImmutableSet;
import java.io.InputStream;
import java.util.HashMap;
-
import javax.annotation.concurrent.NotThreadSafe;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ModuleImport;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-import com.google.common.collect.ImmutableMultimap;
-import com.google.common.collect.ImmutableSet;
-
/**
*
* Resolution task for YANG Source Context
*/
package org.opendaylight.yangtools.yang.parser.impl.util;
+import com.google.common.base.Optional;
import java.io.InputStream;
-
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.util.repo.SchemaSourceProvider;
import org.opendaylight.yangtools.yang.model.util.repo.SchemaSourceProviders;
import org.opendaylight.yangtools.yang.model.util.repo.SourceIdentifier;
-import com.google.common.base.Optional;
-
/**
*
* Source code resolver which resolves Yang Source Context against
*/
package org.opendaylight.yangtools.yang.parser.impl.util;
+import com.google.common.base.Optional;
+import com.google.common.collect.ImmutableMap;
import java.io.InputStream;
import java.util.Map;
import java.util.Map.Entry;
-
import javax.annotation.concurrent.NotThreadSafe;
import org.opendaylight.yangtools.yang.model.util.repo.AdvancedSchemaSourceProvider;
import org.opendaylight.yangtools.yang.model.util.repo.SchemaSourceProvider;
import org.opendaylight.yangtools.yang.model.util.repo.SourceIdentifier;
-import com.google.common.base.Optional;
-import com.google.common.collect.ImmutableMap;
-
/**
* Resolver for YANG Schema Source which is based on DependencyInfo
*
*/
package org.opendaylight.yangtools.yang.parser.util;
+import static java.util.Arrays.asList;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Optional;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
import java.net.URI;
import java.util.ArrayList;
-import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Set;
-
import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.ModuleImport;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Function;
-import com.google.common.collect.Lists;
-import com.google.common.collect.Maps;
-import com.google.common.collect.Sets;
-
/**
* Creates a module dependency graph from provided {@link ModuleBuilder}s and
* provides a {@link #sort(ModuleBuilder...)} method. It is topological sort and
private ModuleDependencySort() {
}
+
/**
* Extracts {@link ModuleBuilder} from a {@link ModuleNodeImpl}.
*/
@Override
public ModuleBuilder apply(final TopologicalSort.Node input) {
// Cast to ModuleBuilder from Node and return
- return (ModuleBuilder) ((ModuleNodeImpl) input).getReference();
+ ModuleOrModuleBuilder moduleOrModuleBuilder = ((ModuleNodeImpl) input).getReference();
+ return moduleOrModuleBuilder.getModuleBuilder();
}
};
* in returned order.
*/
public static List<ModuleBuilder> sort(final ModuleBuilder... builders) {
- return sort(Arrays.asList(builders));
+ return sort(asList(builders));
}
public static List<ModuleBuilder> sort(final Collection<ModuleBuilder> builders) {
- List<TopologicalSort.Node> sorted = sortInternal(builders);
+ List<TopologicalSort.Node> sorted = sortInternal(ModuleOrModuleBuilder.fromAll(
+ Collections.<Module>emptySet(),builders));
return Lists.transform(sorted, NODE_TO_MODULEBUILDER);
}
public static List<ModuleBuilder> sortWithContext(final SchemaContext context, final ModuleBuilder... builders) {
- List<Object> modules = new ArrayList<Object>();
- Collections.addAll(modules, builders);
- modules.addAll(context.getModules());
+ List<ModuleOrModuleBuilder> all = ModuleOrModuleBuilder.fromAll(context.getModules(), asList(builders));
- List<TopologicalSort.Node> sorted = sortInternal(modules);
+ List<TopologicalSort.Node> sorted = sortInternal(all);
// Cast to ModuleBuilder from Node if possible and return
return Lists.transform(sorted, new Function<TopologicalSort.Node, ModuleBuilder>() {
@Override
public ModuleBuilder apply(final TopologicalSort.Node input) {
- if (((ModuleNodeImpl) input).getReference() instanceof ModuleBuilder) {
- return (ModuleBuilder) ((ModuleNodeImpl) input).getReference();
+ ModuleOrModuleBuilder moduleOrModuleBuilder = ((ModuleNodeImpl) input).getReference();
+ if (moduleOrModuleBuilder.isModuleBuilder()) {
+ return moduleOrModuleBuilder.getModuleBuilder();
} else {
return null;
}
* returned order.
*/
public static List<Module> sort(final Module... modules) {
- List<TopologicalSort.Node> sorted = sortInternal(Arrays.asList(modules));
+ List<TopologicalSort.Node> sorted = sortInternal(ModuleOrModuleBuilder.fromAll(asList(modules),
+ Collections.<ModuleBuilder>emptyList()));
// Cast to Module from Node and return
return Lists.transform(sorted, new Function<TopologicalSort.Node, Module>() {
@Override
public Module apply(final TopologicalSort.Node input) {
- return (Module) ((ModuleNodeImpl) input).getReference();
+ ModuleOrModuleBuilder moduleOrModuleBuilder = ((ModuleNodeImpl) input).getReference();
+ return moduleOrModuleBuilder.getModule();
}
});
}
- private static List<TopologicalSort.Node> sortInternal(final Iterable<?> modules) {
+ private static List<TopologicalSort.Node> sortInternal(final Iterable<ModuleOrModuleBuilder> modules) {
Map<String, Map<Date, ModuleNodeImpl>> moduleGraph = createModuleGraph(modules);
Set<TopologicalSort.Node> nodes = Sets.newHashSet();
}
@VisibleForTesting
- static Map<String, Map<Date, ModuleNodeImpl>> createModuleGraph(final Iterable<?> builders) {
+ static Map<String, Map<Date, ModuleNodeImpl>> createModuleGraph(final Iterable<ModuleOrModuleBuilder> builders) {
Map<String, Map<Date, ModuleNodeImpl>> moduleGraph = Maps.newHashMap();
processModules(moduleGraph, builders);
* Extract module:revision from module builders
*/
private static void processDependencies(final Map<String, Map<Date, ModuleNodeImpl>> moduleGraph,
- final Iterable<?> builders) {
+ final Iterable<ModuleOrModuleBuilder> mmbs) {
Map<URI, Object> allNS = new HashMap<>();
// Create edges in graph
- for (Object mb : builders) {
+ for (ModuleOrModuleBuilder mmb : mmbs) {
Map<String, Date> imported = Maps.newHashMap();
- String fromName = null;
- Date fromRevision = null;
- Set<ModuleImport> imports = null;
- URI ns = null;
-
- if (mb instanceof Module) {
- fromName = ((Module) mb).getName();
- fromRevision = ((Module) mb).getRevision();
- imports = ((Module) mb).getImports();
- ns = ((Module) mb).getNamespace();
- } else if (mb instanceof ModuleBuilder) {
- fromName = ((ModuleBuilder) mb).getName();
- fromRevision = ((ModuleBuilder) mb).getRevision();
- imports = ((ModuleBuilder) mb).getModuleImports();
- ns = ((ModuleBuilder) mb).getNamespace();
+ String fromName;
+ Date fromRevision;
+ Set<ModuleImport> imports;
+ URI ns;
+
+ if (mmb.isModule()) {
+ Module module = mmb.getModule();
+ fromName = module.getName();
+ fromRevision = module.getRevision();
+ imports = module.getImports();
+ ns = module.getNamespace();
+ } else {
+ ModuleBuilder moduleBuilder = mmb.getModuleBuilder();
+ fromName = moduleBuilder.getName();
+ fromRevision = moduleBuilder.getRevision();
+ imports = moduleBuilder.getModuleImports();
+ ns = moduleBuilder.getNamespace();
}
// check for existence of module with same namespace
fromName, fromRevision, ns, name, revision);
}
} else {
- allNS.put(ns, mb);
+ allNS.put(ns, mmb);
}
// no need to check if other Type of object, check is performed in
* graph
*/
private static void processModules(final Map<String, Map<Date, ModuleNodeImpl>> moduleGraph,
- final Iterable<?> builders) {
+ final Iterable<ModuleOrModuleBuilder> builders) {
// Process nodes
- for (Object mb : builders) {
+ for (ModuleOrModuleBuilder momb : builders) {
- String name = null;
- Date rev = null;
+ String name;
+ Date rev;
- if (mb instanceof Module) {
- name = ((Module) mb).getName();
- rev = ((Module) mb).getRevision();
- } else if (mb instanceof ModuleBuilder) {
- name = ((ModuleBuilder) mb).getName();
- rev = ((ModuleBuilder) mb).getRevision();
+ if (momb.isModule()) {
+ name = momb.getModule().getName();
+ rev = momb.getModule().getRevision();
} else {
- throw new IllegalStateException(String.format(
- "Unexpected type of node for sort, expected only:%s, %s, got:%s", Module.class,
- ModuleBuilder.class, mb.getClass()));
+ name = momb.getModuleBuilder().getName();
+ rev = momb.getModuleBuilder().getRevision();
}
if (rev == null) {
ex(String.format("Module:%s with revision:%s declared twice", name, formatRevDate(rev)));
}
- moduleGraph.get(name).put(rev, new ModuleNodeImpl(name, rev, mb));
+ moduleGraph.get(name).put(rev, new ModuleNodeImpl(name, rev, momb));
}
}
static class ModuleNodeImpl extends NodeImpl {
private final String name;
private final Date revision;
- private final Object originalObject;
+ private final ModuleOrModuleBuilder originalObject;
- public ModuleNodeImpl(final String name, final Date revision, final Object builder) {
+ public ModuleNodeImpl(final String name, final Date revision, final ModuleOrModuleBuilder builder) {
this.name = name;
this.revision = revision;
this.originalObject = builder;
return "Module [name=" + name + ", revision=" + formatRevDate(revision) + "]";
}
- public Object getReference() {
+ public ModuleOrModuleBuilder getReference() {
return originalObject;
}
}
}
+class ModuleOrModuleBuilder {
+ private final Optional<Module> maybeModule;
+ private final Optional<ModuleBuilder> maybeModuleBuilder;
+
+ ModuleOrModuleBuilder(Module module) {
+ maybeModule = Optional.of(module);
+ maybeModuleBuilder = Optional.absent();
+ }
+
+ ModuleOrModuleBuilder(ModuleBuilder moduleBuilder) {
+ maybeModule = Optional.absent();
+ maybeModuleBuilder = Optional.of(moduleBuilder);
+ }
+ boolean isModule(){
+ return maybeModule.isPresent();
+ }
+ boolean isModuleBuilder(){
+ return maybeModuleBuilder.isPresent();
+ }
+ Module getModule(){
+ return maybeModule.get();
+ }
+ ModuleBuilder getModuleBuilder(){
+ return maybeModuleBuilder.get();
+ }
+
+ static List<ModuleOrModuleBuilder> fromAll(Collection<Module> modules, Collection<ModuleBuilder> moduleBuilders) {
+ List<ModuleOrModuleBuilder> result = new ArrayList<>(modules.size() + moduleBuilders.size());
+ for(Module m: modules){
+ result.add(new ModuleOrModuleBuilder(m));
+ }
+ for (ModuleBuilder mb : moduleBuilders) {
+ result.add(new ModuleOrModuleBuilder(mb));
+ }
+ return result;
+ }
+}
*/
package org.opendaylight.yangtools.yang.parser.util;
-import java.util.List;
-import java.util.Set;
-
import com.google.common.base.Preconditions;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
+import java.util.List;
+import java.util.Set;
/**
* Utility class that provides topological sort
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
-
import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint;
import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
import java.util.Date;
import java.util.List;
import java.util.Set;
-
import org.junit.BeforeClass;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import java.util.List;
import java.util.Set;
-
import org.junit.Test;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
*/
package org.opendaylight.yangtools.yang.parser.impl;
+import static org.junit.Assert.assertEquals;
+
+import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.parser.api.YangModelParser;
-import java.util.Set;
-
-import static org.junit.Assert.assertEquals;
-
public class TwoRevisionsTest {
@Test
import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Ordered_by_argContext;
import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Type_stmtContext;
import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Unique_stmtContext;
-import org.opendaylight.yangtools.yang.parser.impl.YangModelBasicValidationListener;
import org.opendaylight.yangtools.yang.parser.util.YangValidationException;
public class YangModelValidationListTest {
import static org.junit.Assert.assertThat;
import static org.junit.matchers.JUnitMatchers.containsString;
-import static org.mockito.Mockito.*;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Revision_stmtContext;
import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Revision_stmtsContext;
import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Yang_version_stmtContext;
-import org.opendaylight.yangtools.yang.parser.impl.BasicValidations;
-import org.opendaylight.yangtools.yang.parser.impl.YangModelBasicValidationListener;
import org.opendaylight.yangtools.yang.parser.util.YangValidationException;
public class YangModelValidationModuleTest {
import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Belongs_to_stmtContext;
import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Submodule_header_stmtsContext;
import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Submodule_stmtContext;
-import org.opendaylight.yangtools.yang.parser.impl.YangModelBasicValidationListener;
import org.opendaylight.yangtools.yang.parser.util.YangValidationException;
public class YangModelValidationSubModuleTest {
import static org.junit.Assert.assertThat;
import static org.junit.Assert.fail;
import static org.junit.matchers.JUnitMatchers.containsString;
-import static org.mockito.Mockito.*;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+import com.google.common.collect.Sets;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.HashSet;
import java.util.List;
-
import org.antlr.v4.runtime.Token;
import org.antlr.v4.runtime.tree.ParseTree;
import org.antlr.v4.runtime.tree.TerminalNode;
import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Revision_date_stmtContext;
import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Status_argContext;
import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.StringContext;
-import org.opendaylight.yangtools.yang.parser.impl.BasicValidations;
-import org.opendaylight.yangtools.yang.parser.impl.ValidationUtil;
-import org.opendaylight.yangtools.yang.parser.impl.YangModelBasicValidationListener;
import org.opendaylight.yangtools.yang.parser.util.YangValidationException;
-import com.google.common.collect.Sets;
-
public class YangModelValidationTest {
private YangModelBasicValidationListener valid;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
-
import org.junit.Test;
import org.opendaylight.yangtools.yang.model.parser.api.YangContextParser;
import org.opendaylight.yangtools.yang.parser.util.YangParseException;
import java.util.Date;
import java.util.List;
import java.util.Set;
-
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import java.util.List;
import java.util.Map;
import java.util.Set;
-
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
*/
package org.opendaylight.yangtools.yang.parser.impl.util;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
import java.io.InputStream;
-
import org.junit.Test;
public class YangModelDependencyInfoTest {
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
+import com.google.common.collect.Sets;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Arrays;
+import java.util.Collections;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
-
import org.hamcrest.Matcher;
import org.junit.Test;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.parser.util.ModuleDependencySort.ModuleNodeImpl;
import org.opendaylight.yangtools.yang.parser.util.TopologicalSort.Edge;
-import com.google.common.collect.Sets;
-
public class ModuleDependencySortTest {
private final DateFormat SIMPLE_DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd");
private final ModuleBuilder a = mockModuleBuilder("a", null);
List<ModuleBuilder> l = ModuleDependencySort.sort(builders);
- assertDependencyGraph(ModuleDependencySort.createModuleGraph(Arrays.asList(builders)));
+ assertDependencyGraph(ModuleDependencySort.createModuleGraph(ModuleOrModuleBuilder.fromAll(
+ Collections.<Module>emptySet(), Arrays.asList(builders))));
@SuppressWarnings("unchecked")
Matcher<String> cOrD = anyOf(is(c.getName()), is(d.getName()));
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
-
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import static org.hamcrest.core.Is.is;
import static org.junit.Assert.assertThat;
+import com.google.common.collect.Sets;
import java.util.List;
import java.util.Set;
-
import org.junit.Test;
import org.opendaylight.yangtools.yang.parser.util.TopologicalSort.Node;
import org.opendaylight.yangtools.yang.parser.util.TopologicalSort.NodeImpl;
-import com.google.common.collect.Sets;
-
public class TopologicalSortTest {
@Test(expected = IllegalStateException.class)
Code Review / yangtools.git / commitdiff