Split out AbstractTypeStatementSupport.resolveTypeReference()

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

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/type/AbstractTypeStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/type/AbstractTypeStatementSupport.java
index 604c1abe58e93d4f9f7da6bac06bbf83b6a20ceb..3270241d58d914d56ab8542d2cffe7a263846926 100644 (file)
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/type/AbstractTypeStatementSupport.java
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/type/AbstractTypeStatementSupport.java
@@ -7,10 +7,11 @@
  */
 package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
 
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkArgument;
+
 import com.google.common.collect.ImmutableMap;
 import java.util.Collection;
-import java.util.Map;
+import org.eclipse.jdt.annotation.NonNull;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
@@ -48,7 +49,6 @@ import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.Infere
 import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceContext;
 import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.Prerequisite;
 import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
-import org.opendaylight.yangtools.yang.parser.spi.meta.QNameCacheNamespace;
 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;
@@ -92,7 +92,7 @@ abstract class AbstractTypeStatementSupport
     static final String UINT64 = "uint64";
     static final String UNION = "union";
 
-    private static final Map<String, String> BUILT_IN_TYPES = ImmutableMap.<String, String>builder()
+    private static final ImmutableMap<String, String> BUILT_IN_TYPES = ImmutableMap.<String, String>builder()
         .put(BINARY, BINARY)
         .put(BITS, BITS)
         .put(BOOLEAN, BOOLEAN)
@@ -114,7 +114,7 @@ abstract class AbstractTypeStatementSupport
         .put(UNION, UNION)
         .build();
 
-    private static final Map<String, StatementSupport<?, ?, ?>> ARGUMENT_SPECIFIC_SUPPORTS =
+    private static final ImmutableMap<String, StatementSupport<?, ?, ?>> ARGUMENT_SPECIFIC_SUPPORTS =
             ImmutableMap.<String, StatementSupport<?, ?, ?>>builder()
             .put(BITS, new BitsSpecificationSupport())
             .put(DECIMAL64, new Decimal64SpecificationSupport())
@@ -144,54 +144,7 @@ abstract class AbstractTypeStatementSupport
             final StmtContext<String, TypeStatement, EffectiveStatement<String, TypeStatement>> ctx) {
 
         // First look up the proper base type
-        final TypeEffectiveStatement<TypeStatement> typeStmt;
-        switch (ctx.getStatementArgument()) {
-            case BINARY:
-                typeStmt = BuiltinEffectiveStatement.BINARY;
-                break;
-            case BOOLEAN:
-                typeStmt = BuiltinEffectiveStatement.BOOLEAN;
-                break;
-            case EMPTY:
-                typeStmt = BuiltinEffectiveStatement.EMPTY;
-                break;
-            case INSTANCE_IDENTIFIER:
-                typeStmt = BuiltinEffectiveStatement.INSTANCE_IDENTIFIER;
-                break;
-            case INT8:
-                typeStmt = BuiltinEffectiveStatement.INT8;
-                break;
-            case INT16:
-                typeStmt = BuiltinEffectiveStatement.INT16;
-                break;
-            case INT32:
-                typeStmt = BuiltinEffectiveStatement.INT32;
-                break;
-            case INT64:
-                typeStmt = BuiltinEffectiveStatement.INT64;
-                break;
-            case STRING:
-                typeStmt = BuiltinEffectiveStatement.STRING;
-                break;
-            case UINT8:
-                typeStmt = BuiltinEffectiveStatement.UINT8;
-                break;
-            case UINT16:
-                typeStmt = BuiltinEffectiveStatement.UINT16;
-                break;
-            case UINT32:
-                typeStmt = BuiltinEffectiveStatement.UINT32;
-                break;
-            case UINT64:
-                typeStmt = BuiltinEffectiveStatement.UINT64;
-                break;
-            default:
-                final QName qname = StmtContextUtils.qnameFromArgument(ctx, ctx.getStatementArgument());
-                final StmtContext<?, TypedefStatement, TypedefEffectiveStatement> typedef =
-                        SourceException.throwIfNull(ctx.getFromNamespace(TypeNamespace.class, qname),
-                            ctx.getStatementSourceReference(), "Type '%s' not found", qname);
-                typeStmt = typedef.buildEffective().asTypeEffectiveStatement();
-        }
+        final TypeEffectiveStatement<TypeStatement> typeStmt = resolveType(ctx);
 
         if (ctx.declaredSubstatements().isEmpty() && ctx.effectiveSubstatements().isEmpty()) {
             return typeStmt;
@@ -261,7 +214,7 @@ abstract class AbstractTypeStatementSupport
             return;
         }
 
-        final QName typeQName = StmtContextUtils.qnameFromArgument(stmt, stmt.getStatementArgument());
+        final QName typeQName = StmtContextUtils.parseNodeIdentifier(stmt, stmt.getStatementArgument());
         final ModelActionBuilder typeAction = stmt.newInferenceAction(ModelProcessingPhase.EFFECTIVE_MODEL);
         final Prerequisite<StmtContext<?, ?, ?>> typePrereq = typeAction.requiresCtx(stmt, TypeNamespace.class,
                 typeQName, ModelProcessingPhase.EFFECTIVE_MODEL);
@@ -292,8 +245,8 @@ abstract class AbstractTypeStatementSupport
 
     @Override
     public final String internArgument(final String rawArgument) {
-        final String found = BUILT_IN_TYPES.get(rawArgument);
-        return found != null ? found : rawArgument;
+        final String found;
+        return (found = BUILT_IN_TYPES.get(rawArgument)) != null ? found : rawArgument;
     }
 
     @Override
@@ -310,10 +263,54 @@ abstract class AbstractTypeStatementSupport
         final SchemaPath path = stmtCtx.getSchemaPath().get();
         final SchemaPath parent = path.getParent();
         final QName parentQName = parent.getLastComponent();
-        Preconditions.checkArgument(parentQName != null, "Path %s has an empty parent", path);
+        checkArgument(parentQName != null, "Path %s has an empty parent", path);
 
-        final QName qname = stmtCtx.getFromNamespace(QNameCacheNamespace.class,
-            QName.create(parentQName, path.getLastComponent().getLocalName()));
+        final QName qname = path.getLastComponent().withModule(parentQName.getModule()).intern();
         return parent.createChild(qname);
     }
+
+    /**
+     * Resolve type reference, as pointed to by the context's argument.
+     *
+     * @param ctx Statement context
+     * @return Resolved type
+     * @throws SourceException if the target type cannot be found
+     */
+    private static @NonNull TypeEffectiveStatement<TypeStatement> resolveType(final StmtContext<String, ?, ?> ctx) {
+        final String argument = ctx.coerceStatementArgument();
+        switch (argument) {
+            case BINARY:
+                return BuiltinEffectiveStatement.BINARY;
+            case BOOLEAN:
+                return BuiltinEffectiveStatement.BOOLEAN;
+            case EMPTY:
+                return BuiltinEffectiveStatement.EMPTY;
+            case INSTANCE_IDENTIFIER:
+                return BuiltinEffectiveStatement.INSTANCE_IDENTIFIER;
+            case INT8:
+                return BuiltinEffectiveStatement.INT8;
+            case INT16:
+                return BuiltinEffectiveStatement.INT16;
+            case INT32:
+                return BuiltinEffectiveStatement.INT32;
+            case INT64:
+                return BuiltinEffectiveStatement.INT64;
+            case STRING:
+                return BuiltinEffectiveStatement.STRING;
+            case UINT8:
+                return BuiltinEffectiveStatement.UINT8;
+            case UINT16:
+                return BuiltinEffectiveStatement.UINT16;
+            case UINT32:
+                return BuiltinEffectiveStatement.UINT32;
+            case UINT64:
+                return BuiltinEffectiveStatement.UINT64;
+            default:
+                final QName qname = StmtContextUtils.parseNodeIdentifier(ctx, argument);
+                final StmtContext<?, TypedefStatement, TypedefEffectiveStatement> typedef =
+                        SourceException.throwIfNull(ctx.getFromNamespace(TypeNamespace.class, qname),
+                            ctx.getStatementSourceReference(), "Type '%s' not found", qname);
+                return typedef.buildEffective().asTypeEffectiveStatement();
+        }
+    }
 }
\ No newline at end of file