StatementContextBase (yangtools 3.0.0-SNAPSHOT API)

java.lang.Object
- org.opendaylight.yangtools.yang.parser.stmt.reactor.StatementContextBase<A,D,E>

All Implemented Interfaces:: NamespaceBehaviour.NamespaceStorageNode, StmtContext<A,D,E>, StmtContext.Mutable<A,D,E>, StatementWriter.ResumedStatement

Direct Known Subclasses:: RootStatementContext

public abstract class StatementContextBase<A,D extends DeclaredStatement<A>,E extends EffectiveStatement<A,D>>
extends Object
implements StmtContext.Mutable<A,D,E>, StatementWriter.ResumedStatement

Nested Class Summary
- Nested classes/interfaces inherited from interface org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext
  StmtContext.Mutable<A,D extends DeclaredStatement<A>,E extends EffectiveStatement<A,D>>

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addAsEffectOfStatement(Collection<? extends StmtContext<?,?,?>> ctxs)`
`void`	`addAsEffectOfStatement(StmtContext<?,?,?> ctx)`
`<K,KT extends K,N extends StatementNamespace<K,?,?>> void`	`addContext(Class<N> namespace, KT key, StmtContext<?,?,?> stmt)` Adds s statement to namespace map with a key.
`<K,N extends StatementNamespace<K,?,?>> void`	`addContextToNamespace(Class<N> type, K key, StmtContext<?,?,?> value)` Associate a context with a key within a namespace.
`void`	`addEffectiveSubstatement(StmtContext.Mutable<?,?,?> substatement)` Adds an effective statement to collection of substatements.
`void`	`addEffectiveSubstatements(Collection<? extends StmtContext.Mutable<?,?,?>> statements)` Adds an effective statement to collection of substatements.
`<K,V,T extends K,U extends V,N extends IdentifierNamespace<K,V>> void`	`addToNs(Class<N> type, T key, U value)` Associate a value with a key within a namespace.
`protected com.google.common.base.MoreObjects.ToStringHelper`	`addToStringAttributes(com.google.common.base.MoreObjects.ToStringHelper toStringHelper)`
`void`	`appendImplicitStatement(StatementSupport<?,?,?> statementToAdd)`
`D`	`buildDeclared()` Builds `DeclaredStatement` for statement context.
`E`	`buildEffective()` Builds `EffectiveStatement` for statement context.
`protected void`	`checkLocalNamespaceAllowed(Class<? extends IdentifierNamespace<?,?>> type)`
`<X,Y extends DeclaredStatement<X>,Z extends EffectiveStatement<X,Y>> StmtContext.Mutable<X,Y,Z>`	`childCopyOf(StmtContext<X,Y,Z> stmt, CopyType type, QNameModule targetModule)` Create a child sub-statement, which is a child of this statement, inheriting all attributes from specified child and recording copy type.
`<X,Y extends DeclaredStatement<X>,Z extends EffectiveStatement<X,Y>> StatementContextBase<X,Y,Z>`	`createSubstatement(int offset, StatementDefinitionContext<X,Y,Z> def, StatementSourceReference ref, String argument)` Create a new substatement at the specified offset.
`Collection<? extends StmtContext<?,?,?>>`	`declaredSubstatements()` Return declared substatements.
`protected @NonNull StatementDefinitionContext<A,D,E>`	`definition()` Return the context in which this statement was defined.
`Collection<? extends StmtContext<?,?,?>>`	`effectiveSubstatements()` Return effective substatements.
`<K,V,N extends IdentifierNamespace<K,V>> Map<K,V>`	`getAllFromCurrentStmtCtxNamespace(Class<N> type)`
`<K,V,N extends IdentifierNamespace<K,V>> Map<K,V>`	`getAllFromLocalStorage(Class<N> type)`
`<K,V,N extends IdentifierNamespace<K,V>> Map<K,V>`	`getAllFromNamespace(Class<N> type)`
`abstract NamespaceBehaviour.Registry`	`getBehaviourRegistry()` Return the registry of a source context.
`ModelProcessingPhase`	`getCompletedPhase()`
`CopyHistory`	`getCopyHistory()`
`@NonNull StatementDefinition`	`getDefinition()` Return statement definition.
`Collection<? extends StmtContext<?,?,?>>`	`getEffectOfStatement()`
`<K,V,N extends IdentifierNamespace<K,V>> V`	`getFromLocalStorage(Class<N> type, K key)`
`<K,V,N extends IdentifierNamespace<K,V>> Optional<Map.Entry<K,V>>`	`getFromNamespace(Class<N> type, NamespaceKeyCriterion<K> criterion)`
`<K,V,T extends K,N extends IdentifierNamespace<K,V>> V`	`getFromNamespace(Class<N> type, T key)` Return a value associated with specified key within a namespace.
`Optional<StmtContext<?,?,?>>`	`getOriginalCtx()`
`abstract StatementContextBase<?,?,?>`	`getParentContext()` Return the parent statement context, or null if this is the root statement.
`abstract NamespaceBehaviour.NamespaceStorageNode`	`getParentNamespaceStorage()`
`StatementDefinition`	`getPublicDefinition()` See `StatementSupport.getPublicView()`.
`abstract RootStatementContext<?,?,?>`	`getRoot()` Returns the model root for this statement.
`@NonNull StatementSourceReference`	`getSourceReference()` Return statement source reference.
`StatementSource`	`getStatementSource()` Returns the origin of the statement.
`StatementSourceReference`	`getStatementSourceReference()` Returns a reference to statement source.
`boolean`	`isFullyDefined()` Check if the statement has been fully defined.
`protected abstract boolean`	`isIgnoringConfig()`
`protected abstract boolean`	`isIgnoringIfFeatures()`
`protected abstract boolean`	`isParentSupportedByFeatures()`
`boolean`	`isSupportedByFeatures()`
`boolean`	`isSupportedToBuildEffective()`
`Collection<? extends StmtContext.Mutable<?,?,?>>`	`mutableDeclaredSubstatements()`
`Collection<? extends StmtContext.Mutable<?,?,?>>`	`mutableEffectiveSubstatements()`
`ModelActionBuilder`	`newInferenceAction(ModelProcessingPhase phase)` Create a new inference action to be executed during specified phase.
`protected <K,V,N extends IdentifierNamespace<K,V>> void`	`onNamespaceElementAdded(Class<N> type, K key, V value)` Occurs when an item is added to model namespace.
`<K,V,N extends IdentifierNamespace<K,V>> V`	`putToLocalStorage(Class<N> type, K key, V value)` Populate specified namespace with a key/value pair, overwriting previous contents.
`<K,V,N extends IdentifierNamespace<K,V>> V`	`putToLocalStorageIfAbsent(Class<N> type, K key, V value)` Populate specified namespace with a key/value pair unless the key is already associated with a value.
`String`	`rawStatementArgument()` Return the statement argument in literal format.
`void`	`removeStatementFromEffectiveSubstatements(StatementDefinition statementDef)`
`void`	`removeStatementFromEffectiveSubstatements(StatementDefinition statementDef, String statementArg)` Removes a statement context from the effective substatements based on its statement definition (i.e statement keyword) and raw (in String form) statement argument.
`void`	`removeStatementsFromEffectiveSubstatements(Collection<? extends StmtContext<?,?,?>> statements)`
`void`	`setCompletedPhase(ModelProcessingPhase completedPhase)`
`void`	`setIsSupportedToBuildEffective(boolean isSupportedToBuildEffective)`
`String`	`toString()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable
addMutableStmtToSeal, addRequiredSource, addToNs, childCopyOf, coerceParentContext, setRootIdentifier, setRootVersion

Methods inherited from interface org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext
allSubstatements, allSubstatementsStream, coerceRawStatementArgument, coerceStatementArgument, getAllFromCurrentStmtCtxNamespace, getAllFromNamespace, getFromNamespace, getRootVersion, getSchemaPath, getStatementArgument, isConfiguration, isEnabledSemanticVersioning

Methods inherited from interface org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour.NamespaceStorageNode
getStorageNodeType

- Method Detail
  - getEffectOfStatement
```
public Collection<? extends StmtContext<?,?,?>> getEffectOfStatement()
```
    Specified by:
    
    getEffectOfStatement in interface StmtContext<A,D extends DeclaredStatement<A>,E extends EffectiveStatement<A,D>>
  - addAsEffectOfStatement
```
public void addAsEffectOfStatement(StmtContext<?,?,?> ctx)
```
    Specified by:
    
    addAsEffectOfStatement in interface StmtContext.Mutable<A,D extends DeclaredStatement<A>,E extends EffectiveStatement<A,D>>
  - addAsEffectOfStatement
```
public void addAsEffectOfStatement(Collection<? extends StmtContext<?,?,?>> ctxs)
```
    Specified by:
    
    addAsEffectOfStatement in interface StmtContext.Mutable<A,D extends DeclaredStatement<A>,E extends EffectiveStatement<A,D>>
  - isSupportedByFeatures
```
public boolean isSupportedByFeatures()
```
    Specified by:
    
    isSupportedByFeatures in interface StmtContext<A,D extends DeclaredStatement<A>,E extends EffectiveStatement<A,D>>
  - isParentSupportedByFeatures
```
protected abstract boolean isParentSupportedByFeatures()
```
  - isIgnoringIfFeatures
```
protected abstract boolean isIgnoringIfFeatures()
```
  - isIgnoringConfig
```
protected abstract boolean isIgnoringConfig()
```
  - isSupportedToBuildEffective
```
public boolean isSupportedToBuildEffective()
```
    Specified by:
    
    isSupportedToBuildEffective in interface StmtContext<A,D extends DeclaredStatement<A>,E extends EffectiveStatement<A,D>>
  - setIsSupportedToBuildEffective
```
public void setIsSupportedToBuildEffective(boolean isSupportedToBuildEffective)
```
    Specified by:
    
    setIsSupportedToBuildEffective in interface StmtContext.Mutable<A,D extends DeclaredStatement<A>,E extends EffectiveStatement<A,D>>
  - getCopyHistory
```
public CopyHistory getCopyHistory()
```
    Specified by:
    
    getCopyHistory in interface StmtContext<A,D extends DeclaredStatement<A>,E extends EffectiveStatement<A,D>>
  - getOriginalCtx
```
public Optional<StmtContext<?,?,?>> getOriginalCtx()
```
    Specified by:
    
    getOriginalCtx in interface StmtContext<A,D extends DeclaredStatement<A>,E extends EffectiveStatement<A,D>>
  - getCompletedPhase
```
public ModelProcessingPhase getCompletedPhase()
```
    Specified by:
    
    getCompletedPhase in interface StmtContext<A,D extends DeclaredStatement<A>,E extends EffectiveStatement<A,D>>
  - setCompletedPhase
```
public void setCompletedPhase(ModelProcessingPhase completedPhase)
```
    Specified by:
    
    setCompletedPhase in interface StmtContext.Mutable<A,D extends DeclaredStatement<A>,E extends EffectiveStatement<A,D>>
  - getParentContext
```
public abstract StatementContextBase<?,?,?> getParentContext()
```
    Description copied from interface: StmtContext
    
    Return the parent statement context, or null if this is the root statement.
    
    Specified by:
    
    getParentContext in interface StmtContext<A,D extends DeclaredStatement<A>,E extends EffectiveStatement<A,D>>
    
    Specified by:
    
    getParentContext in interface StmtContext.Mutable<A,D extends DeclaredStatement<A>,E extends EffectiveStatement<A,D>>
    
    Returns:
    
    context of parent of statement, or null if this is the root statement.
  - getRoot
```
public abstract RootStatementContext<?,?,?> getRoot()
```
    Returns the model root for this statement.
    
    Specified by:
    
    getRoot in interface StmtContext<A,D extends DeclaredStatement<A>,E extends EffectiveStatement<A,D>>
    
    Specified by:
    
    getRoot in interface StmtContext.Mutable<A,D extends DeclaredStatement<A>,E extends EffectiveStatement<A,D>>
    
    Returns:
    
    root context of statement
  - getStatementSource
```
public StatementSource getStatementSource()
```
    Returns the origin of the statement.
    
    Specified by:
    
    getStatementSource in interface StmtContext<A,D extends DeclaredStatement<A>,E extends EffectiveStatement<A,D>>
    
    Returns:
    
    origin of statement
  - getStatementSourceReference
```
public StatementSourceReference getStatementSourceReference()
```
    Returns a reference to statement source.
    
    Specified by:
    
    getStatementSourceReference in interface StmtContext<A,D extends DeclaredStatement<A>,E extends EffectiveStatement<A,D>>
    
    Returns:
    
    reference of statement source
  - rawStatementArgument
```
public final String rawStatementArgument()
```
    Description copied from interface: StmtContext
    
    Return the statement argument in literal format.
    
    Specified by:
    
    rawStatementArgument in interface StmtContext<A,D extends DeclaredStatement<A>,E extends EffectiveStatement<A,D>>
    
    Returns:
    
    raw statement argument string, or null if this statement does not have an argument.
  - declaredSubstatements
```
public Collection<? extends StmtContext<?,?,?>> declaredSubstatements()
```
    Description copied from interface: StmtContext
    
    Return declared substatements. These are the statements which are explicitly written in the source model.
    
    Specified by:
    
    declaredSubstatements in interface StmtContext<A,D extends DeclaredStatement<A>,E extends EffectiveStatement<A,D>>
    
    Returns:
    
    Collection of declared substatements
  - mutableDeclaredSubstatements
```
public Collection<? extends StmtContext.Mutable<?,?,?>> mutableDeclaredSubstatements()
```
    Specified by:
    
    mutableDeclaredSubstatements in interface StmtContext.Mutable<A,D extends DeclaredStatement<A>,E extends EffectiveStatement<A,D>>
  - effectiveSubstatements
```
public Collection<? extends StmtContext<?,?,?>> effectiveSubstatements()
```
    Description copied from interface: StmtContext
    
    Return effective substatements. These are the statements which are added as this statement's substatements complete their effective model phase.
    
    Specified by:
    
    effectiveSubstatements in interface StmtContext<A,D extends DeclaredStatement<A>,E extends EffectiveStatement<A,D>>
    
    Returns:
    
    Collection of declared substatements
  - mutableEffectiveSubstatements
```
public Collection<? extends StmtContext.Mutable<?,?,?>> mutableEffectiveSubstatements()
```
    Specified by:
    
    mutableEffectiveSubstatements in interface StmtContext.Mutable<A,D extends DeclaredStatement<A>,E extends EffectiveStatement<A,D>>
  - removeStatementsFromEffectiveSubstatements
```
public void removeStatementsFromEffectiveSubstatements(Collection<? extends StmtContext<?,?,?>> statements)
```
  - removeStatementFromEffectiveSubstatements
```
public void removeStatementFromEffectiveSubstatements(StatementDefinition statementDef)
```
  - removeStatementFromEffectiveSubstatements
```
public void removeStatementFromEffectiveSubstatements(StatementDefinition statementDef,
                                                      String statementArg)
```
    Removes a statement context from the effective substatements based on its statement definition (i.e statement keyword) and raw (in String form) statement argument. The statement context is removed only if both statement definition and statement argument match with one of the effective substatements' statement definition and argument.
    If the statementArg parameter is null, the statement context is removed based only on its statement definition.
    
    Parameters:
    
    statementDef - statement definition of the statement context to remove
    
    statementArg - statement argument of the statement context to remove
  - addEffectiveSubstatement
```
public void addEffectiveSubstatement(StmtContext.Mutable<?,?,?> substatement)
```
    Adds an effective statement to collection of substatements.
    
    Parameters:
    
    substatement - substatement
    
    Throws:
    
    IllegalStateException - if added in declared phase
    
    NullPointerException - if statement parameter is null
  - addEffectiveSubstatements
```
public void addEffectiveSubstatements(Collection<? extends StmtContext.Mutable<?,?,?>> statements)
```
    Adds an effective statement to collection of substatements.
    
    Parameters:
    
    statements - substatements
    
    Throws:
    
    IllegalStateException - if added in declared phase
    
    NullPointerException - if statement parameter is null
  - createSubstatement
```
public final <X,Y extends DeclaredStatement<X>,Z extends EffectiveStatement<X,Y>> StatementContextBase<X,Y,Z> createSubstatement(int offset,
                                                                                                                                 StatementDefinitionContext<X,Y,Z> def,
                                                                                                                                 StatementSourceReference ref,
                                                                                                                                 String argument)
```
    Create a new substatement at the specified offset.
    
    Type Parameters:
    
    X - new substatement argument type
    
    Y - new substatement declared type
    
    Z - new substatement effective type
    
    Parameters:
    
    offset - Substatement offset
    
    def - definition context
    
    ref - source reference
    
    argument - statement argument
    
    Returns:
    
    A new substatement
  - appendImplicitStatement
```
public void appendImplicitStatement(StatementSupport<?,?,?> statementToAdd)
```
  - buildDeclared
```
public D buildDeclared()
```
    Description copied from interface: StmtContext
    
    Builds DeclaredStatement for statement context.
    
    Specified by:
    
    buildDeclared in interface StmtContext<A,D extends DeclaredStatement<A>,E extends EffectiveStatement<A,D>>
  - buildEffective
```
public E buildEffective()
```
    Description copied from interface: StmtContext
    
    Builds EffectiveStatement for statement context.
    
    Specified by:
    
    buildEffective in interface StmtContext<A,D extends DeclaredStatement<A>,E extends EffectiveStatement<A,D>>
  - definition
```
protected final @NonNull StatementDefinitionContext<A,D,E> definition()
```
    Return the context in which this statement was defined.
    
    Returns:
    
    statement definition
  - checkLocalNamespaceAllowed
```
protected void checkLocalNamespaceAllowed(Class<? extends IdentifierNamespace<?,?>> type)
```
  - onNamespaceElementAdded
```
protected <K,V,N extends IdentifierNamespace<K,V>> void onNamespaceElementAdded(Class<N> type,
                                                                                K key,
                                                                                V value)
```
    Occurs when an item is added to model namespace.
  - getPublicDefinition
```
public StatementDefinition getPublicDefinition()
```
    See StatementSupport.getPublicView().
    
    Specified by:
    
    getPublicDefinition in interface StmtContext<A,D extends DeclaredStatement<A>,E extends EffectiveStatement<A,D>>
  - newInferenceAction
```
public ModelActionBuilder newInferenceAction(ModelProcessingPhase phase)
```
    Description copied from interface: StmtContext.Mutable
    
    Create a new inference action to be executed during specified phase. The action cannot be cancelled and will be executed even if its definition remains incomplete. The specified phase cannot complete until this action is resolved. If the action cannot be resolved, model processing will fail.
    
    Specified by:
    
    newInferenceAction in interface StmtContext.Mutable<A,D extends DeclaredStatement<A>,E extends EffectiveStatement<A,D>>
    
    Parameters:
    
    phase - Target phase in which the action will resolved.
    
    Returns:
    
    A new action builder.
  - addContext
```
public <K,KT extends K,N extends StatementNamespace<K,?,?>> void addContext(Class<N> namespace,
                                                                            KT key,
                                                                            StmtContext<?,?,?> stmt)
```
    Description copied from interface: StmtContext.Mutable
    
    Adds s statement to namespace map with a key.
    
    Specified by:
    
    addContext in interface StmtContext.Mutable<A,D extends DeclaredStatement<A>,E extends EffectiveStatement<A,D>>
    
    Parameters:
    
    namespace - StatementNamespace child that determines namespace to be added to
    
    key - of type according to namespace class specification
    
    stmt - to be added to namespace map
  - childCopyOf
```
public <X,Y extends DeclaredStatement<X>,Z extends EffectiveStatement<X,Y>> StmtContext.Mutable<X,Y,Z> childCopyOf(StmtContext<X,Y,Z> stmt,
                                                                                                                   CopyType type,
                                                                                                                   QNameModule targetModule)
```
    Description copied from interface: StmtContext.Mutable
    
    Create a child sub-statement, which is a child of this statement, inheriting all attributes from specified child and recording copy type. Resulting object may only be added as a child of this statement.
    
    Specified by:
    
    childCopyOf in interface StmtContext.Mutable<A,D extends DeclaredStatement<A>,E extends EffectiveStatement<A,D>>
    
    Parameters:
    
    stmt - Statement to be used as a template
    
    type - Type of copy to record in history
    
    targetModule - Optional new target module
    
    Returns:
    
    copy of statement considering CopyType (augment, uses)
  - getDefinition
```
public @NonNull StatementDefinition getDefinition()
```
    Description copied from interface: StatementWriter.ResumedStatement
    
    Return statement definition.
    
    Specified by:
    
    getDefinition in interface StatementWriter.ResumedStatement
    
    Returns:
    
    statement definition.
  - getSourceReference
```
public @NonNull StatementSourceReference getSourceReference()
```
    Description copied from interface: StatementWriter.ResumedStatement
    
    Return statement source reference.
    
    Specified by:
    
    getSourceReference in interface StatementWriter.ResumedStatement
    
    Returns:
    
    statement source reference.
  - isFullyDefined
```
public boolean isFullyDefined()
```
    Description copied from interface: StatementWriter.ResumedStatement
    
    Check if the statement has been fully defined. This implies that all its children have been fully defined.
    
    Specified by:
    
    isFullyDefined in interface StatementWriter.ResumedStatement
    
    Returns:
    
    True if the statement has been fully defined.
  - toString
```
public final String toString()
```
    Overrides:
    
    toString in class Object
  - addToStringAttributes
```
protected com.google.common.base.MoreObjects.ToStringHelper addToStringAttributes(com.google.common.base.MoreObjects.ToStringHelper toStringHelper)
```
  - getParentNamespaceStorage
```
public abstract NamespaceBehaviour.NamespaceStorageNode getParentNamespaceStorage()
```
    Specified by:
    
    getParentNamespaceStorage in interface NamespaceBehaviour.NamespaceStorageNode
  - getBehaviourRegistry
```
public abstract NamespaceBehaviour.Registry getBehaviourRegistry()
```
    Return the registry of a source context.
    
    Returns:
    
    registry of source context
  - getFromNamespace
```
public final <K,V,T extends K,N extends IdentifierNamespace<K,V>> V getFromNamespace(Class<N> type,
                                                                                     T key)
```
    Return a value associated with specified key within a namespace.
    
    Type Parameters:
    
    K - namespace key type
    
    V - namespace value type
    
    N - namespace type
    
    T - key type
    
    Parameters:
    
    type - Namespace type
    
    key - Key
    
    Returns:
    
    Value, or null if there is no element
    
    Throws:
    
    NamespaceNotAvailableException - when the namespace is not available.
  - getFromNamespace
```
public final <K,V,N extends IdentifierNamespace<K,V>> Optional<Map.Entry<K,V>> getFromNamespace(Class<N> type,
                                                                                                NamespaceKeyCriterion<K> criterion)
```
  - getAllFromNamespace
```
public final <K,V,N extends IdentifierNamespace<K,V>> Map<K,V> getAllFromNamespace(Class<N> type)
```
  - getAllFromCurrentStmtCtxNamespace
```
public final <K,V,N extends IdentifierNamespace<K,V>> Map<K,V> getAllFromCurrentStmtCtxNamespace(Class<N> type)
```
  - addToNs
```
public final <K,V,T extends K,U extends V,N extends IdentifierNamespace<K,V>> void addToNs(Class<N> type,
                                                                                           T key,
                                                                                           U value)
```
    Associate a value with a key within a namespace.
    
    Type Parameters:
    
    K - namespace key type
    
    V - namespace value type
    
    N - namespace type
    
    T - key type
    
    U - value type
    
    Parameters:
    
    type - Namespace type
    
    key - Key
    
    value - value
    
    Throws:
    
    NamespaceNotAvailableException - when the namespace is not available.
  - addContextToNamespace
```
public final <K,N extends StatementNamespace<K,?,?>> void addContextToNamespace(Class<N> type,
                                                                                K key,
                                                                                StmtContext<?,?,?> value)
```
    Associate a context with a key within a namespace.
    
    Type Parameters:
    
    K - namespace key type
    
    N - namespace type
    
    Parameters:
    
    type - Namespace type
    
    key - Key
    
    value - Context value
    
    Throws:
    
    NamespaceNotAvailableException - when the namespace is not available.
  - getFromLocalStorage
```
public <K,V,N extends IdentifierNamespace<K,V>> V getFromLocalStorage(Class<N> type,
                                                                      K key)
```
    Specified by:
    
    getFromLocalStorage in interface NamespaceBehaviour.NamespaceStorageNode
  - getAllFromLocalStorage
```
public <K,V,N extends IdentifierNamespace<K,V>> Map<K,V> getAllFromLocalStorage(Class<N> type)
```
    Specified by:
    
    getAllFromLocalStorage in interface NamespaceBehaviour.NamespaceStorageNode
  - putToLocalStorage
```
public <K,V,N extends IdentifierNamespace<K,V>> V putToLocalStorage(Class<N> type,
                                                                    K key,
                                                                    V value)
```
    Description copied from interface: NamespaceBehaviour.NamespaceStorageNode
    
    Populate specified namespace with a key/value pair, overwriting previous contents. Similar to Map.put(Object, Object).
    
    Specified by:
    
    putToLocalStorage in interface NamespaceBehaviour.NamespaceStorageNode
    
    Parameters:
    
    type - Namespace identifier
    
    key - Key
    
    value - Value
    
    Returns:
    
    Previously-stored value, or null if the key was not present
  - putToLocalStorageIfAbsent
```
public <K,V,N extends IdentifierNamespace<K,V>> V putToLocalStorageIfAbsent(Class<N> type,
                                                                            K key,
                                                                            V value)
```
    Description copied from interface: NamespaceBehaviour.NamespaceStorageNode
    
    Populate specified namespace with a key/value pair unless the key is already associated with a value. Similar to Map.putIfAbsent(Object, Object).
    
    Specified by:
    
    putToLocalStorageIfAbsent in interface NamespaceBehaviour.NamespaceStorageNode
    
    Parameters:
    
    type - Namespace identifier
    
    key - Key
    
    value - Value
    
    Returns:
    
    Preexisting value or null if there was no previous mapping

Class StatementContextBase<A,D extends DeclaredStatement<A>,E extends EffectiveStatement<A,D>>

Nested Class Summary

Nested classes/interfaces inherited from interface org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable

Methods inherited from interface org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext

Methods inherited from interface org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour.NamespaceStorageNode

Method Detail

getEffectOfStatement

addAsEffectOfStatement

addAsEffectOfStatement

isSupportedByFeatures

isParentSupportedByFeatures

isIgnoringIfFeatures

isIgnoringConfig

isSupportedToBuildEffective

setIsSupportedToBuildEffective

getCopyHistory

getOriginalCtx

getCompletedPhase

setCompletedPhase

getParentContext

getRoot

getStatementSource

getStatementSourceReference

rawStatementArgument

declaredSubstatements

mutableDeclaredSubstatements

effectiveSubstatements

mutableEffectiveSubstatements

removeStatementsFromEffectiveSubstatements

removeStatementFromEffectiveSubstatements

removeStatementFromEffectiveSubstatements

addEffectiveSubstatement

addEffectiveSubstatements

createSubstatement

appendImplicitStatement

buildDeclared

buildEffective

definition

checkLocalNamespaceAllowed

onNamespaceElementAdded

getPublicDefinition

newInferenceAction

addContext

childCopyOf

getDefinition

getSourceReference

isFullyDefined

toString

addToStringAttributes

getParentNamespaceStorage

getBehaviourRegistry

getFromNamespace

getFromNamespace

getAllFromNamespace

getAllFromCurrentStmtCtxNamespace

addToNs

addContextToNamespace

getFromLocalStorage

getAllFromLocalStorage

putToLocalStorage

putToLocalStorageIfAbsent