Convert pattern statement

Convert the mostly trivial case of pattern statement, which can be easily
minimized.

We also terminally-deprecate AbstractConstraintEffectiveStatement,
as it is no longer needed.

JIRA: YANGTOOLS-1065
Change-Id: Ib207d3389959822635578733ef09607fe3f2373a
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/PatternEffectiveStatement.java b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/PatternEffectiveStatement.java
index 9f1c904998a12c5d0b1478572f96e64cf561b3bc..31af61d5c7d4eff7d7d9a5a8ef7cf3cd63a528a9 100644 (file)
--- a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/PatternEffectiveStatement.java
+++ b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/PatternEffectiveStatement.java
@@ -8,10 +8,15 @@
 package org.opendaylight.yangtools.yang.model.api.stmt;
 
 import com.google.common.annotations.Beta;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
 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.type.PatternConstraint;
 
 @Beta
 public interface PatternEffectiveStatement extends EffectiveStatement<PatternConstraint, PatternStatement> {
-
+    @Override
+    default StatementDefinition statementDefinition() {
+        return YangStmtMapping.PATTERN;
+    }
 }

diff --git a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/PatternStatement.java b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/PatternStatement.java
index b147685742e19c85305b3471c5d3ff2151b2438f..7ce9bd73fb2b896d506310f725db78205c1ce100 100644 (file)
--- a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/PatternStatement.java
+++ b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/PatternStatement.java
@@ -12,9 +12,16 @@ 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;
 import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
 
 public interface PatternStatement extends ConstrainedDocumentedDeclaredStatement<PatternConstraint> {
+    @Override
+    default StatementDefinition statementDefinition() {
+        return YangStmtMapping.PATTERN;
+    }
+
     default @NonNull PatternConstraint getValue() {
         // 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/AbstractConstraintEffectiveStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractConstraintEffectiveStatement.java
index 7fd7c36bffb197782d301acecabc1f95d4cbe6e0..12a3e56ee02ed85d933ff08fc6c7242667f5b3ee 100644 (file)
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractConstraintEffectiveStatement.java
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractConstraintEffectiveStatement.java
@@ -19,6 +19,8 @@ import org.opendaylight.yangtools.yang.model.api.type.ModifierKind;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
 
 @Beta
+@Deprecated(forRemoval = true)
+//FIXME: 6.0.0: remove this class
 public abstract class AbstractConstraintEffectiveStatement<A, D extends DeclaredStatement<A>> extends
         AbstractEffectiveDocumentedNode<A, D> implements ConstraintMetaDefinition {
     private final String errorAppTag;

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 8f1a7446d7299fe5822f896e734089a78b809717..d7dd37dbf4af6274a589f6d95664ea5478255695 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
@@ -209,6 +209,43 @@ public abstract class AbstractDeclaredEffectiveStatement<A, D extends DeclaredSt
         }
     }
 
+    /**
+     * A building block on top of {@link Default}, which adds an explicit argument value, which is not related to the
+     * context. This is mostly useful when the effective argument value reflects additional statements and similar.
+     *
+     * @param <A> Argument type ({@link Void} if statement does not have argument.)
+     * @param <D> Class representing declared version of this statement.
+     */
+    public abstract static class DefaultWithArgument<A, D extends DeclaredStatement<A>> extends Default<A, D> {
+        public abstract static class WithSubstatements<A, D extends DeclaredStatement<A>>
+                extends DefaultWithArgument<A, D> {
+            private final @NonNull Object substatements;
+
+            protected WithSubstatements(final D declared, final A argument,
+                    final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+                super(declared, argument);
+                this.substatements = maskList(substatements);
+            }
+
+            @Override
+            public final ImmutableList<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
+                return unmaskList(substatements);
+            }
+        }
+
+        private final A argument;
+
+        protected DefaultWithArgument(final D declared, final A argument) {
+            super(declared);
+            this.argument = argument;
+        }
+
+        @Override
+        public final A argument() {
+            return argument;
+        }
+    }
+
     /**
      * Stateful version of {@link WithSchemaTree}. Schema tree namespace is eagerly instantiated (and checked).
      *

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/AbstractPatternStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/AbstractPatternStatementSupport.java
index c86acbf641fd375382c19cc8529e7220d1776bb0..2c3b487039f99b1b0e9667f5b211330e2dbbfefd 100644 (file)
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/AbstractPatternStatementSupport.java
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/AbstractPatternStatementSupport.java
@@ -7,21 +7,29 @@
  */
 package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.pattern;
 
-import java.util.Optional;
+import com.google.common.collect.ImmutableList;
 import java.util.regex.Pattern;
 import java.util.regex.PatternSyntaxException;
 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.DescriptionEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ErrorAppTagEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ErrorMessageEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ModifierEffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.PatternEffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.PatternStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.type.ModifierKind;
 import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
 import org.opendaylight.yangtools.yang.model.util.RegexUtils;
-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.StmtContext;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 abstract class AbstractPatternStatementSupport
-        extends AbstractStatementSupport<PatternConstraint, PatternStatement, PatternEffectiveStatement> {
+        extends BaseStatementSupport<PatternConstraint, PatternStatement, PatternEffectiveStatement> {
     private static final Logger LOG = LoggerFactory.getLogger(AbstractPatternStatementSupport.class);
 
     AbstractPatternStatementSupport() {
@@ -39,17 +47,45 @@ abstract class AbstractPatternStatementSupport
             return null;
         }
 
-        return new PatternConstraintImpl(pattern, value, Optional.empty(), Optional.empty());
+        return new PatternConstraintImpl(pattern, value);
     }
 
     @Override
-    public final PatternStatement createDeclared(final StmtContext<PatternConstraint, PatternStatement, ?> ctx) {
-        return new PatternStatementImpl(ctx);
+    protected final PatternStatement createDeclared(final StmtContext<PatternConstraint, PatternStatement, ?> ctx,
+            final ImmutableList<? extends DeclaredStatement<?>> substatements) {
+        return new RegularPatternStatement(ctx, substatements);
     }
 
     @Override
-    public final PatternEffectiveStatement createEffective(
-            final StmtContext<PatternConstraint, PatternStatement, PatternEffectiveStatement> ctx) {
-        return new PatternEffectiveStatementImpl(ctx);
+    protected final PatternStatement createEmptyDeclared(
+            final StmtContext<PatternConstraint, PatternStatement, ?> ctx) {
+        return new EmptyPatternStatement(ctx);
     }
-}
\ No newline at end of file
+
+    @Override
+    protected final PatternEffectiveStatement createEffective(
+            final StmtContext<PatternConstraint, PatternStatement, PatternEffectiveStatement> ctx,
+            final PatternStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+        final String description = findFirstArgument(substatements, DescriptionEffectiveStatement.class, null);
+        final String reference = findFirstArgument(substatements, ReferenceEffectiveStatement.class, null);
+        final String errorAppTag = findFirstArgument(substatements, ErrorAppTagEffectiveStatement.class, null);
+        final String errorMessage = findFirstArgument(substatements, ErrorMessageEffectiveStatement.class, null);
+        final ModifierKind modifier = findFirstArgument(substatements, ModifierEffectiveStatement.class, null);
+
+        if (description == null && reference == null && errorAppTag == null && errorMessage == null
+                && modifier == null) {
+            // No customization, just use declared statement for the actual value
+            return new SimplePatternEffectiveStatement(declared, substatements);
+        }
+
+        return new RegularPatternEffectiveStatement(declared, new PatternConstraintImpl(declared.argument(),
+            description, reference, errorAppTag, errorMessage, modifier), substatements);
+    }
+
+    @Override
+    protected final PatternEffectiveStatement createEmptyEffective(
+            final StmtContext<PatternConstraint, PatternStatement, PatternEffectiveStatement> ctx,
+            final PatternStatement declared) {
+        return new EmptyPatternEffectiveStatement(declared);
+    }
+}

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/EmptyPatternEffectiveStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/EmptyPatternEffectiveStatement.java
new file mode 100644 (file)
index 0000000..368f353
--- /dev/null
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/EmptyPatternEffectiveStatement.java
@@ -0,0 +1,21 @@
+/*
+ * 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.pattern;
+
+import org.opendaylight.yangtools.yang.model.api.stmt.PatternEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.PatternStatement;
+import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredEffectiveStatement.DefaultArgument;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.ConstraintMetaDefinitionMixin;
+
+final class EmptyPatternEffectiveStatement extends DefaultArgument<PatternConstraint, PatternStatement>
+        implements PatternEffectiveStatement, ConstraintMetaDefinitionMixin<PatternConstraint, PatternStatement> {
+    EmptyPatternEffectiveStatement(final PatternStatement declared) {
+        super(declared);
+    }
+}

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/PatternStatementImpl.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/EmptyPatternStatement.java
similarity index 59%
rename from yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/PatternStatementImpl.java
rename to yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/EmptyPatternStatement.java
index 27f8aa2d30aaf426123f071e08bc1b5fb7435599..d4898e066a3adeb99985db1e92408f397ff4e17b 100644 (file)
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/PatternStatementImpl.java
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/EmptyPatternStatement.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015 Cisco Systems, Inc. and others.  All rights reserved.
+ * 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,
@@ -9,11 +9,11 @@ package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.pattern;
 
 import org.opendaylight.yangtools.yang.model.api.stmt.PatternStatement;
 import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredStatement.WithArgument;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
 
-public class PatternStatementImpl extends AbstractDeclaredStatement<PatternConstraint> implements PatternStatement {
-    protected PatternStatementImpl(final StmtContext<PatternConstraint, PatternStatement, ?> context) {
+final class EmptyPatternStatement extends WithArgument<PatternConstraint> implements PatternStatement {
+    EmptyPatternStatement(final StmtContext<PatternConstraint, ?, ?> context) {
         super(context);
     }
 }

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/PatternConstraintImpl.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/PatternConstraintImpl.java
index 2bb4fef2a6e02eb10079deb94717de11107054e7..9020579d552df2699ea009ef570f16f0090ef563 100644 (file)
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/PatternConstraintImpl.java
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/PatternConstraintImpl.java
@@ -17,7 +17,6 @@ import org.opendaylight.yangtools.yang.model.api.type.ModifierKind;
 import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
 
 final class PatternConstraintImpl implements PatternConstraint, Immutable {
-
     private final String regEx;
     private final String rawRegEx;
     private final String description;
@@ -26,12 +25,7 @@ final class PatternConstraintImpl implements PatternConstraint, Immutable {
     private final String errorMessage;
     private final ModifierKind modifier;
 
-    PatternConstraintImpl(final String regex, final String rawRegex,
-            final Optional<String> description, final Optional<String> reference) {
-        this(regex, rawRegex, description.orElse(null), reference.orElse(null), null, null, null);
-    }
-
-    PatternConstraintImpl(final String regex, final String rawRegex, final String description,
+    private PatternConstraintImpl(final String regex, final String rawRegex, final String description,
             final String reference, final String errorAppTag, final String errorMessage, final ModifierKind modifier) {
         this.regEx = requireNonNull(regex, "regex must not be null");
         this.rawRegEx = requireNonNull(rawRegex, "raw regex must not be null");
@@ -42,6 +36,16 @@ final class PatternConstraintImpl implements PatternConstraint, Immutable {
         this.modifier = modifier;
     }
 
+    PatternConstraintImpl(final String regex, final String rawRegex) {
+        this(regex, rawRegex, null, null, null, null, null);
+    }
+
+    PatternConstraintImpl(final PatternConstraint original, final String description, final String reference,
+            final String errorAppTag, final String errorMessage, final ModifierKind modifier) {
+        this(original.getJavaPatternString(), original.getRegularExpressionString(), description, reference,
+            errorAppTag, errorMessage, modifier);
+    }
+
     @Override
     public String getJavaPatternString() {
         return regEx;

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/PatternEffectiveStatementImpl.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/PatternEffectiveStatementImpl.java
deleted file mode 100644 (file)
index 747fb8d..0000000
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/PatternEffectiveStatementImpl.java
+++ /dev/null
@@ -1,34 +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.pattern;
-
-import org.opendaylight.yangtools.yang.model.api.stmt.PatternEffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.PatternStatement;
-import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
-import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractConstraintEffectiveStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-
-final class PatternEffectiveStatementImpl
-        extends AbstractConstraintEffectiveStatement<PatternConstraint, PatternStatement>
-        implements PatternEffectiveStatement {
-    PatternEffectiveStatementImpl(final StmtContext<PatternConstraint, PatternStatement, ?> ctx) {
-        super(ctx);
-    }
-
-    @Override
-    protected PatternConstraint createConstraints(final PatternConstraint argument) {
-        if (!isCustomizedStatement()) {
-            return argument;
-        }
-
-        return new PatternConstraintImpl(argument.getJavaPatternString(),
-            argument.getRegularExpressionString(),
-            getDescription().orElse(null), getReference().orElse(null), getErrorAppTag().orElse(null),
-            getErrorMessage().orElse(null), getModifier());
-    }
-}

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/RegularPatternEffectiveStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/RegularPatternEffectiveStatement.java
new file mode 100644 (file)
index 0000000..d13d8e4
--- /dev/null
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/RegularPatternEffectiveStatement.java
@@ -0,0 +1,24 @@
+/*
+ * 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.pattern;
+
+import com.google.common.collect.ImmutableList;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.PatternEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.PatternStatement;
+import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredEffectiveStatement.DefaultWithArgument.WithSubstatements;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.ConstraintMetaDefinitionMixin;
+
+final class RegularPatternEffectiveStatement extends WithSubstatements<PatternConstraint, PatternStatement>
+        implements PatternEffectiveStatement, ConstraintMetaDefinitionMixin<PatternConstraint, PatternStatement> {
+    RegularPatternEffectiveStatement(final PatternStatement declared, final PatternConstraint argument,
+            final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+        super(declared, argument, substatements);
+    }
+}

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/RegularPatternStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/RegularPatternStatement.java
new file mode 100644 (file)
index 0000000..196de30
--- /dev/null
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/RegularPatternStatement.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.pattern;
+
+import com.google.common.collect.ImmutableList;
+import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.PatternStatement;
+import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredStatement.WithArgument.WithSubstatements;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class RegularPatternStatement extends WithSubstatements<PatternConstraint> implements PatternStatement {
+    RegularPatternStatement(final StmtContext<PatternConstraint, ?, ?> context,
+            final ImmutableList<? extends DeclaredStatement<?>> substatements) {
+        super(context, substatements);
+    }
+}

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/SimplePatternEffectiveStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/SimplePatternEffectiveStatement.java
new file mode 100644 (file)
index 0000000..1ae51f0
--- /dev/null
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/SimplePatternEffectiveStatement.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.pattern;
+
+import com.google.common.collect.ImmutableList;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.PatternEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.PatternStatement;
+import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredEffectiveStatement.DefaultArgument.WithSubstatements;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.ConstraintMetaDefinitionMixin;
+
+final class SimplePatternEffectiveStatement extends WithSubstatements<PatternConstraint, PatternStatement>
+    implements PatternEffectiveStatement, ConstraintMetaDefinitionMixin<PatternConstraint, PatternStatement> {
+
+    SimplePatternEffectiveStatement(final PatternStatement declared,
+            final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+        super(declared, substatements);
+    }
+}