Rather than using List<X>/Set<X> we use Collection<? extends X>.
We really want to say 'iterable', but Collection is close enough
and it's slightly more useful.
This allows us to use more efficient facades when coming from
EffectiveStatement world, i.e. filters can use Collections2.filter()
to evaluate substatements lazily.
We also codify proper covariance, which strenghtens the read-only
nature of the returned type.
JIRA: YANGTOOLS-1068
Change-Id: I80be306916dff0575fb4b6824951827e540e482e
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>
import static java.util.Objects.requireNonNull;
import java.util.Collection;
-import java.util.List;
import java.util.Objects;
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
}
@Override
- public Collection<MustDefinition> getMustConstraints() {
+ public Collection<? extends MustDefinition> getMustConstraints() {
return delegateSchemaNode().getMustConstraints();
}
@Override
- public List<UnknownSchemaNode> getUnknownSchemaNodes() {
+ public Collection<? extends UnknownSchemaNode> getUnknownSchemaNodes() {
return delegateSchemaNode().getUnknownSchemaNodes();
}
import static org.junit.Assert.assertTrue;
import java.net.URI;
-import java.util.List;
+import java.util.Collection;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
assertTrue(myContainer2 instanceof ContainerSchemaNode);
assertEquals(myContainer2, yangModeledAnyXml.getSchemaOfAnyXmlData());
- List<UnknownSchemaNode> unknownSchemaNodes = yangModeledAnyXml.getUnknownSchemaNodes();
+ Collection<? extends UnknownSchemaNode> unknownSchemaNodes = yangModeledAnyXml.getUnknownSchemaNodes();
assertEquals(1, unknownSchemaNodes.size());
UnknownSchemaNode next = unknownSchemaNodes.iterator().next();
.buildEffective();
final Module module = context.findModule(NetconfConstants.RFC6241_MODULE).get();
- final Iterator<RpcDefinition> it = module.getRpcs().iterator();
+ final Iterator<? extends RpcDefinition> it = module.getRpcs().iterator();
assertExtension(false, it.next());
assertExtension(false, it.next());
assertExtension(true, it.next());
import com.google.common.collect.ImmutableSet;
import java.io.IOException;
import java.net.URI;
-import java.util.List;
-import java.util.Set;
+import java.util.Collection;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
.buildEffective();
assertNotNull(schemaContext);
- final Set<ExtensionDefinition> extensions = schemaContext.getExtensions();
+ final Collection<? extends ExtensionDefinition> extensions = schemaContext.getExtensions();
assertEquals(1, extensions.size());
final Module foo = schemaContext.findModule(FOO_QNAMEMODULE).get();
- final List<UnknownSchemaNode> unknownSchemaNodes = foo.getUnknownSchemaNodes();
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes = foo.getUnknownSchemaNodes();
assertEquals(2, unknownSchemaNodes.size());
YangDataSchemaNode myYangDataANode = null;
assertNotNull(schemaContext);
final Module baz = schemaContext.findModule("baz", REVISION).get();
- final List<UnknownSchemaNode> unknownSchemaNodes = baz.getUnknownSchemaNodes();
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes = baz.getUnknownSchemaNodes();
assertEquals(1, unknownSchemaNodes.size());
final UnknownSchemaNode unknownSchemaNode = unknownSchemaNodes.iterator().next();
assertNotNull(schemaContext);
final Module foobar = schemaContext.findModule("foobar", REVISION).get();
- final List<UnknownSchemaNode> unknownSchemaNodes = foobar.getUnknownSchemaNodes();
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes = foobar.getUnknownSchemaNodes();
assertEquals(1, unknownSchemaNodes.size());
final UnknownSchemaNode unknownSchemaNode = unknownSchemaNodes.iterator().next();
QName.create(bar.getQNameModule(), "cont")).get();
assertNotNull(cont);
- final Set<ExtensionDefinition> extensions = schemaContext.getExtensions();
+ final Collection<? extends ExtensionDefinition> extensions = schemaContext.getExtensions();
assertEquals(1, extensions.size());
- final List<UnknownSchemaNode> unknownSchemaNodes = cont.getUnknownSchemaNodes();
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes = cont.getUnknownSchemaNodes();
assertEquals(0, unknownSchemaNodes.size());
}
checkArgument(value instanceof String, "Unexpected module leaf value %s", value);
return (String) value;
}).orElseThrow(() -> new IllegalArgumentException("Mount module missing in " + entry));
- final Iterator<Module> it = schemaContext.findModules(moduleName).iterator();
+ final Iterator<? extends Module> it = schemaContext.findModules(moduleName).iterator();
checkArgument(it.hasNext(), "Failed to find a module named %s", moduleName);
final QNameModule module = it.next().getQNameModule();
b.put(module.getPrefix(), module.getQNameModule());
for (ModuleImport i : module.getImports()) {
- final Optional<Module> mod = ctx.findModule(i.getModuleName(), i.getRevision());
+ final Optional<? extends Module> mod = ctx.findModule(i.getModuleName(), i.getRevision());
checkArgument(mod.isPresent(), "Unsatisfied import of %s by module %s", i, module);
b.put(i.getPrefix(), mod.get().getQNameModule());
return parentModule;
}
- final Iterator<Module> modules = schemaContext.findModules(prefix).iterator();
+ final Iterator<? extends Module> modules = schemaContext.findModules(prefix).iterator();
checkArgument(modules.hasNext(), "Could not find module %s", prefix);
return modules.next().getQNameModule();
}).getQName();
@Override
protected final Module moduleForPrefix(final String prefix) {
- final Iterator<Module> modules = context.findModules(prefix).iterator();
+ final Iterator<? extends Module> modules = context.findModules(prefix).iterator();
return modules.hasNext() ? modules.next() : null;
}
@Override
protected final String prefixForNamespace(final URI namespace) {
- final Iterator<Module> modules = context.findModules(namespace).iterator();
+ final Iterator<? extends Module> modules = context.findModules(namespace).iterator();
return modules.hasNext() ? modules.next().getName() : null;
}
moduleNamePart = childName.substring(0, lastIndexOfColon);
nodeNamePart = childName.substring(lastIndexOfColon + 1);
- final Iterator<Module> m = codecs.getSchemaContext().findModules(moduleNamePart).iterator();
+ final Iterator<? extends Module> m = codecs.getSchemaContext().findModules(moduleNamePart).iterator();
namespace = m.hasNext() ? m.next().getNamespace() : null;
} else {
nodeNamePart = childName;
}
final String prefixedNS = ctx.getNamespaceURI(prefix);
- final Iterator<Module> modules = schemaContext.findModules(URI.create(prefixedNS)).iterator();
+ final Iterator<? extends Module> modules = schemaContext.findModules(URI.create(prefixedNS)).iterator();
checkArgument(modules.hasNext(), "Could not find module for namespace %s", prefixedNS);
return modules.next().getQNameModule();
}).getQName();
private Optional<QNameModule> resolveXmlNamespace(final String xmlNamespace) {
return resolvedNamespaces.computeIfAbsent(xmlNamespace, nsUri -> {
- final Iterator<Module> it = codecs.getSchemaContext().findModules(URI.create(nsUri)).iterator();
+ final Iterator<? extends Module> it = codecs.getSchemaContext().findModules(URI.create(nsUri)).iterator();
return it.hasNext() ? Optional.of(it.next().getQNameModule()) : Optional.empty();
});
}
@Override
protected Module moduleForPrefix(final String prefix) {
final String prefixedNS = getNamespaceContext().getNamespaceURI(prefix);
- final Iterator<Module> modules = context.findModules(URI.create(prefixedNS)).iterator();
+ final Iterator<? extends Module> modules = context.findModules(URI.create(prefixedNS)).iterator();
return modules.hasNext() ? modules.next() : null;
}
@Override
protected String prefixForNamespace(final URI namespace) {
- final Iterator<Module> modules = context.findModules(namespace).iterator();
+ final Iterator<? extends Module> modules = context.findModules(namespace).iterator();
return modules.hasNext() ? modules.next().getName() : null;
}
import java.util.Collection;
import java.util.LinkedList;
import java.util.List;
-import java.util.Set;
import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
final LeafRefContextBuilder rootBuilder = new LeafRefContextBuilder(schemaContext.getQName(),
schemaContext.getPath(), schemaContext);
- final Set<Module> modules = schemaContext.getModules();
+ final Collection<? extends Module> modules = schemaContext.getModules();
for (final Module module : modules) {
for (final DataSchemaNode childNode : module.getChildNodes()) {
final LeafRefContext childLeafRefContext = buildLeafRefContextReferencingTree(childNode, module);
}
for (final Module module : modules) {
- final Collection<DataSchemaNode> childNodes = module.getChildNodes();
- for (final DataSchemaNode childNode : childNodes) {
+ for (final DataSchemaNode childNode : module.getChildNodes()) {
final LeafRefContext childLeafRefContext = buildLeafRefContextReferencedByTree(childNode, module);
if (childLeafRefContext.hasReferencedChild() || childLeafRefContext.isReferenced()) {
* @return schema node with newest revision or absent if no schema node with matching qname is found
*/
public static Optional<DataSchemaNode> findFirstSchema(final QName qname,
- final Iterable<DataSchemaNode> dataSchemaNode) {
+ final Iterable<? extends DataSchemaNode> dataSchemaNode) {
DataSchemaNode schema = null;
if (dataSchemaNode != null && qname != null) {
for (final DataSchemaNode dsn : dataSchemaNode) {
}
public static DataSchemaNode findSchemaForChild(final DataNodeContainer schema, final QName qname,
- final Iterable<DataSchemaNode> childNodes) {
+ final Iterable<? extends DataSchemaNode> childNodes) {
final Optional<DataSchemaNode> childSchema = findFirstSchema(qname, childNodes);
checkState(childSchema.isPresent(), "Unknown child(ren) node(s) detected, identified by: %s, in: %s", qname,
schema);
}
private static Map<QName, ChoiceSchemaNode> mapChildElementsFromChoices(final DataNodeContainer schema,
- final Iterable<DataSchemaNode> childNodes) {
+ final Iterable<? extends DataSchemaNode> childNodes) {
final Map<QName, ChoiceSchemaNode> mappedChoices = new LinkedHashMap<>();
for (final DataSchemaNode childSchema : childNodes) {
import java.util.HashMap;
import java.util.Map;
-import java.util.Set;
import org.apache.log4j.BasicConfigurator;
import org.junit.AfterClass;
import org.junit.BeforeClass;
public static void init() throws DataValidationFailedException {
context = YangParserTestUtils.parseYangResourceDirectory("/leafref-validation");
- final Set<Module> modules = context.getModules();
- for (final Module module : modules) {
+ for (final Module module : context.getModules()) {
if (module.getName().equals("leafref-validation")) {
valModule = module;
}
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
-import java.util.Set;
import org.apache.log4j.BasicConfigurator;
import org.junit.AfterClass;
import org.junit.BeforeClass;
public static void init() throws DataValidationFailedException {
context = YangParserTestUtils.parseYangResourceDirectory("/leafref-validation");
- final Set<Module> modules = context.getModules();
- for (final Module module : modules) {
+ for (final Module module : context.getModules()) {
if (module.getName().equals("leafref-validation2")) {
mainModule = module;
}
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
-import java.util.Set;
import org.apache.log4j.BasicConfigurator;
import org.junit.AfterClass;
import org.junit.BeforeClass;
public static void init() throws DataValidationFailedException {
context = YangParserTestUtils.parseYangResourceDirectory("/leafref-validation");
- final Set<Module> modules = context.getModules();
- for (final Module module : modules) {
+ for (final Module module : context.getModules()) {
if (module.getName().equals("leafref-validation3")) {
mainModule = module;
}
import static org.junit.Assert.assertTrue;
import java.util.Map;
-import java.util.Set;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
public static void init() {
context = YangParserTestUtils.parseYangResourceDirectory("/leafref-context-test/correct-modules");
- final Set<Module> modules = context.getModules();
- for (final Module module : modules) {
+ for (final Module module : context.getModules()) {
if (module.getName().equals("leafref-test2")) {
rootMod = module;
}
import static org.junit.Assert.assertTrue;
import java.util.List;
-import java.util.Set;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Ignore;
public static void init() {
context = YangParserTestUtils.parseYangResourceDirectory("/leafref-context-test/correct-modules");
- final Set<Module> modules = context.getModules();
- for (final Module module : modules) {
+ for (final Module module : context.getModules()) {
if (module.getName().equals("leafref-test")) {
tstMod = module;
}
import com.google.common.collect.Maps;
import java.util.Collection;
import java.util.Optional;
-import java.util.Set;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ActionDefinition;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
}
@Override
- public Set<UsesNode> getUses() {
+ public Collection<? extends UsesNode> getUses() {
return ImmutableSet.of();
}
}
@Override
- public Collection<MustDefinition> getMustConstraints() {
+ public Collection<? extends MustDefinition> getMustConstraints() {
return ImmutableList.of();
}
}
@Override
- public Set<GroupingDefinition> getGroupings() {
+ public Collection<? extends GroupingDefinition> getGroupings() {
return rpcDefinition.getGroupings();
}
@Override
- public Set<TypeDefinition<?>> getTypeDefinitions() {
+ public Collection<? extends TypeDefinition<?>> getTypeDefinitions() {
return rpcDefinition.getTypeDefinitions();
}
@Override
- public Set<AugmentationSchemaNode> getAvailableAugmentations() {
+ public Collection<? extends AugmentationSchemaNode> getAvailableAugmentations() {
return ImmutableSet.of();
}
@Override
- public Collection<DataSchemaNode> getChildNodes() {
+ public Collection<? extends DataSchemaNode> getChildNodes() {
final ContainerSchemaNode input = rpcDefinition.getInput();
final ContainerSchemaNode output = rpcDefinition.getOutput();
if (input == null && output == null) {
}
@Override
- public Set<ActionDefinition> getActions() {
+ public Collection<? extends ActionDefinition> getActions() {
return ImmutableSet.of();
}
@Override
- public Set<NotificationDefinition> getNotifications() {
+ public Collection<? extends NotificationDefinition> getNotifications() {
return ImmutableSet.of();
}
}
private static final class NotificationContainerSchemaNode extends AbstractContainerSchemaNode {
private final NotificationDefinition notification;
- private final ImmutableMap<QName, DataSchemaNode> mapNodes;
+ private final ImmutableMap<QName, ? extends DataSchemaNode> mapNodes;
private NotificationContainerSchemaNode(final NotificationDefinition notification) {
super(notification);
}
@Override
- public Set<NotificationDefinition> getNotifications() {
+ public Collection<? extends NotificationDefinition> getNotifications() {
return ImmutableSet.of(notification);
}
@Override
- public Set<AugmentationSchemaNode> getAvailableAugmentations() {
+ public Collection<? extends AugmentationSchemaNode> getAvailableAugmentations() {
return notification.getAvailableAugmentations();
}
@Override
- public Set<TypeDefinition<?>> getTypeDefinitions() {
+ public Collection<? extends TypeDefinition<?>> getTypeDefinitions() {
return notification.getTypeDefinitions();
}
@Override
- public Collection<DataSchemaNode> getChildNodes() {
+ public Collection<? extends DataSchemaNode> getChildNodes() {
return notification.getChildNodes();
}
@Override
- public Set<GroupingDefinition> getGroupings() {
+ public Collection<? extends GroupingDefinition> getGroupings() {
return notification.getGroupings();
}
}
@Override
- public Set<ActionDefinition> getActions() {
+ public Collection<? extends ActionDefinition> getActions() {
return ImmutableSet.of();
}
}
@Override
protected String prefixForNamespace(final URI namespace) {
- final Iterator<Module> modules = context.findModules(namespace).iterator();
+ final Iterator<? extends Module> modules = context.findModules(namespace).iterator();
return modules.hasNext() ? modules.next().getName() : null;
}
}
import java.util.Collection;
import java.util.List;
import java.util.Optional;
-import java.util.Set;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ActionDefinition;
}
@Override
- public final Set<TypeDefinition<?>> getTypeDefinitions() {
+ public final Collection<? extends TypeDefinition<?>> getTypeDefinitions() {
return delegate.getTypeDefinitions();
}
@Override
- public final Set<GroupingDefinition> getGroupings() {
+ public final Collection<? extends GroupingDefinition> getGroupings() {
return delegate.getGroupings();
}
}
@Override
- public Set<UsesNode> getUses() {
+ public Collection<? extends UsesNode> getUses() {
return ImmutableSet.of();
}
@Override
- public final Set<AugmentationSchemaNode> getAvailableAugmentations() {
+ public final Collection<? extends AugmentationSchemaNode> getAvailableAugmentations() {
return ImmutableSet.of();
}
}
@Override
- public final Collection<DataSchemaNode> getChildNodes() {
+ public final Collection<? extends DataSchemaNode> getChildNodes() {
final List<DataSchemaNode> ret = new ArrayList<>();
final ContainerSchemaNode input = getInput();
final ContainerSchemaNode output = getOutput();
}
@Override
- public final Set<ActionDefinition> getActions() {
+ public final Collection<? extends ActionDefinition> getActions() {
return ImmutableSet.of();
}
}
@Override
- public final Set<NotificationDefinition> getNotifications() {
+ public final Collection<? extends NotificationDefinition> getNotifications() {
return ImmutableSet.of();
}
}
@Override
- public final Collection<MustDefinition> getMustConstraints() {
+ public final Collection<? extends MustDefinition> getMustConstraints() {
return ImmutableSet.of();
}
import static java.util.Objects.requireNonNull;
import com.google.common.annotations.Beta;
+import java.util.Collection;
import java.util.Optional;
-import java.util.Set;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
*
* @return set of action nodes
*/
- @NonNull Set<ActionDefinition> getActions();
+ @NonNull Collection<? extends ActionDefinition> getActions();
/**
* Find an action based on its QName. Default implementation searches the set returned by {@link #getActions()}.
*/
package org.opendaylight.yangtools.yang.model.api;
-import java.util.Set;
+import java.util.Collection;
/**
* Interface for all nodes which are possible targets of augmentation. The
*
* @return set of augmentations targeting this element.
*/
- Set<AugmentationSchemaNode> getAvailableAugmentations();
+ Collection<? extends AugmentationSchemaNode> getAvailableAugmentations();
}
* @return set of ChoiceCaseNode objects defined in this node which represents set of arguments of the YANG
* <code>case</code> substatement of the <code>choice</code> statement.
*/
+ // FIXME: 5.0.0: revert back to collection + lookup
SortedMap<QName, CaseSchemaNode> getCases();
/**
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.Optional;
-import java.util.Set;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
*
* @return typedef statements in lexicographical order
*/
- Set<TypeDefinition<?>> getTypeDefinitions();
+ Collection<? extends TypeDefinition<?>> getTypeDefinitions();
/**
* Returns set of all child nodes defined within this DataNodeContainer. Although the return type is a collection,
*
* @return child nodes in lexicographical order
*/
- Collection<DataSchemaNode> getChildNodes();
+ Collection<? extends DataSchemaNode> getChildNodes();
/**
* Returns set of all groupings defined within this DataNodeContainer.
*
* @return grouping statements in lexicographical order
*/
- Set<GroupingDefinition> getGroupings();
+ Collection<? extends GroupingDefinition> getGroupings();
/**
* Returns the child node corresponding to the specified name.
*
* @return Set of all uses nodes defined within this DataNodeContainer
*/
- Set<UsesNode> getUses();
+ Collection<? extends UsesNode> getUses();
/**
* Returns a {@code data node} identified by a QName. This method is distinct from
import com.google.common.annotations.Beta;
import java.util.Collection;
-import java.util.Set;
/**
* Interface describing YANG 'deviate' statement.
*
* @return set of the deviated must statements
*/
- Set<MustDefinition> getDeviatedMusts();
+ Collection<? extends MustDefinition> getDeviatedMusts();
/**
* Returns deviated type statement.
*
* @return collection of the deviated unique statements
*/
- Collection<UniqueConstraint> getDeviatedUniques();
+ Collection<? extends UniqueConstraint> getDeviatedUniques();
/**
* Returns deviated units statement.
*/
package org.opendaylight.yangtools.yang.model.api;
-import java.util.List;
+import java.util.Collection;
+import org.eclipse.jdt.annotation.NonNull;
/**
* Interface describing YANG 'deviation' statement.
/**
* Returns deviate children.
*
- * @return List of all deviate statements defined in this deviation.
+ * @return Collection of all deviate statements defined in this deviation.
*/
- List<DeviateDefinition> getDeviates();
+ @NonNull Collection<? extends DeviateDefinition> getDeviates();
}
package org.opendaylight.yangtools.yang.model.api;
import com.google.common.collect.ImmutableList;
-import java.util.List;
+import java.util.Collection;
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
Optional<String> getReference();
/**
- * Returns unknown schema nodes which belongs to this instance. Default implementation returns an empty list.
+ * Returns unknown schema nodes which belongs to this instance. Default implementation returns an empty collection.
*
- * @return list of unknown schema nodes defined under this node.
+ * @return collection of unknown schema nodes defined under this node.
*/
- default @NonNull List<UnknownSchemaNode> getUnknownSchemaNodes() {
+ default @NonNull Collection<? extends UnknownSchemaNode> getUnknownSchemaNodes() {
return ImmutableList.of();
}
*/
package org.opendaylight.yangtools.yang.model.api;
-import java.util.Set;
+import java.util.Collection;
import org.eclipse.jdt.annotation.NonNull;
/**
* @return set of existing identities from which the new identity is derived or an empty Set if the identity is
* a root identity.
*/
- @NonNull Set<IdentitySchemaNode> getBaseIdentities();
+ @NonNull Collection<? extends IdentitySchemaNode> getBaseIdentities();
/**
* Get identities derived from this identity.
*
* @return collection of identities derived from this identity
*/
- @NonNull Set<IdentitySchemaNode> getDerivedIdentities();
+ // FIXME: 5.0.0: this causes circular references in implementation objects under immutables+builder pattern,
+ // and really should be a SchemaContext-level utility (i.e. walk entire SchemaContext, cache the
+ // result)
+ @NonNull Collection<? extends IdentitySchemaNode> getDerivedIdentities();
}
*
* @return Collection of unique constraints of this list schema node
*/
- @NonNull Collection<UniqueConstraint> getUniqueConstraints();
+ @NonNull Collection<? extends UniqueConstraint> getUniqueConstraints();
}
package org.opendaylight.yangtools.yang.model.api;
import java.net.URI;
-import java.util.List;
+import java.util.Collection;
import java.util.Optional;
-import java.util.Set;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.concepts.SemVer;
import org.opendaylight.yangtools.yang.common.QNameModule;
* @return set of module imports which are specified in the module as the argument of YANG {@code import}
* statements.
*/
- Set<ModuleImport> getImports();
+ Collection<? extends ModuleImport> getImports();
- Set<Module> getSubmodules();
+ Collection<? extends Module> getSubmodules();
/**
* Returns {@link FeatureDefinition} instances which contain data from {@code feature} statements defined in the
* @return feature statements in lexicographical order which are specified in the module as the argument of YANG
* {@code feature} statements.
*/
- Set<FeatureDefinition> getFeatures();
+ Collection<? extends FeatureDefinition> getFeatures();
/**
* Returns {@link AugmentationSchemaNode} instances which contain data from {@code augment} statements defined
* @return set of the augmentation schema instances which are specified in the module as YANG {@code augment}
* statement and are lexicographically ordered
*/
- Set<AugmentationSchemaNode> getAugmentations();
+ Collection<? extends AugmentationSchemaNode> getAugmentations();
/**
* Returns {@link RpcDefinition} instances which contain data from {@code rpc} statements defined in the module.
* @return set of the RPC definition instances which are specified in the module as YANG {@code rpc} statements and
* are lexicographicaly ordered
*/
- Set<RpcDefinition> getRpcs();
+ Collection<? extends RpcDefinition> getRpcs();
/**
* Returns {@link Deviation} instances which contain data from {@code deviation} statements defined in the module.
*
* @return set of the deviation instances
*/
- Set<Deviation> getDeviations();
+ Collection<? extends Deviation> getDeviations();
/**
* Returns {@link IdentitySchemaNode} instances which contain data from {@code identity} statements defined in the
* @return set of identity schema node instances which are specified in the module as YANG {@code identity}
* statements and are lexicographically ordered
*/
- Set<IdentitySchemaNode> getIdentities();
+ Collection<? extends IdentitySchemaNode> getIdentities();
/**
* Returns {@link ExtensionDefinition} instances which contain data from {@code extension} statements defined in
* @return set of extension definition instances which are specified in the module as YANG {@code extension}
* statements and are lexicographically ordered
*/
- List<ExtensionDefinition> getExtensionSchemaNodes();
+ Collection<? extends ExtensionDefinition> getExtensionSchemaNodes();
}
* @return collection of <code>MustDefinition</code> (XPath) instances which represents the concrete data
* constraints
*/
- Collection<MustDefinition> getMustConstraints();
+ Collection<? extends MustDefinition> getMustConstraints();
}
import java.util.Optional;
import org.opendaylight.yangtools.yang.common.Revision;
+// FIXME: 5.0.0: this really is QNameModuleAware (or some such)
public interface NamespaceRevisionAware {
URI getNamespace();
import static java.util.Objects.requireNonNull;
+import java.util.Collection;
import java.util.Optional;
-import java.util.Set;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
*
* @return set of notification nodes
*/
- @NonNull Set<NotificationDefinition> getNotifications();
+ @NonNull Collection<? extends NotificationDefinition> getNotifications();
/**
* Find a notification based on its QName. Default implementation searches the set returned by
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.yangtools.yang.model.api;
import com.google.common.annotations.Beta;
-import java.util.Set;
+import java.util.Collection;
/**
* Common interface for an operation.
*
* @return Set of type definitions declared under this operation.
*/
- Set<TypeDefinition<?>> getTypeDefinitions();
+ Collection<? extends TypeDefinition<?>> getTypeDefinitions();
/**
* Returns the set of grouping statements declared under this operation.
*
* @return Set of grouping statements declared under this operation.
*/
- Set<GroupingDefinition> getGroupings();
+ Collection<? extends GroupingDefinition> getGroupings();
/**
* Returns definition of input parameters for this operation.
import static java.util.Objects.requireNonNull;
import com.google.common.annotations.Beta;
+import com.google.common.collect.Collections2;
import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Sets;
import java.net.URI;
import java.util.Collection;
import java.util.Optional;
-import java.util.Set;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.concepts.Immutable;
* @return set of <code>DataSchemaNode</code> instances which represents
* YANG data nodes at the module top level
*/
- Set<DataSchemaNode> getDataDefinitions();
+ Collection<? extends DataSchemaNode> getDataDefinitions();
/**
* Returns modules which are part of the schema context. Returned set is required to have its iteration ordered
*
* @return set of the modules which belong to the schema context
*/
- Set<Module> getModules();
+ Collection<? extends Module> getModules();
/**
* Returns rpc definition instances which are defined as the direct
* @return set of <code>RpcDefinition</code> instances which represents
* nodes defined via <code>rpc</code> YANG keyword
*/
- Set<RpcDefinition> getOperations();
+ Collection<? extends RpcDefinition> getOperations();
/**
* Returns extension definition instances which are defined as the direct
* @return set of <code>ExtensionDefinition</code> instances which
* represents nodes defined via <code>extension</code> YANG keyword
*/
- Set<ExtensionDefinition> getExtensions();
+ Collection<? extends ExtensionDefinition> getExtensions();
/**
* Returns the module matching specified {@link QNameModule}, if present.
* @return module instance which has name and revision the same as are the values specified in parameters
* <code>name</code> and <code>revision</code>.
*/
- default Optional<Module> findModule(final String name, final Optional<Revision> revision) {
+ default Optional<? extends Module> findModule(final String name, final Optional<Revision> revision) {
return findModules(name).stream().filter(module -> revision.equals(module.getRevision())).findAny();
}
* @return module instance which has name and revision the same as are the values specified in parameters
* <code>name</code> and <code>revision</code>.
*/
- default Optional<Module> findModule(final String name, final @Nullable Revision revision) {
+ default Optional<? extends Module> findModule(final String name, final @Nullable Revision revision) {
return findModule(name, Optional.ofNullable(revision));
}
* and no revision.
* @throws NullPointerException if name is null
*/
- default Optional<Module> findModule(final String name) {
+ default Optional<? extends Module> findModule(final String name) {
return findModule(name, Optional.empty());
}
* string with the module name
* @return set of module instances with specified name.
*/
- default Set<Module> findModules(final String name) {
- return Sets.filter(getModules(), m -> name.equals(m.getName()));
+ default Collection<? extends Module> findModules(final String name) {
+ return Collections2.filter(getModules(), m -> name.equals(m.getName()));
}
/**
* @return module instance which has namespace equal to the
* <code>namespace</code> or <code>null</code> in other cases
*/
- default Set<Module> findModules(final URI namespace) {
- return Sets.filter(getModules(), m -> namespace.equals(m.getNamespace()));
+ default Collection<? extends Module> findModules(final URI namespace) {
+ return Collections2.filter(getModules(), m -> namespace.equals(m.getNamespace()));
}
@Override
- default Set<ActionDefinition> getActions() {
+ default Collection<? extends ActionDefinition> getActions() {
return ImmutableSet.of();
}
@Override
default Optional<NotificationDefinition> findNotification(final QName qname) {
- final Optional<Set<NotificationDefinition>> defs = findModule(qname.getModule()).map(Module::getNotifications);
+ final Optional<Collection<? extends NotificationDefinition>> defs = findModule(qname.getModule())
+ .map(Module::getNotifications);
if (defs.isPresent()) {
for (NotificationDefinition def : defs.get()) {
if (qname.equals(def.getQName())) {
}
@Override
- default Collection<MustDefinition> getMustConstraints() {
+ default Collection<? extends MustDefinition> getMustConstraints() {
return ImmutableSet.of();
}
/**
* An absolute SchemaPath.
*/
+ // FIXME: 5.0.0: expose as a top-level construct (and use in APIs)
private static final class AbsoluteSchemaPath extends SchemaPath {
private AbsoluteSchemaPath(final SchemaPath parent, final QName qname) {
super(parent, qname);
/**
* A relative SchemaPath.
*/
+ // FIXME: 5.0.0: expose as a top-level construct (and use in APIs)
private static final class RelativeSchemaPath extends SchemaPath {
private RelativeSchemaPath(final SchemaPath parent, final QName qname) {
super(parent, qname);
* path from the schema node towards the root.
*/
public Iterable<QName> getPathTowardsRoot() {
- return () -> new UnmodifiableIterator<QName>() {
+ return () -> new UnmodifiableIterator<>() {
private SchemaPath current = SchemaPath.this;
@Override
*/
package org.opendaylight.yangtools.yang.model.api;
+import java.util.Collection;
import java.util.Map;
-import java.util.Set;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.DocumentedNode.WithStatus;
*
* @return schema path to 'grouping' on which this 'uses' statement points
*/
+ // FIXME: 5.0.0: this is effective model, hence we should return GroupingDefinition
@NonNull SchemaPath getGroupingPath();
/**
*
* @return Set of augment statements defined under this uses node
*/
- @NonNull Set<AugmentationSchemaNode> getAugmentations();
+ @NonNull Collection<? extends AugmentationSchemaNode> getAugmentations();
/**
* Some of the properties of each node in the grouping can be refined with the "refine" statement.
*
* @return Map, where key is schema path of refined node and value is refined node
*/
+ // FIXME: 5.0.0: this should probably be SchemaPath.RelativeSchemaPath (which needs to be exposed)
@NonNull Map<SchemaPath, SchemaNode> getRefines();
}
*/
package org.opendaylight.yangtools.yang.model.api.type;
-import java.util.List;
+import java.util.Collection;
import java.util.Objects;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
* @return list of <code>Bit</code> type instastances with data about all
* individual bits of <code>bits</code> YANG built-in type
*/
- @NonNull List<Bit> getBits();
+ @NonNull Collection<? extends Bit> getBits();
static int hashCode(final @NonNull BitsTypeDefinition type) {
return Objects.hash(type.getPath(), type.getUnknownSchemaNodes(), type.getBaseType(),
* Contains the methods for accessing the data about the individual bit of
* <code>bits</code> YANG type.
*/
+ // FIXME: 5.0.0: Bit should not be a SchemaNode
interface Bit extends SchemaNode {
/**
* Returns the name of the concrete bit.
* @return set of identities to which the instance of this type refers (in YANG 1.1 models) or a set containing
* just one identity (in YANG 1.0 models)
*/
- @NonNull Set<IdentitySchemaNode> getIdentities();
+ @NonNull Set<? extends IdentitySchemaNode> getIdentities();
static int hashCode(final @NonNull IdentityrefTypeDefinition type) {
return Objects.hash(type.getPath(), type.getUnknownSchemaNodes(), type.getBaseType(),
final void exportYinModules(final String yangDir, final String yinDir) throws IOException, SAXException,
XMLStreamException {
final SchemaContext schemaContext = YangParserTestUtils.parseYangResourceDirectory(yangDir);
- final Collection<Module> modules = schemaContext.getModules();
+ final Collection<? extends Module> modules = schemaContext.getModules();
assertNotEquals(0, modules.size());
for (Module module : modules) {
import com.google.common.collect.SetMultimap;
import java.net.URI;
import java.util.ArrayList;
+import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
protected abstract Map<QNameModule, Module> getModuleMap();
@Override
- public Set<DataSchemaNode> getDataDefinitions() {
+ public Collection<? extends DataSchemaNode> getDataDefinitions() {
final Set<DataSchemaNode> dataDefs = new HashSet<>();
for (Module m : getModules()) {
dataDefs.addAll(m.getChildNodes());
}
@Override
- public Set<NotificationDefinition> getNotifications() {
+ public Collection<? extends NotificationDefinition> getNotifications() {
final Set<NotificationDefinition> notifications = new HashSet<>();
for (Module m : getModules()) {
notifications.addAll(m.getNotifications());
}
@Override
- public Set<RpcDefinition> getOperations() {
+ public Collection<? extends RpcDefinition> getOperations() {
final Set<RpcDefinition> rpcs = new HashSet<>();
for (Module m : getModules()) {
rpcs.addAll(m.getRpcs());
}
@Override
- public Set<ExtensionDefinition> getExtensions() {
+ public Collection<? extends ExtensionDefinition> getExtensions() {
final Set<ExtensionDefinition> extensions = new HashSet<>();
for (Module m : getModules()) {
extensions.addAll(m.getExtensionSchemaNodes());
}
@Override
- public Optional<Module> findModule(final String name, final Optional<Revision> revision) {
+ public Optional<? extends Module> findModule(final String name, final Optional<Revision> revision) {
for (final Module module : getNameToModules().get(name)) {
if (revision.equals(module.getRevision())) {
return Optional.of(module);
}
@Override
- public Set<Module> findModules(final URI namespace) {
+ public Collection<? extends Module> findModules(final URI namespace) {
return getNamespaceToModules().get(namespace);
}
@Override
- public Set<Module> findModules(final String name) {
+ public Collection<? extends Module> findModules(final String name) {
return getNameToModules().get(name);
}
}
@Override
- public List<UnknownSchemaNode> getUnknownSchemaNodes() {
+ public Collection<? extends UnknownSchemaNode> getUnknownSchemaNodes() {
final List<UnknownSchemaNode> result = new ArrayList<>();
for (Module module : getModules()) {
result.addAll(module.getUnknownSchemaNodes());
}
@Override
- public Set<TypeDefinition<?>> getTypeDefinitions() {
+ public Collection<? extends TypeDefinition<?>> getTypeDefinitions() {
final Set<TypeDefinition<?>> result = new LinkedHashSet<>();
for (Module module : getModules()) {
result.addAll(module.getTypeDefinitions());
}
@Override
- public Set<DataSchemaNode> getChildNodes() {
+ public Collection<? extends DataSchemaNode> getChildNodes() {
final Set<DataSchemaNode> result = new LinkedHashSet<>();
for (Module module : getModules()) {
result.addAll(module.getChildNodes());
}
@Override
- public Set<GroupingDefinition> getGroupings() {
+ public Collection<? extends GroupingDefinition> getGroupings() {
final Set<GroupingDefinition> result = new LinkedHashSet<>();
for (Module module : getModules()) {
result.addAll(module.getGroupings());
}
@Override
- public Set<UsesNode> getUses() {
+ public Collection<? extends UsesNode> getUses() {
return Collections.emptySet();
}
}
@Override
- public Set<AugmentationSchemaNode> getAvailableAugmentations() {
+ public Collection<? extends AugmentationSchemaNode> getAvailableAugmentations() {
return Collections.emptySet();
}
}
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
+import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
-import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
private final ImmutableMap<QName, DataSchemaNode> mappedChildSchemas;
public EffectiveAugmentationSchema(final AugmentationSchemaNode augmentSchema,
- final Set<DataSchemaNode> realChildSchemas) {
+ final Collection<? extends DataSchemaNode> realChildSchemas) {
this.delegate = requireNonNull(augmentSchema);
this.realChildSchemas = ImmutableSet.copyOf(realChildSchemas);
}
@Override
- public List<UnknownSchemaNode> getUnknownSchemaNodes() {
+ public Collection<? extends UnknownSchemaNode> getUnknownSchemaNodes() {
return delegate.getUnknownSchemaNodes();
}
@Override
- public Set<TypeDefinition<?>> getTypeDefinitions() {
+ public Collection<? extends TypeDefinition<?>> getTypeDefinitions() {
return delegate.getTypeDefinitions();
}
@Override
- public Set<DataSchemaNode> getChildNodes() {
+ public Collection<? extends DataSchemaNode> getChildNodes() {
return realChildSchemas;
}
@Override
- public Set<GroupingDefinition> getGroupings() {
+ public Collection<? extends GroupingDefinition> getGroupings() {
return delegate.getGroupings();
}
}
@Override
- public Set<UsesNode> getUses() {
+ public Collection<? extends UsesNode> getUses() {
return delegate.getUses();
}
}
@Override
- public Set<ActionDefinition> getActions() {
+ public Collection<? extends ActionDefinition> getActions() {
return delegate.getActions();
}
}
@Override
- public Set<NotificationDefinition> getNotifications() {
+ public Collection<? extends NotificationDefinition> getNotifications() {
return delegate.getNotifications();
}
module -> checkModuleDependency(module, rootModules)));
}
- private static Multimap<String, Module> getStringModuleMap(final SchemaContext delegate) {
+ private static Multimap<String, ? extends Module> getStringModuleMap(final SchemaContext delegate) {
return Multimaps.index(delegate.getModules(), Module::getName);
}
//dealing with imported module other than root and directly importing root
- private static Collection<Module> getImportedModules(final Map<ModuleId, Module> allModules,
- final Set<Module> baseModules, final TreeMultimap<String, Module> nameToModulesAll) {
+ private static Collection<Module> getImportedModules(final Map<ModuleId, ? extends Module> allModules,
+ final Collection<? extends Module> baseModules, final TreeMultimap<String, Module> nameToModulesAll) {
List<Module> relatedModules = new LinkedList<>();
* @return Sorted list of Modules. Modules can be further processed in returned order.
* @throws IllegalArgumentException when provided modules are not consistent.
*/
- public static List<Module> sort(final Collection<Module> modules) {
+ public static List<Module> sort(final Collection<? extends Module> modules) {
final List<Node> sorted = sortInternal(modules);
// Cast to Module from Node and return
return Lists.transform(sorted, input -> input == null ? null : ((ModuleNodeImpl) input).getReference());
}
- private static List<Node> sortInternal(final Collection<Module> modules) {
+ private static List<Node> sortInternal(final Collection<? extends Module> modules) {
final Table<String, Optional<Revision>, ModuleNodeImpl> moduleGraph = createModuleGraph(modules);
return TopologicalSort.sort(new HashSet<>(moduleGraph.values()));
}
private static Table<String, Optional<Revision>, ModuleNodeImpl> createModuleGraph(
- final Collection<Module> builders) {
+ final Collection<? extends Module> builders) {
final Table<String, Optional<Revision>, ModuleNodeImpl> moduleGraph = HashBasedTable.create();
processModules(moduleGraph, builders);
* Extract module:revision from modules.
*/
private static void processDependencies(final Table<String, Optional<Revision>, ModuleNodeImpl> moduleGraph,
- final Collection<Module> mmbs) {
+ final Collection<? extends Module> mmbs) {
final Map<URI, Module> allNS = new HashMap<>();
// Create edges in graph
}
}
- private static Collection<ModuleImport> allImports(final Module mod) {
+ private static Collection<? extends ModuleImport> allImports(final Module mod) {
if (mod.getSubmodules().isEmpty()) {
return mod.getImports();
}
* Extract dependencies from modules to fill dependency graph.
*/
private static void processModules(final Table<String, Optional<Revision>, ModuleNodeImpl> moduleGraph,
- final Iterable<Module> modules) {
+ final Iterable<? extends Module> modules) {
// Process nodes
for (final Module momb : modules) {
return module;
}
- final Set<ModuleImport> imports = module.getImports();
- for (final ModuleImport mi : imports) {
+ for (final ModuleImport mi : module.getImports()) {
if (prefix.equals(mi.getPrefix())) {
return context.findModule(mi.getModuleName(), mi.getRevision()).orElse(null);
}
import java.util.Collection;
import java.util.List;
import java.util.Optional;
-import java.util.Set;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
return;
}
- final Iterable<DataSchemaNode> childNodes = dataNode.getChildNodes();
- if (childNodes != null) {
- for (DataSchemaNode childNode : childNodes) {
- if (childNode.isAugmenting()) {
- continue;
- }
- aggregator.addChild(childNode);
- if (childNode instanceof ContainerSchemaNode) {
- final ContainerSchemaNode containerNode = (ContainerSchemaNode) childNode;
- aggregator.addContainer(containerNode);
- traverse(aggregator, containerNode);
- } else if (childNode instanceof ListSchemaNode) {
- final ListSchemaNode list = (ListSchemaNode) childNode;
- aggregator.addList(list);
- traverse(aggregator, list);
- } else if (childNode instanceof ChoiceSchemaNode) {
- final ChoiceSchemaNode choiceNode = (ChoiceSchemaNode) childNode;
- aggregator.addChoice(choiceNode);
- for (final CaseSchemaNode caseNode : choiceNode.getCases().values()) {
- traverse(aggregator, caseNode);
- }
+ for (DataSchemaNode childNode : dataNode.getChildNodes()) {
+ if (childNode.isAugmenting()) {
+ continue;
+ }
+ aggregator.addChild(childNode);
+ if (childNode instanceof ContainerSchemaNode) {
+ final ContainerSchemaNode containerNode = (ContainerSchemaNode) childNode;
+ aggregator.addContainer(containerNode);
+ traverse(aggregator, containerNode);
+ } else if (childNode instanceof ListSchemaNode) {
+ final ListSchemaNode list = (ListSchemaNode) childNode;
+ aggregator.addList(list);
+ traverse(aggregator, list);
+ } else if (childNode instanceof ChoiceSchemaNode) {
+ final ChoiceSchemaNode choiceNode = (ChoiceSchemaNode) childNode;
+ aggregator.addChoice(choiceNode);
+ for (final CaseSchemaNode caseNode : choiceNode.getCases().values()) {
+ traverse(aggregator, caseNode);
}
}
}
}
private static void traverseGroupings(final DataNodeAggregator aggregator, final DataNodeContainer dataNode) {
- final Set<GroupingDefinition> groupings = dataNode.getGroupings();
- if (groupings != null) {
- for (GroupingDefinition grouping : groupings) {
- aggregator.addGrouping(grouping);
- traverse(aggregator, grouping);
- }
+ for (GroupingDefinition grouping : dataNode.getGroupings()) {
+ aggregator.addGrouping(grouping);
+ traverse(aggregator, grouping);
}
}
}
import com.google.common.collect.SetMultimap;
import java.net.URI;
import java.util.ArrayList;
+import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Optional;
private final ImmutableSet<Module> modules;
private final ImmutableMap<QName, AnnotationSchemaNode> annotations;
- protected SimpleSchemaContext(final Set<Module> modules) {
+ protected SimpleSchemaContext(final Collection<? extends Module> modules) {
/*
* Instead of doing this on each invocation of getModules(), pre-compute it once and keep it around -- better
* than the set we got in.
* Create a new instance from specified modules. Note that no module validation is done and hence the consistency
* of the resulting SchemaContext is completely in hands of the caller.
*/
- public static SimpleSchemaContext forModules(final Set<Module> modules) {
+ public static SimpleSchemaContext forModules(final Collection<? extends Module> modules) {
return new SimpleSchemaContext(modules);
}
package org.opendaylight.yangtools.yang.model.util.type;
import com.google.common.collect.ImmutableList;
-import java.util.List;
+import java.util.Collection;
import java.util.Optional;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
this(SchemaPath.ROOT.createChild(qname), ImmutableList.of());
}
- AbstractBaseType(final SchemaPath path, final List<UnknownSchemaNode> unknownSchemaNodes) {
+ AbstractBaseType(final SchemaPath path, final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
super(path, unknownSchemaNodes);
}
AbstractDerivedType(final T baseType, final SchemaPath path, final Object defaultValue, final String description,
final String reference, final Status status, final String units,
- final Collection<UnknownSchemaNode> unknownSchemNodes) {
+ final Collection<? extends UnknownSchemaNode> unknownSchemNodes) {
super(path, unknownSchemNodes);
this.baseType = requireNonNull(baseType);
this.status = requireNonNull(status);
AbstractLengthRestrictedDerivedType(final T baseType, final SchemaPath path,
final Object defaultValue, final String description, final String reference, final Status status,
- final String units, final Collection<UnknownSchemaNode> unknownSchemaNodes) {
+ final String units, final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
super(baseType, path, defaultValue, description, reference, status, units, unknownSchemaNodes);
}
private final @Nullable LengthConstraint lengthConstraint;
AbstractLengthRestrictedType(final T baseType, final SchemaPath path,
- final Collection<UnknownSchemaNode> unknownSchemaNodes, final @Nullable LengthConstraint lengthConstraint) {
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes,
+ final @Nullable LengthConstraint lengthConstraint) {
super(baseType, path, unknownSchemaNodes);
this.lengthConstraint = lengthConstraint;
}
import com.google.common.collect.ImmutableRangeSet;
import com.google.common.collect.Range;
-import java.util.List;
+import java.util.Collection;
import java.util.Optional;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ConstraintMetaDefinition;
Range.closed(minValue, maxValue)));
}
- AbstractRangeRestrictedBaseType(final SchemaPath path, final List<UnknownSchemaNode> unknownSchemaNodes,
- final RangeConstraint<N> rangeConstraint) {
+ AbstractRangeRestrictedBaseType(final SchemaPath path,
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes,
+ final RangeConstraint<N> rangeConstraint) {
super(path, unknownSchemaNodes);
this.rangeConstraint = requireNonNull(rangeConstraint);
}
AbstractRangeRestrictedDerivedType(final T baseType, final SchemaPath path,
final Object defaultValue, final String description, final String reference, final Status status,
- final String units, final Collection<UnknownSchemaNode> unknownSchemaNodes) {
+ final String units, final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
super(baseType, path, defaultValue, description, reference, status, units, unknownSchemaNodes);
}
private final @Nullable RangeConstraint<N> rangeConstraint;
AbstractRangeRestrictedType(final T baseType, final SchemaPath path,
- final Collection<UnknownSchemaNode> unknownSchemaNodes, final @Nullable RangeConstraint<N> rangeConstraint) {
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes,
+ final @Nullable RangeConstraint<N> rangeConstraint) {
super(baseType, path, unknownSchemaNodes);
this.rangeConstraint = rangeConstraint;
}
private final @NonNull T baseType;
AbstractRestrictedType(final T baseType, final SchemaPath path,
- final Collection<UnknownSchemaNode> unknownSchemaNodes) {
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
super(path, unknownSchemaNodes);
this.baseType = requireNonNull(baseType);
}
import com.google.common.collect.ImmutableList;
import java.util.Collection;
-import java.util.List;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.common.QName;
private final @NonNull ImmutableList<UnknownSchemaNode> unknownSchemaNodes;
private final @NonNull SchemaPath path;
- AbstractTypeDefinition(final SchemaPath path, final Collection<UnknownSchemaNode> unknownSchemaNodes) {
+ AbstractTypeDefinition(final SchemaPath path, final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
this.path = requireNonNull(path);
this.unknownSchemaNodes = ImmutableList.copyOf(unknownSchemaNodes);
}
}
@Override
- public final List<UnknownSchemaNode> getUnknownSchemaNodes() {
+ public final Collection<? extends UnknownSchemaNode> getUnknownSchemaNodes() {
return unknownSchemaNodes;
}
import com.google.common.collect.ImmutableList;
import java.util.Collection;
-import java.util.List;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
final class BaseBitsType extends AbstractBaseType<BitsTypeDefinition> implements BitsTypeDefinition {
private final @NonNull ImmutableList<Bit> bits;
- BaseBitsType(final SchemaPath path, final List<UnknownSchemaNode> unknownSchemaNodes, final Collection<Bit> bits) {
+ BaseBitsType(final SchemaPath path, final Collection<? extends UnknownSchemaNode> unknownSchemaNodes,
+ final Collection<Bit> bits) {
super(path, unknownSchemaNodes);
this.bits = ImmutableList.copyOf(bits);
}
@Override
- public List<Bit> getBits() {
+ public Collection<? extends Bit> getBits() {
return bits;
}
import com.google.common.collect.ImmutableRangeSet;
import com.google.common.collect.Range;
import java.math.BigDecimal;
-import java.util.List;
+import java.util.Collection;
import java.util.Optional;
import org.opendaylight.yangtools.yang.model.api.ConstraintMetaDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
private final int fractionDigits;
- BaseDecimalType(final SchemaPath path, final List<UnknownSchemaNode> unknownSchemaNodes,
+ BaseDecimalType(final SchemaPath path, final Collection<? extends UnknownSchemaNode> unknownSchemaNodes,
final int fractionDigits, final RangeConstraint<BigDecimal> rangeConstraint) {
super(path, unknownSchemaNodes, rangeConstraint);
this.fractionDigits = fractionDigits;
final class BaseEnumerationType extends AbstractBaseType<EnumTypeDefinition> implements EnumTypeDefinition {
private final @NonNull ImmutableList<EnumPair> values;
- BaseEnumerationType(final SchemaPath path, final List<UnknownSchemaNode> unknownSchemaNodes,
+ BaseEnumerationType(final SchemaPath path, final Collection<? extends UnknownSchemaNode> unknownSchemaNodes,
final Collection<EnumPair> values) {
super(path, unknownSchemaNodes);
this.values = ImmutableList.copyOf(values);
import static java.util.Objects.requireNonNull;
-import java.util.List;
+import java.util.Collection;
import java.util.Set;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
final class BaseIdentityrefType extends AbstractBaseType<IdentityrefTypeDefinition>
implements IdentityrefTypeDefinition {
- private final @NonNull Set<IdentitySchemaNode> identities;
+ private final @NonNull Set<? extends IdentitySchemaNode> identities;
- BaseIdentityrefType(final SchemaPath path, final List<UnknownSchemaNode> unknownSchemaNodes,
- final Set<IdentitySchemaNode> identities) {
+ BaseIdentityrefType(final SchemaPath path, final Collection<? extends UnknownSchemaNode> unknownSchemaNodes,
+ final Set<? extends IdentitySchemaNode> identities) {
super(path, unknownSchemaNodes);
this.identities = requireNonNull(identities);
}
@Override
- public Set<IdentitySchemaNode> getIdentities() {
+ public Set<? extends IdentitySchemaNode> getIdentities() {
return identities;
}
import static java.util.Objects.requireNonNull;
-import java.util.List;
+import java.util.Collection;
import org.opendaylight.yangtools.yang.model.api.PathExpression;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
private final boolean requireInstance;
BaseLeafrefType(final SchemaPath path, final PathExpression pathStatement, final boolean requireInstance,
- final List<UnknownSchemaNode> unknownSchemaNodes) {
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
super(path, unknownSchemaNodes);
this.pathStatement = requireNonNull(pathStatement);
this.requireInstance = requireInstance;
final class BaseUnionType extends AbstractBaseType<UnionTypeDefinition> implements UnionTypeDefinition {
private final ImmutableList<TypeDefinition<?>> types;
- BaseUnionType(final SchemaPath path, final List<UnknownSchemaNode> unknownSchemaNodes,
+ BaseUnionType(final SchemaPath path, final Collection<? extends UnknownSchemaNode> unknownSchemaNodes,
final Collection<TypeDefinition<?>> types) {
super(path, unknownSchemaNodes);
this.types = ImmutableList.copyOf(types);
import static java.util.Objects.requireNonNull;
import com.google.common.collect.ImmutableList;
+import java.util.Collection;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
}
@Override
- public List<UnknownSchemaNode> getUnknownSchemaNodes() {
+ public Collection<? extends UnknownSchemaNode> getUnknownSchemaNodes() {
return unknownNodes;
}
implements BinaryTypeDefinition {
DerivedBinaryType(final BinaryTypeDefinition baseType, final SchemaPath path, final Object defaultValue,
final String description, final String reference, final Status status, final String units,
- final Collection<UnknownSchemaNode> unknownSchemNodes) {
+ final Collection<? extends UnknownSchemaNode> unknownSchemNodes) {
super(baseType, path, defaultValue, description, reference, status, units, unknownSchemNodes);
}
package org.opendaylight.yangtools.yang.model.util.type;
import java.util.Collection;
-import java.util.List;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
final class DerivedBitsType extends AbstractDerivedType<BitsTypeDefinition> implements BitsTypeDefinition {
DerivedBitsType(final BitsTypeDefinition baseType, final SchemaPath path, final Object defaultValue,
final String description, final String reference, final Status status, final String units,
- final Collection<UnknownSchemaNode> unknownSchemNodes) {
+ final Collection<? extends UnknownSchemaNode> unknownSchemNodes) {
super(baseType, path, defaultValue, description, reference, status, units, unknownSchemNodes);
}
@Override
- public List<Bit> getBits() {
+ public Collection<? extends Bit> getBits() {
return baseType().getBits();
}
final class DerivedBooleanType extends AbstractDerivedType<BooleanTypeDefinition> implements BooleanTypeDefinition {
DerivedBooleanType(final BooleanTypeDefinition baseType, final SchemaPath path, final Object defaultValue,
- final String description, final String reference, final Status status, final String units,
- final Collection<UnknownSchemaNode> unknownSchemNodes) {
+ final String description, final String reference, final Status status, final String units,
+ final Collection<? extends UnknownSchemaNode> unknownSchemNodes) {
super(baseType, path, defaultValue, description, reference, status, units, unknownSchemNodes);
}
final class DerivedDecimalType extends AbstractRangeRestrictedDerivedType<DecimalTypeDefinition, BigDecimal>
implements DecimalTypeDefinition {
DerivedDecimalType(final DecimalTypeDefinition baseType, final SchemaPath path, final Object defaultValue,
- final String description, final String reference, final Status status, final String units,
- final Collection<UnknownSchemaNode> unknownSchemNodes) {
+ final String description, final String reference, final Status status, final String units,
+ final Collection<? extends UnknownSchemaNode> unknownSchemNodes) {
super(baseType, path, defaultValue, description, reference, status, units, unknownSchemNodes);
}
final class DerivedEmptyType extends AbstractDerivedType<EmptyTypeDefinition> implements EmptyTypeDefinition {
DerivedEmptyType(final EmptyTypeDefinition baseType, final SchemaPath path, final Object defaultValue,
final String description, final String reference, final Status status, final String units,
- final Collection<UnknownSchemaNode> unknownSchemNodes) {
+ final Collection<? extends UnknownSchemaNode> unknownSchemNodes) {
super(baseType, path, defaultValue, description, reference, status, units, unknownSchemNodes);
}
final class DerivedEnumerationType extends AbstractDerivedType<EnumTypeDefinition> implements EnumTypeDefinition {
DerivedEnumerationType(final EnumTypeDefinition baseType, final SchemaPath path, final Object defaultValue,
final String description, final String reference, final Status status, final String units,
- final Collection<UnknownSchemaNode> unknownSchemNodes) {
+ final Collection<? extends UnknownSchemaNode> unknownSchemNodes) {
super(baseType, path, defaultValue, description, reference, status, units, unknownSchemNodes);
}
final class DerivedIdentityrefType extends AbstractDerivedType<IdentityrefTypeDefinition>
implements IdentityrefTypeDefinition {
DerivedIdentityrefType(final IdentityrefTypeDefinition baseType, final SchemaPath path, final Object defaultValue,
- final String description, final String reference, final Status status, final String units,
- final Collection<UnknownSchemaNode> unknownSchemaNodes) {
+ final String description, final String reference, final Status status, final String units,
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
super(baseType, path, defaultValue, description, reference, status, units, unknownSchemaNodes);
}
@Override
- public Set<IdentitySchemaNode> getIdentities() {
+ public Set<? extends IdentitySchemaNode> getIdentities() {
return baseType().getIdentities();
}
DerivedInstanceIdentifierType(final InstanceIdentifierTypeDefinition baseType, final SchemaPath path,
final Object defaultValue, final String description, final String reference, final Status status,
- final String units, final Collection<UnknownSchemaNode> unknownSchemaNodes,
+ final String units, final Collection<? extends UnknownSchemaNode> unknownSchemaNodes,
final boolean requireInstance) {
super(baseType, path, defaultValue, description, reference, status, units, unknownSchemaNodes);
this.requireInstance = requireInstance;
implements Int16TypeDefinition {
DerivedInt16Type(final Int16TypeDefinition baseType, final SchemaPath path, final Object defaultValue,
final String description, final String reference, final Status status, final String units,
- final Collection<UnknownSchemaNode> unknownSchemaNodes) {
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
super(baseType, path, defaultValue, description, reference, status, units, unknownSchemaNodes);
}
implements Int32TypeDefinition {
DerivedInt32Type(final Int32TypeDefinition baseType, final SchemaPath path, final Object defaultValue,
final String description, final String reference, final Status status, final String units,
- final Collection<UnknownSchemaNode> unknownSchemaNodes) {
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
super(baseType, path, defaultValue, description, reference, status, units, unknownSchemaNodes);
}
implements Int64TypeDefinition {
DerivedInt64Type(final Int64TypeDefinition baseType, final SchemaPath path, final Object defaultValue,
final String description, final String reference, final Status status, final String units,
- final Collection<UnknownSchemaNode> unknownSchemaNodes) {
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
super(baseType, path, defaultValue, description, reference, status, units, unknownSchemaNodes);
}
implements Int8TypeDefinition {
DerivedInt8Type(final Int8TypeDefinition baseType, final SchemaPath path, final Object defaultValue,
final String description, final String reference, final Status status, final String units,
- final Collection<UnknownSchemaNode> unknownSchemaNodes) {
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
super(baseType, path, defaultValue, description, reference, status, units, unknownSchemaNodes);
}
DerivedLeafrefType(final LeafrefTypeDefinition baseType, final SchemaPath path, final Object defaultValue,
final String description, final String reference, final Status status, final String units,
- final Collection<UnknownSchemaNode> unknownSchemaNodes) {
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
super(baseType, path, defaultValue, description, reference, status, units, unknownSchemaNodes);
}
implements StringTypeDefinition {
DerivedStringType(final StringTypeDefinition baseType, final SchemaPath path, final Object defaultValue,
final String description, final String reference, final Status status, final String units,
- final Collection<UnknownSchemaNode> unknownSchemaNodes) {
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
super(baseType, path, defaultValue, description, reference, status, units, unknownSchemaNodes);
}
DerivedUint16Type(final Uint16TypeDefinition baseType, final SchemaPath path,
final Object defaultValue, final String description, final String reference, final Status status,
- final String units, final Collection<UnknownSchemaNode> unknownSchemaNodes) {
+ final String units, final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
super(baseType, path, defaultValue, description, reference, status, units, unknownSchemaNodes);
}
DerivedUint32Type(final Uint32TypeDefinition baseType, final SchemaPath path,
final Object defaultValue, final String description, final String reference, final Status status,
- final String units, final Collection<UnknownSchemaNode> unknownSchemaNodes) {
+ final String units, final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
super(baseType, path, defaultValue, description, reference, status, units, unknownSchemaNodes);
}
implements Uint64TypeDefinition {
DerivedUint64Type(final Uint64TypeDefinition baseType, final SchemaPath path,
final Object defaultValue, final String description, final String reference, final Status status,
- final String units, final Collection<UnknownSchemaNode> unknownSchemaNodes) {
+ final String units, final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
super(baseType, path, defaultValue, description, reference, status, units, unknownSchemaNodes);
}
implements Uint8TypeDefinition {
DerivedUint8Type(final Uint8TypeDefinition baseType, final SchemaPath path,
final Object defaultValue, final String description, final String reference, final Status status,
- final String units, final Collection<UnknownSchemaNode> unknownSchemaNodes) {
+ final String units, final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
super(baseType, path, defaultValue, description, reference, status, units, unknownSchemaNodes);
}
final class DerivedUnionType extends AbstractDerivedType<UnionTypeDefinition> implements UnionTypeDefinition {
DerivedUnionType(final UnionTypeDefinition baseType, final SchemaPath path, final Object defaultValue,
final String description, final String reference, final Status status, final String units,
- final Collection<UnknownSchemaNode> unknownSchemaNodes) {
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
super(baseType, path, defaultValue, description, reference, status, units, unknownSchemaNodes);
}
return this;
}
- public EnumPairBuilder setUnknownSchemaNodes(final Collection<UnknownSchemaNode> unknownSchemaNodes) {
+ public EnumPairBuilder setUnknownSchemaNodes(final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
this.unknownSchemaNodes = ImmutableList.copyOf(unknownSchemaNodes);
return this;
}
import com.google.common.base.MoreObjects;
import com.google.common.collect.ImmutableList;
-import java.util.List;
+import java.util.Collection;
import java.util.Objects;
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
}
@Override
- public List<UnknownSchemaNode> getUnknownSchemaNodes() {
+ public Collection<? extends UnknownSchemaNode> getUnknownSchemaNodes() {
return unknownSchemaNodes;
}
final class RestrictedBinaryType extends AbstractLengthRestrictedType<BinaryTypeDefinition>
implements BinaryTypeDefinition {
RestrictedBinaryType(final BinaryTypeDefinition baseType, final SchemaPath path,
- final Collection<UnknownSchemaNode> unknownSchemaNodes,
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes,
final @Nullable LengthConstraint lengthConstraint) {
super(baseType, path, unknownSchemaNodes, lengthConstraint);
}
import com.google.common.collect.ImmutableList;
import java.util.Collection;
-import java.util.List;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
private final @NonNull ImmutableList<Bit> bits;
RestrictedBitsType(final BitsTypeDefinition baseType, final SchemaPath path,
- final Collection<UnknownSchemaNode> unknownSchemaNodes, final Collection<Bit> bits) {
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes, final Collection<Bit> bits) {
super(baseType, path, unknownSchemaNodes);
this.bits = ImmutableList.copyOf(bits);
}
@Override
- public List<Bit> getBits() {
+ public Collection<? extends Bit> getBits() {
return bits;
}
final class RestrictedBooleanType extends AbstractRestrictedType<BooleanTypeDefinition>
implements BooleanTypeDefinition {
RestrictedBooleanType(final BooleanTypeDefinition baseType, final SchemaPath path,
- final Collection<UnknownSchemaNode> unknownSchemaNodes) {
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
super(baseType, path, unknownSchemaNodes);
}
final class RestrictedDecimalType extends AbstractRangeRestrictedType<DecimalTypeDefinition, BigDecimal>
implements DecimalTypeDefinition {
RestrictedDecimalType(final DecimalTypeDefinition baseType, final SchemaPath path,
- final Collection<UnknownSchemaNode> unknownSchemaNodes,
- final @Nullable RangeConstraint<BigDecimal> rangeConstraint) {
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes,
+ final @Nullable RangeConstraint<BigDecimal> rangeConstraint) {
super(baseType, path, unknownSchemaNodes, rangeConstraint);
}
final class RestrictedEmptyType extends AbstractRestrictedType<EmptyTypeDefinition> implements EmptyTypeDefinition {
RestrictedEmptyType(final EmptyTypeDefinition baseType, final SchemaPath path,
- final Collection<UnknownSchemaNode> unknownSchemaNodes) {
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
super(baseType, path, unknownSchemaNodes);
}
private final @NonNull ImmutableList<EnumPair> values;
RestrictedEnumerationType(final EnumTypeDefinition baseType, final SchemaPath path,
- final Collection<UnknownSchemaNode> unknownSchemaNodes, final Collection<EnumPair> values) {
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes, final Collection<EnumPair> values) {
super(baseType, path, unknownSchemaNodes);
this.values = ImmutableList.copyOf(values);
}
final class RestrictedIdentityrefType extends AbstractRestrictedType<IdentityrefTypeDefinition>
implements IdentityrefTypeDefinition {
RestrictedIdentityrefType(final IdentityrefTypeDefinition baseType, final SchemaPath path,
- final Collection<UnknownSchemaNode> unknownSchemaNodes) {
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
super(baseType, path, unknownSchemaNodes);
}
@Override
- public Set<IdentitySchemaNode> getIdentities() {
+ public Set<? extends IdentitySchemaNode> getIdentities() {
return getBaseType().getIdentities();
}
private final boolean requireInstance;
RestrictedInstanceIdentifierType(final InstanceIdentifierTypeDefinition baseType, final SchemaPath path,
- final Collection<UnknownSchemaNode> unknownSchemaNodes, final boolean requireInstance) {
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes, final boolean requireInstance) {
super(baseType, path, unknownSchemaNodes);
this.requireInstance = requireInstance;
}
final class RestrictedInt16Type extends AbstractRangeRestrictedType<Int16TypeDefinition, Short>
implements Int16TypeDefinition {
RestrictedInt16Type(final Int16TypeDefinition baseType, final SchemaPath path,
- final Collection<UnknownSchemaNode> unknownSchemaNodes,
- final @Nullable RangeConstraint<Short> rangeConstraint) {
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes,
+ final @Nullable RangeConstraint<Short> rangeConstraint) {
super(baseType, path, unknownSchemaNodes, rangeConstraint);
}
final class RestrictedInt32Type extends AbstractRangeRestrictedType<Int32TypeDefinition, Integer>
implements Int32TypeDefinition {
RestrictedInt32Type(final Int32TypeDefinition baseType, final SchemaPath path,
- final Collection<UnknownSchemaNode> unknownSchemaNodes,
- final @Nullable RangeConstraint<Integer> rangeConstraint) {
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes,
+ final @Nullable RangeConstraint<Integer> rangeConstraint) {
super(baseType, path, unknownSchemaNodes, rangeConstraint);
}
final class RestrictedInt64Type extends AbstractRangeRestrictedType<Int64TypeDefinition, Long>
implements Int64TypeDefinition {
RestrictedInt64Type(final Int64TypeDefinition baseType, final SchemaPath path,
- final Collection<UnknownSchemaNode> unknownSchemaNodes, final @Nullable RangeConstraint<Long> rangeConstraint) {
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes,
+ final @Nullable RangeConstraint<Long> rangeConstraint) {
super(baseType, path, unknownSchemaNodes, rangeConstraint);
}
final class RestrictedInt8Type extends AbstractRangeRestrictedType<Int8TypeDefinition, Byte>
implements Int8TypeDefinition {
RestrictedInt8Type(final Int8TypeDefinition baseType, final SchemaPath path,
- final Collection<UnknownSchemaNode> unknownSchemaNodes, final @Nullable RangeConstraint<Byte> rangeConstraint) {
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes,
+ final @Nullable RangeConstraint<Byte> rangeConstraint) {
super(baseType, path, unknownSchemaNodes, rangeConstraint);
}
private final boolean requireInstance;
RestrictedLeafrefType(final LeafrefTypeDefinition baseType, final SchemaPath path,
- final Collection<UnknownSchemaNode> unknownSchemaNodes, final boolean requireInstance) {
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes, final boolean requireInstance) {
super(baseType, path, unknownSchemaNodes);
this.requireInstance = requireInstance;
private final @NonNull ImmutableList<PatternConstraint> patternConstraints;
RestrictedStringType(final StringTypeDefinition baseType, final SchemaPath path,
- final Collection<UnknownSchemaNode> unknownSchemaNodes,
- final @Nullable LengthConstraint lengthConstraints,
- final List<PatternConstraint> patternConstraints) {
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes,
+ final @Nullable LengthConstraint lengthConstraints,
+
final List<PatternConstraint> patternConstraints) {
super(baseType, path, unknownSchemaNodes, lengthConstraints);
this.patternConstraints = ImmutableList.copyOf(patternConstraints);
}
final class RestrictedUint16Type extends AbstractRangeRestrictedType<Uint16TypeDefinition, Uint16>
implements Uint16TypeDefinition {
RestrictedUint16Type(final Uint16TypeDefinition baseType, final SchemaPath path,
- final Collection<UnknownSchemaNode> unknownSchemaNodes,
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes,
final @Nullable RangeConstraint<Uint16> rangeConstraint) {
super(baseType, path, unknownSchemaNodes, rangeConstraint);
}
final class RestrictedUint32Type extends AbstractRangeRestrictedType<Uint32TypeDefinition, Uint32>
implements Uint32TypeDefinition {
RestrictedUint32Type(final Uint32TypeDefinition baseType, final SchemaPath path,
- final Collection<UnknownSchemaNode> unknownSchemaNodes,
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes,
final @Nullable RangeConstraint<Uint32> rangeConstraint) {
super(baseType, path, unknownSchemaNodes, rangeConstraint);
}
final class RestrictedUint64Type extends AbstractRangeRestrictedType<Uint64TypeDefinition, Uint64>
implements Uint64TypeDefinition {
RestrictedUint64Type(final Uint64TypeDefinition baseType, final SchemaPath path,
- final Collection<UnknownSchemaNode> unknownSchemaNodes,
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes,
final @Nullable RangeConstraint<Uint64> rangeConstraint) {
super(baseType, path, unknownSchemaNodes, rangeConstraint);
}
final class RestrictedUint8Type extends AbstractRangeRestrictedType<Uint8TypeDefinition, Uint8>
implements Uint8TypeDefinition {
RestrictedUint8Type(final Uint8TypeDefinition baseType, final SchemaPath path,
- final Collection<UnknownSchemaNode> unknownSchemaNodes,
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes,
final @Nullable RangeConstraint<Uint8> rangeConstraint) {
super(baseType, path, unknownSchemaNodes, rangeConstraint);
}
final class RestrictedUnionType extends AbstractRestrictedType<UnionTypeDefinition> implements UnionTypeDefinition {
RestrictedUnionType(final UnionTypeDefinition baseType, final SchemaPath path,
- final Collection<UnknownSchemaNode> unknownSchemaNodes) {
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
super(baseType, path, unknownSchemaNodes);
}
import static java.util.Objects.requireNonNull;
import com.google.common.collect.ImmutableList;
-import java.util.List;
+import java.util.Collection;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.concepts.Builder;
return path;
}
- final @NonNull List<UnknownSchemaNode> getUnknownSchemaNodes() {
+ final @NonNull Collection<? extends UnknownSchemaNode> getUnknownSchemaNodes() {
return unknownSchemaNodes.build();
}
import com.google.common.collect.ImmutableSet;
import java.net.URI;
import java.util.Arrays;
+import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
final Set<DataSchemaNode> childNodes = Collections.singleton(mockedContainer);
doReturn(childNodes).when(moduleConfig).getChildNodes();
- final Set<DataSchemaNode> dataDefinitions = filteringSchemaContextProxy.getDataDefinitions();
+ final Collection<? extends DataSchemaNode> dataDefinitions =
+ filteringSchemaContextProxy.getDataDefinitions();
assertTrue(dataDefinitions.contains(mockedContainer));
}
final Set<NotificationDefinition> notifications = Collections.singleton(mockedNotification);
doReturn(notifications).when(moduleConfig).getNotifications();
- final Set<NotificationDefinition> schemaContextProxyNotifications =
+ final Collection<? extends NotificationDefinition> schemaContextProxyNotifications =
filteringSchemaContextProxy.getNotifications();
assertTrue(schemaContextProxyNotifications.contains(mockedNotification));
}
final Set<RpcDefinition> rpcs = Collections.singleton(mockedRpc);
doReturn(rpcs).when(moduleConfig).getRpcs();
- final Set<RpcDefinition> operations = filteringSchemaContextProxy.getOperations();
+ final Collection<? extends RpcDefinition> operations = filteringSchemaContextProxy.getOperations();
assertTrue(operations.contains(mockedRpc));
}
final List<ExtensionDefinition> extensions = Collections.singletonList(mockedExtension);
doReturn(extensions).when(moduleConfig).getExtensionSchemaNodes();
- final Set<ExtensionDefinition> schemaContextProxyExtensions = filteringSchemaContextProxy.getExtensions();
+ final Collection<? extends ExtensionDefinition> schemaContextProxyExtensions =
+ filteringSchemaContextProxy.getExtensions();
assertTrue(schemaContextProxyExtensions.contains(mockedExtension));
}
final List<UnknownSchemaNode> unknownSchemaNodes = Collections.singletonList(mockedUnknownSchemaNode);
doReturn(unknownSchemaNodes).when(moduleConfig).getUnknownSchemaNodes();
- final List<UnknownSchemaNode> schemaContextProxyUnknownSchemaNodes =
+ final Collection<? extends UnknownSchemaNode> schemaContextProxyUnknownSchemaNodes =
filteringSchemaContextProxy.getUnknownSchemaNodes();
assertTrue(schemaContextProxyUnknownSchemaNodes.contains(mockedUnknownSchemaNode));
}
final Set<TypeDefinition<?>> typeDefinitions = Collections.singleton(mockedTypeDefinition);
doReturn(typeDefinitions).when(moduleConfig).getTypeDefinitions();
- final Set<TypeDefinition<?>> schemaContextProxyTypeDefinitions = filteringSchemaContextProxy
+ final Collection<? extends TypeDefinition<?>> schemaContextProxyTypeDefinitions = filteringSchemaContextProxy
.getTypeDefinitions();
assertTrue(schemaContextProxyTypeDefinitions.contains(mockedTypeDefinition));
}
final Set<DataSchemaNode> childNodes = Collections.singleton(mockedContainer);
doReturn(childNodes).when(moduleConfig).getChildNodes();
- final Set<DataSchemaNode> schemaContextProxyChildNodes = filteringSchemaContextProxy.getChildNodes();
+ final Collection<? extends DataSchemaNode> schemaContextProxyChildNodes =
+ filteringSchemaContextProxy.getChildNodes();
assertTrue(schemaContextProxyChildNodes.contains(mockedContainer));
}
final Set<GroupingDefinition> groupings = Collections.singleton(mockedGrouping);
doReturn(groupings).when(moduleConfig).getGroupings();
- final Set<GroupingDefinition> schemaContextProxyGroupings = filteringSchemaContextProxy.getGroupings();
+ final Collection<? extends GroupingDefinition> schemaContextProxyGroupings =
+ filteringSchemaContextProxy.getGroupings();
assertTrue(schemaContextProxyGroupings.contains(mockedGrouping));
}
assertEquals(module, filteringSchemaContextProxy.findModule(module.getName(), module.getRevision())
.get());
- Set<Module> mod = filteringSchemaContextProxy.findModules(module.getNamespace());
+ Collection<? extends Module> mod = filteringSchemaContextProxy.findModules(module.getNamespace());
assertTrue(mod.contains(module));
assertEquals(module, filteringSchemaContextProxy.findModule(module.getNamespace(),
module.getRevision().orElse(null)).get());
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import java.net.URI;
+import java.util.Collection;
import java.util.List;
import java.util.Optional;
import java.util.Set;
}
private static void assertGetModules(final List<Module> expected, final Module... modules) {
- final Set<Module> actual = SimpleSchemaContext.forModules(ImmutableSet.copyOf(modules)).getModules();
+ final Set<Module> actual = SimpleSchemaContext.forModules(ImmutableList.copyOf(modules)).getModules();
assertArrayEquals(expected.toArray(), actual.toArray());
}
private static void assertFindModules(final List<Module> expected, final String name, final Module... modules) {
- final Set<Module> actual = SimpleSchemaContext.forModules(ImmutableSet.copyOf(modules)).findModules(name);
+ final Collection<? extends Module> actual = SimpleSchemaContext.forModules(ImmutableList.copyOf(modules))
+ .findModules(name);
assertArrayEquals(expected.toArray(), actual.toArray());
}
private static void assertFindModules(final List<Module> expected, final URI uri, final Module... modules) {
- final Set<Module> actual = SimpleSchemaContext.forModules(ImmutableSet.copyOf(modules)).findModules(uri);
+ final Collection<? extends Module> actual = SimpleSchemaContext.forModules(ImmutableSet.copyOf(modules))
+ .findModules(uri);
assertArrayEquals(expected.toArray(), actual.toArray());
}
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt;
import com.google.common.collect.ImmutableSet;
+import java.util.Collection;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Optional;
}
@Override
- public final Set<TypeDefinition<?>> getTypeDefinitions() {
+ public final Collection<? extends TypeDefinition<?>> getTypeDefinitions() {
return typeDefinitions;
}
@Override
- public final Set<DataSchemaNode> getChildNodes() {
+ public final Collection<? extends DataSchemaNode> getChildNodes() {
return publicChildNodes;
}
import java.lang.invoke.MethodHandles;
import java.lang.invoke.VarHandle;
import java.util.ArrayList;
+import java.util.Collection;
import java.util.List;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.DocumentedNode;
}
@Override
- public final ImmutableList<UnknownSchemaNode> getUnknownSchemaNodes() {
+ public final Collection<? extends UnknownSchemaNode> getUnknownSchemaNodes() {
final ImmutableList<UnknownSchemaNode> existing =
(ImmutableList<UnknownSchemaNode>) UNKNOWN_NODES.getAcquire(this);
return existing != null ? existing : loadUnknownSchemaNodes();
import com.google.common.collect.ImmutableSet;
import java.net.URI;
import java.util.ArrayList;
+import java.util.Collection;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
}
@Override
- public Set<ModuleImport> getImports() {
+ public Collection<? extends ModuleImport> getImports() {
return imports;
}
@Override
- public Set<FeatureDefinition> getFeatures() {
+ public Collection<? extends FeatureDefinition> getFeatures() {
return features;
}
@Override
- public Set<NotificationDefinition> getNotifications() {
+ public Collection<? extends NotificationDefinition> getNotifications() {
return notifications;
}
@Override
- public Set<AugmentationSchemaNode> getAugmentations() {
+ public Collection<? extends AugmentationSchemaNode> getAugmentations() {
return augmentations;
}
@Override
- public Set<RpcDefinition> getRpcs() {
+ public Collection<? extends RpcDefinition> getRpcs() {
return rpcs;
}
@Override
- public Set<Deviation> getDeviations() {
+ public Collection<? extends Deviation> getDeviations() {
return deviations;
}
@Override
- public List<ExtensionDefinition> getExtensionSchemaNodes() {
+ public Collection<? extends ExtensionDefinition> getExtensionSchemaNodes() {
return extensionNodes;
}
@Override
- public Set<IdentitySchemaNode> getIdentities() {
+ public Collection<? extends IdentitySchemaNode> getIdentities() {
return identities;
}
@Override
- public final Set<TypeDefinition<?>> getTypeDefinitions() {
+ public final Collection<? extends TypeDefinition<?>> getTypeDefinitions() {
return typeDefinitions;
}
@Override
- public final Set<DataSchemaNode> getChildNodes() {
+ public final Collection<? extends DataSchemaNode> getChildNodes() {
return publicChildNodes;
}
@Override
- public final Set<GroupingDefinition> getGroupings() {
+ public final Collection<? extends GroupingDefinition> getGroupings() {
return groupings;
}
}
@Override
- public Set<UsesNode> getUses() {
+ public Collection<? extends UsesNode> getUses() {
return uses;
}
import com.google.common.collect.ImmutableSet;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.VarHandle;
+import java.util.Collection;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.MustConstraintAware;
import org.opendaylight.yangtools.yang.model.api.MustDefinition;
}
@Override
- public final ImmutableSet<MustDefinition> getMustConstraints() {
+ public final Collection<? extends MustDefinition> getMustConstraints() {
return derivedSet(MUST_CONSTRAINTS, MustDefinition.class);
}
}
import com.google.common.annotations.Beta;
import com.google.common.base.MoreObjects;
import com.google.common.collect.ImmutableSet;
+import java.util.Collection;
import java.util.Objects;
-import java.util.Set;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ActionDefinition;
import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
}
@Override
- public final Set<ActionDefinition> getActions() {
+ public final Collection<? extends ActionDefinition> getActions() {
return ImmutableSet.of();
}
@Override
- public final Set<NotificationDefinition> getNotifications() {
+ public final Collection<? extends NotificationDefinition> getNotifications() {
return ImmutableSet.of();
}
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt;
import com.google.common.collect.ImmutableSet;
+import java.util.Collection;
import java.util.LinkedHashSet;
import java.util.Optional;
import java.util.Set;
}
@Override
- public Set<AugmentationSchemaNode> getAvailableAugmentations() {
+ public Collection<? extends AugmentationSchemaNode> getAvailableAugmentations() {
return augmentations;
}
import com.google.common.annotations.Beta;
import com.google.common.collect.Collections2;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableSet;
import java.util.Collection;
-import java.util.List;
import java.util.Optional;
-import java.util.Set;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.opendaylight.yangtools.concepts.Mutable;
import org.opendaylight.yangtools.yang.common.QName;
// Marker interface requiring all mixins to be derived from EffectiveStatement.
private interface Mixin<A, D extends DeclaredStatement<A>> extends EffectiveStatement<A, D> {
@SuppressWarnings("unchecked")
- default <T> Collection<T> filterEffectiveStatements(final Class<T> type) {
+ default <T> Collection<? extends T> filterEffectiveStatements(final Class<T> type) {
// Yeah, this is not nice, but saves one transformation
- return (Collection<T>) Collections2.filter(effectiveSubstatements(), type::isInstance);
- }
-
- // FIXME: YANGTOOLS-1068: eliminate this once we can return collections
- default <T> List<T> filterEffectiveStatementsList(final Class<T> type) {
- return ImmutableList.copyOf(filterEffectiveStatements(type));
- }
-
- // FIXME: YANGTOOLS-1068: eliminate this once we can return collections
- default <T> Set<T> filterEffectiveStatementsSet(final Class<T> type) {
- return ImmutableSet.copyOf(filterEffectiveStatements(type));
+ return (Collection<? extends T>) Collections2.filter(effectiveSubstatements(), type::isInstance);
}
}
public interface AugmentationTargetMixin<A, D extends DeclaredStatement<A>>
extends Mixin<A, D>, AugmentationTarget {
@Override
- default Set<AugmentationSchemaNode> getAvailableAugmentations() {
- return filterEffectiveStatementsSet(AugmentationSchemaNode.class);
+ default Collection<? extends AugmentationSchemaNode> getAvailableAugmentations() {
+ return filterEffectiveStatements(AugmentationSchemaNode.class);
}
}
public interface ActionNodeContainerMixin<A, D extends DeclaredStatement<A>>
extends Mixin<A, D>, ActionNodeContainer {
@Override
- default Set<ActionDefinition> getActions() {
- return filterEffectiveStatementsSet(ActionDefinition.class);
+ default Collection<? extends ActionDefinition> getActions() {
+ return filterEffectiveStatements(ActionDefinition.class);
}
}
public interface NotificationNodeContainerMixin<A, D extends DeclaredStatement<A>>
extends Mixin<A, D>, NotificationNodeContainer {
@Override
- default Set<NotificationDefinition> getNotifications() {
- return filterEffectiveStatementsSet(NotificationDefinition.class);
+ default Collection<? extends NotificationDefinition> getNotifications() {
+ return filterEffectiveStatements(NotificationDefinition.class);
}
}
*/
public interface MustConstraintMixin<A, D extends DeclaredStatement<A>> extends Mixin<A, D>, MustConstraintAware {
@Override
- default Collection<MustDefinition> getMustConstraints() {
+ default Collection<? extends MustDefinition> getMustConstraints() {
return filterEffectiveStatements(MustDefinition.class);
}
}
*/
public interface DataNodeContainerMixin<A, D extends DeclaredStatement<A>> extends DataNodeContainer, Mixin<A, D> {
@Override
- default Set<TypeDefinition<?>> getTypeDefinitions() {
+ default Collection<? extends TypeDefinition<?>> getTypeDefinitions() {
// TODO: the cast here is needed to work around Java 11 javac type inference issue
- return (Set) effectiveSubstatements().stream().filter(TypedefEffectiveStatement.class::isInstance)
- .map(stmt -> ((TypedefEffectiveStatement) stmt).getTypeDefinition())
- .collect(ImmutableSet.toImmutableSet());
+ return Collections2.transform(filterEffectiveStatements(TypedefEffectiveStatement.class),
+ TypedefEffectiveStatement::getTypeDefinition);
}
@Override
- default Collection<DataSchemaNode> getChildNodes() {
+ default Collection<? extends DataSchemaNode> getChildNodes() {
return filterEffectiveStatements(DataSchemaNode.class);
}
@Override
- default Set<GroupingDefinition> getGroupings() {
- return filterEffectiveStatementsSet(GroupingDefinition.class);
+ default Collection<? extends GroupingDefinition> getGroupings() {
+ return filterEffectiveStatements(GroupingDefinition.class);
}
@Override
- default Set<UsesNode> getUses() {
- return filterEffectiveStatementsSet(UsesNode.class);
+ default Collection<? extends UsesNode> getUses() {
+ return filterEffectiveStatements(UsesNode.class);
}
}
}
@Override
- default List<UnknownSchemaNode> getUnknownSchemaNodes() {
- return filterEffectiveStatementsList(UnknownSchemaNode.class);
+ default Collection<? extends UnknownSchemaNode> getUnknownSchemaNodes() {
+ return filterEffectiveStatements(UnknownSchemaNode.class);
}
}
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.ImmutableSortedMap;
+import java.util.Collection;
import java.util.LinkedHashSet;
import java.util.Objects;
import java.util.Optional;
}
@Override
- public Set<AugmentationSchemaNode> getAvailableAugmentations() {
+ public Collection<? extends AugmentationSchemaNode> getAvailableAugmentations() {
return augmentations;
}
import com.google.common.base.MoreObjects;
import com.google.common.collect.ImmutableSet;
+import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
}
@Override
- public Set<IdentitySchemaNode> getBaseIdentities() {
+ public Collection<? extends IdentitySchemaNode> getBaseIdentities() {
checkState(sealed, "Attempt to get base identities from unsealed identity effective statement %s", getQName());
return baseIdentities;
}
@Override
- public Set<IdentitySchemaNode> getDerivedIdentities() {
+ public Collection<? extends IdentitySchemaNode> getDerivedIdentities() {
return Collections.unmodifiableSet(derivedIdentities);
}
import com.google.common.collect.ImmutableSet;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.VarHandle;
+import java.util.Collection;
import java.util.LinkedHashSet;
import java.util.Objects;
import java.util.Set;
}
@Override
- public ImmutableSet<MustDefinition> getMustConstraints() {
+ public Collection<? extends MustDefinition> getMustConstraints() {
return derivedSet(MUST_CONSTRAINTS, MustDefinition.class);
}
@Override
- public Set<AugmentationSchemaNode> getAvailableAugmentations() {
+ public Collection<? extends AugmentationSchemaNode> getAvailableAugmentations() {
return augmentations;
}
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
+import java.util.Collection;
import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.Map;
}
@Override
- public Set<AugmentationSchemaNode> getAugmentations() {
+ public Collection<? extends AugmentationSchemaNode> getAugmentations() {
return augmentations;
}
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
+import java.util.Collection;
import java.util.HashSet;
import java.util.Set;
import org.junit.Test;
assertContainsActions(schemaContext, "top-list", "top-list-action");
assertContainsActions(schemaContext, "top", "top-action");
- final Set<GroupingDefinition> groupings = schemaContext.getGroupings();
+ final Collection<? extends GroupingDefinition> groupings = schemaContext.getGroupings();
assertEquals(1, groupings.size());
assertContainsActions(groupings.iterator().next(), "grp-action");
- final Set<Module> modules = schemaContext.getModules();
+ final Collection<? extends Module> modules = schemaContext.getModules();
assertEquals(1, modules.size());
final Module foo = modules.iterator().next();
- final Set<AugmentationSchemaNode> augmentations = foo.getAugmentations();
+ final Collection<? extends AugmentationSchemaNode> augmentations = foo.getAugmentations();
assertEquals(1, augmentations.size());
assertContainsActions(augmentations.iterator().next(), "aug-action", "grp-action");
}
private static void assertContainsActions(final ActionNodeContainer actionContainer,
final String... actionNames) {
- final Set<ActionDefinition> actions = actionContainer.getActions();
+ final Collection<? extends ActionDefinition> actions = actionContainer.getActions();
assertEquals(actionNames.length, actions.size());
final Set<QName> actionQNames = new HashSet<>();
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.yangtools.yang.parser.stmt.rfc7950;
import static org.junit.Assert.assertEquals;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterables;
+import java.util.Collection;
import java.util.HashSet;
import java.util.Set;
import org.junit.Test;
ImmutableSet.of());
assertNotNull(schemaContext);
- final Set<IdentitySchemaNode> identities = getIdentities(schemaContext);
+ final Collection<? extends IdentitySchemaNode> identities = getIdentities(schemaContext);
assertEquals(0, identities.size());
final SchemaNode findNode = findNode(schemaContext, ImmutableList.of("root", "grp-leaf"));
createFeaturesSet("identity-feature", "mandatory-leaf", "tls", "ssh", "two", "three"));
assertNotNull(schemaContext);
- final Set<IdentitySchemaNode> identities = getIdentities(schemaContext);
+ final Collection<? extends IdentitySchemaNode> identities = getIdentities(schemaContext);
assertEquals(1, identities.size());
final SchemaNode findNode = findNode(schemaContext, ImmutableList.of("root", "grp-leaf"));
assertTrue(grpLeaf.isMandatory());
}
- private static Set<IdentitySchemaNode> getIdentities(final SchemaContext schemaContext) {
- final Set<Module> modules = schemaContext.getModules();
+ private static Collection<? extends IdentitySchemaNode> getIdentities(final SchemaContext schemaContext) {
+ final Collection<? extends Module> modules = schemaContext.getModules();
assertEquals(1, modules.size());
final Module module = modules.iterator().next();
return module.getIdentities();
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.yangtools.yang.parser.stmt.rfc7950;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
import java.util.Collection;
-import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
final Module foo = schemaContext.findModule("foo", Revision.of("2016-12-14")).get();
- final Set<NotificationDefinition> notifications = foo.getNotifications();
+ final Collection<? extends NotificationDefinition> notifications = foo.getNotifications();
assertEquals(1, notifications.size());
final NotificationDefinition myNotification = notifications.iterator().next();
- Collection<MustDefinition> mustConstraints = myNotification.getMustConstraints();
+ Collection<? extends MustDefinition> mustConstraints = myNotification.getMustConstraints();
assertEquals(2, mustConstraints.size());
- final Set<RpcDefinition> rpcs = foo.getRpcs();
+ final Collection<? extends RpcDefinition> rpcs = foo.getRpcs();
assertEquals(1, rpcs.size());
final RpcDefinition myRpc = rpcs.iterator().next();
import static org.junit.Assert.fail;
import java.util.Arrays;
+import java.util.Collection;
import java.util.List;
import java.util.stream.Collectors;
import org.junit.Test;
BitsTypeDefinition bitsType = (BitsTypeDefinition) myBitsLeaf.getType();
- List<Bit> bits = bitsType.getBits();
+ Collection<? extends Bit> bits = bitsType.getBits();
assertEquals(2, bits.size());
Bit bitB = createBit(createSchemaPath(true, bar.getQNameModule(), "my-bits-leaf", "my-derived-bits-type",
"bit-b"), 2);
return BitBuilder.create(path, position).build();
}
- private static void assertContainsBits(final List<Bit> bitList, final Bit... bits) {
+ private static void assertContainsBits(final Collection<? extends Bit> bitList, final Bit... bits) {
for (final Bit bit : bits) {
assertTrue(bitList.contains(bit));
}
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
+import java.util.Collection;
import java.util.HashSet;
import java.util.Set;
import org.junit.Test;
assertContainsNotifications(schemaContext, "top-list", "top-list-notification");
assertContainsNotifications(schemaContext, "top", "top-notification");
- final Set<GroupingDefinition> groupings = schemaContext.getGroupings();
+ final Collection<? extends GroupingDefinition> groupings = schemaContext.getGroupings();
assertEquals(1, groupings.size());
assertContainsNotifications(groupings.iterator().next(), "grp-notification");
- final Set<Module> modules = schemaContext.getModules();
+ final Collection<? extends Module> modules = schemaContext.getModules();
assertEquals(1, modules.size());
final Module foo = modules.iterator().next();
- final Set<AugmentationSchemaNode> augmentations = foo.getAugmentations();
+ final Collection<? extends AugmentationSchemaNode> augmentations = foo.getAugmentations();
assertEquals(1, augmentations.size());
assertContainsNotifications(augmentations.iterator().next(), "aug-notification", "grp-notification");
}
private static void assertContainsNotifications(final NotificationNodeContainer notificationContainer,
final String... notificationNames) {
- final Set<NotificationDefinition> notifications = notificationContainer.getNotifications();
+ final Collection<? extends NotificationDefinition> notifications = notificationContainer.getNotifications();
assertEquals(notificationNames.length, notifications.size());
final Set<QName> notificationQNames = new HashSet<>();
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.yangtools.yang.parser.stmt.rfc7950;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import java.util.Set;
+import java.util.Collection;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
assertNotNull(schemaContext);
final Module foo = schemaContext.findModule("foo", Revision.of("2016-12-21")).get();
- final Set<IdentitySchemaNode> identities = foo.getIdentities();
- for (final IdentitySchemaNode identity : identities) {
+ for (final IdentitySchemaNode identity : foo.getIdentities()) {
if ("derived-id".equals(identity.getQName().getLocalName())) {
- final Set<IdentitySchemaNode> baseIdentities = identity.getBaseIdentities();
+ final Collection<? extends IdentitySchemaNode> baseIdentities = identity.getBaseIdentities();
assertEquals(3, baseIdentities.size());
}
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.yangtools.yang.parser.stmt.rfc7950;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
+import java.util.Collection;
import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
assertNotNull(schemaContext);
final Module foo = schemaContext.findModule("foo", Revision.of("2017-01-11")).get();
- final Set<IdentitySchemaNode> identities = foo.getIdentities();
+ final Collection<? extends IdentitySchemaNode> identities = foo.getIdentities();
assertEquals(3, identities.size());
final LeafSchemaNode idrefLeaf = (LeafSchemaNode) foo.getDataChildByName(QName.create(foo.getQNameModule(),
assertNotNull(idrefLeaf);
final IdentityrefTypeDefinition idrefType = (IdentityrefTypeDefinition) idrefLeaf.getType();
- final Set<IdentitySchemaNode> referencedIdentities = idrefType.getIdentities();
+ final Set<? extends IdentitySchemaNode> referencedIdentities = idrefType.getIdentities();
assertEquals(3, referencedIdentities.size());
assertEquals(identities, referencedIdentities);
assertEquals("id-a", idrefType.getIdentities().iterator().next().getQName().getLocalName());
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.yangtools.yang.parser.stmt.rfc7950;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import java.util.Set;
+import java.util.Collection;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Revision;
assertNotNull(schemaContext);
final Module foo = schemaContext.findModule("foo", Revision.of("2016-12-20")).get();
- final Set<TypeDefinition<?>> typeDefinitions = foo.getTypeDefinitions();
+ final Collection<? extends TypeDefinition<?>> typeDefinitions = foo.getTypeDefinitions();
assertEquals(1, typeDefinitions.size());
final TypeDefinition<?> typeDefinition = typeDefinitions.iterator().next();
import java.util.Collection;
import java.util.Collections;
import java.util.List;
-import java.util.Set;
import java.util.SortedMap;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
// foo.yang
final Module module1 = TestUtils.findModule(context, "foo").get();
- Set<AugmentationSchemaNode> augmentations = module1.getAugmentations();
+ Collection<? extends AugmentationSchemaNode> augmentations = module1.getAugmentations();
assertEquals(1, augmentations.size());
final AugmentationSchemaNode augment = augmentations.iterator().next();
assertNotNull(augment);
SchemaPath expectedSchemaPath = SchemaPath.create(qnames, true);
assertEquals(expectedSchemaPath, augment.getTargetPath());
- final Collection<DataSchemaNode> augmentChildren = augment.getChildNodes();
+ final Collection<? extends DataSchemaNode> augmentChildren = augment.getChildNodes();
assertEquals(4, augmentChildren.size());
for (final DataSchemaNode dsn : augmentChildren) {
TestUtils.checkIsAugmenting(dsn, false);
assertEquals(qname, id.getQName());
qnames.add(qname);
assertEquals(SchemaPath.create(qnames, true), id.getPath());
- final Collection<DataSchemaNode> idChildren = id.getChildNodes();
+ final Collection<? extends DataSchemaNode> idChildren = id.getChildNodes();
assertEquals(1, idChildren.size());
// case node1
assertEquals(qname, node1.getQName());
qnames.set(4, qname);
assertEquals(SchemaPath.create(qnames, true), node1.getPath());
- final Collection<DataSchemaNode> node1Children = node1.getChildNodes();
+ final Collection<? extends DataSchemaNode> node1Children = node1.getChildNodes();
assertTrue(node1Children.isEmpty());
// case node2
assertEquals(qname, node2.getQName());
qnames.set(4, qname);
assertEquals(SchemaPath.create(qnames, true), node2.getPath());
- final Collection<DataSchemaNode> node2Children = node2.getChildNodes();
+ final Collection<? extends DataSchemaNode> node2Children = node2.getChildNodes();
assertTrue(node2Children.isEmpty());
// case node3
assertEquals(qname, node3.getQName());
qnames.set(4, qname);
assertEquals(SchemaPath.create(qnames, true), node3.getPath());
- final Collection<DataSchemaNode> node3Children = node3.getChildNodes();
+ final Collection<? extends DataSchemaNode> node3Children = node3.getChildNodes();
assertEquals(1, node3Children.size());
// test cases
final URI NS_FOO = URI.create("urn:opendaylight:foo");
final Revision revision = Revision.of("2013-10-11");
final Module bar = TestUtils.findModule(context, "bar").get();
- final Set<RpcDefinition> rpcs = bar.getRpcs();
+ final Collection<? extends RpcDefinition> rpcs = bar.getRpcs();
assertEquals(2, rpcs.size());
RpcDefinition submit = null;
qnames[3] = QName.create(NS_FOO, revision, "attach");
assertEquals(qnames[3], attach.getQName());
assertEquals(SchemaPath.create(true, qnames), attach.getPath());
- final Collection<DataSchemaNode> attachChildren = attach.getChildNodes();
+ final Collection<? extends DataSchemaNode> attachChildren = attach.getChildNodes();
assertEquals(1, attachChildren.size());
// case create
qnames[3] = QName.create(NS_FOO, revision, "create");
assertEquals(qnames[3], create.getQName());
assertEquals(SchemaPath.create(true, qnames), create.getPath());
- final Collection<DataSchemaNode> createChildren = create.getChildNodes();
+ final Collection<? extends DataSchemaNode> createChildren = create.getChildNodes();
assertEquals(1, createChildren.size());
// case attach
qnames[3] = QName.create(NS_FOO, revision, "destroy");
assertEquals(qnames[3], destroy.getQName());
assertEquals(SchemaPath.create(true, qnames), destroy.getPath());
- final Collection<DataSchemaNode> destroyChildren = destroy.getChildNodes();
+ final Collection<? extends DataSchemaNode> destroyChildren = destroy.getChildNodes();
assertEquals(1, destroyChildren.size());
}
"nodes"));
final ContainerSchemaNode node = (ContainerSchemaNode) nodes.getDataChildByName(QName.create(
test.getQNameModule(), "node"));
- final Set<AugmentationSchemaNode> augments = node.getAvailableAugmentations();
+ final Collection<? extends AugmentationSchemaNode> augments = node.getAvailableAugmentations();
assertEquals(1, augments.size());
assertEquals(1, node.getChildNodes().size());
final LeafSchemaNode id = (LeafSchemaNode) node.getDataChildByName(QName.create(test.getQNameModule(), "id"));
import static org.junit.Assert.assertTrue;
-import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
final Module devicesModule = TestUtils.findModule(context, "augment-module").get();
final ContainerSchemaNode devicesContainer = (ContainerSchemaNode) devicesModule.getDataChildByName(
QName.create(devicesModule.getQNameModule(), "my-container"));
- final Set<UsesNode> uses = devicesContainer.getUses();
-
- for (final UsesNode usesNode : uses) {
+ for (final UsesNode usesNode : devicesContainer.getUses()) {
assertTrue(usesNode.getAugmentations().isEmpty());
}
}
final ContainerSchemaNode devicesContainer = (ContainerSchemaNode) devicesModule.getDataChildByName(QName
.create(devicesModule.getQNameModule(), "my-container"));
- final Set<UsesNode> uses = devicesContainer.getUses();
-
boolean augmentationIsInContainer = false;
- for (final UsesNode usesNode : uses) {
- final Set<AugmentationSchemaNode> augmentations = usesNode.getAugmentations();
- for (final AugmentationSchemaNode augmentationSchema : augmentations) {
+ for (final UsesNode usesNode : devicesContainer.getUses()) {
+ for (final AugmentationSchemaNode augmentationSchema : usesNode.getAugmentations()) {
augmentationIsInContainer = true;
}
}
import static org.junit.Assert.assertNotNull;
import java.net.URI;
-import java.util.List;
+import java.util.Collection;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
final ContainerSchemaNode node = (ContainerSchemaNode) bug1412.getDataChildByName(QName.create(
bug1412.getQNameModule(), "node"));
- List<UnknownSchemaNode> unknownNodes = node.getUnknownSchemaNodes();
+ Collection<? extends UnknownSchemaNode> unknownNodes = node.getUnknownSchemaNodes();
assertEquals(1, unknownNodes.size());
- final UnknownSchemaNode action = unknownNodes.get(0);
+ final UnknownSchemaNode action = unknownNodes.iterator().next();
final QNameModule qm = QNameModule.create(URI.create("urn:test:bug1412"), Revision.of("2014-07-25"));
QName expectedNodeType = QName.create("urn:test:bug1412:ext:definitions", "2014-07-25", "action");
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
-import java.util.List;
+import java.util.Collection;
import org.junit.Test;
import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
import org.opendaylight.yangtools.yang.model.api.Module;
TestUtils.loadModules(getClass().getResource("/bugs/bug1413").toURI()), "bug1413").get();
assertNotNull(bug1413);
- List<ExtensionDefinition> extensions = bug1413.getExtensionSchemaNodes();
+ Collection<? extends ExtensionDefinition> extensions = bug1413.getExtensionSchemaNodes();
assertEquals(1, extensions.size());
- ExtensionDefinition info = extensions.get(0);
+ ExtensionDefinition info = extensions.iterator().next();
assertEquals("text", info.getArgument());
assertTrue(info.isYinElement());
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.yangtools.yang.stmt;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import java.util.Collection;
-import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
SchemaContext schema = StmtTestUtils.parseYangSources("/bugs/bug3799");
assertNotNull(schema);
- Set<Module> modules = schema.getModules();
+ Collection<? extends Module> modules = schema.getModules();
assertNotNull(modules);
assertEquals(1, modules.size());
Module testModule = modules.iterator().next();
- Set<Module> subModules = testModule.getSubmodules();
+ Collection<? extends Module> subModules = testModule.getSubmodules();
assertNotNull(subModules);
assertEquals(1, subModules.size());
Module testSubmodule = subModules.iterator().next();
- Set<NotificationDefinition> notifications = testSubmodule
- .getNotifications();
+ Collection<? extends NotificationDefinition> notifications = testSubmodule.getNotifications();
assertNotNull(notifications);
assertEquals(1, notifications.size());
- NotificationDefinition bazNotification = notifications.iterator()
- .next();
- Collection<DataSchemaNode> childNodes = bazNotification.getChildNodes();
+ NotificationDefinition bazNotification = notifications.iterator().next();
+ Collection<? extends DataSchemaNode> childNodes = bazNotification.getChildNodes();
assertNotNull(childNodes);
assertEquals(1, childNodes.size());
String bar = leafBar.getQName().getLocalName();
assertEquals("bar", bar);
}
-
}
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
-import java.util.List;
+import java.util.Collection;
+import java.util.Iterator;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
bug394.getQNameModule(), "logrecords"));
assertNotNull(logrecords);
- final List<UnknownSchemaNode> nodes = logrecords.getUnknownSchemaNodes();
+ final Collection<? extends UnknownSchemaNode> nodes = logrecords.getUnknownSchemaNodes();
assertEquals(2, nodes.size());
- final List<ExtensionDefinition> extensions = bug394_ext.getExtensionSchemaNodes();
+ final Collection<? extends ExtensionDefinition> extensions = bug394_ext.getExtensionSchemaNodes();
assertEquals(3, extensions.size());
- assertTrue(extensions.contains(nodes.get(0).getExtensionDefinition()));
- assertTrue(extensions.contains(nodes.get(1).getExtensionDefinition()));
+ final Iterator<? extends UnknownSchemaNode> it = nodes.iterator();
+ assertTrue(extensions.contains(it.next().getExtensionDefinition()));
+ assertTrue(extensions.contains(it.next().getExtensionDefinition()));
}
-
}
import static org.junit.Assert.fail;
import java.net.URI;
-import java.util.List;
+import java.util.Collection;
import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
SchemaContext schema = StmtTestUtils.parseYangSources("/bugs/bug4456");
assertNotNull(schema);
- Set<Module> modules = schema.findModules(URI.create("foo"));
+ Set<Module> modules = (Set<Module>) schema.findModules(URI.create("foo"));
assertEquals(1, modules.size());
Module moduleFoo = modules.iterator().next();
- List<ExtensionDefinition> extensionSchemaNodes = moduleFoo.getExtensionSchemaNodes();
+ Collection<? extends ExtensionDefinition> extensionSchemaNodes = moduleFoo.getExtensionSchemaNodes();
assertEquals(5, extensionSchemaNodes.size());
for (ExtensionDefinition extensionDefinition : extensionSchemaNodes) {
- List<UnknownSchemaNode> unknownSchemaNodes = extensionDefinition.getUnknownSchemaNodes();
+ Collection<? extends UnknownSchemaNode> unknownSchemaNodes = extensionDefinition.getUnknownSchemaNodes();
assertEquals(1, unknownSchemaNodes.size());
UnknownSchemaNode unknownSchemaNode = unknownSchemaNodes.iterator().next();
String unknownNodeExtensionDefName = unknownSchemaNode.getExtensionDefinition().getQName().getLocalName();
- List<UnknownSchemaNode> subUnknownSchemaNodes = unknownSchemaNode.getUnknownSchemaNodes();
+ Collection<? extends UnknownSchemaNode> subUnknownSchemaNodes = unknownSchemaNode.getUnknownSchemaNodes();
assertEquals(1, subUnknownSchemaNodes.size());
UnknownSchemaNode subUnknownSchemaNode = subUnknownSchemaNodes.iterator().next();
String subUnknownNodeExtensionDefName = subUnknownSchemaNode.getExtensionDefinition().getQName()
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.yangtools.yang.stmt;
import com.google.common.collect.Range;
import java.io.File;
import java.net.URI;
+import java.util.Collection;
import java.util.List;
import org.junit.Assert;
import org.junit.Test;
final TypeDefinition<?> type = leaf.getType();
Assert.assertNotNull(type);
- final List<UnknownSchemaNode> unknownSchemaNodes = type.getUnknownSchemaNodes();
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes = type.getUnknownSchemaNodes();
Assert.assertNotNull(unknownSchemaNodes);
Assert.assertFalse(unknownSchemaNodes.size() == 0);
- final UnknownSchemaNode unknownSchemaNode = unknownSchemaNodes.get(0);
+ final UnknownSchemaNode unknownSchemaNode = unknownSchemaNodes.iterator().next();
Assert.assertEquals(unknownSchemaNode.getNodeParameter(), "unknown");
Assert.assertEquals(unknownSchemaNode.getNodeType().getModule().getNamespace().toString(),
"urn:simple.extension.typedefs");
final TypeDefinition<?> type = leaf.getType();
Assert.assertNotNull(type);
- final List<UnknownSchemaNode> unknownSchemaNodes = type.getUnknownSchemaNodes();
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes = type.getUnknownSchemaNodes();
Assert.assertNotNull(unknownSchemaNodes);
Assert.assertFalse(unknownSchemaNodes.size() == 0);
- final UnknownSchemaNode unknownSchemaNode = unknownSchemaNodes.get(0);
+ final UnknownSchemaNode unknownSchemaNode = unknownSchemaNodes.iterator().next();
Assert.assertEquals(unknownSchemaNode.getNodeParameter(), "unknown");
Assert.assertEquals(unknownSchemaNode.getNodeType().getModule().getNamespace().toString(),
"urn:simple.extension.typedefs");
final TypeDefinition<?> type = leaf.getType();
Assert.assertNotNull(type);
- final List<UnknownSchemaNode> unknownSchemaNodes = type.getUnknownSchemaNodes();
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes = type.getUnknownSchemaNodes();
Assert.assertNotNull(unknownSchemaNodes);
Assert.assertFalse(unknownSchemaNodes.size() == 0);
- final UnknownSchemaNode unknownSchemaNode = unknownSchemaNodes.get(0);
+ final UnknownSchemaNode unknownSchemaNode = unknownSchemaNodes.iterator().next();
Assert.assertEquals(unknownSchemaNode.getNodeParameter(), "unknown");
Assert.assertEquals(unknownSchemaNode.getNodeType().getModule().getNamespace().toString(),
"urn:simple.extension.typedefs");
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import java.util.Set;
+import java.util.Collection;
import org.junit.Test;
import org.opendaylight.yangtools.yang.model.api.Deviation;
import org.opendaylight.yangtools.yang.model.api.Module;
assertNotNull(context);
final Module foo = context.findModules("foo").iterator().next();
- Set<Deviation> deviations = foo.getDeviations();
+ Collection<? extends Deviation> deviations = foo.getDeviations();
assertEquals(4, deviations.size());
}
final DataSchemaNode dataChildByName = context.getDataChildByName(QName.create("foo", "root"));
assertTrue(dataChildByName instanceof ContainerSchemaNode);
final ContainerSchemaNode root = (ContainerSchemaNode) dataChildByName;
- final Collection<MustDefinition> mustConstraints = root.getMustConstraints();
+ final Collection<? extends MustDefinition> mustConstraints = root.getMustConstraints();
assertEquals(1, mustConstraints.size());
final MustDefinition must = mustConstraints.iterator().next();
assertEquals("not(deref(.)/../same-pass)", must.getXpath().getOriginalString());
import static org.junit.Assert.assertThat;
import java.util.Iterator;
-import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Revision;
final ContainerSchemaNode testContainer = (ContainerSchemaNode) rootContainer.getDataChildByName(
testContainerQname);
final ChoiceSchemaNode dataChildByName = (ChoiceSchemaNode) testContainer.getDataChildByName(choice);
- final Set<AugmentationSchemaNode> augmentations = foo.getAugmentations();
- final Set<AugmentationSchemaNode> availableAugmentations = dataChildByName.getAvailableAugmentations();
- final Iterator<AugmentationSchemaNode> iterator = augmentations.iterator();
- final Iterator<AugmentationSchemaNode> availableIterator = availableAugmentations.iterator();
- testIterator(iterator);
- testIterator(availableIterator);
+ testIterator(foo.getAugmentations().iterator());
+ testIterator(dataChildByName.getAvailableAugmentations().iterator());
}
- private static void testIterator(final Iterator<AugmentationSchemaNode> iterator) {
+ private static void testIterator(final Iterator<? extends AugmentationSchemaNode> iterator) {
while (iterator.hasNext()) {
AugmentationSchemaNode allAugments = iterator.next();
final DataSchemaNode currentChoice = allAugments.getChildNodes().iterator().next();
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
-import java.util.List;
+import java.util.Collection;
import java.util.Optional;
-import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
final DataSchemaNode root = schemaContext.getDataChildByName(QName.create("foo", "2016-06-02", "root"));
assertTrue(root instanceof ContainerSchemaNode);
- final Set<UsesNode> uses = ((ContainerSchemaNode) root).getUses();
+ final Collection<? extends UsesNode> uses = ((ContainerSchemaNode) root).getUses();
assertEquals(1, uses.size());
final UsesNode usesNode = uses.iterator().next();
assertThat(when, instanceOf(WithExpression.class));
assertEquals("0!=1", when.getOriginalString());
- final List<UnknownSchemaNode> unknownSchemaNodes = usesNode.getUnknownSchemaNodes();
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes = usesNode.getUnknownSchemaNodes();
assertEquals(1, unknownSchemaNodes.size());
final UnknownSchemaNode unknownSchemaNode = unknownSchemaNodes.iterator().next();
assertEquals("argument", unknownSchemaNode.getNodeParameter());
import java.io.File;
import java.util.Collection;
+import org.eclipse.jdt.annotation.NonNull;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
.getResource("/bugs/bug5946/foo.yang").toURI()));
assertNotNull(context);
- Collection<UniqueConstraint> uniqueConstraints = getListConstraints(context, WITHOUT_UNIQUE);
+ Collection<? extends UniqueConstraint> uniqueConstraints = getListConstraints(context, WITHOUT_UNIQUE);
assertNotNull(uniqueConstraints);
assertTrue(uniqueConstraints.isEmpty());
- Collection<UniqueConstraint> simpleUniqueConstraints = getListConstraints(context, SIMPLE_UNIQUE);
+ Collection<? extends UniqueConstraint> simpleUniqueConstraints = getListConstraints(context, SIMPLE_UNIQUE);
assertNotNull(simpleUniqueConstraints);
assertEquals(1, simpleUniqueConstraints.size());
Collection<Relative> simpleUniqueConstraintTag = simpleUniqueConstraints.iterator().next().getTag();
assertTrue(simpleUniqueConstraintTag.contains(L1_ID));
assertTrue(simpleUniqueConstraintTag.contains(C_L3_ID));
- Collection<UniqueConstraint> multipleUniqueConstraints = getListConstraints(context, MULTIPLE_UNIQUE);
+ Collection<? extends UniqueConstraint> multipleUniqueConstraints = getListConstraints(context, MULTIPLE_UNIQUE);
assertNotNull(multipleUniqueConstraints);
assertEquals(3, multipleUniqueConstraints.size());
boolean l1l2 = false;
}
}
- private static Collection<UniqueConstraint> getListConstraints(final SchemaContext context, final QName listQName) {
+ private static @NonNull Collection<? extends UniqueConstraint> getListConstraints(final SchemaContext context,
+ final QName listQName) {
DataSchemaNode dataChildByName = context.getDataChildByName(listQName);
assertTrue(dataChildByName instanceof ListSchemaNode);
return ((ListSchemaNode) dataChildByName).getUniqueConstraints();
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.yangtools.yang.stmt;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import java.io.File;
+import java.util.Collection;
import java.util.List;
import java.util.Optional;
-import java.util.Set;
import java.util.regex.Pattern;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
final RevisionAwareXPath whenCondition = bar.getWhenCondition().get();
assertEquals("/foo != \"bar\"", whenCondition.getOriginalString());
- final Set<TypeDefinition<?>> typeDefinitions = schemaContext.getTypeDefinitions();
+ final Collection<? extends TypeDefinition<?>> typeDefinitions = schemaContext.getTypeDefinitions();
assertEquals(1, typeDefinitions.size());
final TypeDefinition<?> type = typeDefinitions.iterator().next();
assertTrue(type instanceof StringTypeDefinition);
final RevisionAwareXPath whenCondition = bar.getWhenCondition().get();
assertEquals("/foo != 'bar'", whenCondition.getOriginalString());
- final Set<TypeDefinition<?>> typeDefinitions = schemaContext.getTypeDefinitions();
+ final Collection<? extends TypeDefinition<?>> typeDefinitions = schemaContext.getTypeDefinitions();
assertEquals(1, typeDefinitions.size());
final TypeDefinition<?> type = typeDefinitions.iterator().next();
assertTrue(type instanceof StringTypeDefinition);
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
-import java.util.Set;
+import java.util.Collection;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
final SchemaContext context = StmtTestUtils.parseYangSources("/bugs/bug6240/correct");
assertNotNull(context);
- final Set<Module> modules = context.getModules();
+ final Collection<? extends Module> modules = context.getModules();
assertEquals(2, modules.size());
Module bar = null;
final TypeDefinition<? extends TypeDefinition<?>> type = bitsLeaf.getType();
assertTrue(type instanceof BitsTypeDefinition);
final BitsTypeDefinition myBits = (BitsTypeDefinition) type;
- final List<Bit> positions = myBits.getBits();
- for (final Bit bit : positions) {
+ for (final Bit bit : myBits.getBits()) {
final String name = bit.getName();
switch (name) {
case "zero":
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.yangtools.yang.stmt;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.sourceForResource;
-import java.util.Set;
+import java.util.Collection;
import org.junit.Test;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
public void testTypedefsInRpc() throws ReactorException {
final SchemaContext schemaContext = StmtTestUtils.parseYangSources(sourceForResource("/bugs/bug6410/foo.yang"));
- final Set<Module> modules = schemaContext.getModules();
+ final Collection<? extends Module> modules = schemaContext.getModules();
assertEquals(1, modules.size());
final Module module = modules.iterator().next();
- final Set<RpcDefinition> rpcs = module.getRpcs();
+ final Collection<? extends RpcDefinition> rpcs = module.getRpcs();
assertEquals(1, rpcs.size());
final RpcDefinition rpc = rpcs.iterator().next();
- final Set<TypeDefinition<?>> typeDefs = rpc.getTypeDefinitions();
+ final Collection<? extends TypeDefinition<?>> typeDefs = rpc.getTypeDefinitions();
assertEquals(2, typeDefs.size());
}
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
+import java.util.Collection;
import java.util.Optional;
-import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.Module;
final SchemaContext context = StmtTestUtils.parseYangSources("/bugs/bug6491/".concat(path));
assertNotNull(context);
final Module module = context.findModule("bar", moduleRevision).get();
- final Set<ModuleImport> imports = module.getImports();
+ final Collection<? extends ModuleImport> imports = module.getImports();
assertNotNull(imports);
assertEquals(1, imports.size());
assertEquals(importedRevision, imports.iterator().next().getRevision());
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.yangtools.yang.stmt;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
+import java.util.Collection;
import java.util.Iterator;
-import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import org.junit.Test;
final SchemaContext context = StmtTestUtils.parseYangSources("/bugs/bug7037");
assertNotNull(context);
- final List<UnknownSchemaNode> unknownSchemaNodes = context.getUnknownSchemaNodes();
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes = context.getUnknownSchemaNodes();
assertEquals(1, unknownSchemaNodes.size());
final UnknownSchemaNode first = unknownSchemaNodes.iterator().next();
- final List<UnknownSchemaNode> firstUnknownNodes = first.getUnknownSchemaNodes();
+ final Collection<? extends UnknownSchemaNode> firstUnknownNodes = first.getUnknownSchemaNodes();
assertEquals(1, firstUnknownNodes.size());
final UnknownSchemaNode barExtCont = firstUnknownNodes.iterator().next();
final DataSchemaNode root = context.getDataChildByName(foo("root"));
assertTrue(root instanceof ContainerSchemaNode);
- final List<UnknownSchemaNode> rootUnknownNodes = root.getUnknownSchemaNodes();
+ final Collection<? extends UnknownSchemaNode> rootUnknownNodes = root.getUnknownSchemaNodes();
assertEquals(2, rootUnknownNodes.size());
final Map<QName, UnknownSchemaNode> rootUnknownNodeMap = rootUnknownNodes.stream()
.collect(Collectors.toMap(u -> u.getNodeType(), u -> u));
final UnknownSchemaNode barExt = rootUnknownNodeMap.get(bar("bar-ext"));
- final List<UnknownSchemaNode> barExtUnknownNodes = barExt.getUnknownSchemaNodes();
+ final Collection<? extends UnknownSchemaNode> barExtUnknownNodes = barExt.getUnknownSchemaNodes();
assertEquals(3, barExtUnknownNodes.size());
- final Iterator<UnknownSchemaNode> iterator = barExtUnknownNodes.iterator();
+ final Iterator<? extends UnknownSchemaNode> iterator = barExtUnknownNodes.iterator();
UnknownSchemaNode barExtCont2 = null;
while (iterator.hasNext()) {
final UnknownSchemaNode next = iterator.next();
assertEquals(foo("bar-ext-con-2"), barExtCont2.getQName());
final UnknownSchemaNode fooExt = rootUnknownNodeMap.get(foo("foo-ext"));
- final List<UnknownSchemaNode> fooUnknownNodes = fooExt.getUnknownSchemaNodes();
+ final Collection<? extends UnknownSchemaNode> fooUnknownNodes = fooExt.getUnknownSchemaNodes();
assertEquals(1, fooUnknownNodes.size());
final UnknownSchemaNode fooExtCont = fooUnknownNodes.iterator().next();
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.yangtools.yang.stmt;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
-import java.util.List;
-import java.util.Set;
+import java.util.Collection;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Revision;
final Module foo = schemaContext.findModule("foo", revision).get();
final Module bar = schemaContext.findModule("bar", revision).get();
- final Set<Deviation> deviations = foo.getDeviations();
+ final Collection<? extends Deviation> deviations = foo.getDeviations();
assertEquals(1, deviations.size());
final Deviation deviation = deviations.iterator().next();
- final List<DeviateDefinition> deviates = deviation.getDeviates();
+ final Collection<? extends DeviateDefinition> deviates = deviation.getDeviates();
assertEquals(1, deviates.size());
final DeviateDefinition deviateReplace = deviates.iterator().next();
import static org.junit.Assert.fail;
import java.net.URI;
-import java.util.Set;
+import java.util.Collection;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.Module;
final SchemaContext context = StmtTestUtils.parseYangSources("/bugs/bug7480/files", "/bugs/bug7480/lib");
assertNotNull(context);
- final Set<Module> modules = context.getModules();
+ final Collection<? extends Module> modules = context.getModules();
assertEquals(8, modules.size());
assertNotNull(context.findModule(new URI("foo-imp"), Revision.of("2017-01-23")));
assertEquals(1, context.findModules(new URI("bar")).size());
assertEquals(1, context.findModules(new URI("baz")).size());
assertTrue(context.findModule(new URI("baz-imp"), Revision.of("2002-01-01")).isPresent());
- final Set<Module> foo = context.findModules(new URI("foo"));
+ final Collection<? extends Module> foo = context.findModules(new URI("foo"));
assertEquals(1, foo.size());
- final Set<Module> subFoos = foo.iterator().next().getSubmodules();
+ final Collection<? extends Module> subFoos = foo.iterator().next().getSubmodules();
assertEquals(1, subFoos.size());
final Module parentMod = context.findModule(new URI("parent-mod-ns"), Revision.of("2017-09-07")).get();
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
-import java.util.List;
+import java.util.Collection;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
final DataSchemaNode root = context.getDataChildByName(foo("root"));
assertTrue(root instanceof ContainerSchemaNode);
- final List<UnknownSchemaNode> unknownSchemaNodes = root.getUnknownSchemaNodes();
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes = root.getUnknownSchemaNodes();
assertEquals(1, unknownSchemaNodes.size());
final UnknownSchemaNode unknownNode = unknownSchemaNodes.iterator().next();
- final List<UnknownSchemaNode> subUnknownSchemaNodes = unknownNode.getUnknownSchemaNodes();
+ final Collection<? extends UnknownSchemaNode> subUnknownSchemaNodes = unknownNode.getUnknownSchemaNodes();
assertEquals(1, subUnknownSchemaNodes.size());
final UnknownSchemaNode subUnknownNode = subUnknownSchemaNodes.iterator().next();
- final List<UnknownSchemaNode> subSubUnknownSchemaNodes = subUnknownNode.getUnknownSchemaNodes();
+ final Collection<? extends UnknownSchemaNode> subSubUnknownSchemaNodes = subUnknownNode.getUnknownSchemaNodes();
assertEquals(1, subSubUnknownSchemaNodes.size());
final UnknownSchemaNode subSubUnknownNode = subSubUnknownSchemaNodes.iterator().next();
private static QName foo(final String localName) {
return QName.create(NS, localName);
}
-
}
import static org.junit.Assert.fail;
import java.util.Optional;
-import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.Module;
assertNotNull(context);
final Module foo = context.findModule("foo").get();
- final Set<ModuleImport> imports = foo.getImports();
-
- for (final ModuleImport moduleImport : imports) {
+ for (final ModuleImport moduleImport : foo.getImports()) {
switch (moduleImport.getModuleName()) {
case "bar":
assertEquals(Revision.ofNullable("1970-01-01"), moduleImport.getRevision());
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
-import java.util.Set;
+import java.util.Collection;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.Module;
final Module foo = context.findModule("foo", Revision.of("2017-07-07")).get();
- final Set<ModuleImport> imports = foo.getImports();
+ final Collection<? extends ModuleImport> imports = foo.getImports();
assertEquals(1, imports.size());
final ModuleImport imp1 = imports.iterator().next();
assertEquals("bar-2", imp1.getModuleName());
assertEquals("bar", imp1.getPrefix());
assertEquals(Revision.ofNullable("2000-01-02"), imp1.getRevision());
- final Set<Module> submodules = foo.getSubmodules();
+ final Collection<? extends Module> submodules = foo.getSubmodules();
assertEquals(1, submodules.size());
final Module submodule = submodules.iterator().next();
- final Set<ModuleImport> subImports = submodule.getImports();
+ final Collection<? extends ModuleImport> subImports = submodule.getImports();
assertEquals(1, subImports.size());
final ModuleImport subImp1 = subImports.iterator().next();
import static org.junit.Assert.assertTrue;
import java.net.URI;
-import java.util.List;
-import java.util.Set;
+import java.util.Collection;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
private static void salDomBrokerImplModuleTest(final SchemaContext context) {
final Module module = context.findModule("opendaylight-sal-dom-broker-impl", Revision.of("2013-10-28")).get();
- final Set<AugmentationSchemaNode> augmentations = module.getAugmentations();
boolean checked = false;
- for (final AugmentationSchemaNode augmentationSchema : augmentations) {
+ for (final AugmentationSchemaNode augmentationSchema : module.getAugmentations()) {
final DataSchemaNode dataNode = augmentationSchema
.getDataChildByName(QName.create(module.getQNameModule(), "dom-broker-impl"));
if (dataNode instanceof CaseSchemaNode) {
final ContainerSchemaNode containerNode = (ContainerSchemaNode) dataNode2;
final DataSchemaNode leaf = containerNode
.getDataChildByName(QName.create(module.getQNameModule(), "type"));
- final List<UnknownSchemaNode> unknownSchemaNodes = leaf.getUnknownSchemaNodes();
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes = leaf.getUnknownSchemaNodes();
assertEquals(1, unknownSchemaNodes.size());
- final UnknownSchemaNode unknownSchemaNode = unknownSchemaNodes.get(0);
+ final UnknownSchemaNode unknownSchemaNode = unknownSchemaNodes.iterator().next();
assertEquals("dom-async-data-broker", unknownSchemaNode.getQName().getLocalName());
assertEquals(unknownSchemaNode.getQName(), unknownSchemaNode.getPath().getLastComponent());
final ContainerSchemaNode containerNode = (ContainerSchemaNode) dataNode2;
final DataSchemaNode leaf = containerNode.getDataChildByName(QName.create(module.getQNameModule(), "type"));
- final List<UnknownSchemaNode> unknownSchemaNodes = leaf.getUnknownSchemaNodes();
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes = leaf.getUnknownSchemaNodes();
assertEquals(1, unknownSchemaNodes.size());
- final UnknownSchemaNode unknownSchemaNode = unknownSchemaNodes.get(0);
+ final UnknownSchemaNode unknownSchemaNode = unknownSchemaNodes.iterator().next();
assertEquals(unknownSchemaNode.getQName(), unknownSchemaNode.getPath().getLastComponent());
assertEquals("dom-async-data-broker", unknownSchemaNode.getQName().getLocalName());
final DataSchemaNode type = schemaServiceContainer.getDataChildByName(QName.create(module.getQNameModule(),
"type"));
- final List<UnknownSchemaNode> typeUnknownSchemaNodes = type.getUnknownSchemaNodes();
+ final Collection<? extends UnknownSchemaNode> typeUnknownSchemaNodes = type.getUnknownSchemaNodes();
assertEquals(1, typeUnknownSchemaNodes.size());
- final UnknownSchemaNode typeUnknownSchemaNode = typeUnknownSchemaNodes.get(0);
+ final UnknownSchemaNode typeUnknownSchemaNode = typeUnknownSchemaNodes.iterator().next();
final QNameModule qNameModule = QNameModule.create(
URI.create("urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom"), Revision.of("2013-10-28"));
final QName qName = QName.create(qNameModule, "schema-service");
final Module testModule = schemaContext.findModules("augment-declared-test").iterator().next();
assertNotNull(testModule);
- final Set<AugmentationSchemaNode> augmentationSchemas = testModule.getAugmentations();
+ final Collection<? extends AugmentationSchemaNode> augmentationSchemas = testModule.getAugmentations();
assertNotNull(augmentationSchemas);
assertEquals(1, augmentationSchemas.size());
final IncludeStatement includeStatement = moduleStatement.getIncludes().iterator().next();
assertEquals("child-module-declared-test", includeStatement.getModule());
- final Set<Module> submodules = testModule.getSubmodules();
+ final Collection<? extends Module> submodules = testModule.getSubmodules();
assertNotNull(submodules);
assertEquals(1, submodules.size());
import static org.junit.Assert.assertTrue;
import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.sourceForResource;
-import java.util.List;
+import java.util.Collection;
import java.util.Optional;
-import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.DeviateDefinition;
assertNotNull(schemaContext);
Module testModule = schemaContext.findModule("foo", Revision.of("2016-06-23")).get();
- Set<Deviation> deviations = testModule.getDeviations();
+ Collection<? extends Deviation> deviations = testModule.getDeviations();
assertEquals(4, deviations.size());
for (Deviation deviation : deviations) {
- final List<DeviateDefinition> deviates = deviation.getDeviates();
+ final Collection<? extends DeviateDefinition> deviates = deviation.getDeviates();
final String targetLocalName = deviation.getTargetPath().getLastComponent().getLocalName();
if ("test-leaf".equals(targetLocalName)) {
assertEquals(Optional.of("test-leaf is not supported"), deviation.getDescription());
Deviation deviation7 = null;
for (Deviation deviation : deviations) {
- final List<DeviateDefinition> deviates = deviation.getDeviates();
+ final Collection<? extends DeviateDefinition> deviates = deviation.getDeviates();
final String targetLocalName = deviation.getTargetPath().getLastComponent().getLocalName();
if ("bar-container-1".equals(targetLocalName)) {
import java.net.URI;
import java.net.URISyntaxException;
import java.util.Collection;
-import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
SchemaContext result = RFC7950Reactors.defaultReactor().newBuild().addSource(YANG_EXT).buildEffective();
assertNotNull(result);
- Set<GroupingDefinition> groupings = result.getGroupings();
+ Collection<? extends GroupingDefinition> groupings = result.getGroupings();
assertEquals(1, groupings.size());
GroupingDefinition grp = groupings.iterator().next();
- Collection<DataSchemaNode> childNodes = grp.getChildNodes();
+ Collection<? extends DataSchemaNode> childNodes = grp.getChildNodes();
assertEquals(1, childNodes.size());
DataSchemaNode child = childNodes.iterator().next();
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.yangtools.yang.stmt;
import static org.junit.Assert.assertEquals;
import com.google.common.collect.Iterables;
import java.net.URISyntaxException;
-import java.util.Set;
+import java.util.Collection;
import org.junit.Test;
import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
@Test
public void identityTest() throws SourceException, ReactorException,
URISyntaxException {
- SchemaContext result = RFC7950Reactors.defaultReactor().newBuild()
- .addSources(IDENTITY_TEST)
- .buildEffective();
-
+ SchemaContext result = RFC7950Reactors.defaultReactor().newBuild().addSources(IDENTITY_TEST).buildEffective();
assertNotNull(result);
Module module = result.findModule("identity-test").get();
- Set<IdentitySchemaNode> identities = module.getIdentities();
+ Collection<? extends IdentitySchemaNode> identities = module.getIdentities();
assertNotNull(identities);
assertEquals(4, identities.size());
assertTrue(root.getBaseIdentities().isEmpty());
- Set<IdentitySchemaNode> rootDerivedIdentities = root
- .getDerivedIdentities();
+ Collection<? extends IdentitySchemaNode> rootDerivedIdentities = root.getDerivedIdentities();
assertEquals(2, rootDerivedIdentities.size());
assertTrue(rootDerivedIdentities.contains(child1));
assertTrue(child2.getDerivedIdentities().isEmpty());
- Set<IdentitySchemaNode> child1DerivedIdentities = child1
- .getDerivedIdentities();
+ Collection<? extends IdentitySchemaNode> child1DerivedIdentities = child1.getDerivedIdentities();
assertEquals(1, child1DerivedIdentities.size());
assertTrue(child1DerivedIdentities.contains(child12));
assertFalse(child1DerivedIdentities.contains(child1));
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.yangtools.yang.stmt;
import static org.junit.Assert.assertEquals;
import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.sourceForResource;
import java.net.URI;
-import java.util.List;
+import java.util.Collection;
import java.util.Optional;
-import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
final ContainerSchemaNode contSchemaNode = (ContainerSchemaNode) rootModule.getDataChildByName(CONT);
assertNotNull(contSchemaNode);
- final Set<AugmentationSchemaNode> augmentations = rootModule.getAugmentations();
+ final Collection<? extends AugmentationSchemaNode> augmentations = rootModule.getAugmentations();
assertEquals(1, augmentations.size());
assertEquals(CONT_SCHEMA_PATH, augmentations.iterator().next().getTargetPath());
- final Set<ModuleImport> imports = rootModule.getImports();
+ final Collection<? extends ModuleImport> imports = rootModule.getImports();
assertEquals(1, imports.size());
final ModuleImport importStmt = imports.iterator().next();
assertNotNull(importStmt);
assertEquals(Optional.of(REVISION), importStmt.getRevision());
assertEquals("imp-pref", importStmt.getPrefix());
- final Set<Module> submodules = rootModule.getSubmodules();
+ final Collection<? extends Module> submodules = rootModule.getSubmodules();
assertEquals(1, submodules.size());
assertEquals("submod", submodules.iterator().next().getName());
- final Set<NotificationDefinition> notifications = rootModule.getNotifications();
+ final Collection<? extends NotificationDefinition> notifications = rootModule.getNotifications();
assertEquals(1, notifications.size());
assertEquals("notif1", notifications.iterator().next().getQName().getLocalName());
- final Set<RpcDefinition> rpcs = rootModule.getRpcs();
+ final Collection<? extends RpcDefinition> rpcs = rootModule.getRpcs();
assertEquals(1, rpcs.size());
assertEquals("rpc1", rpcs.iterator().next().getQName().getLocalName());
- final Set<Deviation> deviations = rootModule.getDeviations();
+ final Collection<? extends Deviation> deviations = rootModule.getDeviations();
assertEquals(1, deviations.size());
final Deviation deviationStmt = deviations.iterator().next();
assertNotNull(deviationStmt);
assertEquals(DeviateKind.ADD, deviationStmt.getDeviates().iterator().next().getDeviateType());
assertEquals(Optional.of("deviate reference"), deviationStmt.getReference());
- final Set<IdentitySchemaNode> identities = rootModule.getIdentities();
+ final Collection<? extends IdentitySchemaNode> identities = rootModule.getIdentities();
assertEquals(1, identities.size());
assertEquals("identity1", identities.iterator().next().getQName().getLocalName());
- final Set<FeatureDefinition> features = rootModule.getFeatures();
+ final Collection<? extends FeatureDefinition> features = rootModule.getFeatures();
assertEquals(1, features.size());
final FeatureDefinition featureStmt = features.iterator().next();
assertNotNull(featureStmt);
assertEquals(Optional.of("feature1 reference"), featureStmt.getReference());
assertEquals(Status.CURRENT, featureStmt.getStatus());
- final List<ExtensionDefinition> extensionSchemaNodes = rootModule.getExtensionSchemaNodes();
+ final Collection<? extends ExtensionDefinition> extensionSchemaNodes = rootModule.getExtensionSchemaNodes();
assertEquals(1, extensionSchemaNodes.size());
assertEquals("ext1", extensionSchemaNodes.iterator().next().getQName().getLocalName());
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.yangtools.yang.stmt;
import static org.junit.Assert.assertEquals;
import java.net.URI;
import java.util.Collection;
import java.util.Optional;
-import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
assertNotNull(result);
- final Set<Module> modules = result.getModules();
+ final Collection<? extends Module> modules = result.getModules();
assertNotNull(modules);
assertEquals(2, modules.size());
assertNotNull(root);
assertNotNull(imported);
- final Collection<DataSchemaNode> rootChildNodes = root.getChildNodes();
- final Collection<DataSchemaNode> importedChildNodes = imported
- .getChildNodes();
+ final Collection<? extends DataSchemaNode> rootChildNodes = root.getChildNodes();
+ final Collection<? extends DataSchemaNode> importedChildNodes = imported.getChildNodes();
assertNotNull(rootChildNodes);
assertNotNull(importedChildNodes);
assertEquals(3, rootChildNodes.size());
assertEquals(1, importedChildNodes.size());
- final Set<Module> rootSubmodules = root.getSubmodules();
- final Set<Module> importedSubmodules = imported.getSubmodules();
+ final Collection<? extends Module> rootSubmodules = root.getSubmodules();
+ final Collection<? extends Module> importedSubmodules = imported.getSubmodules();
assertNotNull(rootSubmodules);
assertNotNull(importedSubmodules);
assertEquals(ROOT, sub1.getQNameModule());
assertEquals(ROOT, sub2.getQNameModule());
- final Collection<DataSchemaNode> sub1ChildNodes = sub1.getChildNodes();
- final Collection<DataSchemaNode> sub2ChildNodes = sub2.getChildNodes();
+ final Collection<? extends DataSchemaNode> sub1ChildNodes = sub1.getChildNodes();
+ final Collection<? extends DataSchemaNode> sub2ChildNodes = sub2.getChildNodes();
assertNotNull(sub1ChildNodes);
assertNotNull(sub2ChildNodes);
assertEquals(1, sub1ChildNodes.size());
assertEquals(1, sub2ChildNodes.size());
- final Set<Module> sub1Submodules = sub1.getSubmodules();
- final Set<Module> sub2Submodules = sub2.getSubmodules();
+ final Collection<? extends Module> sub1Submodules = sub1.getSubmodules();
+ final Collection<? extends Module> sub2Submodules = sub2.getSubmodules();
assertNotNull(sub1Submodules);
assertNotNull(sub2Submodules);
assertEquals(ROOT, sub1Submodule.getQNameModule());
- final Collection<DataSchemaNode> sub1SubmoduleChildNodes = sub1Submodule.getChildNodes();
+ final Collection<? extends DataSchemaNode> sub1SubmoduleChildNodes = sub1Submodule.getChildNodes();
assertNotNull(sub1SubmoduleChildNodes);
assertEquals(1, sub1SubmoduleChildNodes.size());
- final Set<Module> sub1SubmoduleSubmodules = sub1Submodule.getSubmodules();
+ final Collection<? extends Module> sub1SubmoduleSubmodules = sub1Submodule.getSubmodules();
assertNotNull(sub1SubmoduleSubmodules);
assertEquals(0, sub1SubmoduleSubmodules.size());
private static void findModulesSubTest(final SchemaContext result, final Module root, final Module imported) {
final Module foundRoot = result.findModule("root-module").get();
- final Set<Module> foundRoots = result.findModules(URI.create("root-module"));
+ final Collection<? extends Module> foundRoots = result.findModules(URI.create("root-module"));
final Module foundRoot3 = result.findModule(URI.create("root-module")).get();
assertNotNull(foundRoot);
assertEquals(root, foundRoot3);
final Module foundImported = result.findModule("imported-module").get();
- final Set<Module> foundImporteds = result.findModules(URI.create("imported-module"));
+ final Collection<? extends Module> foundImporteds = result.findModules(URI.create("imported-module"));
final Module foundImported3 = result.findModule(URI.create("imported-module")).get();
assertNotNull(foundImported);
import java.net.URISyntaxException;
import java.text.ParseException;
import java.util.Collection;
-import java.util.List;
import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
.buildEffective();
assertNotNull(schemaContext);
- final Set<DataSchemaNode> dataDefinitions = schemaContext.getDataDefinitions();
+ final Collection<? extends DataSchemaNode> dataDefinitions = schemaContext.getDataDefinitions();
assertEquals(3, dataDefinitions.size());
- final Collection<DataSchemaNode> childNodes = schemaContext.getChildNodes();
+ final Collection<? extends DataSchemaNode> childNodes = schemaContext.getChildNodes();
assertEquals(3, childNodes.size());
- final Set<NotificationDefinition> notifications = schemaContext.getNotifications();
+ final Collection<? extends NotificationDefinition> notifications = schemaContext.getNotifications();
assertEquals(3, notifications.size());
- final Set<RpcDefinition> rpcs = schemaContext.getOperations();
+ final Collection<? extends RpcDefinition> rpcs = schemaContext.getOperations();
assertEquals(3, rpcs.size());
- final Set<ExtensionDefinition> extensions = schemaContext.getExtensions();
+ final Collection<? extends ExtensionDefinition> extensions = schemaContext.getExtensions();
assertEquals(3, extensions.size());
- final List<UnknownSchemaNode> unknownSchemaNodes = schemaContext.getUnknownSchemaNodes();
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes = schemaContext.getUnknownSchemaNodes();
assertEquals(3, unknownSchemaNodes.size());
assertNull(schemaContext.getDataChildByName(QName.create("foo-namespace", "2016-09-21", "foo-cont")));
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.yangtools.yang.stmt;
import static org.junit.Assert.assertEquals;
import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.sourceForResource;
import com.google.common.collect.Range;
+import java.util.Iterator;
import java.util.List;
import java.util.Optional;
import org.junit.AfterClass;
currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-bits"));
assertNotNull(currentLeaf.getType());
- final List<BitsTypeDefinition.Bit> bitsEffIter = ((BitsTypeDefinition) currentLeaf.getType()).getBits();
- final Bit bitEff = bitsEffIter.get(0);
- final Bit bitEffSecond = bitsEffIter.get(1);
+ final Iterator<? extends Bit> bitsEffIter = ((BitsTypeDefinition) currentLeaf.getType()).getBits().iterator();
+ final Bit bitEff = bitsEffIter.next();
+ final Bit bitEffSecond = bitsEffIter.next();
final BitsTypeDefinition bitsEff = ((BitsSpecificationEffectiveStatement)
((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next())
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.yangtools.yang.stmt;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.sourceForResource;
+import java.util.Collection;
import java.util.Optional;
-import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
.buildEffective();
assertNotNull(result);
- Set<Module> modules = result.getModules();
+ Collection<? extends Module> modules = result.getModules();
assertNotNull(modules);
assertEquals(1, modules.size());
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.yangtools.yang.stmt;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.sourceForResource;
-import java.util.List;
+import java.util.Collection;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
assertEquals(1, testModule.getExtensionSchemaNodes().size());
- final List<ExtensionDefinition> extensions = testModule.getExtensionSchemaNodes();
- final ExtensionDefinition extension = extensions.get(0);
+ final Collection<? extends ExtensionDefinition> extensions = testModule.getExtensionSchemaNodes();
+ final ExtensionDefinition extension = extensions.iterator().next();
assertEquals("opendaylight", extension.getQName().getLocalName());
assertEquals("name", extension.getArgument());
assertTrue(extension.isYinElement());
assertEquals(1, testModule1.getExtensionSchemaNodes().size());
- final List<ExtensionDefinition> extensions = testModule1.getExtensionSchemaNodes();
- final ExtensionDefinition extensionDefinition = extensions.get(0);
+ final Collection<? extends ExtensionDefinition> extensions = testModule1.getExtensionSchemaNodes();
+ final ExtensionDefinition extensionDefinition = extensions.iterator().next();
final Module testModule2 = result.findModules("ext-use").iterator().next();
assertNotNull(testModule2);
assertNotNull(leaf);
assertEquals(1, leaf.getUnknownSchemaNodes().size());
- final List<UnknownSchemaNode> unknownNodes = leaf.getUnknownSchemaNodes();
- final UnknownSchemaNode extensionUse = unknownNodes.get(0);
+ final Collection<? extends UnknownSchemaNode> unknownNodes = leaf.getUnknownSchemaNodes();
+ final UnknownSchemaNode extensionUse = unknownNodes.iterator().next();
assertEquals(extensionDefinition.getQName().getLocalName(), extensionUse.getExtensionDefinition().getQName()
.getLocalName());
assertEquals(extensionDefinition.getArgument(), extensionUse.getExtensionDefinition().getArgument());
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.yangtools.yang.stmt;
import static org.hamcrest.CoreMatchers.anyOf;
import static org.junit.Assert.assertNotNull;
import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.sourceForResource;
+import java.util.Collection;
import java.util.Iterator;
-import java.util.List;
import java.util.Map;
-import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode;
final Module testModule = result.findModules("baz").iterator().next();
assertNotNull(testModule);
- final Set<GroupingDefinition> groupings = testModule.getGroupings();
+ final Collection<? extends GroupingDefinition> groupings = testModule.getGroupings();
assertEquals(1, groupings.size());
- final Iterator<GroupingDefinition> groupingsIterator = groupings.iterator();
+ final Iterator<? extends GroupingDefinition> groupingsIterator = groupings.iterator();
final GroupingDefinition grouping = groupingsIterator.next();
assertEquals("target", grouping.getQName().getLocalName());
assertEquals(5, grouping.getChildNodes().size());
assertEquals(1, grouping.getTypeDefinitions().size());
assertEquals("group-type", grouping.getTypeDefinitions().iterator().next().getQName().getLocalName());
- final List<UnknownSchemaNode> unknownSchemaNodes = grouping.getUnknownSchemaNodes();
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes = grouping.getUnknownSchemaNodes();
assertEquals(1, unknownSchemaNodes.size());
- final UnknownSchemaNode extensionUse = unknownSchemaNodes.get(0);
+ final UnknownSchemaNode extensionUse = unknownSchemaNodes.iterator().next();
assertEquals("opendaylight", extensionUse.getExtensionDefinition().getQName().getLocalName());
}
final Module testModule = result.findModules("foo").iterator().next();
assertNotNull(testModule);
- final Set<UsesNode> usesNodes = testModule.getUses();
+ final Collection<? extends UsesNode> usesNodes = testModule.getUses();
assertEquals(1, usesNodes.size());
UsesNode usesNode = usesNodes.iterator().next();
import java.net.URI;
import java.text.ParseException;
import java.util.Collection;
-import java.util.List;
import java.util.Map;
import java.util.Optional;
-import java.util.Set;
import java.util.SortedMap;
import org.junit.Before;
import org.junit.Test;
final ContainerSchemaNode destination = (ContainerSchemaNode) peer.getDataChildByName(QName.create(
testModule.getQNameModule(), "destination"));
- final Set<UsesNode> usesNodes = destination.getUses();
+ final Collection<? extends UsesNode> usesNodes = destination.getUses();
assertEquals(1, usesNodes.size());
final UsesNode usesNode = usesNodes.iterator().next();
final Map<SchemaPath, SchemaNode> refines = usesNode.getRefines();
assertEquals(Optional.of("address reference added by refine"), refineLeaf.getReference());
assertFalse(refineLeaf.isConfiguration());
assertFalse(refineLeaf.isMandatory());
- final Collection<MustDefinition> leafMustConstraints = refineLeaf.getMustConstraints();
+ final Collection<? extends MustDefinition> leafMustConstraints = refineLeaf.getMustConstraints();
assertEquals(1, leafMustConstraints.size());
final MustDefinition leafMust = leafMustConstraints.iterator().next();
assertEquals("ifType != 'ethernet' or (ifType = 'ethernet' and ifMTU = 1500)", leafMust.toString());
// container port
assertNotNull(refineContainer);
- final Collection<MustDefinition> mustConstraints = refineContainer.getMustConstraints();
+ final Collection<? extends MustDefinition> mustConstraints = refineContainer.getMustConstraints();
assertTrue(mustConstraints.isEmpty());
assertEquals(Optional.of("description of port defined by refine"), refineContainer.getDescription());
assertEquals(Optional.of("port reference added by refine"), refineContainer.getReference());
@Test
public void testGrouping() {
final Module testModule = TestUtils.findModule(ctx, "baz").get();
- final Set<GroupingDefinition> groupings = testModule.getGroupings();
+ final Collection<? extends GroupingDefinition> groupings = testModule.getGroupings();
assertEquals(1, groupings.size());
final GroupingDefinition grouping = groupings.iterator().next();
- final Collection<DataSchemaNode> children = grouping.getChildNodes();
+ final Collection<? extends DataSchemaNode> children = grouping.getChildNodes();
assertEquals(5, children.size());
}
// get grouping
- final Set<GroupingDefinition> groupings = baz.getGroupings();
+ final Collection<? extends GroupingDefinition> groupings = baz.getGroupings();
assertEquals(1, groupings.size());
final GroupingDefinition grouping = groupings.iterator().next();
foo.getQNameModule(), "destination"));
// check uses
- final Set<UsesNode> uses = destination.getUses();
+ final Collection<? extends UsesNode> uses = destination.getUses();
assertEquals(1, uses.size());
// check uses process
assertEquals(addresses_g, SchemaNodeUtils.getRootOriginalIfPossible(addresses_u));
// grouping defined by 'uses'
- final Set<GroupingDefinition> groupings_u = destination.getGroupings();
+ final Collection<? extends GroupingDefinition> groupings_u = destination.getGroupings();
assertEquals(1, groupings_u.size());
final GroupingDefinition grouping_u = groupings_u.iterator().next();
TestUtils.checkIsAddedByUses(grouping_u, true);
// grouping defined in 'grouping' node
- final Set<GroupingDefinition> groupings_g = grouping.getGroupings();
+ final Collection<? extends GroupingDefinition> groupings_g = grouping.getGroupings();
assertEquals(1, groupings_g.size());
final GroupingDefinition grouping_g = groupings_g.iterator().next();
TestUtils.checkIsAddedByUses(grouping_g, false);
assertFalse(grouping_u.equals(grouping_g));
- final List<UnknownSchemaNode> nodes_u = destination.getUnknownSchemaNodes();
+ final Collection<? extends UnknownSchemaNode> nodes_u = destination.getUnknownSchemaNodes();
assertEquals(1, nodes_u.size());
- final UnknownSchemaNode node_u = nodes_u.get(0);
+ final UnknownSchemaNode node_u = nodes_u.iterator().next();
assertTrue(node_u.isAddedByUses());
- final List<UnknownSchemaNode> nodes_g = grouping.getUnknownSchemaNodes();
+ final Collection<? extends UnknownSchemaNode> nodes_g = grouping.getUnknownSchemaNodes();
assertEquals(1, nodes_g.size());
- final UnknownSchemaNode node_g = nodes_g.get(0);
+ final UnknownSchemaNode node_g = nodes_g.iterator().next();
assertFalse(node_g.isAddedByUses());
assertFalse(node_u.equals(node_g));
}
// suffix _g = defined in grouping
// get grouping
- final Set<GroupingDefinition> groupings = baz.getGroupings();
+ final Collection<? extends GroupingDefinition> groupings = baz.getGroupings();
assertEquals(1, groupings.size());
final GroupingDefinition grouping = groupings.iterator().next();
// check uses
- final Set<UsesNode> uses = foo.getUses();
+ final Collection<? extends UsesNode> uses = foo.getUses();
assertEquals(1, uses.size());
// check uses process
assertEquals(addresses_g, SchemaNodeUtils.getRootOriginalIfPossible(addresses_u));
// grouping defined by 'uses'
- final Set<GroupingDefinition> groupings_u = foo.getGroupings();
+ final Collection<? extends GroupingDefinition> groupings_u = foo.getGroupings();
assertEquals(1, groupings_u.size());
final GroupingDefinition grouping_u = groupings_u.iterator().next();
TestUtils.checkIsAddedByUses(grouping_u, true);
// grouping defined in 'grouping' node
- final Set<GroupingDefinition> groupings_g = grouping.getGroupings();
+ final Collection<? extends GroupingDefinition> groupings_g = grouping.getGroupings();
assertEquals(1, groupings_g.size());
final GroupingDefinition grouping_g = groupings_g.iterator().next();
TestUtils.checkIsAddedByUses(grouping_g, false);
assertFalse(grouping_u.equals(grouping_g));
- final List<UnknownSchemaNode> nodes_u = foo.getUnknownSchemaNodes();
+ final Collection<? extends UnknownSchemaNode> nodes_u = foo.getUnknownSchemaNodes();
assertEquals(1, nodes_u.size());
- final UnknownSchemaNode node_u = nodes_u.get(0);
+ final UnknownSchemaNode node_u = nodes_u.iterator().next();
assertTrue(node_u.isAddedByUses());
- final List<UnknownSchemaNode> nodes_g = grouping.getUnknownSchemaNodes();
+ final Collection<? extends UnknownSchemaNode> nodes_g = grouping.getUnknownSchemaNodes();
assertEquals(1, nodes_g.size());
- final UnknownSchemaNode node_g = nodes_g.get(0);
+ final UnknownSchemaNode node_g = nodes_g.iterator().next();
assertFalse(node_g.isAddedByUses());
assertFalse(node_u.equals(node_g));
final UsesNode un = uses.iterator().next();
- final Set<AugmentationSchemaNode> usesAugments = un.getAugmentations();
+ final Collection<? extends AugmentationSchemaNode> usesAugments = un.getAugmentations();
assertEquals(1, usesAugments.size());
final AugmentationSchemaNode augment = usesAugments.iterator().next();
assertEquals(Optional.of("inner augment"), augment.getDescription());
- final Collection<DataSchemaNode> children = augment.getChildNodes();
+ final Collection<? extends DataSchemaNode> children = augment.getChildNodes();
assertEquals(1, children.size());
final DataSchemaNode leaf = children.iterator().next();
assertTrue(leaf instanceof LeafSchemaNode);
assertEquals(1, ctx.getModules().size());
final Module testModule = TestUtils.findModule(ctx, "cascade-uses").get();
- final Set<GroupingDefinition> groupings = testModule.getGroupings();
+ final Collection<? extends GroupingDefinition> groupings = testModule.getGroupings();
GroupingDefinition gu = null;
GroupingDefinition gv = null;
Revision.of("2013-07-18"));
// grouping-U
- Collection<DataSchemaNode> childNodes = gu.getChildNodes();
+ Collection<? extends DataSchemaNode> childNodes = gu.getChildNodes();
assertEquals(7, childNodes.size());
final LeafSchemaNode leafGroupingU = (LeafSchemaNode) gu.getDataChildByName(QName.create(
.getDataChildByName(QName.create(foo.getQNameModule(), "my-leaf"));
TypeDefinition<?> impType = null;
- final Set<TypeDefinition<?>> typeDefinitions = imp.getTypeDefinitions();
- for (final TypeDefinition<?> typeDefinition : typeDefinitions) {
+ for (final TypeDefinition<?> typeDefinition : imp.getTypeDefinitions()) {
if (typeDefinition.getQName().getLocalName().equals("imp-type")) {
impType = typeDefinition;
break;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.yangtools.yang.stmt;
import static org.hamcrest.CoreMatchers.anyOf;
import static org.junit.Assert.assertThat;
import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.sourceForResource;
+import java.util.Collection;
import java.util.Iterator;
-import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
Module testModule = result.findModules("legal-chained-identity-test").iterator().next();
assertNotNull(testModule);
- Set<IdentitySchemaNode> identities = testModule.getIdentities();
+ Collection<? extends IdentitySchemaNode> identities = testModule.getIdentities();
assertEquals(4, identities.size());
- Iterator<IdentitySchemaNode> identitiesIterator = identities.iterator();
+ Iterator<? extends IdentitySchemaNode> identitiesIterator = identities.iterator();
IdentitySchemaNode identity = identitiesIterator.next();
assertThat(identity.getQName().getLocalName(), anyOf(is("first-identity"), is("second-identity"),
is("third-identity"), is("fourth-identity")));
assertNotNull(result);
Module testModule = result.findModules("duplicate-identity-test").iterator().next();
- Set<IdentitySchemaNode> identities = testModule.getIdentities();
+ Collection<? extends IdentitySchemaNode> identities = testModule.getIdentities();
assertEquals(1, identities.size());
}
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.yangtools.yang.stmt;
import static org.hamcrest.CoreMatchers.anyOf;
import static org.junit.Assert.assertNotNull;
import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.sourceForResource;
+import java.util.Collection;
import java.util.Iterator;
-import java.util.Set;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
final Module testModule = result.findModules("root-module").iterator().next();
assertNotNull(testModule);
- final Set<TypeDefinition<?>> typedefs = testModule.getTypeDefinitions();
+ final Collection<? extends TypeDefinition<?>> typedefs = testModule.getTypeDefinitions();
assertEquals(2, typedefs.size());
- final Iterator<TypeDefinition<?>> typedefsIterator = typedefs.iterator();
+ final Iterator<? extends TypeDefinition<?>> typedefsIterator = typedefs.iterator();
TypeDefinition<?> typedef = typedefsIterator.next();
assertThat(typedef.getQName().getLocalName(), anyOf(is("new-string-type"), is("new-int32-type")));
assertThat(typedef.getBaseType().getQName().getLocalName(), anyOf(is("string"), is("int32")));
final Module testModule = result.findModules("root-module").iterator().next();
assertNotNull(testModule);
- final Set<FeatureDefinition> features = testModule.getFeatures();
+ final Collection<? extends FeatureDefinition> features = testModule.getFeatures();
assertEquals(2, features.size());
- final Iterator<FeatureDefinition> featuresIterator = features.iterator();
+ final Iterator<? extends FeatureDefinition> featuresIterator = features.iterator();
FeatureDefinition feature = featuresIterator.next();
assertThat(feature.getQName().getLocalName(), anyOf(is("new-feature1"), is("new-feature2")));
feature = featuresIterator.next();
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.yangtools.yang.stmt;
import static org.junit.Assert.assertEquals;
import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.sourceForResource;
import java.net.URI;
+import java.util.Collection;
import java.util.Optional;
-import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
.addSources(NETWORK_TOPOLOGY_20130712, NETWORK_TOPOLOGY_20131021, IETF_TYPES)
.buildEffective();
assertNotNull(result);
- Set<Module> modules = result.getModules();
+ Collection<? extends Module> modules = result.getModules();
assertEquals(3, modules.size());
assertEquals(2, StmtTestUtils.findModules(modules, "network-topology").size());
Revision rev20121115 = Revision.of("2012-11-15");
Module interfacesModule20121115 = context.findModule("ietf-interfaces", rev20121115).get();
- Set<ModuleImport> imports = interfacesModule20121115.getImports();
+ Collection<? extends ModuleImport> imports = interfacesModule20121115.getImports();
assertEquals(1, imports.size());
ModuleImport interfacesImport = imports.iterator().next();
assertEquals("ietf-yang-types", interfacesImport.getModuleName());
Revision rev20101004 = Revision.of("2010-10-04");
Module monitoringModule20101004 = context.findModule("ietf-netconf-monitoring", rev20101004).get();
- Set<ModuleImport> imports = monitoringModule20101004.getImports();
+ Collection<? extends ModuleImport> imports = monitoringModule20101004.getImports();
assertEquals(2, imports.size());
for (ModuleImport monitoringImport : imports) {
if (monitoringImport.getModuleName().equals("ietf-yang-types")) {
QName lastChangeTypeQName = ((LeafSchemaNode) leafLastChange).getType().getQName();
assertEquals(dateTimeTypeDef20100924, lastChangeTypeQName);
- Set<ModuleImport> imports = interfacesModule20121115.getImports();
+ Collection<? extends ModuleImport> imports = interfacesModule20121115.getImports();
assertEquals(1, imports.size());
ModuleImport interfacesImport = imports.iterator().next();
assertEquals("ietf-yang-types", interfacesImport.getModuleName());
QName lockedTimeTypeQName = ((LeafSchemaNode) leafLockedTime).getType().getQName();
assertEquals(dateTimeTypeDef20130715, lockedTimeTypeQName);
- Set<ModuleImport> imports = monitoringModule19700101.getImports();
+ Collection<? extends ModuleImport> imports = monitoringModule19700101.getImports();
assertEquals(1, imports.size());
ModuleImport monitoringImport = imports.iterator().next();
assertEquals("ietf-yang-types", monitoringImport.getModuleName());
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.yangtools.yang.stmt;
import static org.hamcrest.CoreMatchers.anyOf;
assertNotNull(container);
assertTrue(container.isPresenceContainer());
- final Collection<MustDefinition> musts = container.getMustConstraints();
+ final Collection<? extends MustDefinition> musts = container.getMustConstraints();
assertEquals(2, musts.size());
- final Iterator<MustDefinition> mustsIterator = musts.iterator();
+ final Iterator<? extends MustDefinition> mustsIterator = musts.iterator();
MustDefinition mustStmt = mustsIterator.next();
assertThat(mustStmt.getXpath().getOriginalString(), anyOf(is("ifType != 'ethernet' or (ifType = 'ethernet' and "
+ "ifMTU = 1500)"), is("ifType != 'atm' or (ifType = 'atm' and ifMTU <= 17966 and ifMTU >= 64)")));
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.yangtools.yang.stmt;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.sourceForResource;
-import java.util.Set;
+import java.util.Collection;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode;
final Module testModule = result.findModules("baz").iterator().next();
assertNotNull(testModule);
- final Set<NotificationDefinition> notifications = testModule.getNotifications();
+ final Collection<? extends NotificationDefinition> notifications = testModule.getNotifications();
assertEquals(1, notifications.size());
final NotificationDefinition notification = notifications.iterator().next();
import java.io.IOException;
import java.net.URISyntaxException;
import java.util.Collection;
-import java.util.Set;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
@Test
public void testOrderingTypedef() throws Exception {
- final Set<TypeDefinition<?>> typedefs = bar.getTypeDefinitions();
+ final Collection<? extends TypeDefinition<?>> typedefs = bar.getTypeDefinitions();
final String[] expectedOrder = { "int32-ext1", "int32-ext2", "string-ext1", "string-ext2", "string-ext3",
"string-ext4", "invalid-string-pattern", "multiple-pattern-string", "my-decimal-type", "my-union",
"my-union-ext", "nested-union2"
@Test
public void testOrderingNestedChildNodes1() throws Exception {
- final Collection<DataSchemaNode> childNodes = foo.getChildNodes();
+ final Collection<? extends DataSchemaNode> childNodes = foo.getChildNodes();
final String[] expectedOrder = { "int32-leaf", "string-leaf", "invalid-pattern-string-leaf",
"invalid-direct-string-pattern-def-leaf", "multiple-pattern-string-leaf",
"multiple-pattern-direct-string-def-leaf", "length-leaf", "decimal-leaf", "decimal-leaf2", "ext",
@Test
public void testOrderingNestedChildNodes2() throws Exception {
- final Set<GroupingDefinition> groupings = baz.getGroupings();
+ final Collection<? extends GroupingDefinition> groupings = baz.getGroupings();
assertEquals(1, groupings.size());
final GroupingDefinition target = groupings.iterator().next();
- final Collection<DataSchemaNode> childNodes = target.getChildNodes();
+ final Collection<? extends DataSchemaNode> childNodes = target.getChildNodes();
final String[] expectedOrder = { "data", "how", "address", "port", "addresses" };
final String[] actualOrder = new String[childNodes.size()];
.getModules().iterator().next();
final ContainerSchemaNode x = (ContainerSchemaNode) justFoo
.getDataChildByName(QName.create(justFoo.getQNameModule(), "x"));
- final Collection<DataSchemaNode> childNodes = x.getChildNodes();
+ final Collection<? extends DataSchemaNode> childNodes = x.getChildNodes();
final String[] expectedOrder = { "x15", "x10", "x5", "x1", "a5", "a1", "x2", "b5", "b1", "x3", "ax15", "ax5" };
final String[] actualOrder = new String[childNodes.size()];
import static org.junit.Assert.assertTrue;
import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.sourceForResource;
-import java.util.Set;
+import java.util.Collection;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Revision;
assertNotNull(anyXml);
final Module fooModule = result.findModule("foo", Revision.of("2016-09-23")).get();
- final Set<RpcDefinition> rpcs = fooModule.getRpcs();
+ final Collection<? extends RpcDefinition> rpcs = fooModule.getRpcs();
assertEquals(2, rpcs.size());
RpcDefinition fooRpc1 = null;
assertNotNull(schemaContext);
final Module barModule = schemaContext.findModule("bar", Revision.of("2016-11-25")).get();
- final Set<RpcDefinition> rpcs = barModule.getRpcs();
+ final Collection<? extends RpcDefinition> rpcs = barModule.getRpcs();
assertEquals(1, rpcs.size());
final RpcDefinition barRpc = rpcs.iterator().next();
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.yangtools.yang.stmt;
import com.google.common.io.Files;
}
}
- public static List<Module> findModules(final Set<Module> modules, final String moduleName) {
+ public static List<Module> findModules(final Collection<? extends Module> modules, final String moduleName) {
final List<Module> result = new ArrayList<>();
for (final Module module : modules) {
if (module.getName().equals(moduleName)) {
}
public static void printReferences(final Module module, final boolean isSubmodule, final String indent) {
- LOG.debug("{}{} {}", indent, (isSubmodule ? "Submodule" : "Module"), module.getName());
- final Set<Module> submodules = module.getSubmodules();
- for (final Module submodule : submodules) {
+ LOG.debug("{}{} {}", indent, isSubmodule ? "Submodule" : "Module", module.getName());
+ for (final Module submodule : module.getSubmodules()) {
printReferences(submodule, true, indent + " ");
printChilds(submodule.getChildNodes(), indent + " ");
}
}
- public static void printChilds(final Collection<DataSchemaNode> childNodes, final String indent) {
+ public static void printChilds(final Collection<? extends DataSchemaNode> childNodes, final String indent) {
for (final DataSchemaNode child : childNodes) {
LOG.debug("{}{} {}", indent, "Child", child.getQName().getLocalName());
public static Module findImportedModule(final SchemaContext context, final Module rootModule,
final String importedModuleName) {
ModuleImport requestedModuleImport = null;
- final Set<ModuleImport> rootImports = rootModule.getImports();
- for (final ModuleImport moduleImport : rootImports) {
+ for (final ModuleImport moduleImport : rootModule.getImports()) {
if (moduleImport.getModuleName().equals(importedModuleName)) {
requestedModuleImport = moduleImport;
break;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.yangtools.yang.stmt;
import static org.junit.Assert.assertEquals;
import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import java.io.UnsupportedEncodingException;
-import java.util.Set;
+import java.util.Collection;
import org.junit.After;
import org.junit.Before;
import org.junit.Rule;
@Test
public void bug6173Test() throws Exception {
- final Set<Module> loadModules = TestUtils.loadModules(getClass().getResource(
- "/substatement-validator/empty-element").toURI()).getModules();
+ final Collection<? extends Module> loadModules = TestUtils.loadModules(getClass()
+ .getResource("/substatement-validator/empty-element").toURI()).getModules();
assertEquals(1, loadModules.size());
}
import java.util.Collection;
import java.util.List;
import java.util.Optional;
-import java.util.Set;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.YangConstants;
return ctx.getModules().iterator().next();
}
- public static Optional<Module> findModule(final SchemaContext context, final String moduleName) {
+ public static Optional<? extends Module> findModule(final SchemaContext context, final String moduleName) {
return context.getModules().stream().filter(module -> moduleName.equals(module.getName())).findAny();
}
- public static ModuleImport findImport(final Set<ModuleImport> imports, final String prefix) {
- ModuleImport result = null;
+ public static ModuleImport findImport(final Collection<? extends ModuleImport> imports, final String prefix) {
for (ModuleImport moduleImport : imports) {
if (moduleImport.getPrefix().equals(prefix)) {
- result = moduleImport;
- break;
+ return moduleImport;
}
}
- return result;
+ return null;
}
- public static TypeDefinition<?> findTypedef(final Set<TypeDefinition<?>> typedefs, final String name) {
- TypeDefinition<?> result = null;
+ public static TypeDefinition<?> findTypedef(final Collection<? extends TypeDefinition<?>> typedefs,
+ final String name) {
for (TypeDefinition<?> td : typedefs) {
if (td.getQName().getLocalName().equals(name)) {
- result = td;
- break;
+ return td;
}
}
- return result;
+ return null;
}
public static SchemaPath createPath(final boolean absolute, final QNameModule module, final String... names) {
}
}
- public static List<Module> findModules(final Set<Module> modules, final String moduleName) {
+ public static List<Module> findModules(final Collection<? extends Module> modules, final String moduleName) {
List<Module> result = new ArrayList<>();
for (Module module : modules) {
if (module.getName().equals(moduleName)) {
import static org.junit.Assert.assertEquals;
-import java.util.Set;
+import java.util.Collection;
import org.junit.Test;
import org.opendaylight.yangtools.yang.model.api.Module;
public class TwoRevisionsTest {
-
@Test
public void testTwoRevisions() throws Exception {
- Set<Module> modules = TestUtils.loadModules(getClass().getResource("/ietf").toURI()).getModules();
+ Collection<? extends Module> modules = TestUtils.loadModules(getClass().getResource("/ietf").toURI())
+ .getModules();
//FIXME: following assert needs module revisions .equals() solution first
assertEquals(2, TestUtils.findModules(modules, "network-topology").size());
}
-
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.yangtools.yang.stmt;
import static org.junit.Assert.assertEquals;
import com.google.common.collect.Range;
import java.math.BigDecimal;
+import java.util.Collection;
import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
assertNotNull(context);
- final Set<TypeDefinition<?>> typeDefinitions = context.getTypeDefinitions();
+ final Collection<? extends TypeDefinition<?>> typeDefinitions = context.getTypeDefinitions();
assertNotNull(typeDefinitions);
assertEquals(1, typeDefinitions.size());
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.yangtools.yang.stmt;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.sourceForResource;
+import java.util.Collection;
import java.util.Optional;
-import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
.buildEffective();
assertNotNull(result);
- Set<TypeDefinition<?>> typedefs = result.getTypeDefinitions();
+ Collection<? extends TypeDefinition<?>> typedefs = result.getTypeDefinitions();
assertEquals(1, typedefs.size());
TypeDefinition<?> typedef = typedefs.iterator().next();
import com.google.common.collect.Iterables;
import com.google.common.collect.Range;
import java.net.URI;
+import java.util.Collection;
+import java.util.Iterator;
import java.util.List;
import java.util.Optional;
-import java.util.Set;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
@Test
public void testIPVersion() {
Module tested = TestUtils.findModule(context, "ietf-inet-types").get();
- Set<TypeDefinition<?>> typedefs = tested.getTypeDefinitions();
+ Collection<? extends TypeDefinition<?>> typedefs = tested.getTypeDefinitions();
assertEquals(14, typedefs.size());
TypeDefinition<?> type = TestUtils.findTypedef(typedefs, "ip-version");
@Test
public void testEnumeration() {
Module tested = TestUtils.findModule(context, "custom-types-test").get();
- Set<TypeDefinition<?>> typedefs = tested.getTypeDefinitions();
+ Collection<? extends TypeDefinition<?>> typedefs = tested.getTypeDefinitions();
TypeDefinition<?> type = TestUtils.findTypedef(typedefs, "ip-version");
EnumTypeDefinition enumType = (EnumTypeDefinition) type.getBaseType();
@Test
public void testIpAddress() {
Module tested = TestUtils.findModule(context, "ietf-inet-types").get();
- Set<TypeDefinition<?>> typedefs = tested.getTypeDefinitions();
+ Collection<? extends TypeDefinition<?>> typedefs = tested.getTypeDefinitions();
TypeDefinition<?> type = TestUtils.findTypedef(typedefs, "ip-address");
UnionTypeDefinition baseType = (UnionTypeDefinition) type.getBaseType();
List<TypeDefinition<?>> unionTypes = baseType.getTypes();
@Test
public void testDomainName() {
Module tested = TestUtils.findModule(context, "ietf-inet-types").get();
- Set<TypeDefinition<?>> typedefs = tested.getTypeDefinitions();
+ Collection<? extends TypeDefinition<?>> typedefs = tested.getTypeDefinitions();
StringTypeDefinition type = (StringTypeDefinition) TestUtils.findTypedef(typedefs, "domain-name");
assertNotNull(type.getBaseType());
List<PatternConstraint> patterns = type.getPatternConstraints();
@Test
public void testIdentity() {
Module tested = TestUtils.findModule(context, "custom-types-test").get();
- Set<IdentitySchemaNode> identities = tested.getIdentities();
+ Collection<? extends IdentitySchemaNode> identities = tested.getIdentities();
assertEquals(5, identities.size());
IdentitySchemaNode cryptoAlg = null;
IdentitySchemaNode cryptoBase = null;
LeafSchemaNode leaf = (LeafSchemaNode) tested.getDataChildByName(
QName.create(tested.getQNameModule(), "mybits"));
BitsTypeDefinition leafType = (BitsTypeDefinition) leaf.getType();
- List<Bit> bits = leafType.getBits();
- assertEquals(3, bits.size());
+ Iterator<? extends Bit> bits = leafType.getBits().iterator();
- Bit bit1 = bits.get(0);
+ Bit bit1 = bits.next();
assertEquals("disable-nagle", bit1.getName());
assertEquals(0L, bit1.getPosition());
- Bit bit2 = bits.get(1);
+ Bit bit2 = bits.next();
assertEquals("auto-sense-speed", bit2.getName());
assertEquals(1L, bit2.getPosition());
- Bit bit3 = bits.get(2);
+ Bit bit3 = bits.next();
assertEquals("only-10-Mb", bit3.getName());
assertEquals(2L, bit3.getPosition());
+
+ assertFalse(bits.hasNext());
}
@Test
public void testBitsType2() {
Module tested = TestUtils.findModule(context, "custom-types-test").get();
- Set<TypeDefinition<?>> typedefs = tested.getTypeDefinitions();
+ Collection<? extends TypeDefinition<?>> typedefs = tested.getTypeDefinitions();
TypeDefinition<?> testedType = TestUtils.findTypedef(typedefs, "access-operations-type");
BitsTypeDefinition bitsType = (BitsTypeDefinition) testedType.getBaseType();
- List<Bit> bits = bitsType.getBits();
- assertEquals(5, bits.size());
+ Iterator<? extends Bit> bits = bitsType.getBits().iterator();
- Bit bit0 = bits.get(0);
+ Bit bit0 = bits.next();
assertEquals("create", bit0.getName());
assertEquals(0L, bit0.getPosition());
- Bit bit1 = bits.get(1);
+ Bit bit1 = bits.next();
assertEquals("delete", bit1.getName());
assertEquals(365L, bit1.getPosition());
- Bit bit2 = bits.get(2);
+ Bit bit2 = bits.next();
assertEquals("read", bit2.getName());
assertEquals(500L, bit2.getPosition());
- Bit bit3 = bits.get(3);
+ Bit bit3 = bits.next();
assertEquals("update", bit3.getName());
assertEquals(501L, bit3.getPosition());
- Bit bit4 = bits.get(4);
+ Bit bit4 = bits.next();
assertEquals("exec", bit4.getName());
assertEquals(502L, bit4.getPosition());
+
+ assertFalse(bits.hasNext());
}
@Test
public void testIanaTimezones() {
Module tested = TestUtils.findModule(context, "iana-timezones").get();
- Set<TypeDefinition<?>> typedefs = tested.getTypeDefinitions();
+ Collection<? extends TypeDefinition<?>> typedefs = tested.getTypeDefinitions();
TypeDefinition<?> testedType = TestUtils.findTypedef(typedefs, "iana-timezone");
String expectedDesc = "A timezone location as defined by the IANA timezone";
@Test
public void testObjectId128() {
Module tested = TestUtils.findModule(context, "ietf-yang-types").get();
- Set<TypeDefinition<?>> typedefs = tested.getTypeDefinitions();
+ Collection<? extends TypeDefinition<?>> typedefs = tested.getTypeDefinitions();
StringTypeDefinition testedType = (StringTypeDefinition) TestUtils.findTypedef(typedefs,
"object-identifier-128");
@Test
public void testIdentityref() {
Module tested = TestUtils.findModule(context, "custom-types-test").get();
- Set<TypeDefinition<?>> typedefs = tested.getTypeDefinitions();
+ Collection<? extends TypeDefinition<?>> typedefs = tested.getTypeDefinitions();
TypeDefinition<?> testedType = TestUtils.findTypedef(typedefs, "service-type-ref");
IdentityrefTypeDefinition baseType = (IdentityrefTypeDefinition) testedType.getBaseType();
QName identity = baseType.getIdentities().iterator().next().getQName();
import java.util.ArrayDeque;
import java.util.Collection;
import java.util.Deque;
-import java.util.Set;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
final Deque<QName> path = new ArrayDeque<>();
// * notification pcreq
- final Set<NotificationDefinition> notifications = testModule.getNotifications();
+ final Collection<? extends NotificationDefinition> notifications = testModule.getNotifications();
assertEquals(1, notifications.size());
final NotificationDefinition pcreq = notifications.iterator().next();
assertNotNull(pcreq);
path.offer(expectedQName);
SchemaPath expectedPath = SchemaPath.create(path, true);
assertEquals(expectedPath, pcreq.getPath());
- Collection<DataSchemaNode> childNodes = pcreq.getChildNodes();
+ Collection<? extends DataSchemaNode> childNodes = pcreq.getChildNodes();
assertEquals(4, childNodes.size());
// * |-- leaf version
LeafSchemaNode version = (LeafSchemaNode) pcreq.getDataChildByName(QName.create(testModule.getQNameModule(),
@Test
public void testTypedefs() throws Exception {
final Module testModule = TestUtils.findModule(context, "grouping-definitions").get();
- final Set<TypeDefinition<?>> types = testModule.getTypeDefinitions();
+ final Collection<? extends TypeDefinition<?>> types = testModule.getTypeDefinitions();
TypeDefinition<?> intExt = null;
for (final TypeDefinition<?> td : types) {
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.yangtools.yang.stmt;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotEquals;
import java.io.IOException;
-import java.util.Set;
+import java.util.Collection;
import org.junit.Test;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.ModuleImport;
public void testParsingImportPrefixIdentityTestModule() throws Exception {
Module module = TestUtils.findModule(TestUtils.loadModules(getClass().getResource("/identity/import").toURI()),
"prefiximportidentitytest").get();
- Set<ModuleImport> imports = module.getImports();
+ Collection<? extends ModuleImport> imports = module.getImports();
assertEquals(imports.size(), 1);
ModuleImport dummy = TestUtils.findImport(imports, "dummy");
assertNotEquals(dummy.getPrefix(), module.getPrefix());
import java.util.Collection;
import java.util.List;
import java.util.Optional;
-import java.util.Set;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
assertTrue(data.isMandatory());
assertEquals("class != 'wheel'", data.getWhenCondition().get().getOriginalString());
- final Collection<MustDefinition> mustConstraints = data.getMustConstraints();
+ final Collection<? extends MustDefinition> mustConstraints = data.getMustConstraints();
assertEquals(2, mustConstraints.size());
final String must1 = "ifType != 'ethernet' or (ifType = 'ethernet' and ifMTU = 1500)";
assertTrue(anydata.isMandatory());
assertTrue(anydata.getWhenCondition().isPresent());
assertEquals("class != 'wheel'", anydata.getWhenCondition().get().getOriginalString());
- final Collection<MustDefinition> mustConstraints = anydata.getMustConstraints();
+ final Collection<? extends MustDefinition> mustConstraints = anydata.getMustConstraints();
assertEquals(2, mustConstraints.size());
final String must1 = "ifType != 'ethernet' or (ifType = 'ethernet' and ifMTU = 1500)";
// constraints
assertEquals("class != 'wheel'", nodes.getWhenCondition().get().getOriginalString());
- final Collection<MustDefinition> mustConstraints = nodes.getMustConstraints();
+ final Collection<? extends MustDefinition> mustConstraints = nodes.getMustConstraints();
assertEquals(2, mustConstraints.size());
final String must1 = "ifType != 'atm' or (ifType = 'atm' and ifMTU <= 17966 and ifMTU >= 64)";
assertTrue(nodes.isPresenceContainer());
// typedef
- final Set<TypeDefinition<?>> typedefs = nodes.getTypeDefinitions();
+ final Collection<? extends TypeDefinition<?>> typedefs = nodes.getTypeDefinitions();
assertEquals(1, typedefs.size());
final TypeDefinition<?> nodesType = typedefs.iterator().next();
final QName typedefQName = QName.create(SN, "nodes-type");
testModule.getQNameModule(), "links"));
assertFalse(links.isUserOrdered());
- final Set<GroupingDefinition> groupings = nodes.getGroupings();
+ final Collection<? extends GroupingDefinition> groupings = nodes.getGroupings();
assertEquals(1, groupings.size());
final GroupingDefinition nodeGroup = groupings.iterator().next();
final QName groupQName = QName.create(SN, "node-group");
final SchemaPath nodeGroupPath = SN_NODES_PATH.createChild(groupQName);
assertEquals(nodeGroupPath, nodeGroup.getPath());
- final Set<UsesNode> uses = nodes.getUses();
+ final Collection<? extends UsesNode> uses = nodes.getUses();
assertEquals(1, uses.size());
final UsesNode use = uses.iterator().next();
assertEquals(nodeGroupPath, use.getGroupingPath());
assertEquals(FOO.getNamespace(), foo.getNamespace());
assertEquals("foo", foo.getPrefix());
- final Set<ModuleImport> imports = foo.getImports();
+ final Collection<? extends ModuleImport> imports = foo.getImports();
assertEquals(2, imports.size());
final ModuleImport import2 = TestUtils.findImport(imports, "br");
assertEquals(1, constraints.getMinElements().intValue());
assertEquals(11, constraints.getMaxElements().intValue());
// test AugmentationTarget args
- final Set<AugmentationSchemaNode> availableAugmentations = ifEntry.getAvailableAugmentations();
+ final Collection<? extends AugmentationSchemaNode> availableAugmentations = ifEntry.getAvailableAugmentations();
assertEquals(2, availableAugmentations.size());
// test ListSchemaNode args
final List<QName> expectedKey = new ArrayList<>();
@Test
public void testDeviation() {
- final Set<Deviation> deviations = foo.getDeviations();
+ final Collection<? extends Deviation> deviations = foo.getDeviations();
assertEquals(1, deviations.size());
final Deviation dev = deviations.iterator().next();
assertEquals(Optional.of("system/user ref"), dev.getReference());
public void testUnknownNode() {
final ContainerSchemaNode network = (ContainerSchemaNode) baz.getDataChildByName(
QName.create(baz.getQNameModule(), "network"));
- final List<UnknownSchemaNode> unknownNodes = network.getUnknownSchemaNodes();
+ final Collection<? extends UnknownSchemaNode> unknownNodes = network.getUnknownSchemaNodes();
assertEquals(1, unknownNodes.size());
- final UnknownSchemaNode unknownNode = unknownNodes.get(0);
+ final UnknownSchemaNode unknownNode = unknownNodes.iterator().next();
assertNotNull(unknownNode.getNodeType());
assertEquals("point", unknownNode.getNodeParameter());
}
@Test
public void testFeature() {
- final Set<FeatureDefinition> features = baz.getFeatures();
+ final Collection<? extends FeatureDefinition> features = baz.getFeatures();
assertEquals(3, features.size());
}
@Test
public void testExtension() {
- final List<ExtensionDefinition> extensions = baz.getExtensionSchemaNodes();
+ final Collection<? extends ExtensionDefinition> extensions = baz.getExtensionSchemaNodes();
assertEquals(1, extensions.size());
- final ExtensionDefinition extension = extensions.get(0);
+ final ExtensionDefinition extension = extensions.iterator().next();
assertEquals("name", extension.getArgument());
assertEquals(
Optional.of("Takes as argument a name string. Makes the code generator use the given name in the #define."),
@Test
public void testNotification() {
- final Set<NotificationDefinition> notifications = baz.getNotifications();
+ final Collection<? extends NotificationDefinition> notifications = baz.getNotifications();
assertEquals(1, notifications.size());
final NotificationDefinition notification = notifications.iterator().next();
@Test
public void testRpc() {
- final Set<RpcDefinition> rpcs = baz.getRpcs();
+ final Collection<? extends RpcDefinition> rpcs = baz.getRpcs();
assertEquals(1, rpcs.size());
final RpcDefinition rpc = rpcs.iterator().next();
@Test
public void testTypePath() throws ParseException {
- final Set<TypeDefinition<?>> types = bar.getTypeDefinitions();
+ final Collection<? extends TypeDefinition<?>> types = bar.getTypeDefinitions();
// int32-ext1
final Int32TypeDefinition int32ext1 = (Int32TypeDefinition) TestUtils.findTypedef(types, "int32-ext1");
@Test
public void testTypePath2() throws ParseException {
- final Set<TypeDefinition<?>> types = bar.getTypeDefinitions();
+ final Collection<? extends TypeDefinition<?>> types = bar.getTypeDefinitions();
// my-decimal-type
final DecimalTypeDefinition myDecType = (DecimalTypeDefinition) TestUtils.findTypedef(types, "my-decimal-type");
final Module testModule = context.findModule("test2", Revision.of("2013-06-18")).get();
final Module contextModule = context.findModules(URI.create("urn:opendaylight.baz")).iterator().next();
assertNotNull(contextModule);
- final Set<GroupingDefinition> groupings = contextModule.getGroupings();
+ final Collection<? extends GroupingDefinition> groupings = contextModule.getGroupings();
assertEquals(1, groupings.size());
final GroupingDefinition grouping = groupings.iterator().next();
testModule.getQNameModule(), "destination"));
// check uses
- final Set<UsesNode> uses = destination.getUses();
+ final Collection<? extends UsesNode> uses = destination.getUses();
assertEquals(1, uses.size());
// check uses process
assertFalse(addresses_u.equals(addresses_g));
// grouping defined by 'uses'
- final Set<GroupingDefinition> groupings_u = destination.getGroupings();
+ final Collection<? extends GroupingDefinition> groupings_u = destination.getGroupings();
assertEquals(1, groupings_u.size());
final GroupingDefinition grouping_u = groupings_u.iterator().next();
assertTrue(grouping_u.isAddedByUses());
// grouping defined in 'grouping' node
- final Set<GroupingDefinition> groupings_g = grouping.getGroupings();
+ final Collection<? extends GroupingDefinition> groupings_g = grouping.getGroupings();
assertEquals(1, groupings_g.size());
final GroupingDefinition grouping_g = groupings_g.iterator().next();
assertFalse(grouping_g.isAddedByUses());
assertFalse(grouping_u.equals(grouping_g));
- final List<UnknownSchemaNode> nodes_u = destination.getUnknownSchemaNodes();
+ final Collection<? extends UnknownSchemaNode> nodes_u = destination.getUnknownSchemaNodes();
assertEquals(1, nodes_u.size());
- final UnknownSchemaNode node_u = nodes_u.get(0);
+ final UnknownSchemaNode node_u = nodes_u.iterator().next();
assertTrue(node_u.isAddedByUses());
- final List<UnknownSchemaNode> nodes_g = grouping.getUnknownSchemaNodes();
+ final Collection<? extends UnknownSchemaNode> nodes_g = grouping.getUnknownSchemaNodes();
assertEquals(1, nodes_g.size());
- final UnknownSchemaNode node_g = nodes_g.get(0);
+ final UnknownSchemaNode node_g = nodes_g.iterator().next();
assertFalse(node_g.isAddedByUses());
assertFalse(node_u.equals(node_g));
}
module.getQNameModule(), "peer"));
final ContainerSchemaNode destination = (ContainerSchemaNode) peer.getDataChildByName(QName.create(
module.getQNameModule(), "destination"));
- final Set<UsesNode> usesNodes = destination.getUses();
+ final Collection<? extends UsesNode> usesNodes = destination.getUses();
assertEquals(1, usesNodes.size());
final UsesNode usesNode = usesNodes.iterator().next();
assertEquals(Optional.of("address reference added by refine"), refineLeaf.getReference());
assertFalse(refineLeaf.isConfiguration());
assertTrue(refineLeaf.isMandatory());
- final Collection<MustDefinition> leafMustConstraints = refineLeaf.getMustConstraints();
+ final Collection<? extends MustDefinition> leafMustConstraints = refineLeaf.getMustConstraints();
assertEquals(1, leafMustConstraints.size());
final MustDefinition leafMust = leafMustConstraints.iterator().next();
assertEquals("ifType != 'ethernet' or (ifType = 'ethernet' and ifMTU = 1500)", leafMust.toString());
// container port
assertNotNull(refineContainer);
- final Collection<MustDefinition> mustConstraints = refineContainer.getMustConstraints();
+ final Collection<? extends MustDefinition> mustConstraints = refineContainer.getMustConstraints();
assertTrue(mustConstraints.isEmpty());
assertEquals(Optional.of("description of port defined by refine"), refineContainer.getDescription());
assertEquals(Optional.of("port reference added by refine"), refineContainer.getReference());
.buildEffective();
final Module module = context.findModule("test3", Revision.of("2013-06-18")).get();
- final Set<IdentitySchemaNode> identities = module.getIdentities();
+ final Collection<? extends IdentitySchemaNode> identities = module.getIdentities();
assertEquals(1, identities.size());
final IdentitySchemaNode identity = identities.iterator().next();
final Module module = context.findModule("test3", Revision.of("2013-06-18")).get();
final ContainerSchemaNode network = (ContainerSchemaNode) module.getDataChildByName(QName.create(
module.getQNameModule(), "network"));
- final List<UnknownSchemaNode> unknownNodes = network.getUnknownSchemaNodes();
+ final Collection<? extends UnknownSchemaNode> unknownNodes = network.getUnknownSchemaNodes();
assertEquals(1, unknownNodes.size());
- final UnknownSchemaNode un = unknownNodes.get(0);
+ final UnknownSchemaNode un = unknownNodes.iterator().next();
final QName unType = un.getNodeType();
assertEquals(URI.create("urn:custom.types.demo"), unType.getNamespace());
assertEquals(Revision.ofNullable("2012-04-16"), unType.getRevision());
.buildEffective();
final Module testModule = context.findModule("deviation-test", Revision.of("2013-02-27")).get();
- final Set<Deviation> deviations = testModule.getDeviations();
+ final Collection<? extends Deviation> deviations = testModule.getDeviations();
assertEquals(1, deviations.size());
final Deviation dev = deviations.iterator().next();
import static org.junit.Assert.fail;
import java.net.URI;
-import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.concepts.SemVer;
import org.opendaylight.yangtools.yang.model.api.Module;
private static Module findImportedModule(final SchemaContext context, final Module rootModule,
final String importedModuleName) {
ModuleImport requestedModuleImport = null;
- Set<ModuleImport> rootImports = rootModule.getImports();
- for (ModuleImport moduleImport : rootImports) {
+ for (ModuleImport moduleImport : rootModule.getImports()) {
if (moduleImport.getModuleName().equals(importedModuleName)) {
requestedModuleImport = moduleImport;
break;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
+import java.util.Collection;
import java.util.Iterator;
-import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
final Module testModule = TestUtils.findModule(context, "main-impl").get();
assertNotNull(testModule);
- final Set<AugmentationSchemaNode> augmentations = testModule.getAugmentations();
+ final Collection<? extends AugmentationSchemaNode> augmentations = testModule.getAugmentations();
assertEquals(1, augmentations.size());
- final Iterator<AugmentationSchemaNode> augmentIterator = augmentations.iterator();
+ final Iterator<? extends AugmentationSchemaNode> augmentIterator = augmentations.iterator();
final AugmentationSchemaNode augment = augmentIterator.next();
assertNotNull(augment);
assertTrue(augment.getTargetPath().toString().contains(
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
+import java.util.Collection;
import java.util.Iterator;
-import java.util.List;
import java.util.Optional;
import org.junit.Test;
import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
Module testModule = TestUtils.findModule(context, "config").get();
assertNotNull(testModule);
- List<ExtensionDefinition> extensions = testModule.getExtensionSchemaNodes();
+ Collection<? extends ExtensionDefinition> extensions = testModule.getExtensionSchemaNodes();
assertEquals(5, extensions.size());
- Iterator<ExtensionDefinition> extIterator = extensions.iterator();
+ Iterator<? extends ExtensionDefinition> extIterator = extensions.iterator();
ExtensionDefinition extension = extIterator.next();
assertEquals("name", extension.getArgument());
assertEquals("java-class", extension.getQName().getLocalName());
import java.io.IOException;
import java.net.URISyntaxException;
+import java.util.Collection;
import java.util.Iterator;
-import java.util.Set;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.yang.model.api.FeatureDefinition;
Module testModule = TestUtils.findModule(context, "yang-with-features").get();
assertNotNull(testModule);
- Set<FeatureDefinition> features = testModule.getFeatures();
+ Collection<? extends FeatureDefinition> features = testModule.getFeatures();
assertEquals(2, features.size());
- Iterator<FeatureDefinition> featuresIterator = features.iterator();
+ Iterator<? extends FeatureDefinition> featuresIterator = features.iterator();
FeatureDefinition feature = featuresIterator.next();
assertThat(feature.getQName().getLocalName(), anyOf(is("arbitrary-names"), is("pre-provisioning")));
import java.util.Collection;
import java.util.Iterator;
import java.util.Optional;
-import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
final Module testModule = TestUtils.findModule(context, "config").get();
assertNotNull(testModule);
- final Set<GroupingDefinition> groupings = testModule.getGroupings();
+ final Collection<? extends GroupingDefinition> groupings = testModule.getGroupings();
assertEquals(1, groupings.size());
- final Iterator<GroupingDefinition> groupingsIterator = groupings.iterator();
+ final Iterator<? extends GroupingDefinition> groupingsIterator = groupings.iterator();
final GroupingDefinition grouping = groupingsIterator.next();
assertEquals("service-ref", grouping.getQName().getLocalName());
assertEquals(Optional.of("Type of references to a particular service instance. This type\n"
+ "is expected to inject a reference to the service as the value\n"
+ "of the container."), grouping.getDescription());
- final Collection<DataSchemaNode> children = grouping.getChildNodes();
+ final Collection<? extends DataSchemaNode> children = grouping.getChildNodes();
assertEquals(2, children.size());
final LeafSchemaNode leaf1 = (LeafSchemaNode) grouping.findDataChildByName(QName.create(
import static org.junit.Assert.assertTrue;
import java.net.URISyntaxException;
+import java.util.Collection;
import java.util.Iterator;
-import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
Module testModule = TestUtils.findModule(context, "config").get();
assertNotNull(testModule);
- Set<IdentitySchemaNode> identities = testModule.getIdentities();
+ Collection<? extends IdentitySchemaNode> identities = testModule.getIdentities();
assertEquals(2, identities.size());
- Iterator<IdentitySchemaNode> idIterator = identities.iterator();
+ Iterator<? extends IdentitySchemaNode> idIterator = identities.iterator();
IdentitySchemaNode id = idIterator.next();
assertThat(id.getQName().getLocalName(), anyOf(is("module-type"), is("service-type")));
import static org.junit.Assert.assertThat;
import java.text.ParseException;
+import java.util.Collection;
import java.util.Iterator;
-import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.ModuleImport;
Module testModule = TestUtils.findModule(context, "ietf-netconf-monitoring").get();
assertNotNull(testModule);
- Set<ModuleImport> imports = testModule.getImports();
+ Collection<? extends ModuleImport> imports = testModule.getImports();
assertEquals(2, imports.size());
- Iterator<ModuleImport> importsIterator = imports.iterator();
+ Iterator<? extends ModuleImport> importsIterator = imports.iterator();
ModuleImport moduleImport = importsIterator.next();
assertThat(moduleImport.getModuleName(), anyOf(is("ietf-yang-types"), is("ietf-inet-types")));
assertNotNull(parentModule);
assertEquals(1, parentModule.getSubmodules().size());
- Iterator<Module> submodulesIterator = parentModule.getSubmodules().iterator();
+ Iterator<? extends Module> submodulesIterator = parentModule.getSubmodules().iterator();
Module childModule = submodulesIterator.next() ;
assertNotNull(childModule);
assertEquals(1, keys.size());
assertEquals("name", keys.get(0).getLocalName());
- final Collection<DataSchemaNode> children = list.getChildNodes();
+ final Collection<? extends DataSchemaNode> children = list.getChildNodes();
assertEquals(4, children.size());
- final Iterator<DataSchemaNode> childrenIterator = children.iterator();
+ final Iterator<? extends DataSchemaNode> childrenIterator = children.iterator();
LeafSchemaNode leaf = (LeafSchemaNode) childrenIterator.next();
assertEquals("name", leaf.getQName().getLocalName());
assertEquals(Optional.of("Unique module instance name"), leaf.getDescription());
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
+import java.util.Collection;
import java.util.Optional;
-import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
public void testRpc() {
Module testModule = TestUtils.findModule(context, "ietf-netconf-monitoring").get();
- Set<RpcDefinition> rpcs = testModule.getRpcs();
+ Collection<? extends RpcDefinition> rpcs = testModule.getRpcs();
assertEquals(1, rpcs.size());
RpcDefinition rpc = rpcs.iterator().next();
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
+import java.util.Collection;
import java.util.Iterator;
import java.util.Optional;
-import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.stmt.TestUtils;
public class YinFileTypeDefStmtTest extends AbstractYinModulesTest {
-
@Test
public void testTypedef() {
Module testModule = TestUtils.findModule(context, "config").get();
assertNotNull(testModule);
- Set<TypeDefinition<?>> typeDefs = testModule.getTypeDefinitions();
+ Collection<? extends TypeDefinition<?>> typeDefs = testModule.getTypeDefinitions();
assertEquals(1, typeDefs.size());
- Iterator<TypeDefinition<?>> typeDefIterator = typeDefs.iterator();
+ Iterator<? extends TypeDefinition<?>> typeDefIterator = typeDefs.iterator();
TypeDefinition<?> typeDef = typeDefIterator.next();
assertEquals("service-type-ref", typeDef.getQName().getLocalName());
assertEquals(Optional.of("Internal type of references to service type identity."), typeDef.getDescription());
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertThat;
+import java.util.Collection;
import java.util.Iterator;
-import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
public void testUses() {
final Module testModule = TestUtils.findModule(context, "main-impl").get();
- final Set<AugmentationSchemaNode> augmentations = testModule.getAugmentations();
+ final Collection<? extends AugmentationSchemaNode> augmentations = testModule.getAugmentations();
assertEquals(1, augmentations.size());
- final Iterator<AugmentationSchemaNode> augmentIterator = augmentations.iterator();
+ final Iterator<? extends AugmentationSchemaNode> augmentIterator = augmentations.iterator();
final AugmentationSchemaNode augment = augmentIterator.next();
final ContainerSchemaNode container = (ContainerSchemaNode) augment.findDataChildByName(
import java.io.IOException;
import java.net.URISyntaxException;
-import java.util.List;
+import java.util.Collection;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
final ContainerSchemaNode root = (ContainerSchemaNode) dataChildByName;
- final List<UnknownSchemaNode> unknownSchemaNodes = root.getUnknownSchemaNodes();
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes = root.getUnknownSchemaNodes();
assertEquals(1, unknownSchemaNodes.size());
- final UnknownSchemaNode unknownSchemaNode = unknownSchemaNodes.get(0);
+ final UnknownSchemaNode unknownSchemaNode = unknownSchemaNodes.iterator().next();
assertThat(unknownSchemaNode, isA(ThirdPartyExtensionEffectiveStatement.class));
final ThirdPartyExtensionEffectiveStatement thirdPartyExtensionStmt =
(ThirdPartyExtensionEffectiveStatement) unknownSchemaNode;
Code Review / yangtools.git / commitdiff