yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/StmtContext.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.spi.meta;
   9
  10 import com.google.common.base.Optional;
  11 import java.util.Collection;
  12 import java.util.Map;
  13 import javax.annotation.Nonnull;
  14 import javax.annotation.Nullable;
  15 import org.opendaylight.yangtools.yang.common.QNameModule;
  16 import org.opendaylight.yangtools.yang.common.YangVersion;
  17 import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier;
  18 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  19 import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
  20 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
  21 import org.opendaylight.yangtools.yang.model.api.meta.IdentifierNamespace;
  22 import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
  23 import org.opendaylight.yangtools.yang.model.api.meta.StatementSource;
  24 import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference;
  25 import org.opendaylight.yangtools.yang.parser.stmt.reactor.StatementContextBase;
  26
  27 public interface StmtContext<A, D extends DeclaredStatement<A>, E extends EffectiveStatement<A, D>> {
  28
  29     @Nonnull
  30     StatementSource getStatementSource();
  31
  32     @Nonnull
  33     StatementSourceReference getStatementSourceReference();
  34
  35     @Nonnull
  36     StatementDefinition getPublicDefinition();
  37
  38     /**
  39      * Return the parent statement context, or null if this is the root statement.
  40      *
  41      * @return context of parent of statement, or null if this is the root statement.
  42      */
  43     @Nullable
  44     StmtContext<?, ?, ?> getParentContext();
  45
  46     /**
  47      * @return raw statement argument string
  48      */
  49     @Nullable
  50     String rawStatementArgument();
  51
  52     @Nullable
  53     A getStatementArgument();
  54
  55     /**
  56      * Return the {@link SchemaPath} of this statement. Not all statements have a SchemaPath, in which case
  57      * {@link Optional#absent()} is returned.
  58      *
  59      * @return Optional SchemaPath
  60      */
  61     @Nonnull Optional<SchemaPath> getSchemaPath();
  62
  63     boolean isConfiguration();
  64
  65     /**
  66      * Checks whether this statement is placed within a 'yang-data' extension statement.
  67      * Some YANG statements are constrained when used within a 'yang-data' statement.
  68      * See the following link for more information - https://tools.ietf.org/html/rfc8040#section-8
  69      *
  70      * @return true if it is placed within a 'yang-data' extension statement, otherwise false
  71      */
  72     boolean isInYangDataExtensionBody();
  73
  74     boolean isEnabledSemanticVersioning();
  75
  76     @Nonnull
  77     <K, V, KT extends K, N extends IdentifierNamespace<K, V>> V getFromNamespace(
  78             Class<N> type, KT key) throws NamespaceNotAvailableException;
  79
  80     <K, V, N extends IdentifierNamespace<K, V>> Map<K, V> getAllFromNamespace(
  81             Class<N> type);
  82
  83     <K, V, N extends IdentifierNamespace<K, V>> Map<K, V> getAllFromCurrentStmtCtxNamespace(Class<N> type);
  84
  85     @Nonnull
  86     StmtContext<?, ?, ?> getRoot();
  87
  88     /**
  89      * Return declared substatements. These are the statements which are explicitly written in the source model.
  90      *
  91      * @return Collection of declared substatements
  92      */
  93     @Nonnull
  94     Collection<? extends StmtContext<?, ?, ?>> declaredSubstatements();
  95
  96     /**
  97      * Return effective substatements. These are the statements which are added as this statement's substatements
  98      * complete their effective model phase.
  99      *
 100      * @return Collection of declared substatements
 101      */
 102     @Nonnull
 103     Collection<? extends StmtContext<?, ?, ?>> effectiveSubstatements();
 104
 105     /**
 106      * Builds {@link DeclaredStatement} for statement context.
 107      */
 108     D buildDeclared();
 109
 110     /**
 111      * Builds {@link EffectiveStatement} for statement context
 112      */
 113     E buildEffective();
 114
 115     boolean isSupportedToBuildEffective();
 116
 117     Collection<? extends StmtContext<?, ?, ?>> getEffectOfStatement();
 118
 119     Mutable<A, D, E> createCopy(StatementContextBase<?, ?, ?> newParent, CopyType typeOfCopy);
 120
 121     Mutable<A, D, E> createCopy(QNameModule newQNameModule, StatementContextBase<?, ?, ?> newParent,
 122             CopyType typeOfCopy);
 123
 124     CopyHistory getCopyHistory();
 125
 126     boolean isSupportedByFeatures();
 127
 128     StmtContext<?, ?, ?> getOriginalCtx();
 129
 130     int getOrder();
 131
 132     ModelProcessingPhase getCompletedPhase();
 133
 134     /**
 135      * Return version of root statement context.
 136      *
 137      * @return version of root statement context
 138      */
 139     @Nonnull YangVersion getRootVersion();
 140
 141     interface Mutable<A, D extends DeclaredStatement<A>, E extends EffectiveStatement<A, D>>
 142             extends StmtContext<A, D, E> {
 143
 144         @Override
 145         Mutable<?, ?, ?> getParentContext();
 146
 147         <K, V, KT extends K, VT extends V, N extends IdentifierNamespace<K, V>> void addToNs(Class<N> type, KT key,
 148                 VT value) throws NamespaceNotAvailableException;
 149
 150         @Nonnull
 151         @Override
 152         Mutable<?, ?, ?> getRoot();
 153
 154         @Nonnull
 155         Collection<? extends Mutable<?, ?, ?>> mutableDeclaredSubstatements();
 156
 157         @Nonnull
 158         Collection<? extends Mutable<?, ?, ?>> mutableEffectiveSubstatements();
 159
 160         /**
 161          * Create a new inference action to be executed during specified phase. The action cannot be cancelled
 162          * and will be executed even if its definition remains incomplete.
 163          *
 164          * @param phase Target phase in which the action will resolved.
 165          * @return A new action builder.
 166          * @throws NullPointerException if the specified phase is null
 167          */
 168         @Nonnull ModelActionBuilder newInferenceAction(@Nonnull ModelProcessingPhase phase);
 169
 170         /**
 171          * adds statement to namespace map with the key
 172          *
 173          * @param namespace
 174          *            {@link StatementNamespace} child that determines namespace to be added to
 175          * @param key
 176          *            of type according to namespace class specification
 177          * @param stmt
 178          *            to be added to namespace map
 179          */
 180         <K, KT extends K, N extends StatementNamespace<K, ?, ?>> void addContext(Class<N> namespace, KT key,
 181                 StmtContext<?, ?, ?> stmt);
 182
 183         /**
 184          * Set version of root statement context.
 185          *
 186          * @param version
 187          *            of root statement context
 188          */
 189         void setRootVersion(YangVersion version);
 190
 191         /**
 192          * Add mutable statement to seal. Each mutable statement must be sealed
 193          * as the last step of statement parser processing.
 194          *
 195          * @param mutableStatement
 196          *            mutable statement which should be sealed
 197          */
 198         void addMutableStmtToSeal(MutableStatement mutableStatement);
 199
 200         /**
 201          * Add required module. Based on these dependencies are collected
 202          * required sources from library sources.
 203          *
 204          * @param dependency
 205          *            ModuleIdentifier of module required by current root
 206          *            context
 207          */
 208         void addRequiredModule(ModuleIdentifier dependency);
 209
 210         void addAsEffectOfStatement(StmtContext<?, ?, ?> ctx);
 211
 212         void addAsEffectOfStatement(Collection<? extends StmtContext<?, ?, ?>> ctxs);
 213
 214         /**
 215          * Set identifier of current root context.
 216          *
 217          * @param identifier
 218          *            of current root context
 219          */
 220         void setRootIdentifier(ModuleIdentifier identifier);
 221
 222         void setIsSupportedToBuildEffective(boolean isSupportedToBuild);
 223
 224         void setOrder(int order);
 225
 226         // FIXME: this seems to be unused, but looks useful.
 227         void setCompletedPhase(ModelProcessingPhase completedPhase);
 228     }
 229 }