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