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 context of parent of statement
  40      */
  41     @Nullable
  42     StmtContext<?, ?, ?> getParentContext();
  43
  44     /**
  45      * @return raw statement argument string
  46      */
  47     @Nullable
  48     String rawStatementArgument();
  49
  50     @Nullable
  51     A getStatementArgument();
  52
  53     /**
  54      * Return the {@link SchemaPath} of this statement. Not all statements have a SchemaPath, in which case
  55      * {@link Optional#absent()} is returned.
  56      *
  57      * @return Optional SchemaPath
  58      */
  59     @Nonnull Optional<SchemaPath> getSchemaPath();
  60
  61     boolean isConfiguration();
  62
  63     /**
  64      * Checks whether this statement is placed within a 'yang-data' extension statement.
  65      * Some YANG statements are constrained when used within a 'yang-data' statement.
  66      * See the following link for more information - https://tools.ietf.org/html/rfc8040#section-8
  67      *
  68      * @return true if it is placed within a 'yang-data' extension statement, otherwise false
  69      */
  70     boolean isInYangDataExtensionBody();
  71
  72     boolean isEnabledSemanticVersioning();
  73
  74     @Nonnull
  75     <K, V, KT extends K, N extends IdentifierNamespace<K, V>> V getFromNamespace(
  76             Class<N> type, KT key) throws NamespaceNotAvailableException;
  77
  78     <K, V, N extends IdentifierNamespace<K, V>> Map<K, V> getAllFromNamespace(
  79             Class<N> type);
  80
  81     <K, V, N extends IdentifierNamespace<K, V>> Map<K, V> getAllFromCurrentStmtCtxNamespace(Class<N> type);
  82
  83     @Nonnull
  84     StmtContext<?, ?, ?> getRoot();
  85
  86     /**
  87      * Return declared substatements. These are the statements which are explicitly written in the source model.
  88      *
  89      * @return Collection of declared substatements
  90      */
  91     @Nonnull
  92     Collection<? extends StmtContext<?, ?, ?>> declaredSubstatements();
  93
  94     /**
  95      * Return effective substatements. These are the statements which are added as this statement's substatements
  96      * complete their effective model phase.
  97      *
  98      * @return Collection of declared substatements
  99      */
 100     @Nonnull
 101     Collection<? extends StmtContext<?, ?, ?>> effectiveSubstatements();
 102
 103     /**
 104      * Builds {@link DeclaredStatement} for statement context.
 105      */
 106     D buildDeclared();
 107
 108     /**
 109      * Builds {@link EffectiveStatement} for statement context
 110      */
 111     E buildEffective();
 112
 113     boolean isSupportedToBuildEffective();
 114
 115     Collection<? extends StmtContext<?, ?, ?>> getEffectOfStatement();
 116
 117     Mutable<A, D, E> createCopy(StatementContextBase<?, ?, ?> newParent, CopyType typeOfCopy);
 118
 119     Mutable<A, D, E> createCopy(QNameModule newQNameModule, StatementContextBase<?, ?, ?> newParent,
 120             CopyType typeOfCopy);
 121
 122     CopyHistory getCopyHistory();
 123
 124     boolean isSupportedByFeatures();
 125
 126     StmtContext<?, ?, ?> getOriginalCtx();
 127
 128     boolean isRootContext();
 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 appendCopyHistory(CopyType typeOfCopy, CopyHistory toAppend);
 225
 226         void setOriginalCtx(StmtContext<?, ?, ?> originalCtx);
 227
 228         void setOrder(int order);
 229
 230         // FIXME: this seems to be unused, but looks useful.
 231         void setCompletedPhase(ModelProcessingPhase completedPhase);
 232     }
 233 }