X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=yang%2Fyang-parser-impl%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fyangtools%2Fyang%2Fparser%2Fstmt%2Freactor%2FStatementDefinitionContext.java;h=bab8ef1d23dd0fd74e637fe27e543e142839a470;hb=4e23de902b25ea5cdd8e0e21525f51a30adc61d1;hp=7fd1442691ffb4ee9b412c664381372a495bc5d4;hpb=c4dc5b33e7d24670b59cc81b65e15b37a3268608;p=yangtools.git

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementDefinitionContext.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementDefinitionContext.java
index 7fd1442691..bab8ef1d23 100644
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementDefinitionContext.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementDefinitionContext.java
@@ -7,7 +7,15 @@
  */
 package org.opendaylight.yangtools.yang.parser.stmt.reactor;
 
+import com.google.common.base.MoreObjects;
+import com.google.common.base.MoreObjects.ToStringHelper;
+import com.google.common.base.Preconditions;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+import javax.annotation.Nonnull;
 import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.QNameModule;
 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.IdentifierNamespace;
@@ -17,25 +25,30 @@ import org.opendaylight.yangtools.yang.parser.spi.meta.StatementFactory;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StatementSupport;
 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.source.SourceException;
 
-public class StatementDefinitionContext<A,D extends DeclaredStatement<A>,E extends EffectiveStatement<A,D>> {
-    private final StatementSupport<A,D,E> support;
-    public StatementDefinitionContext(StatementSupport<A,D,E> support) {
-        this.support= support;
-    }
+public class StatementDefinitionContext<A, D extends DeclaredStatement<A>, E extends EffectiveStatement<A, D>> {
+    private final StatementSupport<A, D, E> support;
+    private final Map<String, StatementDefinitionContext<?, ?, ?>> argumentSpecificSubDefinitions;
+    private Map<StatementDefinitionContext<?,?,?>, StatementDefinitionContext<?,?,?>> unknownStmtDefsOfYangStmts;
 
+    public StatementDefinitionContext(final StatementSupport<A, D, E> support) {
+        this.support = Preconditions.checkNotNull(support);
+        this.argumentSpecificSubDefinitions = support.hasArgumentSpecificSupports() ? new HashMap<>() : null;
+    }
 
     public StatementFactory<A,D,E> getFactory() {
         return support;
     }
 
-    public A parseArgumentValue(StmtContext<A,D,E> context, String value) throws SourceException {
-        return support.parseArgumentValue(context,value);
+    public A parseArgumentValue(final StmtContext<A, D, E> context, final String value) {
+        return support.parseArgumentValue(context, value);
     }
 
+    public A adaptArgumentValue(final StmtContext<A, D, E> context, final QNameModule targetModule) {
+        return support.adaptArgumentValue(context, targetModule);
+    }
 
-    public void checkNamespaceAllowed(Class<? extends IdentifierNamespace<?,?>> namespace) {
+    public void checkNamespaceAllowed(final Class<? extends IdentifierNamespace<?,?>> namespace) {
         // Noop
     }
 
@@ -43,41 +56,113 @@ public class StatementDefinitionContext<A,D extends DeclaredStatement<A>,E exten
         return support.getPublicView();
     }
 
-    public boolean onStatementAdded(Mutable<A,D,E> stmt) {
-        return false;
+    public Optional<StatementSupport<?, ?, ?>> getImplicitParentFor(final StatementDefinition stmtDef) {
+        return support.getImplicitParentFor(stmtDef);
     }
 
+    public boolean onStatementAdded(final Mutable<A, D, E> stmt) {
+        support.onStatementAdded(stmt);
+        return false;
+    }
 
-    public void onDeclarationFinished(Mutable<A,D,E> statement, ModelProcessingPhase phase) throws SourceException {
+    public void onDeclarationFinished(final Mutable<A, D, E> statement, final ModelProcessingPhase phase) {
         switch (phase) {
-        case SOURCE_LINKAGE:
-            support.onLinkageDeclared(statement);
-            break;
-        case STATEMENT_DEFINITION:
-            support.onStatementDefinitionDeclared(statement);
-            break;
-        case FULL_DECLARATION:
-            support.onFullDefinitionDeclared(statement);
-            break;
-        default:
-            break;
+            case SOURCE_PRE_LINKAGE:
+                support.onPreLinkageDeclared(statement);
+                break;
+            case SOURCE_LINKAGE:
+                support.onLinkageDeclared(statement);
+                break;
+            case STATEMENT_DEFINITION:
+                support.onStatementDefinitionDeclared(statement);
+                break;
+            case FULL_DECLARATION:
+                support.onFullDefinitionDeclared(statement);
+                break;
+            default:
+                break;
         }
     }
 
-
-
     public Class<?> getRepresentingClass() {
         return support.getDeclaredRepresentationClass();
     }
 
-
     public boolean hasArgument() {
         return support.getArgumentName() != null;
     }
 
+    public boolean isArgumentYinElement() {
+        return support.isArgumentYinElement();
+    }
 
     public QName getStatementName() {
         return support.getStatementName();
     }
 
+    public QName getArgumentName() {
+        return support.getArgumentName();
+    }
+
+    @Override
+    public final String toString() {
+        return addToStringAttributes(MoreObjects.toStringHelper(this).omitNullValues()).toString();
+    }
+
+    protected ToStringHelper addToStringAttributes(final ToStringHelper toStringHelper) {
+        return toStringHelper.add("statement", getStatementName());
+    }
+
+    @Nonnull
+    StatementDefinitionContext<?, ?, ?> getSubDefinitionSpecificForArgument(final String argument) {
+        if (!hasArgumentSpecificSubDefinitions()) {
+            return this;
+        }
+
+        StatementDefinitionContext<?, ?, ?> potential = argumentSpecificSubDefinitions.get(argument);
+        if (potential == null) {
+            final StatementSupport<?, ?, ?> argumentSpecificSupport = support.getSupportSpecificForArgument(argument);
+            potential = argumentSpecificSupport != null ? new StatementDefinitionContext<>(argumentSpecificSupport)
+                    : this;
+            argumentSpecificSubDefinitions.put(argument, potential);
+        }
+
+        return potential;
+    }
+
+    boolean hasArgumentSpecificSubDefinitions() {
+        return support.hasArgumentSpecificSupports();
+    }
+
+    String internArgument(final String rawArgument) {
+        return support.internArgument(rawArgument);
+    }
+
+    StatementDefinitionContext<?, ?, ?> getAsUnknownStatementDefinition(
+            final StatementDefinitionContext<?, ?, ?> yangStmtDef) {
+        if (unknownStmtDefsOfYangStmts != null) {
+            final StatementDefinitionContext<?, ?, ?> existing = unknownStmtDefsOfYangStmts.get(yangStmtDef);
+            if (existing != null) {
+                return existing;
+            }
+        } else {
+            unknownStmtDefsOfYangStmts = new HashMap<>();
+        }
+
+        @SuppressWarnings("unchecked")
+        final StatementDefinitionContext<?, ?, ?> ret = support.getUnknownStatementDefinitionOf(
+            yangStmtDef.getPublicView()).map(StatementDefinitionContext::new).orElse(null);
+        if (ret != null) {
+            unknownStmtDefsOfYangStmts.put(yangStmtDef, ret);
+        }
+        return ret;
+    }
+
+    boolean isIgnoringIfFeatures() {
+        return support.isIgnoringIfFeatures();
+    }
+
+    boolean isIgnoringConfig() {
+        return support.isIgnoringConfig();
+    }
 }