exports org.opendaylight.yangtools.openconfig.model.api;
requires transitive org.opendaylight.yangtools.yang.model.api;
+ requires org.opendaylight.yangtools.yang.common;
// Annotations
requires static com.github.spotbugs.annotations;
*/
package org.opendaylight.yangtools.openconfig.model.api;
+import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
/**
* @author Robert Varga
*/
public interface OpenConfigHashedValueEffectiveStatement
- extends EffectiveStatement<Void, OpenConfigHashedValueStatement> {
+ extends EffectiveStatement<Empty, OpenConfigHashedValueStatement> {
}
*/
package org.opendaylight.yangtools.openconfig.model.api;
+import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.model.api.stmt.UnknownStatement;
/**
*
* @author Robert Varga
*/
-public interface OpenConfigHashedValueStatement extends UnknownStatement<Void> {
+public interface OpenConfigHashedValueStatement extends UnknownStatement<Empty> {
}
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.openconfig.model.api.OpenConfigHashedValueEffectiveStatement;
import org.opendaylight.yangtools.openconfig.model.api.OpenConfigHashedValueStatement;
+import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredStatement.WithoutArgument.WithSubstatements;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractVoidStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractEmptyStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.SchemaPathSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
abstract class AbstractHashedValueStatementSupport
- extends AbstractVoidStatementSupport<OpenConfigHashedValueStatement, OpenConfigHashedValueEffectiveStatement> {
+ extends AbstractEmptyStatementSupport<OpenConfigHashedValueStatement, OpenConfigHashedValueEffectiveStatement> {
private static final class Declared extends WithSubstatements implements OpenConfigHashedValueStatement {
private final @NonNull StatementDefinition definition;
}
private static final class Effective
- extends UnknownEffectiveStatementBase<Void, OpenConfigHashedValueStatement>
+ extends UnknownEffectiveStatementBase<Empty, OpenConfigHashedValueStatement>
implements OpenConfigHashedValueEffectiveStatement {
private final @NonNull StatementDefinition definition;
private final @NonNull Object path;
- Effective(final Current<Void, OpenConfigHashedValueStatement> stmt,
+ Effective(final Current<Empty, OpenConfigHashedValueStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements);
definition = stmt.publicDefinition();
@Override
protected final OpenConfigHashedValueStatement createDeclared(
- final StmtContext<Void, OpenConfigHashedValueStatement, ?> ctx,
+ final StmtContext<Empty, OpenConfigHashedValueStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
return new Declared(getPublicView(), substatements);
}
@Override
protected final OpenConfigHashedValueStatement createEmptyDeclared(
- final StmtContext<Void, OpenConfigHashedValueStatement, ?> ctx) {
+ final StmtContext<Empty, OpenConfigHashedValueStatement, ?> ctx) {
return createDeclared(ctx, ImmutableList.of());
}
@Override
protected OpenConfigHashedValueEffectiveStatement createEffective(
- final Current<Void, OpenConfigHashedValueStatement> stmt,
+ final Current<Empty, OpenConfigHashedValueStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
return new Effective(stmt, substatements);
}
exports org.opendaylight.yangtools.rfc6241.model.api;
requires transitive org.opendaylight.yangtools.yang.model.api;
+ requires org.opendaylight.yangtools.yang.common;
}
package org.opendaylight.yangtools.rfc6241.model.api;
import com.google.common.annotations.Beta;
+import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
*/
@Beta
public interface GetFilterElementAttributesEffectiveStatement
- extends EffectiveStatement<Void, GetFilterElementAttributesStatement> {
+ extends EffectiveStatement<Empty, GetFilterElementAttributesStatement> {
@Override
default StatementDefinition statementDefinition() {
return NetconfStatements.GET_FILTER_ELEMENT_ATTRIBUTES;
package org.opendaylight.yangtools.rfc6241.model.api;
import com.google.common.annotations.Beta;
+import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
import org.opendaylight.yangtools.yang.model.api.stmt.UnknownStatement;
* <a href="https://tools.ietf.org/html/rfc6241">RFC6241</a>.
*/
@Beta
-public interface GetFilterElementAttributesStatement extends UnknownStatement<Void> {
+public interface GetFilterElementAttributesStatement extends UnknownStatement<Empty> {
@Override
default StatementDefinition statementDefinition() {
return NetconfStatements.GET_FILTER_ELEMENT_ATTRIBUTES;
import org.opendaylight.yangtools.rfc6241.model.api.GetFilterElementAttributesSchemaNode;
import org.opendaylight.yangtools.rfc6241.model.api.GetFilterElementAttributesStatement;
import org.opendaylight.yangtools.rfc6241.model.api.NetconfStatements;
+import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredStatement.WithoutArgument.WithSubstatements;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractVoidStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractEmptyStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.SchemaPathSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.slf4j.LoggerFactory;
@Beta
-public final class GetFilterElementAttributesStatementSupport extends AbstractVoidStatementSupport<
+public final class GetFilterElementAttributesStatementSupport extends AbstractEmptyStatementSupport<
GetFilterElementAttributesStatement, GetFilterElementAttributesEffectiveStatement> {
private static final class Declared extends WithSubstatements implements GetFilterElementAttributesStatement {
}
private static final class Effective
- extends UnknownEffectiveStatementBase<Void, GetFilterElementAttributesStatement>
+ extends UnknownEffectiveStatementBase<Empty, GetFilterElementAttributesStatement>
implements GetFilterElementAttributesEffectiveStatement, GetFilterElementAttributesSchemaNode {
private final @NonNull Object path;
- Effective(final Current<Void, GetFilterElementAttributesStatement> stmt,
+ Effective(final Current<Empty, GetFilterElementAttributesStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements);
path = SchemaPathSupport.toEffectivePath(stmt.getEffectiveParent().getSchemaPath()
}
@Override
- public void onFullDefinitionDeclared(final Mutable<Void, GetFilterElementAttributesStatement,
+ public void onFullDefinitionDeclared(final Mutable<Empty, GetFilterElementAttributesStatement,
GetFilterElementAttributesEffectiveStatement> stmt) {
super.onFullDefinitionDeclared(stmt);
stmt.setIsSupportedToBuildEffective(computeSupported(stmt));
@Override
protected GetFilterElementAttributesStatement createDeclared(
- final StmtContext<Void, GetFilterElementAttributesStatement, ?> ctx,
+ final StmtContext<Empty, GetFilterElementAttributesStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
return new Declared(substatements);
}
@Override
protected GetFilterElementAttributesStatement createEmptyDeclared(
- final StmtContext<Void, GetFilterElementAttributesStatement, ?> ctx) {
+ final StmtContext<Empty, GetFilterElementAttributesStatement, ?> ctx) {
return Declared.EMPTY;
}
@Override
protected GetFilterElementAttributesEffectiveStatement createEffective(
- final Current<Void, GetFilterElementAttributesStatement> stmt,
+ final Current<Empty, GetFilterElementAttributesStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
return new Effective(stmt, substatements);
}
exports org.opendaylight.yangtools.rfc6536.model.api;
requires transitive org.opendaylight.yangtools.yang.model.api;
+ requires org.opendaylight.yangtools.yang.common;
}
package org.opendaylight.yangtools.rfc6536.model.api;
import com.google.common.annotations.Beta;
+import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
* <a href="https://tools.ietf.org/html/rfc6536">RFC6536</a>.
*/
@Beta
-public interface DefaultDenyAllEffectiveStatement extends EffectiveStatement<Void, DefaultDenyAllStatement> {
+public interface DefaultDenyAllEffectiveStatement extends EffectiveStatement<Empty, DefaultDenyAllStatement> {
@Override
default StatementDefinition statementDefinition() {
return NACMStatements.DEFAULT_DENY_ALL;
package org.opendaylight.yangtools.rfc6536.model.api;
import com.google.common.annotations.Beta;
+import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
import org.opendaylight.yangtools.yang.model.api.stmt.UnknownStatement;
* <a href="https://tools.ietf.org/html/rfc6536">RFC6536</a>.
*/
@Beta
-public interface DefaultDenyAllStatement extends UnknownStatement<Void> {
+public interface DefaultDenyAllStatement extends UnknownStatement<Empty> {
@Override
default StatementDefinition statementDefinition() {
return NACMStatements.DEFAULT_DENY_ALL;
package org.opendaylight.yangtools.rfc6536.model.api;
import com.google.common.annotations.Beta;
+import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
* <a href="https://tools.ietf.org/html/rfc6536">RFC6536</a>.
*/
@Beta
-public interface DefaultDenyWriteEffectiveStatement extends EffectiveStatement<Void, DefaultDenyWriteStatement> {
+public interface DefaultDenyWriteEffectiveStatement extends EffectiveStatement<Empty, DefaultDenyWriteStatement> {
@Override
default StatementDefinition statementDefinition() {
return NACMStatements.DEFAULT_DENY_WRITE;
package org.opendaylight.yangtools.rfc6536.model.api;
import com.google.common.annotations.Beta;
+import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
import org.opendaylight.yangtools.yang.model.api.stmt.UnknownStatement;
* <a href="https://tools.ietf.org/html/rfc6536">RFC6536</a>.
*/
@Beta
-public interface DefaultDenyWriteStatement extends UnknownStatement<Void> {
+public interface DefaultDenyWriteStatement extends UnknownStatement<Empty> {
@Override
default StatementDefinition statementDefinition() {
return NACMStatements.DEFAULT_DENY_WRITE;
import org.opendaylight.yangtools.rfc6536.model.api.DefaultDenyAllSchemaNode;
import org.opendaylight.yangtools.rfc6536.model.api.DefaultDenyAllStatement;
import org.opendaylight.yangtools.rfc6536.model.api.NACMStatements;
+import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredStatement.WithoutArgument.WithSubstatements;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractVoidStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractEmptyStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.SchemaPathSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
public final class DefaultDenyAllStatementSupport
- extends AbstractVoidStatementSupport<DefaultDenyAllStatement, DefaultDenyAllEffectiveStatement> {
+ extends AbstractEmptyStatementSupport<DefaultDenyAllStatement, DefaultDenyAllEffectiveStatement> {
private static final class Declared extends WithSubstatements implements DefaultDenyAllStatement {
static final @NonNull Declared EMPTY = new Declared(ImmutableList.of());
}
}
- private static final class Effective extends UnknownEffectiveStatementBase<Void, DefaultDenyAllStatement>
+ private static final class Effective extends UnknownEffectiveStatementBase<Empty, DefaultDenyAllStatement>
implements DefaultDenyAllEffectiveStatement, DefaultDenyAllSchemaNode {
private final @NonNull Object path;
- Effective(final Current<Void, DefaultDenyAllStatement> stmt,
+ Effective(final Current<Empty, DefaultDenyAllStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements);
path = SchemaPathSupport.toEffectivePath(stmt.getEffectiveParent().getSchemaPath()
}
@Override
- protected DefaultDenyAllStatement createDeclared(final StmtContext<Void, DefaultDenyAllStatement, ?> ctx,
+ protected DefaultDenyAllStatement createDeclared(final StmtContext<Empty, DefaultDenyAllStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
return new Declared(substatements);
}
@Override
- protected DefaultDenyAllStatement createEmptyDeclared(final StmtContext<Void, DefaultDenyAllStatement, ?> ctx) {
+ protected DefaultDenyAllStatement createEmptyDeclared(final StmtContext<Empty, DefaultDenyAllStatement, ?> ctx) {
return Declared.EMPTY;
}
@Override
- protected DefaultDenyAllEffectiveStatement createEffective(final Current<Void, DefaultDenyAllStatement> stmt,
+ protected DefaultDenyAllEffectiveStatement createEffective(final Current<Empty, DefaultDenyAllStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
return new Effective(stmt, substatements);
}
import org.opendaylight.yangtools.rfc6536.model.api.DefaultDenyWriteSchemaNode;
import org.opendaylight.yangtools.rfc6536.model.api.DefaultDenyWriteStatement;
import org.opendaylight.yangtools.rfc6536.model.api.NACMStatements;
+import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredStatement.WithoutArgument.WithSubstatements;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractVoidStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractEmptyStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.SchemaPathSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
public final class DefaultDenyWriteStatementSupport
- extends AbstractVoidStatementSupport<DefaultDenyWriteStatement, DefaultDenyWriteEffectiveStatement> {
+ extends AbstractEmptyStatementSupport<DefaultDenyWriteStatement, DefaultDenyWriteEffectiveStatement> {
private static final class Declared extends WithSubstatements implements DefaultDenyWriteStatement {
static final @NonNull Declared EMPTY = new Declared(ImmutableList.of());
}
}
- private static final class Effective extends UnknownEffectiveStatementBase<Void, DefaultDenyWriteStatement>
+ private static final class Effective extends UnknownEffectiveStatementBase<Empty, DefaultDenyWriteStatement>
implements DefaultDenyWriteEffectiveStatement, DefaultDenyWriteSchemaNode {
private final @NonNull Object path;
- Effective(final Current<Void, DefaultDenyWriteStatement> stmt,
+ Effective(final Current<Empty, DefaultDenyWriteStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements);
path = SchemaPathSupport.toEffectivePath(stmt.getEffectiveParent().getSchemaPath()
}
@Override
- protected DefaultDenyWriteStatement createDeclared(final StmtContext<Void, DefaultDenyWriteStatement, ?> ctx,
+ protected DefaultDenyWriteStatement createDeclared(final StmtContext<Empty, DefaultDenyWriteStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
return new Declared(substatements);
}
@Override
- protected DefaultDenyWriteStatement createEmptyDeclared(final StmtContext<Void, DefaultDenyWriteStatement, ?> ctx) {
+ protected DefaultDenyWriteStatement createEmptyDeclared(
+ final StmtContext<Empty, DefaultDenyWriteStatement, ?> ctx) {
return Declared.EMPTY;
}
@Override
- protected DefaultDenyWriteEffectiveStatement createEffective(final Current<Void, DefaultDenyWriteStatement> stmt,
+ protected DefaultDenyWriteEffectiveStatement createEffective(final Current<Empty, DefaultDenyWriteStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
return new Effective(stmt, substatements);
}
import java.util.stream.Stream;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
+import org.opendaylight.yangtools.yang.common.Empty;
/**
* Effective model statement which should be used to derive application behaviour.
*
- * @param <A> Argument type ({@link Void} if statement does not have argument.)
+ * @param <A> Argument type ({@link Empty} if statement does not have argument.)
* @param <D> Class representing declared version of this statement.
*/
public interface EffectiveStatement<A, D extends DeclaredStatement<A>> extends ModelStatement<A> {
package org.opendaylight.yangtools.yang.model.api.meta;
import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.yangtools.yang.common.Empty;
/**
* Model statement. There are two base types of model statements:
* </li>
* </ul>
*
- * @param <A> Argument type ({@link Void} if statement does not have argument.)
+ * @param <A> Argument type ({@link Empty} if statement does not have argument.)
*/
public interface ModelStatement<A> {
/**
/**
* Returns statement argument.
*
- * @return statement argument or null if statement does not have argument.
+ * @return statement argument.
*/
- A argument();
+ @NonNull A argument();
/**
* Returns statement source, which denotes if statement was
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import static com.google.common.base.Verify.verifyNotNull;
-
import java.util.Optional;
-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.YangStmtMapping;
return YangStmtMapping.ARGUMENT;
}
- default @NonNull QName getName() {
- // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
- return verifyNotNull(argument());
- }
-
default @Nullable YinElementStatement getYinElement() {
final Optional<YinElementStatement> opt = findFirstDeclaredSubstatement(YinElementStatement.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.Collection;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
return YangStmtMapping.AUGMENT;
}
- default @NonNull SchemaNodeIdentifier getTargetNode() {
- // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
- return verifyNotNull(argument());
- }
-
+ // FIXME: 7.0.0: determine the utility of this method
default @NonNull Collection<? extends CaseStatement> getCases() {
return declaredSubstatements(CaseStatement.class);
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-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.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
default StatementDefinition statementDefinition() {
return YangStmtMapping.BASE;
}
-
- 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 org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
return YangStmtMapping.BELONGS_TO;
}
- default @NonNull String getModule() {
- // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
- return verifyNotNull(argument());
- }
-
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 org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
return YangStmtMapping.BIT;
}
- default @NonNull String getName() {
- // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
- return verifyNotNull(argument());
- }
-
default @Nullable PositionStatement getPosition() {
final Optional<PositionStatement> opt = findFirstDeclaredSubstatement(PositionStatement.class);
return opt.isPresent() ? opt.get() : null;
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-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.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
default StatementDefinition statementDefinition() {
return YangStmtMapping.CASE;
}
-
- 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 org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
default StatementDefinition statementDefinition() {
return YangStmtMapping.CONTACT;
}
-
- 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 org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
/**
- * Statement that defines new data nodes.
- * One of container, leaf, leaf-list, list, choice, case,
- * augment, uses, anyxml and anydata.
+ * Statement that defines new data nodes. One of container, leaf, leaf-list, list, choice, case, augment, uses, anyxml
+ * and anydata.
*
* <p>
* Defined in: <a href="https://tools.ietf.org/html/rfc6020#section-3">RFC6020, Section 3</a>
@Rfc6020AbnfRule("data-def-stmt")
public interface DataDefinitionStatement extends DocumentedDeclaredStatement.WithStatus<QName>,
WhenStatementAwareDeclaredStatement<QName> {
- 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 org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
default StatementDefinition statementDefinition() {
return YangStmtMapping.DEFAULT;
}
-
- 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 static com.google.common.base.Verify.verifyNotNull;
-
-import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
default StatementDefinition statementDefinition() {
return YangStmtMapping.DESCRIPTION;
}
-
- 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 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.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
default StatementDefinition statementDefinition() {
return YangStmtMapping.DEVIATE;
}
-
- 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 org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
return YangStmtMapping.DEVIATION;
}
- default @NonNull Absolute getTargetNode() {
- // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
- return verifyNotNull(argument());
- }
-
+ // FIXME: 7.0.0: evaluate usefulness of this
default @NonNull Collection<? extends DeviateStatement> getDeviateStatements() {
return declaredSubstatements(DeviateStatement.class);
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import static com.google.common.base.Verify.verifyNotNull;
-
import java.util.Optional;
-import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
return YangStmtMapping.ENUM;
}
- default @NonNull String getName() {
- // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
- return verifyNotNull(argument());
- }
-
default @Nullable ValueStatement getValue() {
final Optional<ValueStatement> opt = findFirstDeclaredSubstatement(ValueStatement.class);
return opt.isPresent() ? opt.get() : null;
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import static com.google.common.base.Verify.verifyNotNull;
-
-import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
default StatementDefinition statementDefinition() {
return YangStmtMapping.ERROR_APP_TAG;
}
-
- 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 static com.google.common.base.Verify.verifyNotNull;
-
-import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
default StatementDefinition statementDefinition() {
return YangStmtMapping.ERROR_MESSAGE;
}
-
- 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 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.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
default StatementDefinition statementDefinition() {
return YangStmtMapping.FEATURE;
}
-
- 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 org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
default StatementDefinition statementDefinition() {
return YangStmtMapping.GROUPING;
}
-
- 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 org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
return YangStmtMapping.IDENTITY;
}
- default @NonNull QName getName() {
- // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
- return verifyNotNull(argument());
- }
-
/**
* Returns the base identities of this identity.
*
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import static com.google.common.base.Verify.verifyNotNull;
-
import com.google.common.annotations.Beta;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
* @return Predicate on a collection of QNames against which to evaluate
*/
@Beta
+ // FIXME: YANGTOOLS-908: remove this method
default @NonNull IfFeatureExpr getIfFeaturePredicate() {
- // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
- return verifyNotNull(argument());
+ return argument();
}
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import static com.google.common.base.Verify.verifyNotNull;
-
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
return YangStmtMapping.IMPORT;
}
- default @NonNull String getModule() {
- // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
- return verifyNotNull(rawArgument());
- }
-
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 org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
return YangStmtMapping.INCLUDE;
}
- default @NonNull String getModule() {
- // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
- return verifyNotNull(argument());
- }
-
default @Nullable RevisionDateStatement getRevisionDate() {
final Optional<RevisionDateStatement> opt = findFirstDeclaredSubstatement(RevisionDateStatement.class);
return opt.isPresent() ? opt.get() : null;
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import static com.google.common.base.Verify.verifyNotNull;
-
-import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
return YangStmtMapping.MANDATORY;
}
- default @NonNull Boolean getValue() {
- // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
- return verifyNotNull(argument());
+ default boolean getValue() {
+ return argument();
}
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import static com.google.common.base.Verify.verifyNotNull;
-
-import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
default StatementDefinition statementDefinition() {
return YangStmtMapping.MAX_ELEMENTS;
}
-
- 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 static com.google.common.base.Verify.verifyNotNull;
-
-import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
default StatementDefinition statementDefinition() {
return YangStmtMapping.MIN_ELEMENTS;
}
-
- 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 org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
default StatementDefinition statementDefinition() {
return YangStmtMapping.MODIFIER;
}
-
- 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 static com.google.common.base.Verify.verifyNotNull;
-
import java.util.Optional;
-import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.UnqualifiedQName;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
return YangStmtMapping.MODULE;
}
- default @NonNull String getName() {
- // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
- return verifyNotNull(rawArgument());
- }
-
@Override
default YangVersionStatement getYangVersion() {
final Optional<YangVersionStatement> opt = findFirstDeclaredSubstatement(YangVersionStatement.class);
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import static com.google.common.base.Verify.verifyNotNull;
-
-import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
import org.opendaylight.yangtools.yang.xpath.api.YangXPathExpression.QualifiedBound;
default StatementDefinition statementDefinition() {
return YangStmtMapping.MUST;
}
-
- default @NonNull QualifiedBound getCondition() {
- // 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.net.URI;
-import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
default StatementDefinition statementDefinition() {
return YangStmtMapping.NAMESPACE;
}
-
- 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 static com.google.common.base.Verify.verifyNotNull;
-
import com.google.common.annotations.Beta;
import org.opendaylight.yangtools.concepts.Identifiable;
import org.opendaylight.yangtools.yang.common.QName;
@Override
default QName getIdentifier() {
- return verifyNotNull(argument());
+ return argument();
}
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-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.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
default StatementDefinition statementDefinition() {
return YangStmtMapping.NOTIFICATION;
}
-
- 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 com.google.common.annotations.Beta;
import java.util.Collection;
import java.util.Optional;
@Beta
public interface OperationDeclaredStatement extends DocumentedDeclaredStatement.WithStatus<QName>,
IfFeatureAwareDeclaredStatement<QName> {
- default @NonNull QName getName() {
- // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
- return verifyNotNull(argument());
- }
-
default @NonNull Optional<InputStatement> getInput() {
return findFirstDeclaredSubstatement(InputStatement.class);
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import static com.google.common.base.Verify.verifyNotNull;
-
-import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.Ordering;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
default StatementDefinition statementDefinition() {
return YangStmtMapping.ORDERED_BY;
}
-
- default @NonNull Ordering 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 org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
default StatementDefinition statementDefinition() {
return YangStmtMapping.ORGANIZATION;
}
-
- 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 static com.google.common.base.Verify.verifyNotNull;
-
-import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.PathExpression;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
default StatementDefinition statementDefinition() {
return YangStmtMapping.PATH;
}
-
- default @NonNull PathExpression 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 org.opendaylight.yangtools.yang.common.Uint32;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
default StatementDefinition statementDefinition() {
return YangStmtMapping.POSITION;
}
-
- default Uint32 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 org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
default StatementDefinition statementDefinition() {
return YangStmtMapping.PREFIX;
}
-
- 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 org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
default StatementDefinition statementDefinition() {
return YangStmtMapping.PRESENCE;
}
-
- 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 static com.google.common.base.Verify.verifyNotNull;
-
-import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
default StatementDefinition statementDefinition() {
return YangStmtMapping.REFERENCE;
}
-
- 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 org.eclipse.jdt.annotation.NonNull;
return YangStmtMapping.REFINE;
}
- default @NonNull String getTargetNode() {
- // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
- return verifyNotNull(rawArgument());
- }
-
default @NonNull Collection<? extends DefaultStatement> getDefaults() {
return declaredSubstatements(DefaultStatement.class);
}
default StatementDefinition statementDefinition() {
return YangStmtMapping.REVISION_DATE;
}
-
- default Revision getDate() {
- return argument();
- }
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import static com.google.common.base.Verify.verifyNotNull;
-
-import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
default StatementDefinition statementDefinition() {
return YangStmtMapping.REVISION;
}
-
- default @NonNull Revision getDate() {
- // 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 org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
default StatementDefinition statementDefinition() {
return YangStmtMapping.STATUS;
}
-
- 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 org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
return YangStmtMapping.SUBMODULE;
}
- default @NonNull String getName() {
- // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
- return verifyNotNull(rawArgument());
- }
-
default @Nullable YangVersionStatement getYangVersion() {
final Optional<YangVersionStatement> opt = findFirstDeclaredSubstatement(YangVersionStatement.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.Collection;
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
return YangStmtMapping.TYPE;
}
- default @NonNull String getName() {
- // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
- return verifyNotNull(argument());
- }
-
@Rfc6020AbnfRule("numerical-restrictions")
// FIXME: 7.0.0: this interface does not have an implementation
interface NumericalRestrictions extends TypeStatement {
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-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.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
default StatementDefinition statementDefinition() {
return YangStmtMapping.TYPEDEF;
}
-
- 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.Set;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
-import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Descendant;
public interface UniqueStatement extends DeclaredStatement<Set<SchemaNodeIdentifier.Descendant>> {
@Override
default StatementDefinition statementDefinition() {
return YangStmtMapping.UNIQUE;
}
-
- default Set<Descendant> getTag() {
- // 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 org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
default StatementDefinition statementDefinition() {
return YangStmtMapping.UNITS;
}
-
- 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 org.eclipse.jdt.annotation.Nullable;
+import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
/**
* interfaces in this package. This interface is meant to be specialized by external semantic plugins, such that they
* are properly anchored in the metamodel.
*
- * @param <A> Argument type ({@link Void} if statement does not have argument.)
+ * @param <A> Argument type ({@link Empty} if statement does not have argument.)
*/
public interface UnknownStatement<A> extends DeclaredStatement<A> {
- default @Nullable A getArgument() {
- return argument();
- }
+
}
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
@Beta
-public interface UnrecognizedEffectiveStatement extends EffectiveStatement<String, UnrecognizedStatement> {
+public interface UnrecognizedEffectiveStatement extends EffectiveStatement<Object, UnrecognizedStatement> {
}
import com.google.common.annotations.Beta;
/**
- * Common interface for unrecognized unknown statements. UnrecognizedStatement
- * is an instance of a statement defined via an 'extension' statement, for which
- * the parser did not have semantic support (in which case the statement would
+ * Common interface for unrecognized unknown statements. UnrecognizedStatement is an instance of a statement defined via
+ * an 'extension' statement, for which the parser did not have semantic support (in which case the statement would
* result in a corresponding semantic subclass of {@link UnknownStatement}).
*/
@Beta
-public interface UnrecognizedStatement extends UnknownStatement<String> {
+public interface UnrecognizedStatement extends UnknownStatement<Object> {
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import static com.google.common.base.Verify.verifyNotNull;
-
-import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
import org.opendaylight.yangtools.yang.xpath.api.YangXPathExpression.QualifiedBound;
default StatementDefinition statementDefinition() {
return YangStmtMapping.WHEN;
}
-
- default @NonNull QualifiedBound getCondition() {
- // 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 org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.YangVersion;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
default StatementDefinition statementDefinition() {
return YangStmtMapping.YANG_VERSION;
}
-
- default @NonNull YangVersion getValue() {
- // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
- return verifyNotNull(argument());
- }
}
}
default boolean getValue() {
- return argument().booleanValue();
+ return argument();
}
}
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt;
+import static com.google.common.base.Verify.verifyNotNull;
import static java.util.Objects.requireNonNull;
import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableList;
import java.util.Collection;
import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementSource;
}
public abstract static class WithRawArgument<A> extends AbstractDeclaredStatement<A> {
+ public abstract static class WithSubstatements<A> extends WithRawArgument<A> {
+ private final @NonNull Object substatements;
+
+ protected WithSubstatements(final String rawArgument,
+ final ImmutableList<? extends DeclaredStatement<?>> substatements) {
+ super(rawArgument);
+ this.substatements = maskList(substatements);
+ }
+
+ @Override
+ public final Collection<? extends DeclaredStatement<?>> declaredSubstatements() {
+ return unmaskList(substatements);
+ }
+ }
+
private final String rawArgument;
protected WithRawArgument(final String rawArgument) {
}
@Override
- public final @NonNull QName argument() {
+ public final QName argument() {
return argument;
}
}
protected WithRawStringArgument(final String rawArgument) {
- super(rawArgument);
+ super(verifyNotNull(rawArgument));
}
@Override
public final String argument() {
- return rawArgument();
+ return verifyNotNull(rawArgument());
}
}
}
}
- private final A argument;
+ private final @NonNull A argument;
protected WithArgument(final String rawArgument, final A argument) {
super(rawArgument);
- this.argument = argument;
+ this.argument = requireNonNull(argument);
}
@Override
private final @NonNull A argument;
- protected ArgumentToString(final A argument) {
+ protected ArgumentToString(final @NonNull A argument) {
this.argument = requireNonNull(argument);
}
@Override
- public final @NonNull A argument() {
+ public final A argument() {
return argument;
}
}
}
- public abstract static class WithoutArgument extends AbstractDeclaredStatement<Void> {
+ public abstract static class WithoutArgument extends AbstractDeclaredStatement<Empty> {
public abstract static class WithSubstatements extends WithoutArgument {
private final @NonNull Object substatements;
}
@Override
- public final Void argument() {
- return null;
+ public final Empty argument() {
+ return Empty.getInstance();
}
@Override
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-final class UnrecognizedEffectiveStatementImpl extends UnknownEffectiveStatementBase<String, UnrecognizedStatement>
+final class UnrecognizedEffectiveStatementImpl extends UnknownEffectiveStatementBase<Object, UnrecognizedStatement>
implements UnrecognizedEffectiveStatement {
private static final Logger LOG = LoggerFactory.getLogger(UnrecognizedEffectiveStatementImpl.class);
private final QName maybeQNameArgument;
private final @Nullable SchemaPath path;
- UnrecognizedEffectiveStatementImpl(final Current<String, UnrecognizedStatement> stmt,
+ UnrecognizedEffectiveStatementImpl(final Current<Object, UnrecognizedStatement> stmt,
final @NonNull ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final QName qnameArgument) {
super(stmt, substatements);
this.maybeQNameArgument = qnameArgument != null ? qnameArgument : getNodeType();
import com.google.common.collect.ImmutableList;
import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
import org.opendaylight.yangtools.yang.model.api.stmt.UnrecognizedStatement;
-import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredStatement.WithRawStringArgument.WithSubstatements;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredStatement.WithRawArgument.WithSubstatements;
-final class UnrecognizedStatementImpl extends WithSubstatements implements UnrecognizedStatement {
+final class UnrecognizedStatementImpl extends WithSubstatements<Object> implements UnrecognizedStatement {
private final @NonNull StatementDefinition definition;
UnrecognizedStatementImpl(final String rawArgument, final @NonNull StatementDefinition statementDefinition,
public StatementDefinition statementDefinition() {
return definition;
}
+
+ @Override
+ public Object argument() {
+ final String raw = rawArgument();
+ return raw != null ? raw : Empty.getInstance();
+ }
}
// FIXME: YANGTOOLS-1196: remove this class
@Deprecated
final class UnrecognizedStatementSupport
- extends AbstractStatementSupport<String, UnrecognizedStatement, UnrecognizedEffectiveStatement> {
+ extends AbstractStatementSupport<Object, UnrecognizedStatement, UnrecognizedEffectiveStatement> {
UnrecognizedStatementSupport(final StatementDefinition publicDefinition) {
super(publicDefinition, StatementPolicy.alwaysCopyDeclared());
}
}
@Override
- protected UnrecognizedStatement createDeclared(final StmtContext<String, UnrecognizedStatement, ?> ctx,
+ protected UnrecognizedStatement createDeclared(final StmtContext<Object, UnrecognizedStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
return new UnrecognizedStatementImpl(ctx.rawArgument(), ctx.publicDefinition(), substatements);
}
@Override
- protected UnrecognizedStatement createEmptyDeclared(final StmtContext<String, UnrecognizedStatement, ?> ctx) {
+ protected UnrecognizedStatement createEmptyDeclared(final StmtContext<Object, UnrecognizedStatement, ?> ctx) {
return createDeclared(ctx, ImmutableList.of());
}
@Override
- protected UnrecognizedEffectiveStatement createEffective(final Current<String, UnrecognizedStatement> stmt,
+ protected UnrecognizedEffectiveStatement createEffective(final Current<Object, UnrecognizedStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
// FIXME: Remove following section after fixing 4380
final UnknownSchemaNode original = (UnknownSchemaNode) stmt.original();
original == null ? qnameFromArgument(stmt) : original.getQName());
}
- private static QName qnameFromArgument(final Current<String, UnrecognizedStatement> stmt) {
- final String value = stmt.argument();
+ private static QName qnameFromArgument(final Current<Object, UnrecognizedStatement> stmt) {
+ final String value = stmt.rawArgument();
if (value == null || value.isEmpty()) {
return stmt.publicDefinition().getStatementName();
}
@Override
public String getPrefix() {
- return getDeclared().getPrefix().getValue();
+ return getDeclared().getPrefix().argument();
}
@Override
}
@Override
- public final @NonNull Set<QName> argument() {
+ public final Set<QName> argument() {
return KeyStatementSupport.unmaskSet(argument);
}
}
}
@Override
- public final @NonNull Ordering argument() {
+ public final Ordering argument() {
return argument;
}
}
@Override
- public final @NonNull Status argument() {
+ public final Status argument() {
return argument;
}
assertNotNull(anyxmlSchemaNode);
final AnyxmlStatement anyxmlStatement = ((AnyxmlEffectiveStatement) anyxmlSchemaNode).getDeclared();
- final QName name = anyxmlStatement.getName();
+ final QName name = anyxmlStatement.argument();
assertNotNull(name);
final WhenStatement whenStatement = anyxmlStatement.getWhenStatement().get();
- assertNotNull(whenStatement.getCondition());
+ assertNotNull(whenStatement.argument());
final DescriptionStatement whenStatementDescription = whenStatement.getDescription().get();
assertTrue(whenStatement.getReference().isPresent());
assertNotNull(mustStatements);
assertEquals(1, mustStatements.size());
final MustStatement mustStatement = mustStatements.iterator().next();
- assertNotNull(mustStatement.getCondition());
+ assertNotNull(mustStatement.argument());
assertTrue(mustStatement.getErrorAppTagStatement().isPresent());
assertTrue(mustStatement.getErrorMessageStatement().isPresent());
assertTrue(mustStatement.getDescription().isPresent());
assertFalse(configStatement.getValue());
final StatusStatement statusStatement = anyxmlStatement.getStatus().get();
- final Status status = statusStatement.getValue();
+ final Status status = statusStatement.argument();
assertNotNull(status);
final DescriptionStatement descriptionStatement = anyxmlStatement.getDescription().get();
- assertEquals("anyxml description", descriptionStatement.getText());
+ assertEquals("anyxml description", descriptionStatement.argument());
final ReferenceStatement referenceStatement = anyxmlStatement.getReference().get();
- assertEquals("anyxml reference", referenceStatement.getText());
+ assertEquals("anyxml reference", referenceStatement.argument());
assertTrue(anyxmlStatement.getMandatory().isPresent());
}
assertNotNull(choiceSchemaNode);
final ChoiceStatement choiceStatement = ((ChoiceEffectiveStatement) choiceSchemaNode).getDeclared();
- final QName name = choiceStatement.getName();
+ final QName name = choiceStatement.argument();
assertNotNull(name);
final DefaultStatement defaultStatement = choiceStatement.getDefault().get();
- assertEquals("case-two", defaultStatement.getValue());
+ assertEquals("case-two", defaultStatement.argument());
assertTrue(choiceStatement.getConfig().isPresent());
assertTrue(choiceStatement.getMandatory().isPresent());
assertNotNull(caseStatements);
assertEquals(3, caseStatements.size());
final CaseStatement caseStatement = caseStatements.iterator().next();
- final QName caseStatementName = caseStatement.getName();
+ final QName caseStatementName = caseStatement.argument();
assertNotNull(caseStatementName);
final WhenStatement caseStatementWhen = caseStatement.getWhenStatement().get();
final Collection<? extends IfFeatureStatement> caseStatementIfFeatures = caseStatement.getIfFeatures();
final AugmentationSchemaNode augmentationSchema = augmentationSchemas.iterator().next();
final AugmentStatement augmentStatement = ((AugmentEffectiveStatement) augmentationSchema).getDeclared();
- final SchemaNodeIdentifier targetNode = augmentStatement.getTargetNode();
+ final SchemaNodeIdentifier targetNode = augmentStatement.argument();
assertNotNull(targetNode);
final Collection<? extends DataDefinitionStatement> augmentStatementDataDefinitions =
assertNotNull(testModule);
final ModuleStatement moduleStatement = ((ModuleEffectiveStatement) testModule).getDeclared();
-
- final String moduleStatementName = moduleStatement.getName();
- assertNotNull(moduleStatementName);
+ assertNotNull(moduleStatement.argument());
final YangVersionStatement moduleStatementYangVersion = moduleStatement.getYangVersion();
assertNotNull(moduleStatementYangVersion);
- assertNotNull(moduleStatementYangVersion.getValue());
+ assertNotNull(moduleStatementYangVersion.argument());
final NamespaceStatement moduleStatementNamspace = moduleStatement.getNamespace();
assertNotNull(moduleStatementNamspace);
- assertNotNull(moduleStatementNamspace.getUri());
+ assertNotNull(moduleStatementNamspace.argument());
final PrefixStatement moduleStatementPrefix = moduleStatement.getPrefix();
assertNotNull(moduleStatementPrefix);
- assertNotNull(moduleStatementPrefix.getValue());
+ assertNotNull(moduleStatementPrefix.argument());
assertEquals(1, moduleStatement.getIncludes().size());
final IncludeStatement includeStatement = moduleStatement.getIncludes().iterator().next();
- assertEquals("child-module-declared-test", includeStatement.getModule());
+ assertEquals("child-module-declared-test", includeStatement.argument());
final Collection<? extends Submodule> submodules = testModule.getSubmodules();
assertNotNull(submodules);
final Submodule submodule = submodules.iterator().next();
final SubmoduleStatement submoduleStatement = ((SubmoduleEffectiveStatement) submodule).getDeclared();
- final String submoduleStatementName = submoduleStatement.getName();
- assertNotNull(submoduleStatementName);
+ assertNotNull(submoduleStatement.argument());
final YangVersionStatement submoduleStatementYangVersion = submoduleStatement.getYangVersion();
assertNotNull(submoduleStatementYangVersion);
final BelongsToStatement belongsToStatement = submoduleStatement.getBelongsTo();
assertNotNull(belongsToStatement);
- assertNotNull(belongsToStatement.getModule());
+ assertNotNull(belongsToStatement.argument());
assertNotNull(belongsToStatement.getPrefix());
}
assertEquals(1, moduleStatement.getImports().size());
final ImportStatement importStatement = moduleStatement.getImports().iterator().next();
- assertEquals("imported-module-declared-test", importStatement.getModule());
- assertEquals("imdt", importStatement.getPrefix().getValue());
- assertEquals(revision, importStatement.getRevisionDate().getDate());
+ assertEquals("imported-module-declared-test", importStatement.argument());
+ assertEquals("imdt", importStatement.getPrefix().argument());
+ assertEquals(revision, importStatement.getRevisionDate().argument());
- assertEquals("test description", moduleStatement.getDescription().get().getText());
- assertEquals("test reference", moduleStatement.getReference().get().getText());
- assertEquals("test organization", moduleStatement.getOrganization().get().getText());
- assertEquals("test contact", moduleStatement.getContact().get().getText());
+ assertEquals("test description", moduleStatement.getDescription().get().argument());
+ assertEquals("test reference", moduleStatement.getReference().get().argument());
+ assertEquals("test organization", moduleStatement.getOrganization().get().argument());
+ assertEquals("test contact", moduleStatement.getContact().get().argument());
assertEquals(1, moduleStatement.getRevisions().size());
final RevisionStatement revisionStatement = moduleStatement.getRevisions().iterator().next();
- assertEquals(revision, revisionStatement.getDate());
- assertEquals("test description", revisionStatement.getDescription().get().getText());
- assertEquals("test reference", revisionStatement.getReference().get().getText());
+ assertEquals(revision, revisionStatement.argument());
+ assertEquals("test description", revisionStatement.getDescription().get().argument());
+ assertEquals("test reference", revisionStatement.getReference().get().argument());
assertEquals(1, moduleStatement.getExtensions().size());
final ExtensionStatement extensionStatement = moduleStatement.getExtensions().iterator().next();
- assertEquals(Status.CURRENT, extensionStatement.getStatus().get().getValue());
- assertEquals("test description", extensionStatement.getDescription().get().getText());
- assertEquals("test reference", extensionStatement.getReference().get().getText());
+ assertEquals(Status.CURRENT, extensionStatement.getStatus().get().argument());
+ assertEquals("test description", extensionStatement.getDescription().get().argument());
+ assertEquals("test reference", extensionStatement.getReference().get().argument());
final ArgumentStatement argumentStatement = extensionStatement.getArgument();
- assertEquals("ext-argument", argumentStatement.getName().getLocalName());
- assertTrue(argumentStatement.getYinElement().getValue());
+ assertEquals("ext-argument", argumentStatement.argument().getLocalName());
+ assertTrue(argumentStatement.getYinElement().argument());
assertEquals(2, moduleStatement.getFeatures().size());
final FeatureStatement featureStatement = moduleStatement.getFeatures().iterator().next();
- assertEquals(Status.CURRENT, featureStatement.getStatus().get().getValue());
- assertEquals("test description", featureStatement.getDescription().get().getText());
- assertEquals("test reference", featureStatement.getReference().get().getText());
- assertEquals("test-feature", featureStatement.getName().getLocalName());
+ assertEquals(Status.CURRENT, featureStatement.getStatus().get().argument());
+ assertEquals("test description", featureStatement.getDescription().get().argument());
+ assertEquals("test reference", featureStatement.getReference().get().argument());
+ assertEquals("test-feature", featureStatement.argument().getLocalName());
assertEquals(1, featureStatement.getIfFeatures().size());
assertEquals(2, moduleStatement.getIdentities().size());
IdentityStatement identityStatement = null;
for (final IdentityStatement identity : moduleStatement.getIdentities()) {
- if (identity.getName().getLocalName().equals("test-id")) {
+ if (identity.argument().getLocalName().equals("test-id")) {
identityStatement = identity;
}
}
- assertEquals("test-base-id", identityStatement.getBases().iterator().next().getName().getLocalName());
- assertEquals(Status.CURRENT, identityStatement.getStatus().get().getValue());
- assertEquals("test description", identityStatement.getDescription().get().getText());
- assertEquals("test reference", identityStatement.getReference().get().getText());
- assertEquals("test-id", identityStatement.getName().getLocalName());
+ assertEquals("test-base-id", identityStatement.getBases().iterator().next().argument().getLocalName());
+ assertEquals(Status.CURRENT, identityStatement.getStatus().get().argument());
+ assertEquals("test description", identityStatement.getDescription().get().argument());
+ assertEquals("test reference", identityStatement.getReference().get().argument());
+ assertEquals("test-id", identityStatement.argument().getLocalName());
assertEquals(1, moduleStatement.getTypedefs().size());
final TypedefStatement typedefStatement = moduleStatement.getTypedefs().iterator().next();
- assertEquals(Status.CURRENT, typedefStatement.getStatus().get().getValue());
- assertEquals("test description", typedefStatement.getDescription().get().getText());
- assertEquals("test reference", typedefStatement.getReference().get().getText());
- assertEquals("test-typedef", typedefStatement.getName().getLocalName());
- assertEquals("int32", typedefStatement.getType().getName());
- assertEquals("meter", typedefStatement.getUnits().get().getName());
+ assertEquals(Status.CURRENT, typedefStatement.getStatus().get().argument());
+ assertEquals("test description", typedefStatement.getDescription().get().argument());
+ assertEquals("test reference", typedefStatement.getReference().get().argument());
+ assertEquals("test-typedef", typedefStatement.argument().getLocalName());
+ assertEquals("int32", typedefStatement.getType().argument());
+ assertEquals("meter", typedefStatement.getUnits().get().argument());
}
@Test
final ContainerStatement containerStatement =
((ContainerEffectiveStatement) containerSchemaNode).getDeclared();
- final QName name = containerStatement.getName();
+ final QName name = containerStatement.argument();
assertNotNull(name);
final WhenStatement containerStatementWhen = containerStatement.getWhenStatement().get();
final PresenceStatement containerStatementPresence = containerStatement.getPresence();
assertNotNull(containerStatementPresence);
- assertNotNull(containerStatementPresence.getValue());
+ assertNotNull(containerStatementPresence.argument());
assertTrue(containerStatement.getConfig().isPresent());
assertTrue(containerStatement.getStatus().isPresent());
package org.opendaylight.yangtools.yang.parser.spi.meta;
import com.google.common.annotations.Beta;
+import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
@Beta
-public abstract class AbstractVoidStatementSupport<D extends DeclaredStatement<Void>,
- E extends EffectiveStatement<Void, D>> extends AbstractStatementSupport<Void, D, E> {
- protected AbstractVoidStatementSupport(final StatementDefinition publicDefinition,
- final StatementPolicy<Void, D> policy) {
+public abstract class AbstractEmptyStatementSupport<D extends DeclaredStatement<Empty>,
+ E extends EffectiveStatement<Empty, D>> extends AbstractStatementSupport<Empty, D, E> {
+ protected AbstractEmptyStatementSupport(final StatementDefinition publicDefinition,
+ final StatementPolicy<Empty, D> policy) {
super(publicDefinition, policy);
}
@Override
- public final Void parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return null;
+ public final Empty parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ InferenceException.throwIf(value != null, ctx, "Unexpected argument value %s", value);
+ return Empty.getInstance();
}
}
Code Review / yangtools.git / commitdiff