*/
package org.opendaylight.yangtools.yang.model.api.stmt;
+import static com.google.common.base.Verify.verifyNotNull;
+
import java.util.Optional;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
@Rfc6020AbnfRule("argument-stmt")
public interface ArgumentStatement extends DeclaredStatement<QName> {
- default @Nonnull QName getName() {
- return argument();
+ default @NonNull QName getName() {
+ // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
+ return verifyNotNull(argument());
}
default @Nullable YinElementStatement getYinElement() {
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
+import static com.google.common.base.Verify.verifyNotNull;
+
import java.util.Collection;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.stmt.DocumentedDeclaredStatement.WithStatus;
public interface AugmentStatement extends WithStatus<SchemaNodeIdentifier>,
ActionStatementAwareDeclaredStatement<SchemaNodeIdentifier>,
WhenStatementAwareDeclaredStatement<SchemaNodeIdentifier> {
- default @Nonnull SchemaNodeIdentifier getTargetNode() {
- return argument();
+ default @NonNull SchemaNodeIdentifier getTargetNode() {
+ // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
+ return verifyNotNull(argument());
}
- default @Nonnull Collection<? extends CaseStatement> getCases() {
+ default @NonNull Collection<? extends CaseStatement> getCases() {
return declaredSubstatements(CaseStatement.class);
}
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import javax.annotation.Nonnull;
+import static com.google.common.base.Verify.verifyNotNull;
+
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public interface BaseStatement extends DeclaredStatement<QName> {
- default @Nonnull QName getName() {
- return argument();
+ default @NonNull QName getName() {
+ // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
+ return verifyNotNull(argument());
}
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import javax.annotation.Nonnull;
+import static com.google.common.base.Verify.verifyNotNull;
+
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public interface BelongsToStatement extends DeclaredStatement<String> {
- default @Nonnull String getModule() {
- return argument();
+ default @NonNull String getModule() {
+ // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
+ return verifyNotNull(argument());
}
- default @Nonnull PrefixStatement getPrefix() {
+ default @NonNull PrefixStatement getPrefix() {
return findFirstDeclaredSubstatement(PrefixStatement.class).get();
}
}
-
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
+import static com.google.common.base.Verify.verifyNotNull;
+
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
public interface BitStatement extends DocumentedDeclaredStatement.WithStatus<QName>,
IfFeatureAwareDeclaredStatement<QName> {
- default @Nonnull String getName() {
- return argument().getLocalName();
+ default @NonNull String getName() {
+ // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
+ return verifyNotNull(argument()).getLocalName();
}
- default PositionStatement getPosition() {
+ default @Nullable PositionStatement getPosition() {
final Optional<PositionStatement> opt = findFirstDeclaredSubstatement(PositionStatement.class);
return opt.isPresent() ? opt.get() : null;
}
import com.google.common.annotations.Beta;
import java.util.Collection;
-import javax.annotation.Nonnull;
@Beta
public interface BodyDeclaredStatement extends NotificationStatementAwareDeclaredStatement<String>,
DataDefinitionAwareDeclaredStatement.WithReusableDefinitions<String>, BodyGroup {
@Override
- default @Nonnull Collection<? extends ExtensionStatement> getExtensions() {
+ default Collection<? extends ExtensionStatement> getExtensions() {
return declaredSubstatements(ExtensionStatement.class);
}
@Override
- default @Nonnull Collection<? extends FeatureStatement> getFeatures() {
+ default Collection<? extends FeatureStatement> getFeatures() {
return declaredSubstatements(FeatureStatement.class);
}
@Override
- default @Nonnull Collection<? extends IdentityStatement> getIdentities() {
+ default Collection<? extends IdentityStatement> getIdentities() {
return declaredSubstatements(IdentityStatement.class);
}
@Override
- default @Nonnull Collection<? extends AugmentStatement> getAugments() {
+ default Collection<? extends AugmentStatement> getAugments() {
return declaredSubstatements(AugmentStatement.class);
}
@Override
- default @Nonnull Collection<? extends RpcStatement> getRpcs() {
+ default Collection<? extends RpcStatement> getRpcs() {
return declaredSubstatements(RpcStatement.class);
}
@Override
- default @Nonnull Collection<? extends DeviationStatement> getDeviations() {
+ default Collection<? extends DeviationStatement> getDeviations() {
return declaredSubstatements(DeviationStatement.class);
}
}
package org.opendaylight.yangtools.yang.model.api.stmt;
import java.util.Collection;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
@Rfc6020AbnfRule("body-stmts")
@Deprecated
public interface BodyGroup extends DataDefinitionContainer.WithReusableDefinitions, NotificationStatementContainer {
- @Nonnull Collection<? extends ExtensionStatement> getExtensions();
+ @NonNull Collection<? extends ExtensionStatement> getExtensions();
- @Nonnull Collection<? extends FeatureStatement> getFeatures();
+ @NonNull Collection<? extends FeatureStatement> getFeatures();
- @Nonnull Collection<? extends IdentityStatement> getIdentities();
+ @NonNull Collection<? extends IdentityStatement> getIdentities();
- @Nonnull Collection<? extends AugmentStatement> getAugments();
+ @NonNull Collection<? extends AugmentStatement> getAugments();
- @Nonnull Collection<? extends RpcStatement> getRpcs();
+ @NonNull Collection<? extends RpcStatement> getRpcs();
- @Nonnull Collection<? extends DeviationStatement> getDeviations();
+ @NonNull Collection<? extends DeviationStatement> getDeviations();
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import javax.annotation.Nonnull;
+import static com.google.common.base.Verify.verifyNotNull;
+
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
public interface CaseStatement extends DocumentedDeclaredStatement.WithStatus<QName>,
DataDefinitionAwareDeclaredStatement<QName>, WhenStatementAwareDeclaredStatement<QName> {
- default @Nonnull QName getName() {
- return argument();
+ default @NonNull QName getName() {
+ // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
+ return verifyNotNull(argument());
}
}
package org.opendaylight.yangtools.yang.model.api.stmt;
import java.util.Collection;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
public interface ChoiceStatement extends DataDefinitionStatement, ConfigStatementAwareDeclaredStatement<QName>,
DefaultStatementAwareDeclaredStatement, MandatoryStatementAwareDeclaredStatement<QName> {
- default @Nonnull Collection<? extends CaseStatement> getCases() {
+ default @NonNull Collection<? extends CaseStatement> getCases() {
return declaredSubstatements(CaseStatement.class);
}
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.Nullable;
@Deprecated
public interface ConditionalDataDefinition extends ConditionalFeature {
package org.opendaylight.yangtools.yang.model.api.stmt;
import java.util.Collection;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
@Rfc6020AbnfRule("*(if-feature-stmt)")
@Deprecated
*
* @return collection of if-feature statements
*/
- @Nonnull Collection<? extends IfFeatureStatement> getIfFeatures();
+ @NonNull Collection<? extends IfFeatureStatement> getIfFeatures();
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import javax.annotation.Nonnull;
+import static com.google.common.base.Verify.verifyNotNull;
+
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public interface ContactStatement extends DeclaredStatement<String> {
- default @Nonnull String getText() {
- return rawArgument();
+ default @NonNull String getText() {
+ // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
+ return verifyNotNull(rawArgument());
}
}
import com.google.common.annotations.Beta;
import java.util.Collection;
-import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
@Beta
public interface DataDefinitionAwareDeclaredStatement<A> extends DeclaredStatement<A>, DataDefinitionContainer {
@Override
- default @Nonnull Collection<? extends DataDefinitionStatement> getDataDefinitions() {
+ default Collection<? extends DataDefinitionStatement> getDataDefinitions() {
return declaredSubstatements(DataDefinitionStatement.class);
}
interface WithReusableDefinitions<A> extends DataDefinitionAwareDeclaredStatement<A>,
DataDefinitionContainer.WithReusableDefinitions {
@Override
- default @Nonnull Collection<? extends TypedefStatement> getTypedefs() {
+ default Collection<? extends TypedefStatement> getTypedefs() {
return declaredSubstatements(TypedefStatement.class);
}
@Override
- default @Nonnull Collection<? extends GroupingStatement> getGroupings() {
+ default Collection<? extends GroupingStatement> getGroupings() {
return declaredSubstatements(GroupingStatement.class);
}
}
package org.opendaylight.yangtools.yang.model.api.stmt;
import java.util.Collection;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
@Deprecated
public interface DataDefinitionContainer {
- @Nonnull Collection<? extends DataDefinitionStatement> getDataDefinitions();
+ @NonNull Collection<? extends DataDefinitionStatement> getDataDefinitions();
interface WithReusableDefinitions extends DataDefinitionContainer {
- @Nonnull Collection<? extends TypedefStatement> getTypedefs();
+ @NonNull Collection<? extends TypedefStatement> getTypedefs();
- @Nonnull Collection<? extends GroupingStatement> getGroupings();
+ @NonNull Collection<? extends GroupingStatement> getGroupings();
}
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import javax.annotation.Nonnull;
+import static com.google.common.base.Verify.verifyNotNull;
+
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
/**
@Rfc6020AbnfRule("data-def-stmt")
public interface DataDefinitionStatement extends DocumentedDeclaredStatement.WithStatus<QName>,
WhenStatementAwareDeclaredStatement<QName> {
- default @Nonnull QName getName() {
- return argument();
+ default @NonNull QName getName() {
+ // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
+ return verifyNotNull(argument());
}
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import javax.annotation.Nonnull;
+import static com.google.common.base.Verify.verifyNotNull;
+
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public interface DefaultStatement extends DeclaredStatement<String> {
- default @Nonnull String getValue() {
- return argument();
+ default @NonNull String getValue() {
+ // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
+ return verifyNotNull(argument());
}
}
-
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.Nullable;
/**
* Marker interface for statements which may contain a 'default' statement, as defined in RFC7950.
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import javax.annotation.Nonnull;
+import static com.google.common.base.Verify.verifyNotNull;
+
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public interface DescriptionStatement extends DeclaredStatement<String> {
- default @Nonnull String getText() {
- return argument();
+ default @NonNull String getText() {
+ // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
+ return verifyNotNull(argument());
}
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import javax.annotation.Nonnull;
+import static com.google.common.base.Verify.verifyNotNull;
+
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.DeviateKind;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public interface DeviateStatement extends DeclaredStatement<DeviateKind> {
- default @Nonnull DeviateKind getValue() {
- return argument();
+ default @NonNull DeviateKind getValue() {
+ // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
+ return verifyNotNull(argument());
}
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
+import static com.google.common.base.Verify.verifyNotNull;
+
import java.util.Collection;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
public interface DeviationStatement extends DocumentedDeclaredStatement<SchemaNodeIdentifier> {
- default @Nonnull SchemaNodeIdentifier getTargetNode() {
- return argument();
+ default @NonNull SchemaNodeIdentifier getTargetNode() {
+ // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
+ return verifyNotNull(argument());
}
- default @Nonnull Collection<? extends DeviateStatement> getDeviateStatements() {
+ default @NonNull Collection<? extends DeviateStatement> getDeviateStatements() {
return declaredSubstatements(DeviateStatement.class);
}
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.Nullable;
/**
* Common interface for statements which contain either a description/reference or a description/reference/status combo.
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.Nullable;
/**
* Documented constraints.
import com.google.common.annotations.Beta;
import java.util.Optional;
-import javax.annotation.Nullable;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
/**
interface WithStatus<T> extends DocumentedDeclaredStatement<T>, DocumentationGroup.WithStatus {
@Override
- default @Nullable StatusStatement getStatus() {
+ default StatusStatement getStatus() {
final Optional<StatusStatement> opt = findFirstDeclaredSubstatement(StatusStatement.class);
return opt.isPresent() ? opt.get() : null;
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
+import static com.google.common.base.Verify.verifyNotNull;
+
import java.util.Optional;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
public interface EnumStatement extends DocumentedDeclaredStatement.WithStatus<String>,
IfFeatureAwareDeclaredStatement<String> {
- default @Nonnull String getName() {
- return argument();
+ default @NonNull String getName() {
+ // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
+ return verifyNotNull(argument());
}
default @Nullable ValueStatement getValue() {
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import javax.annotation.Nonnull;
+import static com.google.common.base.Verify.verifyNotNull;
+
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public interface ErrorAppTagStatement extends DeclaredStatement<String> {
-
- @Nonnull String getValue();
+ default @NonNull String getValue() {
+ // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
+ return verifyNotNull(argument());
+ }
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import javax.annotation.Nonnull;
+import static com.google.common.base.Verify.verifyNotNull;
+
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public interface ErrorMessageStatement extends DeclaredStatement<String> {
- default @Nonnull String getValue() {
- return argument();
+ default @NonNull String getValue() {
+ // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
+ return verifyNotNull(argument());
}
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import javax.annotation.Nonnull;
+import static com.google.common.base.Verify.verifyNotNull;
+
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
public interface FeatureStatement extends DocumentedDeclaredStatement.WithStatus<QName>,
IfFeatureAwareDeclaredStatement<QName> {
- default @Nonnull QName getName() {
- return argument();
+ default @NonNull QName getName() {
+ // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
+ return verifyNotNull(argument());
}
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import javax.annotation.Nonnull;
+import static com.google.common.base.Verify.verifyNotNull;
+
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
public interface GroupingStatement extends DocumentedDeclaredStatement.WithStatus<QName>,
DataDefinitionAwareDeclaredStatement.WithReusableDefinitions<QName>,
NotificationStatementAwareDeclaredStatement<QName>, ActionStatementAwareDeclaredStatement<QName> {
- default @Nonnull QName getName() {
- return argument();
+ default @NonNull QName getName() {
+ // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
+ return verifyNotNull(argument());
}
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
+import static com.google.common.base.Verify.verifyNotNull;
+
import java.util.Collection;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
public interface IdentityStatement extends DocumentedDeclaredStatement.WithStatus<QName>,
IfFeatureAwareDeclaredStatement<QName> {
- default @Nonnull QName getName() {
- return argument();
+ default @NonNull QName getName() {
+ // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
+ return verifyNotNull(argument());
}
/**
*
* @return base identities, empty if there are none.
*/
- default @Nonnull Collection<? extends BaseStatement> getBases() {
+ default @NonNull Collection<? extends BaseStatement> getBases() {
return declaredSubstatements(BaseStatement.class);
}
}
import com.google.common.annotations.Beta;
import java.util.Collection;
-import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
@Beta
public interface IfFeatureAwareDeclaredStatement<A> extends DeclaredStatement<A>, ConditionalFeature {
@Override
- default @Nonnull Collection<? extends IfFeatureStatement> getIfFeatures() {
+ default Collection<? extends IfFeatureStatement> getIfFeatures() {
return declaredSubstatements(IfFeatureStatement.class);
}
}
import com.google.common.annotations.Beta;
import java.util.Set;
import java.util.function.Predicate;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
/**
- * Represents YANG if-feature statement.
- * The "if-feature" statement makes its parent statement conditional.
+ * Represents YANG if-feature statement. The "if-feature" statement makes its parent statement conditional.
*/
public interface IfFeatureStatement extends DeclaredStatement<Predicate<Set<QName>>> {
/**
- * In Yang 1.1 (RFC7950) implementation of IfFeatureStatement, the
- * argument is a boolean expression over feature names defined by
- * "feature" statements. Hence, add implementation to return a
- * predicate on a collection of features against which to evaluate.
+ * In YANG 1.1 (RFC7950) implementation of IfFeatureStatement, the argument is a boolean expression over feature
+ * names defined by "feature" statements. Hence, add implementation to return a predicate on a collection
+ * of features against which to evaluate.
*
* @return Predicate on a collection of QNames against which to evaluate
*/
@Beta
- @Nonnull
- Predicate<Set<QName>> getIfFeaturePredicate();
+ @NonNull Predicate<Set<QName>> getIfFeaturePredicate();
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
+import static com.google.common.base.Verify.verifyNotNull;
+
import java.util.Optional;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
public interface ImportStatement extends DocumentedDeclaredStatement<String> {
- default @Nonnull String getModule() {
- return rawArgument();
+ default @NonNull String getModule() {
+ // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
+ return verifyNotNull(rawArgument());
}
- default @Nonnull PrefixStatement getPrefix() {
+ default @NonNull PrefixStatement getPrefix() {
return findFirstDeclaredSubstatement(PrefixStatement.class).get();
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
+import static com.google.common.base.Verify.verifyNotNull;
+
import java.util.Optional;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
public interface IncludeStatement extends DocumentedDeclaredStatement<String> {
- default @Nonnull String getModule() {
- return argument();
+ default @NonNull String getModule() {
+ // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
+ return verifyNotNull(argument());
}
default @Nullable RevisionDateStatement getRevisionDate() {
return opt.isPresent() ? opt.get() : null;
}
}
-
package org.opendaylight.yangtools.yang.model.api.stmt;
import java.util.Collection;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
public interface LeafListStatement extends MultipleElementsDeclaredStatement, TypeAwareDeclaredStatement,
*
* @return collection of default statements
*/
- default @Nonnull Collection<? extends DefaultStatement> getDefaults() {
+ default @NonNull Collection<? extends DefaultStatement> getDefaults() {
return declaredSubstatements(DefaultStatement.class);
}
}
package org.opendaylight.yangtools.yang.model.api.stmt;
import java.util.List;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
public interface LengthStatement extends ConstrainedDocumentedDeclaredStatement<List<ValueRange>> {
- @Nonnull
@Override
- List<ValueRange> argument();
+ @NonNull List<ValueRange> argument();
}
import com.google.common.annotations.Beta;
import java.util.Collection;
-import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
@Beta
public interface LinkageDeclaredStatement extends DeclaredStatement<String>, LinkageGroup {
@Override
- default @Nonnull Collection<? extends ImportStatement> getImports() {
+ default Collection<? extends ImportStatement> getImports() {
return declaredSubstatements(ImportStatement.class);
}
@Override
- default @Nonnull Collection<? extends IncludeStatement> getIncludes() {
+ default Collection<? extends IncludeStatement> getIncludes() {
return declaredSubstatements(IncludeStatement.class);
}
}
package org.opendaylight.yangtools.yang.model.api.stmt;
import java.util.Collection;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
@Rfc6020AbnfRule("linkage-stms")
@Deprecated
public interface LinkageGroup {
- @Nonnull Collection<? extends ImportStatement> getImports();
+ @NonNull Collection<? extends ImportStatement> getImports();
- @Nonnull Collection<? extends IncludeStatement> getIncludes();
+ @NonNull Collection<? extends IncludeStatement> getIncludes();
}
import java.util.Collection;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
public interface ListStatement extends MultipleElementsDeclaredStatement,
DataDefinitionAwareDeclaredStatement.WithReusableDefinitions<QName>,
ConfigStatementAwareDeclaredStatement<QName>, ActionStatementAwareDeclaredStatement<QName>,
MustStatementAwareDeclaredStatement<QName>, NotificationStatementAwareDeclaredStatement<QName> {
- default KeyStatement getKey() {
+ default @Nullable KeyStatement getKey() {
final Optional<KeyStatement> opt = findFirstDeclaredSubstatement(KeyStatement.class);
return opt.isPresent() ? opt.get() : null;
}
- default @Nonnull Collection<? extends UniqueStatement> getUnique() {
+ default @NonNull Collection<? extends UniqueStatement> getUnique() {
return declaredSubstatements(UniqueStatement.class);
}
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import javax.annotation.Nonnull;
+import static com.google.common.base.Verify.verifyNotNull;
+
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public interface MandatoryStatement extends DeclaredStatement<Boolean> {
- default @Nonnull Boolean getValue() {
- return argument();
+ default @NonNull Boolean getValue() {
+ // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
+ return verifyNotNull(argument());
}
}
-
import com.google.common.annotations.Beta;
import java.util.Optional;
-import javax.annotation.Nullable;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
/**
* @return A {@link MandatoryStatement}, or null if none is present.
*/
@Override
- default @Nullable MandatoryStatement getMandatory() {
+ default MandatoryStatement getMandatory() {
final Optional<MandatoryStatement> opt = findFirstDeclaredSubstatement(MandatoryStatement.class);
return opt.isPresent() ? opt.get() : null;
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.Nullable;
/**
* Marker interface for statements which may contain a 'mandatory' statement, as defined in RFC7950.
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import javax.annotation.Nonnull;
+import static com.google.common.base.Verify.verifyNotNull;
+
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public interface MaxElementsStatement extends DeclaredStatement<String> {
- default @Nonnull String getValue() {
- return argument();
+ default @NonNull String getValue() {
+ // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
+ return verifyNotNull(argument());
}
}
-
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.Nullable;
@Rfc6020AbnfRule("meta-stmts")
@Deprecated
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import javax.annotation.Nonnull;
+import static com.google.common.base.Verify.verifyNotNull;
+
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public interface MinElementsStatement extends DeclaredStatement<Integer> {
- default @Nonnull Integer getValue() {
- return argument();
+ default @NonNull Integer getValue() {
+ // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
+ return verifyNotNull(argument());
}
}
-
package org.opendaylight.yangtools.yang.model.api.stmt;
+import static com.google.common.base.Verify.verifyNotNull;
+
import com.google.common.annotations.Beta;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.type.ModifierKind;
* Represents YANG modifier statement.
*
* <p>
- * The "modifier" statement, which is an optional substatement
- * to the "pattern" statement, takes as an argument the string "invert-match".
- * If a pattern has the "invert-match" modifier present, the type is
- * restricted to values that do not match the pattern.
+ * The "modifier" statement, which is an optional substatement to the "pattern" statement, takes as an argument
+ * the string "invert-match". If a pattern has the "invert-match" modifier present, the type is restricted to values
+ * that do not match the pattern.
*/
@Beta
public interface ModifierStatement extends DeclaredStatement<ModifierKind> {
- default @Nonnull ModifierKind getValue() {
- return argument();
+ default @NonNull ModifierKind getValue() {
+ // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
+ return verifyNotNull(argument());
}
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
@Rfc6020AbnfRule("module-header-stmts")
public interface ModuleHeaderGroup {
@Nullable YangVersionStatement getYangVersion();
- @Nonnull NamespaceStatement getNamespace();
+ @NonNull NamespaceStatement getNamespace();
- @Nonnull PrefixStatement getPrefix();
+ @NonNull PrefixStatement getPrefix();
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
+import static com.google.common.base.Verify.verifyNotNull;
+
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
public interface ModuleStatement extends MetaDeclaredStatement<String>, ModuleHeaderGroup, LinkageDeclaredStatement,
RevisionAwareDeclaredStatement, BodyDeclaredStatement {
- default @Nonnull String getName() {
- return rawArgument();
+ default @NonNull String getName() {
+ // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
+ return verifyNotNull(rawArgument());
}
@Override
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.Nullable;
/**
* Common statements of collection-like statements.
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import javax.annotation.Nonnull;
+import static com.google.common.base.Verify.verifyNotNull;
+
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath;
public interface MustStatement extends ConstrainedDocumentedDeclaredStatement<RevisionAwareXPath> {
- default @Nonnull RevisionAwareXPath getCondition() {
- return argument();
+ default @NonNull RevisionAwareXPath getCondition() {
+ // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
+ return verifyNotNull(argument());
}
}
import com.google.common.annotations.Beta;
import java.util.Collection;
-import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
@Beta
public interface MustStatementAwareDeclaredStatement<A> extends DeclaredStatement<A>,
MustStatementContainer {
@Override
- default @Nonnull Collection<? extends MustStatement> getMusts() {
+ default Collection<? extends MustStatement> getMusts() {
return declaredSubstatements(MustStatement.class);
}
}
package org.opendaylight.yangtools.yang.model.api.stmt;
import java.util.Collection;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
/**
* Marker interface for statements which may contain a 'must' statement, as defined in RFC7950. There is a significant
*
* @return collection of must statements
*/
- @Nonnull Collection<? extends MustStatement> getMusts();
+ @NonNull Collection<? extends MustStatement> getMusts();
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
+import static com.google.common.base.Verify.verifyNotNull;
+
import java.net.URI;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public interface NamespaceStatement extends DeclaredStatement<URI> {
- default @Nonnull URI getUri() {
- return argument();
+ default @NonNull URI getUri() {
+ // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
+ return verifyNotNull(argument());
}
}
-
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import javax.annotation.Nonnull;
+import static com.google.common.base.Verify.verifyNotNull;
+
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
public interface NotificationStatement extends DocumentedDeclaredStatement.WithStatus<QName>,
DataDefinitionAwareDeclaredStatement.WithReusableDefinitions<QName>, IfFeatureAwareDeclaredStatement<QName>,
MustStatementAwareDeclaredStatement<QName> {
- default @Nonnull QName getName() {
- return argument();
+ default @NonNull QName getName() {
+ // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
+ return verifyNotNull(argument());
}
}
import com.google.common.annotations.Beta;
import java.util.Collection;
-import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
@Beta
public interface NotificationStatementAwareDeclaredStatement<A> extends DeclaredStatement<A>,
NotificationStatementContainer {
@Override
- default @Nonnull Collection<? extends NotificationStatement> getNotifications() {
+ default Collection<? extends NotificationStatement> getNotifications() {
return declaredSubstatements(NotificationStatement.class);
}
}
package org.opendaylight.yangtools.yang.model.api.stmt;
import java.util.Collection;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
/**
* Marker interface for statements which may contain a 'notification' statement, as defined in RFC7950. There is
*
* @return collection of notification statements
*/
- @Nonnull Collection<? extends NotificationStatement> getNotifications();
+ @NonNull Collection<? extends NotificationStatement> getNotifications();
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
+import static com.google.common.base.Verify.verifyNotNull;
+
import com.google.common.annotations.Beta;
import java.util.Collection;
import java.util.Optional;
-import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
/**
public interface OperationDeclaredStatement extends DocumentedDeclaredStatement.WithStatus<QName>, OperationGroup,
IfFeatureAwareDeclaredStatement<QName> {
@Override
- default @Nonnull QName getName() {
- return argument();
+ default QName getName() {
+ // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
+ return verifyNotNull(argument());
}
@Override
}
@Override
- default @Nonnull Collection<? extends TypedefStatement> getTypedefs() {
+ default Collection<? extends TypedefStatement> getTypedefs() {
return declaredSubstatements(TypedefStatement.class);
}
@Override
- default @Nonnull Collection<? extends GroupingStatement> getGroupings() {
+ default Collection<? extends GroupingStatement> getGroupings() {
return declaredSubstatements(GroupingStatement.class);
}
}
import com.google.common.annotations.Beta;
import java.util.Collection;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
/**
@Beta
public interface OperationGroup extends DocumentationGroup.WithStatus, ConditionalFeature {
- @Nonnull QName getName();
+ @NonNull QName getName();
- @Nonnull Collection<? extends TypedefStatement> getTypedefs();
+ @NonNull Collection<? extends TypedefStatement> getTypedefs();
- @Nonnull Collection<? extends GroupingStatement> getGroupings();
+ @NonNull Collection<? extends GroupingStatement> getGroupings();
@Nullable InputStatement getInput();
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import javax.annotation.Nonnull;
+import static com.google.common.base.Verify.verifyNotNull;
+
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public interface OrderedByStatement extends DeclaredStatement<String> {
- default @Nonnull String getValue() {
- return argument();
+ default @NonNull String getValue() {
+ // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
+ return verifyNotNull(argument());
}
}
-
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import javax.annotation.Nonnull;
+import static com.google.common.base.Verify.verifyNotNull;
+
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public interface OrganizationStatement extends DeclaredStatement<String> {
- default @Nonnull String getText() {
- return argument();
+ default @NonNull String getText() {
+ // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
+ return verifyNotNull(argument());
}
}
-
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import javax.annotation.Nonnull;
+import static com.google.common.base.Verify.verifyNotNull;
+
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public interface PathStatement extends DeclaredStatement<RevisionAwareXPath> {
// FIXME: Introduce proper type representing parsed leafref
- default @Nonnull String getValue() {
- return rawArgument();
+ default @NonNull String getValue() {
+ // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
+ return verifyNotNull(rawArgument());
}
}
-
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
+import static com.google.common.base.Verify.verifyNotNull;
+
import java.util.Optional;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
public interface PatternStatement extends ConstrainedDocumentedDeclaredStatement<PatternConstraint> {
- default @Nonnull PatternConstraint getValue() {
- return argument();
+ default @NonNull PatternConstraint getValue() {
+ // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
+ return verifyNotNull(argument());
}
/**
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import javax.annotation.Nonnull;
+import static com.google.common.base.Verify.verifyNotNull;
+
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public interface PrefixStatement extends DeclaredStatement<String> {
- default @Nonnull String getValue() {
- return rawArgument();
+ default @NonNull String getValue() {
+ // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
+ return verifyNotNull(rawArgument());
}
}
-
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import javax.annotation.Nonnull;
+import static com.google.common.base.Verify.verifyNotNull;
+
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public interface PresenceStatement extends DeclaredStatement<String> {
- default @Nonnull String getValue() {
- return argument();
+ default @NonNull String getValue() {
+ // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
+ return verifyNotNull(argument());
}
}
-
package org.opendaylight.yangtools.yang.model.api.stmt;
import java.util.List;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
public interface RangeStatement extends ConstrainedDocumentedDeclaredStatement<List<ValueRange>> {
- @Nonnull
@Override
- List<ValueRange> argument();
+ @NonNull List<ValueRange> argument();
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import javax.annotation.Nonnull;
+import static com.google.common.base.Verify.verifyNotNull;
+
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public interface ReferenceStatement extends DeclaredStatement<String> {
- default @Nonnull String getText() {
- return rawArgument();
+ default @NonNull String getText() {
+ // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
+ return verifyNotNull(rawArgument());
}
}
-
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
+import static com.google.common.base.Verify.verifyNotNull;
+
import java.util.Collection;
import java.util.Optional;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
public interface RefineStatement extends ConfigStatementAwareDeclaredStatement<SchemaNodeIdentifier>,
DocumentedDeclaredStatement<SchemaNodeIdentifier>, IfFeatureAwareDeclaredStatement<SchemaNodeIdentifier>,
MandatoryStatementAwareDeclaredStatement<SchemaNodeIdentifier>,
MustStatementAwareDeclaredStatement<SchemaNodeIdentifier> {
- default @Nonnull String getTargetNode() {
- return rawArgument();
+ default @NonNull String getTargetNode() {
+ // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
+ return verifyNotNull(rawArgument());
}
- default @Nonnull Collection<? extends DefaultStatement> getDefaults() {
+ default @NonNull Collection<? extends DefaultStatement> getDefaults() {
return declaredSubstatements(DefaultStatement.class);
}
import com.google.common.annotations.Beta;
import java.util.Collection;
-import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
@Beta
public interface RevisionAwareDeclaredStatement extends DeclaredStatement<String>, RevisionGroup {
@Override
- default @Nonnull Collection<? extends RevisionStatement> getRevisions() {
+ default Collection<? extends RevisionStatement> getRevisions() {
return declaredSubstatements(RevisionStatement.class);
}
}
package org.opendaylight.yangtools.yang.model.api.stmt;
import java.util.Collection;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
@Rfc6020AbnfRule("revision-stmts")
@Deprecated
public interface RevisionGroup {
- @Nonnull Collection<? extends RevisionStatement> getRevisions();
+ @NonNull Collection<? extends RevisionStatement> getRevisions();
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import javax.annotation.Nonnull;
+import static com.google.common.base.Verify.verifyNotNull;
+
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public interface StatusStatement extends DeclaredStatement<Status> {
- default @Nonnull Status getValue() {
- return argument();
+ default @NonNull Status getValue() {
+ // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
+ return verifyNotNull(argument());
}
}
-
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
+import static com.google.common.base.Verify.verifyNotNull;
+
import java.util.Optional;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
public interface SubmoduleStatement extends MetaDeclaredStatement<String>, LinkageDeclaredStatement,
RevisionAwareDeclaredStatement, BodyDeclaredStatement {
- default @Nonnull String getName() {
- return rawArgument();
+ default @NonNull String getName() {
+ // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
+ return verifyNotNull(rawArgument());
}
default @Nullable YangVersionStatement getYangVersion() {
return opt.isPresent() ? opt.get() : null;
}
- default @Nonnull BelongsToStatement getBelongsTo() {
+ default @NonNull BelongsToStatement getBelongsTo() {
return findFirstDeclaredSubstatement(BelongsToStatement.class).get();
}
}
import com.google.common.annotations.Beta;
import java.util.Optional;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
@Beta
public interface TypeAwareDeclaredStatement extends DeclaredStatement<QName>, TypeGroup {
@Override
- default @Nonnull TypeStatement getType() {
+ default TypeStatement getType() {
return findFirstDeclaredSubstatement(TypeStatement.class).get();
}
@Override
- default @Nullable UnitsStatement getUnits() {
+ default UnitsStatement getUnits() {
final Optional<UnitsStatement> opt = findFirstDeclaredSubstatement(UnitsStatement.class);
return opt.isPresent() ? opt.get() : null;
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
@Deprecated
public interface TypeGroup {
- @Nonnull TypeStatement getType();
+ @NonNull TypeStatement getType();
@Nullable UnitsStatement getUnits();
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
+import static com.google.common.base.Verify.verifyNotNull;
+
import java.util.Collection;
import java.util.Optional;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
@Rfc6020AbnfRule("type-stmt")
public interface TypeStatement extends DeclaredStatement<String> {
- default @Nonnull String getName() {
- return argument();
+ default @NonNull String getName() {
+ // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
+ return verifyNotNull(argument());
}
@Rfc6020AbnfRule("numerical-restrictions")
interface NumericalRestrictions extends TypeStatement {
- default @Nonnull RangeStatement getRange() {
+ default @NonNull RangeStatement getRange() {
return findFirstDeclaredSubstatement(RangeStatement.class).get();
}
}
@Rfc6020AbnfRule("decimal64-specification")
interface Decimal64Specification extends TypeStatement {
- default @Nonnull FractionDigitsStatement getFractionDigits() {
+ default @NonNull FractionDigitsStatement getFractionDigits() {
return findFirstDeclaredSubstatement(FractionDigitsStatement.class).get();
}
return opt.isPresent() ? opt.get() : null;
}
- default @Nonnull Collection<? extends PatternStatement> getPatterns() {
+ default @NonNull Collection<? extends PatternStatement> getPatterns() {
return declaredSubstatements(PatternStatement.class);
}
}
@Rfc6020AbnfRule("enum-specification")
interface EnumSpecification extends TypeStatement {
- default @Nonnull Collection<? extends EnumStatement> getEnums() {
+ default @NonNull Collection<? extends EnumStatement> getEnums() {
return declaredSubstatements(EnumStatement.class);
}
}
@Rfc6020AbnfRule("leafref-specification")
interface LeafrefSpecification extends TypeStatement {
- default @Nonnull PathStatement getPath() {
+ default @NonNull PathStatement getPath() {
return findFirstDeclaredSubstatement(PathStatement.class).get();
}
* @return collection of base statements (in YANG 1.1 models) or a collection containing just one base
* statement (in YANG 1.0 models)
*/
- default @Nonnull Collection<? extends BaseStatement> getBases() {
+ default @NonNull Collection<? extends BaseStatement> getBases() {
return declaredSubstatements(BaseStatement.class);
}
}
@Rfc6020AbnfRule("bits-specification")
interface BitsSpecification extends TypeStatement {
- default @Nonnull Collection<? extends BitStatement> getBits() {
+ default @NonNull Collection<? extends BitStatement> getBits() {
return declaredSubstatements(BitStatement.class);
}
}
@Rfc6020AbnfRule("union-specification")
interface UnionSpecification extends TypeStatement {
- default @Nonnull Collection<? extends TypeStatement> getTypes() {
+ default @NonNull Collection<? extends TypeStatement> getTypes() {
return declaredSubstatements(TypeStatement.class);
}
}
@Rfc6020AbnfRule("binary-specification")
interface BinarySpecification extends TypeStatement {
- default @Nonnull Collection<? extends LengthStatement> getLength() {
+ default @NonNull Collection<? extends LengthStatement> getLength() {
return declaredSubstatements(LengthStatement.class);
}
}
package org.opendaylight.yangtools.yang.model.api.stmt;
import com.google.common.annotations.Beta;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
* @return Effective type statement.
*/
@Beta
- @Nonnull TypeEffectiveStatement<TypeStatement> asTypeEffectiveStatement();
+ @NonNull TypeEffectiveStatement<TypeStatement> asTypeEffectiveStatement();
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import javax.annotation.Nonnull;
+import static com.google.common.base.Verify.verifyNotNull;
+
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
public interface TypedefStatement extends DocumentedDeclaredStatement.WithStatus<QName>, TypeAwareDeclaredStatement,
DefaultStatementAwareDeclaredStatement {
- default @Nonnull QName getName() {
- return argument();
+ default @NonNull QName getName() {
+ // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
+ return verifyNotNull(argument());
}
}
-
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
+import static com.google.common.base.Verify.verifyNotNull;
+
import java.util.Collection;
-import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Relative;
public interface UniqueStatement extends DeclaredStatement<Collection<SchemaNodeIdentifier.Relative>> {
- @Nonnull Collection<SchemaNodeIdentifier.Relative> getTag();
+ default Collection<Relative> getTag() {
+ // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
+ return verifyNotNull(argument());
+ }
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import javax.annotation.Nonnull;
+import static com.google.common.base.Verify.verifyNotNull;
+
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public interface UnitsStatement extends DeclaredStatement<String> {
- default @Nonnull String getName() {
- return argument();
+ default @NonNull String getName() {
+ // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
+ return verifyNotNull(argument());
}
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
/**
package org.opendaylight.yangtools.yang.model.api.stmt;
import java.util.Collection;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
public interface UsesStatement extends DataDefinitionStatement {
- default @Nonnull Collection<? extends RefineStatement> getRefines() {
+ default @NonNull Collection<? extends RefineStatement> getRefines() {
return declaredSubstatements(RefineStatement.class);
}
- default @Nonnull Collection<? extends AugmentStatement> getAugments() {
+ default @NonNull Collection<? extends AugmentStatement> getAugments() {
return declaredSubstatements(AugmentStatement.class);
}
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import javax.annotation.Nonnull;
+import static com.google.common.base.Verify.verifyNotNull;
+
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath;
public interface WhenStatement extends DocumentedDeclaredStatement<RevisionAwareXPath> {
- default @Nonnull RevisionAwareXPath getCondition() {
- return argument();
+ default @NonNull RevisionAwareXPath getCondition() {
+ // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
+ return verifyNotNull(argument());
}
}
-
import com.google.common.annotations.Beta;
import java.util.Optional;
-import javax.annotation.Nullable;
@Beta
public interface WhenStatementAwareDeclaredStatement<A> extends IfFeatureAwareDeclaredStatement<A>,
ConditionalDataDefinition {
@Override
- default @Nullable WhenStatement getWhenStatement() {
+ default WhenStatement getWhenStatement() {
final Optional<WhenStatement> opt = findFirstDeclaredSubstatement(WhenStatement.class);
return opt.isPresent() ? opt.get() : null;
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import javax.annotation.Nonnull;
+import static com.google.common.base.Verify.verifyNotNull;
+
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.YangVersion;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public interface YangVersionStatement extends DeclaredStatement<YangVersion> {
- default @Nonnull YangVersion getValue() {
- return argument();
+ default @NonNull YangVersion getValue() {
+ // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
+ return verifyNotNull(argument());
}
}
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.error_app_tag;
-import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.stmt.ErrorAppTagStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
ErrorAppTagStatementImpl(final StmtContext<String, ErrorAppTagStatement, ?> context) {
super(context);
}
-
- @Nonnull
- @Override
- public String getValue() {
- return argument();
- }
}
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.if_feature;
+import static com.google.common.base.Verify.verifyNotNull;
+
import java.util.Set;
import java.util.function.Predicate;
import org.opendaylight.yangtools.yang.common.QName;
@Override
public Predicate<Set<QName>> getIfFeaturePredicate() {
- return argument();
+ // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
+ return verifyNotNull(argument());
}
}
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.unique;
import java.util.Collection;
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Relative;
import org.opendaylight.yangtools.yang.model.api.stmt.UniqueStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-final class UniqueStatementImpl extends AbstractDeclaredStatement<Collection<SchemaNodeIdentifier.Relative>>
- implements UniqueStatement {
- UniqueStatementImpl(final StmtContext<Collection<SchemaNodeIdentifier.Relative>, UniqueStatement, ?> context) {
+final class UniqueStatementImpl extends AbstractDeclaredStatement<Collection<Relative>> implements UniqueStatement {
+ UniqueStatementImpl(final StmtContext<Collection<Relative>, UniqueStatement, ?> context) {
super(context);
}
-
- @Nonnull
- @Override
- public Collection<Relative> getTag() {
- return argument();
- }
}
Code Review / yangtools.git / commitdiff