yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/SubstatementContext.java

   1 /*
   2  * Copyright (c) 2015 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.yangtools.yang.parser.stmt.reactor;
   9
  10 import static java.util.Objects.requireNonNull;
  11
  12 import com.google.common.base.Verify;
  13 import java.util.Optional;
  14 import org.opendaylight.yangtools.yang.common.QName;
  15 import org.opendaylight.yangtools.yang.common.QNameModule;
  16 import org.opendaylight.yangtools.yang.common.YangVersion;
  17 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  18 import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
  19 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
  20 import org.opendaylight.yangtools.yang.model.api.stmt.AugmentStatement;
  21 import org.opendaylight.yangtools.yang.model.api.stmt.DeviationStatement;
  22 import org.opendaylight.yangtools.yang.model.api.stmt.RefineStatement;
  23 import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
  24 import org.opendaylight.yangtools.yang.model.api.stmt.UsesStatement;
  25 import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
  26 import org.opendaylight.yangtools.yang.parser.spi.meta.CopyType;
  27 import org.opendaylight.yangtools.yang.parser.spi.meta.MutableStatement;
  28 import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour.NamespaceStorageNode;
  29 import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour.Registry;
  30 import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour.StorageNodeType;
  31 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
  32 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
  33 import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference;
  34
  35 final class SubstatementContext<A, D extends DeclaredStatement<A>, E extends EffectiveStatement<A, D>> extends
  36         AbstractResumedStatement<A, D, E> {
  37     private final StatementContextBase<?, ?, ?> parent;
  38     private final A argument;
  39
  40     private volatile SchemaPath schemaPath;
  41
  42     SubstatementContext(final StatementContextBase<?, ?, ?> parent, final StatementDefinitionContext<A, D, E> def,
  43             final StatementSourceReference ref, final String rawArgument) {
  44         super(def, ref, rawArgument);
  45         this.parent = requireNonNull(parent, "Parent must not be null");
  46         this.argument = def.parseArgumentValue(this, rawStatementArgument());
  47     }
  48
  49     SubstatementContext(final StatementContextBase<?, ?, ?> parent, final StatementDefinitionContext<A, D, E> def,
  50         final StatementSourceReference ref, final String rawArgument, final A argument, final CopyType copyType) {
  51         super(def, ref, rawArgument, copyType);
  52         this.parent = requireNonNull(parent, "Parent must not be null");
  53         this.argument = argument;
  54     }
  55
  56     SubstatementContext(final StatementContextBase<A, D, E> original, final StatementContextBase<?, ?, ?> parent,
  57             final CopyType copyType, final QNameModule targetModule) {
  58         super(original, copyType);
  59         this.parent = requireNonNull(parent, "Parent must not be null");
  60         this.argument = targetModule == null ? original.getStatementArgument()
  61                 : original.definition().adaptArgumentValue(original, targetModule);
  62     }
  63
  64     private SubstatementContext(final SubstatementContext<A, D, E> original,
  65             final StatementContextBase<?, ?, ?> parent) {
  66         super(original);
  67         this.parent = requireNonNull(parent, "Parent must not be null");
  68         this.argument = original.argument;
  69     }
  70
  71     @Override
  72     public StatementContextBase<?, ?, ?> getParentContext() {
  73         return parent;
  74     }
  75
  76     @Override
  77     public StorageNodeType getStorageNodeType() {
  78         return StorageNodeType.STATEMENT_LOCAL;
  79     }
  80
  81     @Override
  82     public NamespaceStorageNode getParentNamespaceStorage() {
  83         return parent;
  84     }
  85
  86     @Override
  87     public Registry getBehaviourRegistry() {
  88         return parent.getBehaviourRegistry();
  89     }
  90
  91     @Override
  92     public RootStatementContext<?, ?, ?> getRoot() {
  93         return parent.getRoot();
  94     }
  95
  96     @Override
  97     public A getStatementArgument() {
  98         return argument;
  99     }
 100
 101     private SchemaPath createSchemaPath() {
 102         final Optional<SchemaPath> maybeParentPath = parent.getSchemaPath();
 103         Verify.verify(maybeParentPath.isPresent(), "Parent %s does not have a SchemaPath", parent);
 104         final SchemaPath parentPath = maybeParentPath.get();
 105
 106         if (StmtContextUtils.isUnknownStatement(this)) {
 107             return parentPath.createChild(getPublicDefinition().getStatementName());
 108         }
 109         if (argument instanceof QName) {
 110             final QName qname = (QName) argument;
 111             if (StmtContextUtils.producesDeclared(this, UsesStatement.class)) {
 112                 return maybeParentPath.orElse(null);
 113             }
 114
 115             return parentPath.createChild(qname);
 116         }
 117         if (argument instanceof String) {
 118             // FIXME: This may yield illegal argument exceptions
 119             final Optional<StmtContext<?, ?, ?>> originalCtx = getOriginalCtx();
 120             final QName qname = StmtContextUtils.qnameFromArgument(originalCtx.orElse(this), (String) argument);
 121             return parentPath.createChild(qname);
 122         }
 123         if (argument instanceof SchemaNodeIdentifier
 124                 && (StmtContextUtils.producesDeclared(this, AugmentStatement.class)
 125                         || StmtContextUtils.producesDeclared(this, RefineStatement.class)
 126                         || StmtContextUtils.producesDeclared(this, DeviationStatement.class))) {
 127
 128             return parentPath.createChild(((SchemaNodeIdentifier) argument).getPathFromRoot());
 129         }
 130
 131         // FIXME: this does not look right
 132         return maybeParentPath.orElse(null);
 133     }
 134
 135     @Override
 136     public Optional<SchemaPath> getSchemaPath() {
 137         SchemaPath local = schemaPath;
 138         if (local == null) {
 139             synchronized (this) {
 140                 local = schemaPath;
 141                 if (local == null) {
 142                     local = createSchemaPath();
 143                     schemaPath = local;
 144                 }
 145             }
 146         }
 147
 148         return Optional.ofNullable(local);
 149     }
 150
 151     @Override
 152     public boolean isConfiguration() {
 153         return isConfiguration(parent);
 154     }
 155
 156     @Override
 157     public boolean isEnabledSemanticVersioning() {
 158         return parent.isEnabledSemanticVersioning();
 159     }
 160
 161     @Override
 162     public YangVersion getRootVersion() {
 163         return getRoot().getRootVersion();
 164     }
 165
 166     @Override
 167     public void setRootVersion(final YangVersion version) {
 168         getRoot().setRootVersion(version);
 169     }
 170
 171     @Override
 172     public void addMutableStmtToSeal(final MutableStatement mutableStatement) {
 173         getRoot().addMutableStmtToSeal(mutableStatement);
 174     }
 175
 176     @Override
 177     public void addRequiredSource(final SourceIdentifier dependency) {
 178         getRoot().addRequiredSource(dependency);
 179     }
 180
 181     @Override
 182     public void setRootIdentifier(final SourceIdentifier identifier) {
 183         getRoot().setRootIdentifier(identifier);
 184     }
 185
 186     @Override
 187     protected boolean isIgnoringIfFeatures() {
 188         return isIgnoringIfFeatures(parent);
 189     }
 190
 191     @Override
 192     protected boolean isIgnoringConfig() {
 193         return isIgnoringConfig(parent);
 194     }
 195
 196     @Override
 197     protected boolean isParentSupportedByFeatures() {
 198         return parent.isSupportedByFeatures();
 199     }
 200
 201     @Override
 202     SubstatementContext<A, D, E> reparent(final StatementContextBase<?, ?, ?> newParent) {
 203         return new SubstatementContext<>(this, newParent);
 204     }
 205 }