*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt;
+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.QName;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementSource;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
/**
* An abstract base class for {@link DeclaredStatement} implementations. This is a direct competition to
* implementations.
*/
@Beta
-public abstract class AbstractDeclaredStatement<A> implements DeclaredStatement<A> {
+// FIXME: 7.0.0: we should be able to promote this to model.spi.meta package.
+public abstract class AbstractDeclaredStatement<A> extends AbstractModelStatement<A> implements DeclaredStatement<A> {
protected AbstractDeclaredStatement() {
}
@Override
- public final StatementSource getStatementSource() {
+ public StatementSource getStatementSource() {
return StatementSource.DECLARATION;
}
}
/**
- * Utility method for squashing singleton lists into single objects. This is a CPU/mem trade-off, which we are
- * usually willing to make: for the cost of an instanceof check we can save one object and re-create it when needed.
- * The inverse operation is #unmaskSubstatements(Object)}.
- *
- * @param substatements substatements to mask
- * @return Masked substatements
- * @throws NullPointerException if substatements is null
- */
- protected static final @NonNull Object maskSubstatements(
- final ImmutableList<? extends DeclaredStatement<?>> substatements) {
- // Note: ImmutableList guarantees non-null content
- return substatements.size() == 1 ? substatements.get(0) : substatements;
- }
-
- /**
- * Utility method for recovering singleton lists squashed by {@link #maskSubstatements(ImmutableList)}.
+ * Utility method for recovering singleton lists squashed by {@link #maskList(ImmutableList)}.
*
- * @param masked substatements to unmask
- * @return List of substatements
+ * @param masked list to unmask
+ * @return Unmasked list
* @throws NullPointerException if masked is null
- * @throws ClassCastException if masked object was not produced by {@link #maskSubstatements(ImmutableList)}
+ * @throws ClassCastException if masked object does not match DeclaredStatement
*/
- @SuppressWarnings("unchecked")
- protected static final @NonNull ImmutableList<? extends DeclaredStatement<?>> unmaskSubstatements(
+ @SuppressWarnings({ "rawtypes", "unchecked" })
+ protected static final @NonNull ImmutableList<? extends DeclaredStatement<?>> unmaskList(
final @NonNull Object masked) {
- return masked instanceof ImmutableList ? (ImmutableList<? extends DeclaredStatement<?>>) masked
- // Yes, this is ugly code, which could use an explicit verify, that would just change the what sort
- // of exception we throw. ClassCastException is as good as VerifyException.
- : ImmutableList.of((DeclaredStatement<?>) masked);
+ return (ImmutableList) unmaskList(masked, DeclaredStatement.class);
}
public abstract static class WithRawArgument<A> extends AbstractDeclaredStatement<A> {
private final String rawArgument;
- protected WithRawArgument(final StmtContext<A, ?, ?> context) {
- rawArgument = context.rawStatementArgument();
+ protected WithRawArgument(final String rawArgument) {
+ this.rawArgument = rawArgument;
}
@Override
}
}
+ public abstract static class WithQNameArgument extends AbstractDeclaredStatement<QName> {
+ public abstract static class WithSubstatements extends WithQNameArgument {
+ private final @NonNull Object substatements;
+
+ protected WithSubstatements(final QName argument,
+ final ImmutableList<? extends DeclaredStatement<?>> substatements) {
+ super(argument);
+ this.substatements = maskList(substatements);
+ }
+
+ @Override
+ public final Collection<? extends DeclaredStatement<?>> declaredSubstatements() {
+ return unmaskList(substatements);
+ }
+ }
+
+ private final @NonNull QName argument;
+
+ protected WithQNameArgument(final QName argument) {
+ this.argument = requireNonNull(argument);
+ }
+
+ @Override
+ public final @NonNull QName argument() {
+ return argument;
+ }
+
+ @Override
+ public final String rawArgument() {
+ return argument.getLocalName();
+ }
+ }
+
public abstract static class WithRawStringArgument extends WithRawArgument<String> {
- protected WithRawStringArgument(final StmtContext<String, ?, ?> context) {
- super(context);
+ public abstract static class WithSubstatements extends WithRawStringArgument {
+ 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);
+ }
+ }
+
+ protected WithRawStringArgument(final String rawArgument) {
+ super(rawArgument);
}
@Override
}
public abstract static class WithArgument<A> extends WithRawArgument<A> {
+ public abstract static class WithSubstatements<A> extends WithArgument<A> {
+ private final @NonNull Object substatements;
+
+ protected WithSubstatements(final String rawArgument, final A argument,
+ final ImmutableList<? extends DeclaredStatement<?>> substatements) {
+ super(rawArgument, argument);
+ this.substatements = maskList(substatements);
+ }
+
+ @Override
+ public final Collection<? extends DeclaredStatement<?>> declaredSubstatements() {
+ return unmaskList(substatements);
+ }
+ }
+
private final A argument;
- protected WithArgument(final StmtContext<A, ?, ?> context) {
- super(context);
- argument = context.getStatementArgument();
+ protected WithArgument(final String rawArgument, final A argument) {
+ super(rawArgument);
+ this.argument = argument;
}
@Override
return argument;
}
}
+
+ public abstract static class ArgumentToString<A> extends AbstractDeclaredStatement<A> {
+ public abstract static class WithSubstatements<A> extends ArgumentToString<A> {
+ private final @NonNull Object substatements;
+
+ protected WithSubstatements(final A argument,
+ final ImmutableList<? extends DeclaredStatement<?>> substatements) {
+ super(argument);
+ this.substatements = maskList(substatements);
+ }
+
+ @Override
+ public final Collection<? extends DeclaredStatement<?>> declaredSubstatements() {
+ return unmaskList(substatements);
+ }
+ }
+
+ private final @NonNull A argument;
+
+ protected ArgumentToString(final A argument) {
+ this.argument = requireNonNull(argument);
+ }
+
+ @Override
+ public final @NonNull A argument() {
+ return argument;
+ }
+
+ @Override
+ public final String rawArgument() {
+ return argument.toString();
+ }
+ }
+
+ public abstract static class WithoutArgument extends AbstractDeclaredStatement<Void> {
+ public abstract static class WithSubstatements extends WithoutArgument {
+ private final @NonNull Object substatements;
+
+ protected WithSubstatements(final ImmutableList<? extends DeclaredStatement<?>> substatements) {
+ this.substatements = maskList(substatements);
+ }
+
+ @Override
+ public final Collection<? extends DeclaredStatement<?>> declaredSubstatements() {
+ return unmaskList(substatements);
+ }
+ }
+
+ @Override
+ public final Void argument() {
+ return null;
+ }
+
+ @Override
+ public final String rawArgument() {
+ return null;
+ }
+ }
}
Code Review / yangtools.git / blobdiff