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