Migrate case statement

Optimize declared/effective implementations to save memory and
share more codepaths. As a side-effect of this refactor,
implicitly-created case statements accurately do not retain
declared instances.

JIRA: YANGTOOLS-1065
Change-Id: Iaf4a7171c006d4f3818c1f5a021ceb0c35ea0366
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>

diff --git a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/CaseEffectiveStatement.java b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/CaseEffectiveStatement.java
index 1f9a675d3e26db5955e951b4a75dd2c8fe75c11c..0fd818834b1f52376d2ae391ece2d1c2d0f2f9d1 100644 (file)
--- a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/CaseEffectiveStatement.java
+++ b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/CaseEffectiveStatement.java
@@ -9,9 +9,14 @@ package org.opendaylight.yangtools.yang.model.api.stmt;
 
 import com.google.common.annotations.Beta;
 import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
 
 @Beta
 public interface CaseEffectiveStatement extends SchemaTreeEffectiveStatement<CaseStatement>,
-    SchemaTreeAwareEffectiveStatement<QName, CaseStatement> {
-
+        SchemaTreeAwareEffectiveStatement<QName, CaseStatement> {
+    @Override
+    default StatementDefinition statementDefinition() {
+        return YangStmtMapping.CASE;
+    }
 }

diff --git a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/CaseStatement.java b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/CaseStatement.java
index a520928765599db046f6422eac4d48d7b20317c9..389b9c71f03cb4bd306675180b5399279578a7b5 100644 (file)
--- a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/CaseStatement.java
+++ b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/CaseStatement.java
@@ -11,9 +11,16 @@ 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;
 
 public interface CaseStatement extends DocumentedDeclaredStatement.WithStatus<QName>,
         DataDefinitionAwareDeclaredStatement<QName>, WhenStatementAwareDeclaredStatement<QName> {
+    @Override
+    default StatementDefinition statementDefinition() {
+        return YangStmtMapping.CASE;
+    }
+
     default @NonNull QName getName() {
         // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here
         return verifyNotNull(argument());

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractDeclaredEffectiveStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractDeclaredEffectiveStatement.java
index c11092bf592a54ecaf342d45cac891378527d1df..02f12e609bf20cdeb2805b6d04100f265e2ee84c 100644 (file)
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractDeclaredEffectiveStatement.java
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractDeclaredEffectiveStatement.java
@@ -176,6 +176,22 @@ public abstract class AbstractDeclaredEffectiveStatement<A, D extends DeclaredSt
      */
     public abstract static class DefaultWithSchemaTree<A, D extends DeclaredStatement<A>,
             E extends SchemaTreeAwareEffectiveStatement<A, D>> extends WithSchemaTree<A, D, E> {
+        public abstract static class WithSubstatements<A, D extends DeclaredStatement<A>,
+                E extends SchemaTreeAwareEffectiveStatement<A, D>> extends DefaultWithSchemaTree<A, D, E> {
+            private final @NonNull Object substatements;
+
+            protected WithSubstatements(final D declared, final StmtContext<?, ?, ?> ctx,
+                    final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+                super(declared, ctx, substatements);
+                this.substatements = maskList(substatements);
+            }
+
+            @Override
+            public final ImmutableList<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
+                return unmaskList(substatements);
+            }
+        }
+
         private final @NonNull ImmutableMap<QName, SchemaTreeEffectiveStatement<?>> schemaTree;
         private final @NonNull D declared;
 

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractEffectiveSimpleDataNodeContainer.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractEffectiveSimpleDataNodeContainer.java
index a5fafd4976704abee61a4060279a28fc1bcb5908..4a8b5e1be0f6b4f7fdda5216cb62b19e9e47699c 100644 (file)
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractEffectiveSimpleDataNodeContainer.java
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractEffectiveSimpleDataNodeContainer.java
@@ -26,6 +26,7 @@ import org.opendaylight.yangtools.yang.parser.spi.meta.CopyHistory;
 import org.opendaylight.yangtools.yang.parser.spi.meta.CopyType;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
 
+@Deprecated(forRemoval = true)
 public abstract class AbstractEffectiveSimpleDataNodeContainer<D extends DeclaredStatement<QName>> extends
         AbstractEffectiveDocumentedDataNodeContainer<QName, D> implements AugmentationTarget, DataSchemaNode {
 

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractUndeclaredEffectiveStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractUndeclaredEffectiveStatement.java
index e09c3714e4ff5ecc3effa89b84fb335400d44094..cf2c2bd52c7a5ce52e5d1937feee67e4840eacd0 100644 (file)
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractUndeclaredEffectiveStatement.java
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractUndeclaredEffectiveStatement.java
@@ -108,9 +108,25 @@ public abstract class AbstractUndeclaredEffectiveStatement<A, D extends Declared
      */
     public abstract static class DefaultWithSchemaTree<A, D extends DeclaredStatement<A>,
             E extends SchemaTreeAwareEffectiveStatement<A, D>> extends WithSchemaTree<A, D, E> {
+        public abstract static class WithSubstatements<A, D extends DeclaredStatement<A>,
+                E extends SchemaTreeAwareEffectiveStatement<A, D>> extends DefaultWithSchemaTree<A, D, E> {
+            private final @NonNull Object substatements;
+
+            protected WithSubstatements(final StmtContext<?, ?, ?> ctx,
+                    final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+                super(ctx, substatements);
+                this.substatements = maskList(substatements);
+            }
+
+            @Override
+            public final ImmutableList<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
+                return unmaskList(substatements);
+            }
+        }
+
         private final @NonNull ImmutableMap<QName, SchemaTreeEffectiveStatement<?>> schemaTree;
 
-        protected DefaultWithSchemaTree(final D declared, final StmtContext<?, ?, ?> ctx,
+        protected DefaultWithSchemaTree(final StmtContext<?, ?, ?> ctx,
                 final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
             this.schemaTree = ImmutableMap.copyOf(AbstractSchemaEffectiveDocumentedNode.createSchemaTreeNamespace(
                 ctx.getStatementSourceReference(), substatements));

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/BaseImplicitStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/BaseImplicitStatementSupport.java
new file mode 100644 (file)
index 0000000..44d4ac8
--- /dev/null
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/BaseImplicitStatementSupport.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others.  All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt;
+
+import com.google.common.annotations.Beta;
+import com.google.common.collect.ImmutableList;
+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.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
+import org.opendaylight.yangtools.yang.model.api.meta.StatementSource;
+import org.opendaylight.yangtools.yang.parser.rfc7950.namespace.ChildSchemaNodeNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
+
+/**
+ * A massively-misnamed superclass for statements which are both schema tree participants and can be created as implicit
+ * nodes. This covers {@code case}, {@code input} and {@code output} statements.
+ *
+ * @param <D> Declared Statement representation
+ * @param <E> Effective Statement representation
+ */
+@Beta
+public abstract class BaseImplicitStatementSupport<D extends DeclaredStatement<QName>,
+        E extends EffectiveStatement<QName, D>> extends BaseQNameStatementSupport<D, E> {
+    protected BaseImplicitStatementSupport(final StatementDefinition publicDefinition) {
+        super(publicDefinition);
+    }
+
+    @Override
+    public final void onStatementAdded(final Mutable<QName, D, E> stmt) {
+        stmt.coerceParentContext().addToNs(ChildSchemaNodeNamespace.class, stmt.coerceStatementArgument(), stmt);
+    }
+
+    @Override
+    protected final E createEffective(
+            final StmtContext<QName, D, E> ctx,
+            final D declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+        final StatementSource source = ctx.getStatementSource();
+        switch (ctx.getStatementSource()) {
+            case CONTEXT:
+                return createUndeclaredEffective(ctx, substatements);
+            case DECLARATION:
+                return createDeclaredEffective(ctx, substatements, declared);
+            default:
+                throw new IllegalStateException("Unhandled statement source " + source);
+        }
+    }
+
+    @Override
+    protected final E createEmptyEffective(final StmtContext<QName, D, E> ctx, final D declared) {
+        return createEffective(ctx, declared, ImmutableList.of());
+    }
+
+    protected abstract @NonNull E createDeclaredEffective(@NonNull StmtContext<QName, D, E> ctx,
+            @NonNull ImmutableList<? extends EffectiveStatement<?, ?>> substatements, @NonNull D declared);
+
+    protected abstract @NonNull E createUndeclaredEffective(@NonNull StmtContext<QName, D, E> ctx,
+            @NonNull ImmutableList<? extends EffectiveStatement<?, ?>> substatements);
+
+}

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/BaseOperationContainerStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/BaseOperationContainerStatementSupport.java
index 63bf9c1449c20c61d6f158e5ed6ae2a1baaeee51..afe52b893548cc02fd5ee2b2b3fe02ed734c2726 100644 (file)
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/BaseOperationContainerStatementSupport.java
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/BaseOperationContainerStatementSupport.java
@@ -15,12 +15,9 @@ import org.opendaylight.yangtools.yang.model.api.Status;
 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;
-import org.opendaylight.yangtools.yang.model.api.meta.StatementSource;
 import org.opendaylight.yangtools.yang.model.api.stmt.StatusEffectiveStatement;
-import org.opendaylight.yangtools.yang.parser.rfc7950.namespace.ChildSchemaNodeNamespace;
 import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.EffectiveStatementWithFlags.FlagsBuilder;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
 
 /**
  * Specialization of {@link BaseQNameStatementSupport} for {@code input} and {@code output} statements.
@@ -30,40 +27,26 @@ import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
  */
 @Beta
 public abstract class BaseOperationContainerStatementSupport<D extends DeclaredStatement<QName>,
-        E extends EffectiveStatement<QName, D>> extends BaseQNameStatementSupport<D, E> {
+        E extends EffectiveStatement<QName, D>> extends BaseImplicitStatementSupport<D, E> {
     protected BaseOperationContainerStatementSupport(final StatementDefinition publicDefinition) {
         super(publicDefinition);
     }
 
     @Override
-    public final void onStatementAdded(final Mutable<QName, D, E> stmt) {
-        stmt.coerceParentContext().addToNs(ChildSchemaNodeNamespace.class, stmt.coerceStatementArgument(), stmt);
+    protected final @NonNull E createDeclaredEffective(final StmtContext<QName, D, E> ctx,
+            final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final D declared) {
+        return createDeclaredEffective(computeFlags(ctx, substatements), ctx, substatements, declared);
     }
 
-    @Override
-    protected final E createEffective(
-            final StmtContext<QName, D, E> ctx,
-            final D declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
-        final StatementSource source = ctx.getStatementSource();
-        final int flags = computeFlags(ctx, substatements);
-        switch (source) {
-            case CONTEXT:
-                return createUndeclaredEffective(flags, ctx, substatements);
-            case DECLARATION:
-                return createDeclaredEffective(flags, ctx, substatements, declared);
-            default:
-                throw new IllegalStateException("Unhandled statement source " + source);
-        }
-    }
+    protected abstract @NonNull E createDeclaredEffective(int flags, @NonNull StmtContext<QName, D, E> ctx,
+            @NonNull ImmutableList<? extends EffectiveStatement<?, ?>> substatements, @NonNull D declared);
 
     @Override
-    protected final E createEmptyEffective(final StmtContext<QName, D, E> ctx, final D declared) {
-        return createEffective(ctx, declared, ImmutableList.of());
+    protected final E createUndeclaredEffective(final StmtContext<QName, D, E> ctx,
+            final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+        return createUndeclaredEffective(computeFlags(ctx, substatements), ctx, substatements);
     }
 
-    protected abstract @NonNull E createDeclaredEffective(int flags, @NonNull StmtContext<QName, D, E> ctx,
-            @NonNull ImmutableList<? extends EffectiveStatement<?, ?>> substatements, @NonNull D declared);
-
     protected abstract @NonNull E createUndeclaredEffective(int flags, @NonNull StmtContext<QName, D, E> ctx,
             @NonNull ImmutableList<? extends EffectiveStatement<?, ?>> substatements);
 

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/case_/AbstractCaseStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/case_/AbstractCaseStatementSupport.java
index 8853092be24dfb632336a5dc6f52dfe166a07ccb..6b5881e9b3505a8dba99bd2031f7d4ed022eef59 100644 (file)
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/case_/AbstractCaseStatementSupport.java
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/case_/AbstractCaseStatementSupport.java
@@ -7,18 +7,25 @@
  */
 package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.case_;
 
+import com.google.common.collect.ImmutableList;
+import org.eclipse.jdt.annotation.Nullable;
 import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
+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;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.meta.StatementSource;
 import org.opendaylight.yangtools.yang.model.api.stmt.CaseEffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.CaseStatement;
-import org.opendaylight.yangtools.yang.parser.rfc7950.namespace.ChildSchemaNodeNamespace;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
+import org.opendaylight.yangtools.yang.model.api.stmt.StatusEffectiveStatement;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseImplicitStatementSupport;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.EffectiveStatementWithFlags.FlagsBuilder;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
 
 abstract class AbstractCaseStatementSupport
-        extends AbstractQNameStatementSupport<CaseStatement, CaseEffectiveStatement> {
+        extends BaseImplicitStatementSupport<CaseStatement, CaseEffectiveStatement> {
     AbstractCaseStatementSupport() {
         super(YangStmtMapping.CASE);
     }
@@ -29,18 +36,59 @@ abstract class AbstractCaseStatementSupport
     }
 
     @Override
-    public final void onStatementAdded(final Mutable<QName, CaseStatement, CaseEffectiveStatement> stmt) {
-        stmt.coerceParentContext().addToNs(ChildSchemaNodeNamespace.class, stmt.coerceStatementArgument(), stmt);
+    protected final CaseStatement createDeclared(final StmtContext<QName, CaseStatement, ?> ctx,
+            final ImmutableList<? extends DeclaredStatement<?>> substatements) {
+        final StatementSource source = ctx.getStatementSource();
+        switch (ctx.getStatementSource()) {
+            case CONTEXT:
+                return new RegularUndeclaredCaseStatement(ctx.coerceStatementArgument(), substatements);
+            case DECLARATION:
+                return new RegularCaseStatement(ctx.coerceStatementArgument(), substatements);
+            default:
+                throw new IllegalStateException("Unhandled statement source " + source);
+        }
     }
 
     @Override
-    public final CaseStatement createDeclared(final StmtContext<QName, CaseStatement, ?> ctx) {
-        return new CaseStatementImpl(ctx);
+    protected final CaseStatement createEmptyDeclared(final StmtContext<QName, CaseStatement, ?> ctx) {
+        final StatementSource source = ctx.getStatementSource();
+        switch (ctx.getStatementSource()) {
+            case CONTEXT:
+                return new EmptyUndeclaredCaseStatement(ctx.coerceStatementArgument());
+            case DECLARATION:
+                return new EmptyCaseStatement(ctx.coerceStatementArgument());
+            default:
+                throw new IllegalStateException("Unhandled statement source " + source);
+        }
     }
 
     @Override
-    public final CaseEffectiveStatement createEffective(
-            final StmtContext<QName, CaseStatement, CaseEffectiveStatement> ctx) {
-        return new CaseEffectiveStatementImpl(ctx);
+    protected final CaseEffectiveStatement createDeclaredEffective(
+            final StmtContext<QName, CaseStatement, CaseEffectiveStatement> ctx,
+            final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final CaseStatement declared) {
+        return new DeclaredCaseEffectiveStatement(declared, ctx, substatements, computeFlags(ctx, substatements),
+            findOriginal(ctx));
+    }
+
+    @Override
+    protected final CaseEffectiveStatement createUndeclaredEffective(
+            final StmtContext<QName, CaseStatement, CaseEffectiveStatement> ctx,
+            final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+        return new UndeclaredCaseEffectiveStatement(ctx, substatements, computeFlags(ctx, substatements),
+            findOriginal(ctx));
+    }
+
+    private static @Nullable CaseSchemaNode findOriginal(final StmtContext<?, ?, ?> ctx) {
+        return (CaseSchemaNode) ctx.getOriginalCtx().map(StmtContext::buildEffective).orElse(null);
+    }
+
+    private static int computeFlags(final StmtContext<?, ?, ?> ctx,
+            final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+        return new FlagsBuilder()
+                .setHistory(ctx.getCopyHistory())
+                .setStatus(findFirstArgument(substatements, StatusEffectiveStatement.class, Status.CURRENT))
+                .setConfiguration(ctx.isConfiguration()
+                    && ctx.allSubstatementsStream().anyMatch(StmtContext::isConfiguration))
+                .toFlags();
     }
 }
\ No newline at end of file

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/case_/CaseEffectiveStatementImpl.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/case_/CaseEffectiveStatementImpl.java
deleted file mode 100644 (file)
index 175a6d6..0000000
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/case_/CaseEffectiveStatementImpl.java
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others.  All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.case_;
-
-import java.util.Optional;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.DerivableSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.stmt.CaseEffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.CaseStatement;
-import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractEffectiveSimpleDataNodeContainer;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-
-final class CaseEffectiveStatementImpl extends AbstractEffectiveSimpleDataNodeContainer<CaseStatement>
-        implements CaseEffectiveStatement, CaseSchemaNode, DerivableSchemaNode {
-
-    private final CaseSchemaNode original;
-    private final boolean configuration;
-
-    CaseEffectiveStatementImpl(final StmtContext<QName, CaseStatement, CaseEffectiveStatement> ctx) {
-        super(ctx);
-        this.original = (CaseSchemaNode) ctx.getOriginalCtx().map(StmtContext::buildEffective).orElse(null);
-
-        if (ctx.isConfiguration()) {
-            configuration = ctx.allSubstatementsStream().anyMatch(StmtContext::isConfiguration);
-        } else {
-            configuration = false;
-        }
-    }
-
-    @Override
-    public Optional<CaseSchemaNode> getOriginal() {
-        return Optional.ofNullable(original);
-    }
-
-    @Override
-    public boolean isConfiguration() {
-        return configuration;
-    }
-
-    @Override
-    public String toString() {
-        return CaseEffectiveStatementImpl.class.getSimpleName() + "[" + "qname=" + getQName() + "]";
-    }
-}

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/case_/CaseEffectiveStatementMixin.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/case_/CaseEffectiveStatementMixin.java
new file mode 100644 (file)
index 0000000..46df556
--- /dev/null
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/case_/CaseEffectiveStatementMixin.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others.  All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.case_;
+
+import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.DerivableSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.stmt.CaseEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.CaseStatement;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.AugmentationTargetMixin;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.DataNodeContainerMixin;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.DataSchemaNodeMixin;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.DocumentedNodeMixin;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.MustConstraintMixin;
+
+interface CaseEffectiveStatementMixin extends CaseEffectiveStatement, CaseSchemaNode, DerivableSchemaNode,
+        DataSchemaNodeMixin<QName, CaseStatement>, DocumentedNodeMixin.WithStatus<QName, CaseStatement>,
+        DataNodeContainerMixin<QName, CaseStatement>, MustConstraintMixin<QName, CaseStatement>,
+        AugmentationTargetMixin<QName, CaseStatement> {
+
+    @Override
+    default @NonNull QName argument() {
+        return getPath().getLastComponent();
+    }
+
+    @Override
+    default @NonNull QName getQName() {
+        return argument();
+    }
+}

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/case_/DeclaredCaseEffectiveStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/case_/DeclaredCaseEffectiveStatement.java
new file mode 100644 (file)
index 0000000..078b091
--- /dev/null
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/case_/DeclaredCaseEffectiveStatement.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others.  All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.case_;
+
+import com.google.common.collect.ImmutableList;
+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.CaseSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.CaseEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.CaseStatement;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredEffectiveStatement.DefaultWithSchemaTree.WithSubstatements;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class DeclaredCaseEffectiveStatement extends WithSubstatements<QName, CaseStatement, CaseEffectiveStatement>
+        implements CaseEffectiveStatementMixin {
+    private final CaseSchemaNode original;
+    private final @NonNull SchemaPath path;
+    private final int flags;
+
+    DeclaredCaseEffectiveStatement(final CaseStatement declared,
+            final StmtContext<QName, CaseStatement, CaseEffectiveStatement> ctx,
+            final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final int flags,
+            final @Nullable CaseSchemaNode original) {
+        super(declared,  ctx, substatements);
+        this.flags = flags;
+        this.path = ctx.getSchemaPath().get();
+        this.original = original;
+    }
+
+    @Override
+    public int flags() {
+        return flags;
+    }
+
+    @Override
+    public SchemaPath getPath() {
+        return path;
+    }
+
+    @Override
+    public Optional<CaseSchemaNode> getOriginal() {
+        return Optional.ofNullable(original);
+    }
+
+    @Override
+    public Optional<DataSchemaNode> findDataChildByName(final QName name) {
+        return findDataSchemaNode(name);
+    }
+
+    @Override
+    public String toString() {
+        return DeclaredCaseEffectiveStatement.class.getSimpleName() + "[" + "qname=" + getQName() + "]";
+    }
+}

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/case_/CaseStatementImpl.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/case_/EmptyCaseStatement.java
similarity index 59%
rename from yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/case_/CaseStatementImpl.java
rename to yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/case_/EmptyCaseStatement.java
index 863ca708f5b43aa389c19a8d660290cbc1e30ea7..0b47d04e1af5e1eab1805c8d9d6c4c79ae580350 100644 (file)
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/case_/CaseStatementImpl.java
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/case_/EmptyCaseStatement.java
@@ -9,11 +9,10 @@ package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.case_;
 
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.model.api.stmt.CaseStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredStatement.WithQNameArgument;
 
-final class CaseStatementImpl extends AbstractDeclaredStatement<QName> implements CaseStatement {
-    CaseStatementImpl(final StmtContext<QName, CaseStatement, ?> context) {
-        super(context);
+class EmptyCaseStatement extends WithQNameArgument implements CaseStatement {
+    EmptyCaseStatement(final QName argument) {
+        super(argument);
     }
 }

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/case_/EmptyUndeclaredCaseStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/case_/EmptyUndeclaredCaseStatement.java
new file mode 100644 (file)
index 0000000..2749945
--- /dev/null
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/case_/EmptyUndeclaredCaseStatement.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others.  All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.case_;
+
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.meta.StatementSource;
+
+final class EmptyUndeclaredCaseStatement extends EmptyCaseStatement {
+    EmptyUndeclaredCaseStatement(final QName argument) {
+        super(argument);
+    }
+
+    @Override
+    public StatementSource getStatementSource() {
+        return StatementSource.CONTEXT;
+    }
+}

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/case_/RegularCaseStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/case_/RegularCaseStatement.java
new file mode 100644 (file)
index 0000000..3f557de
--- /dev/null
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/case_/RegularCaseStatement.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others.  All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.case_;
+
+import com.google.common.collect.ImmutableList;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.CaseStatement;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredStatement.WithQNameArgument.WithSubstatements;
+
+class RegularCaseStatement extends WithSubstatements implements CaseStatement {
+    RegularCaseStatement(final QName argument, final ImmutableList<? extends DeclaredStatement<?>> substatements) {
+        super(argument, substatements);
+    }
+}

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/case_/RegularUndeclaredCaseStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/case_/RegularUndeclaredCaseStatement.java
new file mode 100644 (file)
index 0000000..2e7bace
--- /dev/null
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/case_/RegularUndeclaredCaseStatement.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others.  All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.case_;
+
+import com.google.common.collect.ImmutableList;
+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;
+
+final class RegularUndeclaredCaseStatement extends RegularCaseStatement {
+    RegularUndeclaredCaseStatement(final QName argument,
+            final ImmutableList<? extends DeclaredStatement<?>> substatements) {
+        super(argument, substatements);
+    }
+
+    @Override
+    public StatementSource getStatementSource() {
+        return StatementSource.CONTEXT;
+    }
+}

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/case_/UndeclaredCaseEffectiveStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/case_/UndeclaredCaseEffectiveStatement.java
new file mode 100644 (file)
index 0000000..f95ba71
--- /dev/null
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/case_/UndeclaredCaseEffectiveStatement.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others.  All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.case_;
+
+import com.google.common.collect.ImmutableList;
+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.CaseSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.CaseEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.CaseStatement;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractUndeclaredEffectiveStatement.DefaultWithSchemaTree.WithSubstatements;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class UndeclaredCaseEffectiveStatement extends WithSubstatements<QName, CaseStatement, CaseEffectiveStatement>
+        implements CaseEffectiveStatementMixin {
+    private final CaseSchemaNode original;
+    private final @NonNull SchemaPath path;
+    private final int flags;
+
+    UndeclaredCaseEffectiveStatement(final StmtContext<QName, CaseStatement, CaseEffectiveStatement> ctx,
+            final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final int flags,
+            final @Nullable CaseSchemaNode original) {
+        super(ctx, substatements);
+        this.flags = flags;
+        this.path = ctx.getSchemaPath().get();
+        this.original = original;
+    }
+
+    @Override
+    public int flags() {
+        return flags;
+    }
+
+    @Override
+    public SchemaPath getPath() {
+        return path;
+    }
+
+    @Override
+    public Optional<CaseSchemaNode> getOriginal() {
+        return Optional.ofNullable(original);
+    }
+
+    @Override
+    public Optional<DataSchemaNode> findDataChildByName(final QName name) {
+        return findDataSchemaNode(name);
+    }
+
+    @Override
+    public String toString() {
+        return UndeclaredCaseEffectiveStatement.class.getSimpleName() + "[" + "qname=" + getQName() + "]";
+    }
+}