Switch DocumentedNode and its implementation to JDT nullable
annotations.
JIRA: YANGTOOLS-907
Change-Id: I7eea3429d1ee7617f0731c7416456a44e2caffbe
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>
24 files changed:
import com.google.common.collect.ImmutableList;
import java.util.List;
import java.util.Optional;
import com.google.common.collect.ImmutableList;
import java.util.List;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
/**
* Node which can have documentation assigned.
/**
* Node which can have documentation assigned.
*
* @return list of unknown schema nodes defined under this node.
*/
*
* @return list of unknown schema nodes defined under this node.
*/
- @Nonnull default List<UnknownSchemaNode> getUnknownSchemaNodes() {
+ default @NonNull List<UnknownSchemaNode> getUnknownSchemaNodes() {
return ImmutableList.of();
}
return ImmutableList.of();
}
* @return status of this node which represents the argument of the YANG
* <code>status</code> substatement
*/
* @return status of this node which represents the argument of the YANG
* <code>status</code> substatement
*/
- @Nonnull Status getStatus();
+ @NonNull Status getStatus();
*/
package org.opendaylight.yangtools.yang.model.api;
*/
package org.opendaylight.yangtools.yang.model.api;
+import org.eclipse.jdt.annotation.NonNullByDefault;
+
/**
* Enumeration describing YANG 'status' statement. If no status is specified, the
* default is CURRENT.
*/
/**
* Enumeration describing YANG 'status' statement. If no status is specified, the
* default is CURRENT.
*/
/**
* CURRENT means that the definition is current and valid.
*/
CURRENT,
/**
* CURRENT means that the definition is current and valid.
*/
CURRENT,
/**
* DEPRECATED indicates an obsolete definition, but it permits new/
* continued implementation in order to foster interoperability with
* older/existing implementations.
*/
DEPRECATED,
/**
* DEPRECATED indicates an obsolete definition, but it permits new/
* continued implementation in order to foster interoperability with
* older/existing implementations.
*/
DEPRECATED,
/**
* OBSOLETE means the definition is obsolete and SHOULD NOT be implemented
* and/or can be removed from implementations.
*/
OBSOLETE
/**
* OBSOLETE means the definition is obsolete and SHOULD NOT be implemented
* and/or can be removed from implementations.
*/
OBSOLETE
return SchemaPath.ROOT;
}
return SchemaPath.ROOT;
}
@Override
public Status getStatus() {
return Status.CURRENT;
}
@Override
public Status getStatus() {
return Status.CURRENT;
}
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
final List<UnknownSchemaNode> result = new ArrayList<>();
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
final List<UnknownSchemaNode> result = new ArrayList<>();
import com.google.common.collect.ImmutableList;
import java.util.List;
import java.util.Optional;
import com.google.common.collect.ImmutableList;
import java.util.List;
import java.util.Optional;
-import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
return Optional.empty();
}
return Optional.empty();
}
@Override
public final Status getStatus() {
return Status.CURRENT;
@Override
public final Status getStatus() {
return Status.CURRENT;
*/
package org.opendaylight.yangtools.yang.model.util.type;
*/
package org.opendaylight.yangtools.yang.model.util.type;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.MoreObjects;
import com.google.common.base.MoreObjects;
-import com.google.common.base.Preconditions;
import java.util.Collection;
import java.util.Optional;
import java.util.Collection;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
abstract class AbstractDerivedType<T extends TypeDefinition<T>> extends AbstractTypeDefinition<T> {
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
abstract class AbstractDerivedType<T extends TypeDefinition<T>> extends AbstractTypeDefinition<T> {
- private final T baseType;
+ private final @NonNull T baseType;
private final Object defaultValue;
private final String description;
private final String reference;
private final Object defaultValue;
private final String description;
private final String reference;
- private final Status status;
+ private final @NonNull Status status;
private final String units;
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) {
super(path, unknownSchemNodes);
private final String units;
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) {
super(path, unknownSchemNodes);
- this.baseType = Preconditions.checkNotNull(baseType);
- this.status = Preconditions.checkNotNull(status);
+ this.baseType = requireNonNull(baseType);
+ this.status = requireNonNull(status);
this.defaultValue = defaultValue;
this.description = description;
this.reference = reference;
this.defaultValue = defaultValue;
this.description = description;
this.reference = reference;
return Optional.ofNullable(reference);
}
return Optional.ofNullable(reference);
}
@Override
public final Status getStatus() {
return status;
@Override
public final Status getStatus() {
return status;
*/
package org.opendaylight.yangtools.yang.model.util.type;
*/
package org.opendaylight.yangtools.yang.model.util.type;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.util.Collection;
import java.util.Optional;
import java.util.Collection;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
abstract class AbstractRestrictedType<T extends TypeDefinition<T>> extends AbstractTypeDefinition<T> {
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
abstract class AbstractRestrictedType<T extends TypeDefinition<T>> extends AbstractTypeDefinition<T> {
- private final T baseType;
+ private final @NonNull T baseType;
AbstractRestrictedType(final T baseType, final SchemaPath path,
final Collection<UnknownSchemaNode> unknownSchemaNodes) {
super(path, unknownSchemaNodes);
AbstractRestrictedType(final T baseType, final SchemaPath path,
final Collection<UnknownSchemaNode> unknownSchemaNodes) {
super(path, unknownSchemaNodes);
- this.baseType = Preconditions.checkNotNull(baseType);
+ this.baseType = requireNonNull(baseType);
return baseType.getReference();
}
return baseType.getReference();
}
@Override
public final Status getStatus() {
return baseType.getStatus();
@Override
public final Status getStatus() {
return baseType.getStatus();
*/
package org.opendaylight.yangtools.yang.model.util.type;
*/
package org.opendaylight.yangtools.yang.model.util.type;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableList;
import java.util.Collection;
import java.util.List;
import javax.annotation.Nonnull;
import com.google.common.collect.ImmutableList;
import java.util.Collection;
import java.util.List;
import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
abstract class AbstractTypeDefinition<T extends TypeDefinition<T>> implements Immutable, TypeDefinition<T> {
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
abstract class AbstractTypeDefinition<T extends TypeDefinition<T>> implements Immutable, TypeDefinition<T> {
- private final List<UnknownSchemaNode> unknownSchemaNodes;
- private final SchemaPath path;
+ private final @NonNull List<UnknownSchemaNode> unknownSchemaNodes;
+ private final @NonNull SchemaPath path;
AbstractTypeDefinition(final SchemaPath path, final Collection<UnknownSchemaNode> unknownSchemaNodes) {
AbstractTypeDefinition(final SchemaPath path, final Collection<UnknownSchemaNode> unknownSchemaNodes) {
- this.path = Preconditions.checkNotNull(path);
+ this.path = requireNonNull(path);
this.unknownSchemaNodes = ImmutableList.copyOf(unknownSchemaNodes);
}
this.unknownSchemaNodes = ImmutableList.copyOf(unknownSchemaNodes);
}
@Override
public final List<UnknownSchemaNode> getUnknownSchemaNodes() {
return unknownSchemaNodes;
@Override
public final List<UnknownSchemaNode> getUnknownSchemaNodes() {
return unknownSchemaNodes;
*/
package org.opendaylight.yangtools.yang.model.util.type;
*/
package org.opendaylight.yangtools.yang.model.util.type;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Objects.requireNonNull;
+
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import javax.annotation.Nonnull;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition.Bit;
final class BitImpl implements Bit, Immutable {
import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition.Bit;
final class BitImpl implements Bit, Immutable {
- private final List<UnknownSchemaNode> unknownNodes;
- private final SchemaPath schemaPath;
+ private final @NonNull List<UnknownSchemaNode> unknownNodes;
+ private final @NonNull SchemaPath schemaPath;
private final String description;
private final String reference;
private final String description;
private final String reference;
- private final Status status;
+ private final @NonNull Status status;
private final long position;
BitImpl(final SchemaPath schemaPath, final long position, final String description,
final String reference, final Status status, final List<UnknownSchemaNode> unknownNodes) {
private final long position;
BitImpl(final SchemaPath schemaPath, final long position, final String description,
final String reference, final Status status, final List<UnknownSchemaNode> unknownNodes) {
- this.schemaPath = Preconditions.checkNotNull(schemaPath, "Schema Path should not be null");
+ this.schemaPath = requireNonNull(schemaPath, "Schema Path should not be null");
- Preconditions.checkArgument(position >= 0L && position <= 4294967295L, "Invalid position %s", position);
+ checkArgument(position >= 0L && position <= 4294967295L, "Invalid position %s", position);
this.position = position;
this.description = description;
this.reference = reference;
this.position = position;
this.description = description;
this.reference = reference;
- this.status = Preconditions.checkNotNull(status);
- this.unknownNodes = Preconditions.checkNotNull(unknownNodes);
+ this.status = requireNonNull(status);
+ this.unknownNodes = requireNonNull(unknownNodes);
return Optional.ofNullable(reference);
}
return Optional.ofNullable(reference);
}
@Override
public Status getStatus() {
return status;
}
@Override
public Status getStatus() {
return status;
}
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
return unknownNodes;
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
return unknownNodes;
public String toString() {
return Bit.class.getSimpleName() + "[name=" + getQName().getLocalName() + ", position=" + position + "]";
}
public String toString() {
return Bit.class.getSimpleName() + "[name=" + getQName().getLocalName() + ", position=" + position + "]";
}
*/
package org.opendaylight.yangtools.yang.model.util.type;
*/
package org.opendaylight.yangtools.yang.model.util.type;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.MoreObjects;
import com.google.common.base.MoreObjects;
-import com.google.common.base.Preconditions;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition.EnumPair;
final class EnumPairImpl implements EnumPair, Immutable {
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition.EnumPair;
final class EnumPairImpl implements EnumPair, Immutable {
- private final List<UnknownSchemaNode> unknownSchemaNodes;
+ private final @NonNull List<UnknownSchemaNode> unknownSchemaNodes;
private final String description;
private final String reference;
private final String description;
private final String reference;
- private final Status status;
- private final String name;
+ private final @NonNull Status status;
+ private final @NonNull String name;
private final int value;
EnumPairImpl(final String name, final int value, final String description, final String reference,
final Status status, final List<UnknownSchemaNode> unknownSchemaNodes) {
private final int value;
EnumPairImpl(final String name, final int value, final String description, final String reference,
final Status status, final List<UnknownSchemaNode> unknownSchemaNodes) {
- this.name = Preconditions.checkNotNull(name);
+ this.name = requireNonNull(name);
this.value = value;
this.description = description;
this.reference = reference;
this.value = value;
this.description = description;
this.reference = reference;
- this.status = Preconditions.checkNotNull(status);
- this.unknownSchemaNodes = Preconditions.checkNotNull(unknownSchemaNodes);
+ this.status = requireNonNull(status);
+ this.unknownSchemaNodes = requireNonNull(unknownSchemaNodes);
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
return unknownSchemaNodes;
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
return unknownSchemaNodes;
return Optional.ofNullable(reference);
}
return Optional.ofNullable(reference);
}
@Override
public Status getStatus() {
return status;
@Override
public Status getStatus() {
return status;
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt;
import java.util.Optional;
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.DocumentedNode;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.DocumentedNode;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
private final String description;
private final String reference;
private final String description;
private final String reference;
- private final Status status;
+ private final @NonNull Status status;
return Optional.ofNullable(reference);
}
return Optional.ofNullable(reference);
}
@Override
public final Status getStatus() {
return status;
@Override
public final Status getStatus() {
return status;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
-import javax.annotation.Nonnull;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.SemVer;
import org.opendaylight.yangtools.openconfig.model.api.OpenConfigVersionEffectiveStatement;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.SemVer;
import org.opendaylight.yangtools.openconfig.model.api.OpenConfigVersionEffectiveStatement;
private final Set<Deviation> deviations;
private final List<ExtensionDefinition> extensionNodes;
private final Set<IdentitySchemaNode> identities;
private final Set<Deviation> deviations;
private final List<ExtensionDefinition> extensionNodes;
private final Set<IdentitySchemaNode> identities;
- private final List<UnknownSchemaNode> unknownNodes;
+ private final @NonNull List<UnknownSchemaNode> unknownNodes;
private final Map<QName, DataSchemaNode> childNodes;
private final Set<GroupingDefinition> groupings;
private final Set<UsesNode> uses;
private final Map<QName, DataSchemaNode> childNodes;
private final Set<GroupingDefinition> groupings;
private final Set<UsesNode> uses;
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
return unknownNodes;
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
return unknownNodes;
import com.google.common.collect.ImmutableList;
import java.util.List;
import com.google.common.collect.ImmutableList;
import java.util.List;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
public abstract class AbstractEffectiveSchemaNode<D extends DeclaredStatement<QName>> extends
AbstractSchemaEffectiveDocumentedNode<QName, D> implements SchemaNode {
public abstract class AbstractEffectiveSchemaNode<D extends DeclaredStatement<QName>> extends
AbstractSchemaEffectiveDocumentedNode<QName, D> implements SchemaNode {
- private final SchemaPath path;
- private final List<UnknownSchemaNode> unknownNodes;
+ private final @NonNull SchemaPath path;
+ private final @NonNull List<UnknownSchemaNode> unknownNodes;
protected AbstractEffectiveSchemaNode(final StmtContext<QName, D, ?> ctx) {
super(ctx);
protected AbstractEffectiveSchemaNode(final StmtContext<QName, D, ?> ctx) {
super(ctx);
this.unknownNodes = listBuilder.build();
}
this.unknownNodes = listBuilder.build();
}
@Override
public final QName getQName() {
return path.getLastComponent();
}
@Override
public final QName getQName() {
return path.getLastComponent();
}
@Override
public final SchemaPath getPath() {
return path;
}
@Override
public final SchemaPath getPath() {
return path;
}
@Override
public final List<UnknownSchemaNode> getUnknownSchemaNodes() {
return unknownNodes;
@Override
public final List<UnknownSchemaNode> getUnknownSchemaNodes() {
return unknownNodes;
import java.util.Optional;
import java.util.Set;
import javax.annotation.Nonnull;
import java.util.Optional;
import java.util.Set;
import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
import org.opendaylight.yangtools.yang.model.api.AugmentationTarget;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
import org.opendaylight.yangtools.yang.model.api.AugmentationTarget;
AbstractEffectiveDocumentedDataNodeContainer<QName, D> implements AugmentationTarget, DataSchemaNode {
private final Set<AugmentationSchemaNode> augmentations;
AbstractEffectiveDocumentedDataNodeContainer<QName, D> implements AugmentationTarget, DataSchemaNode {
private final Set<AugmentationSchemaNode> augmentations;
- private final List<UnknownSchemaNode> unknownNodes;
+ private final @NonNull List<UnknownSchemaNode> unknownNodes;
private final RevisionAwareXPath whenCondition;
private final SchemaPath path;
private final boolean configuration;
private final RevisionAwareXPath whenCondition;
private final SchemaPath path;
private final boolean configuration;
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
return unknownNodes;
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
return unknownNodes;
import com.google.common.collect.ImmutableList.Builder;
import java.util.List;
import javax.annotation.Nonnull;
import com.google.common.collect.ImmutableList.Builder;
import java.util.List;
import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
private final boolean addedByAugmentation;
private final ExtensionDefinition extension;
private final boolean addedByAugmentation;
private final ExtensionDefinition extension;
- private final List<UnknownSchemaNode> unknownNodes;
+ private final @NonNull List<UnknownSchemaNode> unknownNodes;
private final QName nodeType;
private final String nodeParameter;
private final QName nodeType;
private final String nodeParameter;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.ActionDefinition;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.ActionDefinition;
private final Revision revision;
private final Set<ActionDefinition> actions;
private final Set<NotificationDefinition> notifications;
private final Revision revision;
private final Set<ActionDefinition> actions;
private final Set<NotificationDefinition> notifications;
- private final List<UnknownSchemaNode> unknownNodes;
+ private final @NonNull List<UnknownSchemaNode> unknownNodes;
private final RevisionAwareXPath whenCondition;
private final AugmentationSchemaNode copyOf;
private final RevisionAwareXPath whenCondition;
private final AugmentationSchemaNode copyOf;
return Optional.ofNullable(whenCondition);
}
return Optional.ofNullable(whenCondition);
}
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
return unknownNodes;
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
return unknownNodes;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
private final QName qname;
private final SchemaPath schemaPath;
private final Long declaredPosition;
private final QName qname;
private final SchemaPath schemaPath;
private final Long declaredPosition;
- private final List<UnknownSchemaNode> unknownSchemaNodes;
+ private final @NonNull List<UnknownSchemaNode> unknownSchemaNodes;
BitEffectiveStatementImpl(final StmtContext<QName, BitStatement, ?> ctx) {
super(ctx);
BitEffectiveStatementImpl(final StmtContext<QName, BitStatement, ?> ctx) {
super(ctx);
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
return unknownSchemaNodes;
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
return unknownSchemaNodes;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import java.util.Collection;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import java.util.Collection;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.UsesNode;
// FIXME: hide this somewhere
import org.opendaylight.yangtools.yang.model.api.UsesNode;
// FIXME: hide this somewhere
- @Nonnull
- @Override
- public List<UnknownSchemaNode> getUnknownSchemaNodes() {
- return ImmutableList.of();
- }
-
@Override
public Optional<String> getDescription() {
return caseShorthandNode.getDescription();
@Override
public Optional<String> getDescription() {
return caseShorthandNode.getDescription();
return caseShorthandNode.getReference();
}
return caseShorthandNode.getReference();
}
@Override
public Status getStatus() {
return caseShorthandNode.getStatus();
@Override
public Status getStatus() {
return caseShorthandNode.getStatus();
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.model.api.DeviateDefinition;
import org.opendaylight.yangtools.yang.model.api.Deviation;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.model.api.DeviateDefinition;
import org.opendaylight.yangtools.yang.model.api.Deviation;
private final SchemaPath targetPath;
private final String description;
private final String reference;
private final SchemaPath targetPath;
private final String description;
private final String reference;
- private final List<UnknownSchemaNode> unknownSchemaNodes;
+ private final @NonNull List<UnknownSchemaNode> unknownSchemaNodes;
private final List<DeviateDefinition> deviateDefinitions;
DeviationEffectiveStatementImpl(final StmtContext<SchemaNodeIdentifier, DeviationStatement, ?> ctx) {
private final List<DeviateDefinition> deviateDefinitions;
DeviationEffectiveStatementImpl(final StmtContext<SchemaNodeIdentifier, DeviationStatement, ?> ctx) {
import com.google.common.collect.ImmutableList;
import java.util.ArrayList;
import java.util.List;
import com.google.common.collect.ImmutableList;
import java.util.ArrayList;
import java.util.List;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.EnumEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.EnumEffectiveStatement;
// FIXME: hide this class
public final class EnumEffectiveStatementImpl extends AbstractEffectiveDocumentedNode<String, EnumStatement>
implements EnumEffectiveStatement {
// FIXME: hide this class
public final class EnumEffectiveStatementImpl extends AbstractEffectiveDocumentedNode<String, EnumStatement>
implements EnumEffectiveStatement {
- private final List<UnknownSchemaNode> unknownSchemaNodes;
+ private final @NonNull List<UnknownSchemaNode> unknownSchemaNodes;
private final String name;
private final Integer declaredValue;
private final String name;
private final Integer declaredValue;
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
return unknownSchemaNodes;
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
return unknownSchemaNodes;
import java.util.Objects;
import java.util.Optional;
import javax.annotation.Nonnull;
import java.util.Objects;
import java.util.Optional;
import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.util.RecursiveObjectLeaker;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
import org.opendaylight.yangtools.util.RecursiveObjectLeaker;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
private final QName qname;
private final String argument;
private final QName qname;
private final String argument;
- private final SchemaPath schemaPath;
+ private final @NonNull SchemaPath schemaPath;
- private final List<UnknownSchemaNode> unknownNodes;
+ private final @NonNull List<UnknownSchemaNode> unknownNodes;
private final boolean yin;
private ExtensionEffectiveStatementImpl(
private final boolean yin;
private ExtensionEffectiveStatementImpl(
@Override
public SchemaPath getPath() {
return schemaPath;
}
@Override
public SchemaPath getPath() {
return schemaPath;
}
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
return unknownNodes;
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
return unknownNodes;
import java.util.Objects;
import java.util.Set;
import javax.annotation.Nonnull;
import java.util.Objects;
import java.util.Set;
import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ActionDefinition;
import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ActionDefinition;
import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
private final boolean addedByUses;
private final Set<ActionDefinition> actions;
private final Set<NotificationDefinition> notifications;
private final boolean addedByUses;
private final Set<ActionDefinition> actions;
private final Set<NotificationDefinition> notifications;
- private final List<UnknownSchemaNode> unknownNodes;
+ private final @NonNull List<UnknownSchemaNode> unknownNodes;
GroupingEffectiveStatementImpl(
final StmtContext<QName, GroupingStatement, EffectiveStatement<QName, GroupingStatement>> ctx) {
GroupingEffectiveStatementImpl(
final StmtContext<QName, GroupingStatement, EffectiveStatement<QName, GroupingStatement>> ctx) {
import java.util.Objects;
import java.util.Set;
import javax.annotation.Nonnull;
import java.util.Objects;
import java.util.Set;
import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
import org.opendaylight.yangtools.yang.model.api.MustDefinition;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
import org.opendaylight.yangtools.yang.model.api.MustDefinition;
private final QName qname;
private final SchemaPath path;
private final Set<AugmentationSchemaNode> augmentations;
private final QName qname;
private final SchemaPath path;
private final Set<AugmentationSchemaNode> augmentations;
- private final List<UnknownSchemaNode> unknownNodes;
+ private final @NonNull List<UnknownSchemaNode> unknownNodes;
private final boolean augmenting;
private final boolean addedByUses;
private final Collection<MustDefinition> mustConstraints;
private final boolean augmenting;
private final boolean addedByUses;
private final Collection<MustDefinition> mustConstraints;
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
return unknownNodes;
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
return unknownNodes;
import java.util.List;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
import java.util.List;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
implements RefineEffectiveStatement, SchemaNode {
private final QName qname;
implements RefineEffectiveStatement, SchemaNode {
private final QName qname;
- private final SchemaPath path;
- private final List<UnknownSchemaNode> unknownNodes;
+ private final @NonNull SchemaPath path;
+ private final @NonNull List<UnknownSchemaNode> unknownNodes;
private final SchemaNode refineTargetNode;
RefineEffectiveStatementImpl(final StmtContext<SchemaNodeIdentifier, RefineStatement, ?> ctx) {
private final SchemaNode refineTargetNode;
RefineEffectiveStatementImpl(final StmtContext<SchemaNodeIdentifier, RefineStatement, ?> ctx) {
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
return unknownNodes;
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
return unknownNodes;
import java.util.Optional;
import java.util.Set;
import javax.annotation.Nonnull;
import java.util.Optional;
import java.util.Set;
import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath;
private final boolean addedByUses;
private final Map<SchemaPath, SchemaNode> refines;
private final Set<AugmentationSchemaNode> augmentations;
private final boolean addedByUses;
private final Map<SchemaPath, SchemaNode> refines;
private final Set<AugmentationSchemaNode> augmentations;
- private final List<UnknownSchemaNode> unknownNodes;
+ private final @NonNull List<UnknownSchemaNode> unknownNodes;
private final RevisionAwareXPath whenCondition;
UsesEffectiveStatementImpl(final StmtContext<QName, UsesStatement, EffectiveStatement<QName, UsesStatement>> ctx) {
private final RevisionAwareXPath whenCondition;
UsesEffectiveStatementImpl(final StmtContext<QName, UsesStatement, EffectiveStatement<QName, UsesStatement>> ctx) {