yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/SourceSpecificContext.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 org.opendaylight.yangtools.yang.common.QNameModule;
  11 import org.opendaylight.yangtools.yang.common.YangConstants;
  12 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
  13
  14 import com.google.common.base.Preconditions;
  15 import com.google.common.collect.HashMultimap;
  16 import com.google.common.collect.ImmutableMap;
  17 import com.google.common.collect.Multimap;
  18 import java.util.ArrayList;
  19 import java.util.Collection;
  20 import java.util.Iterator;
  21 import java.util.Map;
  22 import java.util.Objects;
  23 import javax.annotation.Nullable;
  24 import org.opendaylight.yangtools.concepts.Mutable;
  25 import org.opendaylight.yangtools.yang.common.QName;
  26 import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
  27 import org.opendaylight.yangtools.yang.model.api.meta.IdentifierNamespace;
  28 import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
  29 import org.opendaylight.yangtools.yang.parser.spi.ExtensionNamespace;
  30 import org.opendaylight.yangtools.yang.parser.spi.meta.ImportedNamespaceContext;
  31 import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
  32 import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder;
  33 import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
  34 import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour;
  35 import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour.NamespaceStorageNode;
  36 import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour.StorageNodeType;
  37 import org.opendaylight.yangtools.yang.parser.spi.meta.StatementSupport;
  38 import org.opendaylight.yangtools.yang.parser.spi.source.PrefixToModule;
  39 import org.opendaylight.yangtools.yang.parser.spi.source.PrefixToModuleMap;
  40 import org.opendaylight.yangtools.yang.parser.spi.source.QNameToStatementDefinition;
  41 import org.opendaylight.yangtools.yang.parser.spi.source.QNameToStatementDefinitionMap;
  42 import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
  43 import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference;
  44 import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
  45 import org.opendaylight.yangtools.yang.parser.stmt.reactor.StatementContextBase.ContextBuilder;
  46 import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.UnknownStatementImpl;
  47 import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.Utils;
  48
  49 public class SourceSpecificContext implements NamespaceStorageNode, NamespaceBehaviour.Registry, Mutable {
  50
  51     public enum PhaseCompletionProgress {
  52         NO_PROGRESS,
  53         PROGRESS,
  54         FINISHED
  55     }
  56
  57     private final StatementStreamSource source;
  58     private final BuildGlobalContext currentContext;
  59     private final Collection<NamespaceStorageNode> importedNamespaces = new ArrayList<>();
  60     private final Multimap<ModelProcessingPhase, ModifierImpl> modifiers = HashMultimap.create();
  61
  62     private RootStatementContext<?,?, ?> root;
  63
  64     private ModelProcessingPhase inProgressPhase;
  65     private ModelProcessingPhase finishedPhase;
  66     private QNameToStatementDefinitionMap qNameToStmtDefMap = new QNameToStatementDefinitionMap();
  67     private PrefixToModuleMap prefixToModuleMap = new PrefixToModuleMap();
  68
  69
  70     SourceSpecificContext(BuildGlobalContext currentContext,StatementStreamSource source) {
  71         this.source = source;
  72         this.currentContext = currentContext;
  73     }
  74
  75     StatementDefinitionContext<?,?,?> getDefinition(QName name) {
  76         return currentContext.getStatementDefinition(name);
  77     }
  78
  79     ContextBuilder<?, ?, ?> createDeclaredChild(StatementContextBase<?, ?, ?> current, QName name, StatementSourceReference ref) {
  80         StatementDefinitionContext<?,?,?> def = getDefinition(name);
  81
  82         //extensions
  83         if (def == null) {
  84             if (Utils.isValidStatementDefinition(prefixToModuleMap, qNameToStmtDefMap, name)) {
  85                 def = new StatementDefinitionContext<>(new UnknownStatementImpl.Definition(qNameToStmtDefMap.get(Utils.trimPrefix(name))));
  86             }
  87         }
  88
  89         Preconditions.checkArgument(def != null, "Statement %s does not have type mapping defined.", name);
  90         if(current == null) {
  91             return createDeclaredRoot(def,ref);
  92         }
  93         return current.substatementBuilder(def, ref);
  94     }
  95
  96     @SuppressWarnings({ "rawtypes", "unchecked" })
  97     private ContextBuilder<?,?, ?> createDeclaredRoot(StatementDefinitionContext<?,?,?> def, StatementSourceReference ref) {
  98         return new ContextBuilder(def,ref) {
  99
 100             @Override
 101             public StatementContextBase build() throws SourceException {
 102                 if(root == null) {
 103                     root = new RootStatementContext(this, SourceSpecificContext.this);
 104                 } else {
 105                     Preconditions.checkState(root.getIdentifier().equals(getIdentifier()), "Root statement was already defined as %s.", root.getIdentifier());
 106                 }
 107                 root.resetLists();
 108                 return root;
 109             }
 110
 111         };
 112     }
 113
 114     RootStatementContext<?,?,?> getRoot() {
 115         return root;
 116     }
 117
 118     DeclaredStatement<?> buildDeclared() {
 119         return root.buildDeclared();
 120     }
 121
 122     EffectiveStatement<?,?> buildEffective() {
 123         return root.buildEffective();
 124     }
 125
 126     void startPhase(ModelProcessingPhase phase) {
 127         @Nullable ModelProcessingPhase previousPhase = phase.getPreviousPhase();
 128         Preconditions.checkState(Objects.equals(previousPhase, finishedPhase));
 129         Preconditions.checkState(modifiers.get(previousPhase).isEmpty());
 130         inProgressPhase = phase;
 131     }
 132
 133     @Override
 134     public <K, V, N extends IdentifierNamespace<K, V>> void addToLocalStorage(Class<N> type, K key, V value) {
 135         if(ImportedNamespaceContext.class.isAssignableFrom(type)) {
 136             importedNamespaces.add((NamespaceStorageNode) value);
 137         }
 138         getRoot().addToLocalStorage(type, key, value);
 139     }
 140
 141     @Override
 142     public StorageNodeType getStorageNodeType() {
 143         return StorageNodeType.SOURCE_LOCAL_SPECIAL;
 144     }
 145
 146     @Override
 147     public <K, V, N extends IdentifierNamespace<K, V>> V getFromLocalStorage(Class<N> type, K key) {
 148         final V potentialLocal = getRoot().getFromLocalStorage(type, key);
 149         if(potentialLocal != null) {
 150             return potentialLocal;
 151         }
 152         for(NamespaceStorageNode importedSource : importedNamespaces) {
 153             V potential = importedSource.getFromLocalStorage(type, key);
 154             if(potential != null) {
 155                 return potential;
 156             }
 157         }
 158         return null;
 159     }
 160
 161     @Override
 162     public <K, V, N extends IdentifierNamespace<K, V>> NamespaceBehaviour<K, V, N> getNamespaceBehaviour(Class<N> type) {
 163         return currentContext.getNamespaceBehaviour(type);
 164     }
 165
 166     @Override
 167     public NamespaceStorageNode getParentNamespaceStorage() {
 168         return currentContext;
 169     }
 170
 171     PhaseCompletionProgress tryToCompletePhase(ModelProcessingPhase phase) throws SourceException {
 172         Collection<ModifierImpl> currentPhaseModifiers = modifiers.get(phase);
 173
 174         boolean hasProgressed = hasProgress(currentPhaseModifiers);
 175
 176         boolean phaseCompleted = root.tryToCompletePhase(phase);
 177
 178         hasProgressed = (hasProgress(currentPhaseModifiers) | hasProgressed);
 179
 180         if(phaseCompleted && (currentPhaseModifiers.isEmpty())) {
 181             finishedPhase = phase;
 182             return PhaseCompletionProgress.FINISHED;
 183
 184         }
 185         if(hasProgressed) {
 186             return PhaseCompletionProgress.PROGRESS;
 187         }
 188         return PhaseCompletionProgress.NO_PROGRESS;
 189     }
 190
 191
 192     private boolean hasProgress(Collection<ModifierImpl> currentPhaseModifiers) {
 193
 194         Iterator<ModifierImpl> modifier = currentPhaseModifiers.iterator();
 195         boolean hasProgressed = false;
 196         while(modifier.hasNext()) {
 197             if(modifier.next().isApplied()) {
 198                 modifier.remove();
 199                 hasProgressed = true;
 200             }
 201         }
 202
 203         return hasProgressed;
 204
 205     }
 206
 207     ModelActionBuilder newInferenceAction(ModelProcessingPhase phase) {
 208         ModifierImpl action = new ModifierImpl(phase);
 209         modifiers.put(phase, action);
 210         return action;
 211     }
 212
 213     @Override
 214     public String toString() {
 215         return "SourceSpecificContext [source=" + source + ", current=" + inProgressPhase + ", finished="
 216                 + finishedPhase + "]";
 217     }
 218
 219     SourceException failModifiers(ModelProcessingPhase identifier) {
 220         InferenceException sourceEx = new InferenceException("Fail to infer source relationships", root.getStatementSourceReference());
 221
 222
 223         for(ModifierImpl mod : modifiers.get(identifier)) {
 224             try {
 225                 mod.failModifier();
 226             } catch (SourceException e) {
 227                 sourceEx.addSuppressed(e);
 228             }
 229         }
 230         return sourceEx;
 231     }
 232
 233     void loadStatements() throws SourceException {
 234         switch (inProgressPhase) {
 235             case SOURCE_LINKAGE:
 236             source.writeLinkage(new StatementContextWriter(this, inProgressPhase),stmtDef());
 237             break;
 238             case STATEMENT_DEFINITION:
 239             source.writeLinkageAndStatementDefinitions(new StatementContextWriter(this, inProgressPhase), stmtDef(), prefixes());
 240             break;
 241             case FULL_DECLARATION:
 242             source.writeFull(new StatementContextWriter(this, inProgressPhase), stmtDef(), prefixes());
 243             break;
 244         default:
 245             break;
 246         }
 247     }
 248
 249     private PrefixToModule prefixes() {
 250         Map<String, QNameModule> prefixes = (Map<String, QNameModule>) currentContext.getAllFromNamespace(PrefixToModule.class);
 251         for (Map.Entry<String, QNameModule> prefix : prefixes.entrySet()) {
 252             prefixToModuleMap.put(prefix.getKey(), prefix.getValue());
 253         }
 254         return prefixToModuleMap;
 255     }
 256
 257     private QNameToStatementDefinition stmtDef() {
 258         //regular YANG statements added
 259         ImmutableMap<QName, StatementSupport<?, ?, ?>> definitions = currentContext.getSupportsForPhase(
 260                 inProgressPhase).getDefinitions();
 261         for (Map.Entry<QName, StatementSupport<?,?,?>> entry : definitions.entrySet()) {
 262             qNameToStmtDefMap.put(entry.getKey(), entry.getValue());
 263         }
 264
 265         //extensions added
 266         if (inProgressPhase.equals(ModelProcessingPhase.FULL_DECLARATION)) {
 267             Map<QName, SubstatementContext<?, ?, ?>> extensions = (Map<QName, SubstatementContext<?, ?, ?>>) currentContext.getAllFromNamespace(ExtensionNamespace.class);
 268             if (extensions != null) {
 269                 for (Map.Entry<QName, SubstatementContext<?, ?, ?>> extension : extensions.entrySet()) {
 270                     qNameToStmtDefMap.put(new QName(YangConstants.RFC6020_YIN_NAMESPACE, extension.getKey().getLocalName()), (StatementDefinition) extension.getValue().definition().getFactory());
 271                 }
 272             }
 273         }
 274         return qNameToStmtDefMap;
 275     }
 276 }