*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.ordered_by;
+import com.google.common.collect.ImmutableList;
+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;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.OrderedByEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.OrderedByStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
public final class OrderedByStatementSupport
- extends AbstractStatementSupport<String, OrderedByStatement, EffectiveStatement<String, OrderedByStatement>> {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
- YangStmtMapping.ORDERED_BY)
- .build();
+ extends BaseStatementSupport<Ordering, OrderedByStatement, OrderedByEffectiveStatement> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.ORDERED_BY).build();
private static final OrderedByStatementSupport INSTANCE = new OrderedByStatementSupport();
+ /*
+ * Ordered-by has low argument cardinality, hence we can reuse them in case declaration does not have any
+ * substatements (which is the usual case).
+ */
+ private static final @NonNull EmptyOrderedByStatement EMPTY_SYSTEM_DECL =
+ new EmptyOrderedByStatement(Ordering.SYSTEM);
+ private static final @NonNull EmptyOrderedByStatement EMPTY_USER_DECL =
+ new EmptyOrderedByStatement(Ordering.USER);
+ private static final @NonNull EmptyOrderedByEffectiveStatement EMPTY_SYSTEM_EFF =
+ new EmptyOrderedByEffectiveStatement(EMPTY_SYSTEM_DECL);
+ private static final @NonNull EmptyOrderedByEffectiveStatement EMPTY_USER_EFF =
+ new EmptyOrderedByEffectiveStatement(EMPTY_USER_DECL);
+
private OrderedByStatementSupport() {
- super(YangStmtMapping.ORDERED_BY);
+ super(YangStmtMapping.ORDERED_BY, CopyPolicy.CONTEXT_INDEPENDENT);
}
public static OrderedByStatementSupport getInstance() {
}
@Override
- public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return value;
+ public Ordering parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ try {
+ return Ordering.forArgument(value);
+ } catch (IllegalArgumentException e) {
+ throw new SourceException(ctx.sourceReference(), e, "Invalid ordered-by argument '%s'", value);
+ }
}
@Override
- public OrderedByStatement createDeclared(final StmtContext<String, OrderedByStatement, ?> ctx) {
- return new OrderedByStatementImpl(ctx);
+ public String internArgument(final String rawArgument) {
+ if ("user".equals(rawArgument)) {
+ return "user";
+ } else if ("system".equals(rawArgument)) {
+ return "system";
+ } else {
+ return rawArgument;
+ }
}
@Override
- public EffectiveStatement<String, OrderedByStatement> createEffective(
- final StmtContext<String, OrderedByStatement, EffectiveStatement<String, OrderedByStatement>> ctx) {
- return new OrderedByEffectiveStatementImpl(ctx);
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
}
@Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
+ protected OrderedByStatement createDeclared(final StmtContext<Ordering, OrderedByStatement, ?> ctx,
+ final ImmutableList<? extends DeclaredStatement<?>> substatements) {
+ return new RegularOrderedByStatement(ctx.getArgument(), substatements);
}
@Override
- public String internArgument(final String rawArgument) {
- if ("user".equals(rawArgument)) {
- return "user";
- } else if ("system".equals(rawArgument)) {
- return "system";
+ protected OrderedByStatement createEmptyDeclared(final StmtContext<Ordering, OrderedByStatement, ?> ctx) {
+ final Ordering argument = ctx.getArgument();
+ switch (argument) {
+ case SYSTEM:
+ return EMPTY_SYSTEM_DECL;
+ case USER:
+ return EMPTY_USER_DECL;
+ default:
+ throw new IllegalStateException("Unhandled argument " + argument);
+ }
+ }
+
+ @Override
+ protected OrderedByEffectiveStatement createEffective(final Current<Ordering, OrderedByStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ return substatements.isEmpty() ? createEmptyEffective(stmt.declared())
+ : new RegularOrderedByEffectiveStatement(stmt.declared(), substatements);
+ }
+
+ private static @NonNull OrderedByEffectiveStatement createEmptyEffective(final OrderedByStatement declared) {
+ // Aggressively reuse effective instances which are backed by the corresponding empty declared instance, as this
+ // is the case unless there is a weird extension in use.
+ if (EMPTY_USER_DECL.equals(declared)) {
+ // Most likely to be seen (as system is the default)
+ return EMPTY_USER_EFF;
+ } else if (EMPTY_SYSTEM_DECL.equals(declared)) {
+ return EMPTY_SYSTEM_EFF;
} else {
- return rawArgument;
+ return new EmptyOrderedByEffectiveStatement(declared);
}
}
-}
\ No newline at end of file
+}