Migrate coerceStatementArgument() callers

[yangtools.git] / yang / yang-parser-rfc7950 / src / main / java / org / opendaylight / yangtools / yang / parser / rfc7950 / stmt / ordered_by / OrderedByStatementSupport.java

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/ordered_by/OrderedByStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/ordered_by/OrderedByStatementSupport.java
index 765564205e5e17cd9143f21c941c0629929bfb09..316b574293010b9796ab34d0667d5bcc83af8b16 100644 (file)
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/ordered_by/OrderedByStatementSupport.java
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/ordered_by/OrderedByStatementSupport.java
@@ -7,37 +7,65 @@
  */
 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();
 
-    public OrderedByStatementSupport() {
-        super(YangStmtMapping.ORDERED_BY);
+    /*
+     * 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, CopyPolicy.CONTEXT_INDEPENDENT);
     }
 
-    @Override
-    public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
-        return value;
+    public static OrderedByStatementSupport getInstance() {
+        return INSTANCE;
     }
 
     @Override
-    public OrderedByStatement createDeclared(final StmtContext<String, OrderedByStatement, ?> ctx) {
-        return new OrderedByStatementImpl(ctx);
+    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 EffectiveStatement<String, OrderedByStatement> createEffective(
-            final StmtContext<String, OrderedByStatement, EffectiveStatement<String, OrderedByStatement>> ctx) {
-        return new OrderedByEffectiveStatementImpl(ctx);
+    public String internArgument(final String rawArgument) {
+        if ("user".equals(rawArgument)) {
+            return "user";
+        } else if ("system".equals(rawArgument)) {
+            return "system";
+        } else {
+            return rawArgument;
+        }
     }
 
     @Override
@@ -46,13 +74,41 @@ public final class OrderedByStatementSupport
     }
 
     @Override
-    public String internArgument(final String rawArgument) {
-        if ("user".equals(rawArgument)) {
-            return "user";
-        } else if ("system".equals(rawArgument)) {
-            return "system";
+    protected OrderedByStatement createDeclared(final StmtContext<Ordering, OrderedByStatement, ?> ctx,
+            final ImmutableList<? extends DeclaredStatement<?>> substatements) {
+        return new RegularOrderedByStatement(ctx.getArgument(), substatements);
+    }
+
+    @Override
+    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
+}