91301d02044df1baad6ae255cb0104a3d869aa4d
[yangtools.git] / yang / yang-parser-impl / src / main / java / org / opendaylight / yangtools / yang / parser / stmt / reactor / StatementContextBase.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.base.Throwables;
12 import com.google.common.collect.HashMultimap;
13 import com.google.common.collect.Multimap;
14 import java.util.ArrayList;
15 import java.util.Collection;
16 import java.util.Collections;
17 import java.util.EventListener;
18 import java.util.Iterator;
19 import java.util.LinkedHashMap;
20 import java.util.List;
21 import java.util.Map;
22 import javax.annotation.Nonnull;
23 import org.opendaylight.yangtools.concepts.Identifiable;
24 import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
25 import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
26 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
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.model.api.meta.StatementSource;
30 import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder;
31 import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
32 import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour;
33 import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour.StorageNodeType;
34 import org.opendaylight.yangtools.yang.parser.spi.meta.StatementNamespace;
35 import org.opendaylight.yangtools.yang.parser.spi.meta.StatementSupport;
36 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
37 import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
38 import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference;
39 import org.opendaylight.yangtools.yang.parser.stmt.reactor.NamespaceBehaviourWithListeners.ValueAddedListener;
40
41 public abstract class StatementContextBase<A, D extends DeclaredStatement<A>, E extends EffectiveStatement<A, D>>
42         extends NamespaceStorageSupport implements StmtContext.Mutable<A, D, E>, Identifiable<StatementIdentifier> {
43
44     /**
45      * event listener when an item is added to model namespace
46      */
47     interface OnNamespaceItemAdded extends EventListener {
48
49         void namespaceItemAdded(StatementContextBase<?, ?, ?> context, Class<?> namespace, Object key, Object value)
50                 throws SourceException;
51
52     }
53
54     /**
55      * event listener when a parsing {@link ModelProcessingPhase} is completed
56      */
57     interface OnPhaseFinished extends EventListener {
58
59         boolean phaseFinished(StatementContextBase<?, ?, ?> context, ModelProcessingPhase phase) throws SourceException;
60
61     }
62
63     /**
64      * interface for all mutations within an {@link ModelActionBuilder.InferenceAction}
65      */
66     interface ContextMutation {
67
68         boolean isFinished();
69
70     }
71
72     private final StatementDefinitionContext<A, D, E> definition;
73     private final StatementIdentifier identifier;
74     private final StatementSourceReference statementDeclSource;
75     private int order = 0;
76
77     private final Map<StatementIdentifier, StatementContextBase<?, ?, ?>> substatements = new LinkedHashMap<>();
78
79     private final Collection<StatementContextBase<?, ?, ?>> declared = new ArrayList<>();
80     private final Collection<StatementContextBase<?, ?, ?>> effective = new ArrayList<>();
81     private final Collection<StatementContextBase<?, ?, ?>> effectOfStatement = new ArrayList<>();
82
83     @Override
84     public Collection<StatementContextBase<?, ?, ?>> getEffectOfStatement() {
85         return effectOfStatement;
86     }
87
88     @Override
89     public void addAsEffectOfStatement(final StatementContextBase<?, ?, ?> ctx) {
90         effectOfStatement.add(ctx);
91     }
92
93     private ModelProcessingPhase completedPhase;
94
95     private final Multimap<ModelProcessingPhase, OnPhaseFinished> phaseListeners = HashMultimap.create();
96     private final Multimap<ModelProcessingPhase, ContextMutation> phaseMutation = HashMultimap.create();
97
98     private D declaredInstance;
99     private E effectiveInstance;
100
101     private StatementContextBase<?, ?, ?> originalCtx;
102     private final List<TypeOfCopy> copyHistory = new ArrayList<>(1);
103
104     private boolean isSupportedToBuildEffective = true;
105
106     @Override
107     public boolean isSupportedToBuildEffective() {
108         return isSupportedToBuildEffective;
109     }
110
111     @Override
112     public void setIsSupportedToBuildEffective(final boolean isSupportedToBuildEffective) {
113         this.isSupportedToBuildEffective = isSupportedToBuildEffective;
114     }
115
116     @Override
117     public List<TypeOfCopy> getCopyHistory() {
118         return copyHistory;
119     }
120
121     @Override
122     public void addToCopyHistory(final TypeOfCopy typeOfCopy) {
123         this.copyHistory.add(typeOfCopy);
124     }
125
126     @Override
127     public void addAllToCopyHistory(final List<TypeOfCopy> typeOfCopyList) {
128         this.copyHistory.addAll(typeOfCopyList);
129     }
130
131     @Override
132     public StatementContextBase<?, ?, ?> getOriginalCtx() {
133         return originalCtx;
134     }
135
136     @Override
137     public void setOriginalCtx(final StatementContextBase<?, ?, ?> originalCtx) {
138         this.originalCtx = originalCtx;
139     }
140
141     @Override
142     public void setOrder(final int order) {
143         this.order = order;
144     }
145
146     @Override
147     public int getOrder() {
148         return order;
149     }
150
151     @Override
152     public ModelProcessingPhase getCompletedPhase() {
153         return completedPhase;
154     }
155
156     @Override
157     public void setCompletedPhase(final ModelProcessingPhase completedPhase) {
158         this.completedPhase = completedPhase;
159     }
160
161     StatementContextBase(@Nonnull final ContextBuilder<A, D, E> builder) throws SourceException {
162         this.definition = builder.getDefinition();
163         this.identifier = builder.createIdentifier();
164         this.statementDeclSource = builder.getStamementSource();
165         this.completedPhase = null;
166         this.copyHistory.add(TypeOfCopy.ORIGINAL);
167     }
168
169     StatementContextBase(final StatementContextBase<A, D, E> original) {
170         this.definition = Preconditions
171                 .checkNotNull(original.definition, "Statement context definition cannot be null");
172         this.identifier = Preconditions
173                 .checkNotNull(original.identifier, "Statement context identifier cannot be null");
174         this.statementDeclSource = Preconditions.checkNotNull(original.statementDeclSource,
175                 "Statement context statementDeclSource cannot be null");
176         this.completedPhase = null;
177         this.copyHistory.add(TypeOfCopy.ORIGINAL);
178     }
179
180     /**
181      * @return context of parent of statement
182      */
183     @Override
184     public abstract StatementContextBase<?, ?, ?> getParentContext();
185
186     /**
187      * @return root context of statement
188      */
189     @Override
190     public abstract RootStatementContext<?, ?, ?> getRoot();
191
192     /**
193      * @return statement identifier
194      */
195     @Override
196     public StatementIdentifier getIdentifier() {
197         return identifier;
198     }
199
200     /**
201      * @return origin of statement
202      */
203     @Override
204     public StatementSource getStatementSource() {
205         return statementDeclSource.getStatementSource();
206     }
207
208     /**
209      * @return reference of statement source
210      */
211     @Override
212     public StatementSourceReference getStatementSourceReference() {
213         return statementDeclSource;
214     }
215
216     /**
217      * @return raw statement argument string
218      */
219     @Override
220     public String rawStatementArgument() {
221         return identifier.getArgument();
222     }
223
224     /**
225      * @return collection of declared substatements
226      */
227     @Override
228     public Collection<StatementContextBase<?, ?, ?>> declaredSubstatements() {
229         return Collections.unmodifiableCollection(declared);
230     }
231
232     /**
233      * @return collection of substatements
234      */
235     @Override
236     public Collection<StatementContextBase<?, ?, ?>> substatements() {
237         return Collections.unmodifiableCollection(substatements.values());
238     }
239
240     /**
241      * @return collection of effective substatements
242      */
243     @Override
244     public Collection<StatementContextBase<?, ?, ?>> effectiveSubstatements() {
245         return Collections.unmodifiableCollection(effective);
246     }
247
248     public void removeStatementsFromEffectiveSubstatements(final Collection<StatementContextBase<?, ?, ?>> substatements) {
249         effective.removeAll(substatements);
250     }
251
252     public void removeStatementFromEffectiveSubstatements(final StatementDefinition refineSubstatementDef) {
253         Iterator<StatementContextBase<?, ?, ?>> iterator = effective.iterator();
254         while (iterator.hasNext()) {
255             StatementContextBase<?, ?, ?> next = iterator.next();
256             if (next.getPublicDefinition().equals(refineSubstatementDef)) {
257                 iterator.remove();
258             }
259         }
260     }
261
262     /**
263      * adds effective statement to collection of substatements
264      *
265      * @throws IllegalStateException
266      *             if added in declared phase
267      * @throws NullPointerException
268      *             if statement parameter is null
269      *
270      * @param substatement substatement
271      */
272     public void addEffectiveSubstatement(final StatementContextBase<?, ?, ?> substatement) {
273
274         final ModelProcessingPhase inProgressPhase = getRoot().getSourceContext().getInProgressPhase();
275         Preconditions.checkState(inProgressPhase == ModelProcessingPhase.FULL_DECLARATION
276                 || inProgressPhase == ModelProcessingPhase.EFFECTIVE_MODEL,
277                 "Effective statement cannot be added in declared phase");
278
279         effective.add(Preconditions.checkNotNull(substatement,
280                 "StatementContextBase effective substatement cannot be null"));
281     }
282
283     /**
284      * adds declared statement to collection of substatements
285      *
286      * @throws IllegalStateException
287      *             if added in effective phase
288      * @throws NullPointerException
289      *             if statement parameter is null
290      *
291      * @param substatement substatement
292      */
293     public void addDeclaredSubstatement(final StatementContextBase<?, ?, ?> substatement) {
294
295         final ModelProcessingPhase inProgressPhase = getRoot().getSourceContext().getInProgressPhase();
296         Preconditions.checkState(inProgressPhase != ModelProcessingPhase.EFFECTIVE_MODEL,
297                 "Declared statement cannot be added in effective phase");
298
299         declared.add(Preconditions.checkNotNull(substatement,
300                 "StatementContextBase declared substatement cannot be null"));
301     }
302
303     /**
304      * builds new substatement from statement definition context and statement source reference
305      *
306      * @param def definition context
307      * @param ref source reference
308      *
309      * @return instance of ContextBuilder
310      */
311     @SuppressWarnings({ "rawtypes", "unchecked" })
312     public ContextBuilder<?, ?, ?> substatementBuilder(final StatementDefinitionContext<?, ?, ?> def,
313             final StatementSourceReference ref) {
314         return new ContextBuilder(def, ref) {
315
316             @Override
317             public StatementContextBase build() throws SourceException {
318                 StatementContextBase<?, ?, ?> potential = null;
319
320                 if (getDefinition().getPublicView() != Rfc6020Mapping.AUGMENT) {
321                     potential = substatements.get(createIdentifier());
322                 }
323                 if (potential == null) {
324                     potential = new SubstatementContext(StatementContextBase.this, this);
325                     substatements.put(createIdentifier(), potential);
326                     getDefinition().onStatementAdded(potential);
327                 }
328                 potential.resetLists();
329                 switch (this.getStamementSource().getStatementSource()) {
330                 case DECLARATION:
331                     addDeclaredSubstatement(potential);
332                     break;
333                 case CONTEXT:
334                     addEffectiveSubstatement(potential);
335                     break;
336                 }
337                 return potential;
338             }
339         };
340     }
341
342     /**
343      * @return local namespace behaviour type {@link NamespaceBehaviour}
344      */
345     @Override
346     public StorageNodeType getStorageNodeType() {
347         return StorageNodeType.STATEMENT_LOCAL;
348     }
349
350     /**
351      * builds {@link DeclaredStatement} for statement context
352      */
353     @Override
354     public D buildDeclared() {
355         Preconditions.checkArgument(completedPhase == ModelProcessingPhase.FULL_DECLARATION
356                 || completedPhase == ModelProcessingPhase.EFFECTIVE_MODEL);
357         if (declaredInstance == null) {
358             declaredInstance = definition().getFactory().createDeclared(this);
359         }
360         return declaredInstance;
361     }
362
363     /**
364      * builds {@link EffectiveStatement} for statement context
365      */
366     @Override
367     public E buildEffective() {
368         if (effectiveInstance == null) {
369             effectiveInstance = definition().getFactory().createEffective(this);
370         }
371         return effectiveInstance;
372     }
373
374     /**
375      * clears collection of declared substatements
376      *
377      * @throws IllegalStateException
378      *             if invoked in effective build phase
379      */
380     void resetLists() {
381
382         final SourceSpecificContext sourceContext = getRoot().getSourceContext();
383         Preconditions.checkState(sourceContext.getInProgressPhase() != ModelProcessingPhase.EFFECTIVE_MODEL,
384                 "Declared statements list cannot be cleared in effective phase");
385
386         declared.clear();
387     }
388
389     /**
390      * tries to execute current {@link ModelProcessingPhase} of source parsing
391      *
392      * @param phase
393      *            to be executed (completed)
394      * @return if phase was successfully completed
395      * @throws SourceException
396      *             when an error occured in source parsing
397      */
398     boolean tryToCompletePhase(final ModelProcessingPhase phase) throws SourceException {
399         Iterator<ContextMutation> openMutations = phaseMutation.get(phase).iterator();
400         boolean finished = true;
401         while (openMutations.hasNext()) {
402             ContextMutation current = openMutations.next();
403             if (current.isFinished()) {
404                 openMutations.remove();
405             } else {
406                 finished = false;
407             }
408         }
409         for (StatementContextBase<?, ?, ?> child : declared) {
410             finished &= child.tryToCompletePhase(phase);
411         }
412         for (StatementContextBase<?, ?, ?> child : effective) {
413             finished &= child.tryToCompletePhase(phase);
414         }
415
416         if (finished) {
417             onPhaseCompleted(phase);
418             return true;
419         }
420         return false;
421     }
422
423     /**
424      * occurs on end of {@link ModelProcessingPhase} of source parsing
425      *
426      * @param phase
427      *            that was to be completed (finished)
428      * @throws SourceException
429      *             when an error occured in source parsing
430      */
431     private void onPhaseCompleted(final ModelProcessingPhase phase) throws SourceException {
432         completedPhase = phase;
433         Iterator<OnPhaseFinished> listener = phaseListeners.get(completedPhase).iterator();
434         while (listener.hasNext()) {
435             OnPhaseFinished next = listener.next();
436             if (next.phaseFinished(this, phase)) {
437                 listener.remove();
438             }
439         }
440     }
441
442     /**
443      * Ends declared section of current node.
444      *
445      * @param ref
446      * @throws SourceException
447      */
448     void endDeclared(final StatementSourceReference ref, final ModelProcessingPhase phase) throws SourceException {
449         definition().onDeclarationFinished(this, phase);
450     }
451
452     /**
453      * @return statement definition
454      */
455     protected final StatementDefinitionContext<A, D, E> definition() {
456         return definition;
457     }
458
459     @Override
460     protected void checkLocalNamespaceAllowed(final Class<? extends IdentifierNamespace<?, ?>> type) {
461         definition().checkNamespaceAllowed(type);
462     }
463
464     /**
465      * occurs when an item is added to model namespace
466      *
467      * @throws SourceException instance of SourceException
468      */
469     @Override
470     protected <K, V, N extends IdentifierNamespace<K, V>> void onNamespaceElementAdded(final Class<N> type, final K key, final V value) {
471         // definition().onNamespaceElementAdded(this, type, key, value);
472     }
473
474     <K, V, N extends IdentifierNamespace<K, V>> void onNamespaceItemAddedAction(final Class<N> type, final K key,
475             final OnNamespaceItemAdded listener) throws SourceException {
476         Object potential = getFromNamespace(type, key);
477         if (potential != null) {
478             listener.namespaceItemAdded(this, type, key, potential);
479             return;
480         }
481         NamespaceBehaviour<K, V, N> behaviour = getBehaviourRegistry().getNamespaceBehaviour(type);
482         if (behaviour instanceof NamespaceBehaviourWithListeners) {
483             NamespaceBehaviourWithListeners<K, V, N> casted = (NamespaceBehaviourWithListeners<K, V, N>) behaviour;
484             casted.addValueListener(new ValueAddedListener<K>(this, key) {
485                 @Override
486                 void onValueAdded(final Object key, final Object value) {
487                     try {
488                         listener.namespaceItemAdded(StatementContextBase.this, type, key, value);
489                     } catch (SourceException e) {
490                         throw Throwables.propagate(e);
491                     }
492                 }
493             });
494         }
495     }
496
497     /**
498      * @see StatementSupport#getPublicView()
499      */
500     @Override
501     public StatementDefinition getPublicDefinition() {
502         return definition().getPublicView();
503     }
504
505     /**
506      * @return new {@link ModelActionBuilder} for the phase
507      */
508     @Override
509     public ModelActionBuilder newInferenceAction(final ModelProcessingPhase phase) {
510         return getRoot().getSourceContext().newInferenceAction(phase);
511     }
512
513     /**
514      * adds {@link OnPhaseFinished} listener for a {@link ModelProcessingPhase} end
515      *
516      * @throws SourceException
517      */
518     void addPhaseCompletedListener(final ModelProcessingPhase phase, final OnPhaseFinished listener) throws SourceException {
519
520         Preconditions.checkNotNull(phase, "Statement context processing phase cannot be null");
521         Preconditions.checkNotNull(listener, "Statement context phase listener cannot be null");
522
523         ModelProcessingPhase finishedPhase = completedPhase;
524         while (finishedPhase != null) {
525             if (phase.equals(finishedPhase)) {
526                 listener.phaseFinished(this, finishedPhase);
527                 return;
528             }
529             finishedPhase = finishedPhase.getPreviousPhase();
530         }
531         phaseListeners.put(phase, listener);
532     }
533
534     /**
535      * adds {@link ContextMutation} to {@link ModelProcessingPhase}
536      *
537      * @throws IllegalStateException
538      *             when the mutation was registered after phase was completed
539      */
540     void addMutation(final ModelProcessingPhase phase, final ContextMutation mutation) {
541         ModelProcessingPhase finishedPhase = completedPhase;
542         while (finishedPhase != null) {
543             if (phase.equals(finishedPhase)) {
544                 throw new IllegalStateException("Mutation registered after phase was completed.");
545             }
546             finishedPhase = finishedPhase.getPreviousPhase();
547         }
548         phaseMutation.put(phase, mutation);
549     }
550
551     /**
552      * adds statement to namespace map with the key
553      *
554      * @param namespace
555      *            {@link StatementNamespace} child that determines namespace to be added to
556      * @param key
557      *            of type according to namespace class specification
558      * @param stmt
559      *            to be added to namespace map
560      */
561     @Override
562     public <K, KT extends K, N extends StatementNamespace<K, ?, ?>> void addContext(final Class<N> namespace, final KT key,
563             final StmtContext<?, ?, ?> stmt) {
564         addContextToNamespace(namespace, (K) key, stmt);
565     }
566 }