Propagate @Nonnull and @Nullable annotations

[yangtools.git] / yang / yang-parser-impl / src / main / java / org / opendaylight / yangtools / yang / parser / stmt / reactor / StatementContextBase.java

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementContextBase.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementContextBase.java
index 2741ce81070ae7585c5e46d9f6c61e1be7608594..61244458cd561d6581535248b6f9dfdb3626b17f 100644 (file)
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementContextBase.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementContextBase.java
@@ -7,11 +7,12 @@
  */
 package org.opendaylight.yangtools.yang.parser.stmt.reactor;
 
+import com.google.common.base.MoreObjects;
+import com.google.common.base.MoreObjects.ToStringHelper;
 import com.google.common.base.Preconditions;
 import com.google.common.base.Throwables;
 import com.google.common.collect.ImmutableCollection;
 import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableMultimap;
 import com.google.common.collect.Multimap;
 import com.google.common.collect.Multimaps;
@@ -21,11 +22,8 @@ import java.util.Collections;
 import java.util.EnumMap;
 import java.util.EventListener;
 import java.util.Iterator;
-import java.util.LinkedHashMap;
-import java.util.Map;
 import javax.annotation.Nonnull;
 import org.opendaylight.yangtools.concepts.Identifiable;
-import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
 import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.meta.IdentifierNamespace;
@@ -47,6 +45,37 @@ import org.opendaylight.yangtools.yang.parser.stmt.reactor.NamespaceBehaviourWit
 public abstract class StatementContextBase<A, D extends DeclaredStatement<A>, E extends EffectiveStatement<A, D>>
         extends NamespaceStorageSupport implements StmtContext.Mutable<A, D, E>, Identifiable<StatementIdentifier> {
 
+    @SuppressWarnings({ "rawtypes", "unchecked" })
+    private final class SubContextBuilder extends ContextBuilder {
+        final int childId;
+
+        SubContextBuilder(final int childId, final StatementDefinitionContext def,
+            final StatementSourceReference sourceRef) {
+            super(def, sourceRef);
+            this.childId = childId;
+        }
+
+        @Override
+        public StatementContextBase build() {
+            StatementContextBase<?, ?, ?> potential = substatements.get(childId);
+            if (potential == null) {
+                potential = new SubstatementContext(StatementContextBase.this, this);
+                substatements = substatements.put(childId, potential);
+                getDefinition().onStatementAdded(potential);
+            }
+            potential.resetLists();
+            switch (this.getStamementSource().getStatementSource()) {
+            case DECLARATION:
+                addDeclaredSubstatement(potential);
+                break;
+            case CONTEXT:
+                addEffectiveSubstatement(potential);
+                break;
+            }
+            return potential;
+        }
+    }
+
     /**
      * event listener when an item is added to model namespace
      */
@@ -81,10 +110,10 @@ public abstract class StatementContextBase<A, D extends DeclaredStatement<A>, E
 
     private Multimap<ModelProcessingPhase, OnPhaseFinished> phaseListeners = ImmutableMultimap.of();
     private Multimap<ModelProcessingPhase, ContextMutation> phaseMutation = ImmutableMultimap.of();
-    private Map<StatementIdentifier, StatementContextBase<?, ?, ?>> substatements = ImmutableMap.of();
     private Collection<StatementContextBase<?, ?, ?>> declared = ImmutableList.of();
     private Collection<StatementContextBase<?, ?, ?>> effective = ImmutableList.of();
     private Collection<StatementContextBase<?, ?, ?>> effectOfStatement = ImmutableList.of();
+    private StatementMap substatements = StatementMap.empty();
 
     private SupportedByFeatures supportedByFeatures = SupportedByFeatures.UNDEFINED;
     private CopyHistory copyHistory = CopyHistory.original();
@@ -126,6 +155,10 @@ public abstract class StatementContextBase<A, D extends DeclaredStatement<A>, E
 
     @Override
     public void addAsEffectOfStatement(final Collection<StatementContextBase<?, ?, ?>> ctxs) {
+        if (ctxs.isEmpty()) {
+            return;
+        }
+
         if (effectOfStatement.isEmpty()) {
             effectOfStatement = new ArrayList<>(ctxs.size());
         }
@@ -201,6 +234,7 @@ public abstract class StatementContextBase<A, D extends DeclaredStatement<A>, E
     /**
      * @return root context of statement
      */
+    @Nonnull
     @Override
     public abstract RootStatementContext<?, ?, ?> getRoot();
 
@@ -215,6 +249,7 @@ public abstract class StatementContextBase<A, D extends DeclaredStatement<A>, E
     /**
      * @return origin of statement
      */
+    @Nonnull
     @Override
     public StatementSource getStatementSource() {
         return statementDeclSource.getStatementSource();
@@ -223,6 +258,7 @@ public abstract class StatementContextBase<A, D extends DeclaredStatement<A>, E
     /**
      * @return reference of statement source
      */
+    @Nonnull
     @Override
     public StatementSourceReference getStatementSourceReference() {
         return statementDeclSource;
@@ -244,19 +280,13 @@ public abstract class StatementContextBase<A, D extends DeclaredStatement<A>, E
         return Collections.unmodifiableCollection(input);
     }
 
+    @Nonnull
     @Override
     public Collection<StatementContextBase<?, ?, ?>> declaredSubstatements() {
         return maybeWrap(declared);
     }
 
-    /**
-     * @return collection of all substatements
-     */
-    @Override
-    public Collection<StatementContextBase<?, ?, ?>> substatements() {
-        return maybeWrap(substatements.values());
-    }
-
+    @Nonnull
     @Override
     public Collection<StatementContextBase<?, ?, ?>> effectiveSubstatements() {
         return maybeWrap(effective);
@@ -317,6 +347,10 @@ public abstract class StatementContextBase<A, D extends DeclaredStatement<A>, E
      *             if statement parameter is null
      */
     public void addEffectiveSubstatements(final Collection<StatementContextBase<?, ?, ?>> substatements) {
+        if (substatements.isEmpty()) {
+            return;
+        }
+
         substatements.forEach(Preconditions::checkNotNull);
         beforeAddEffectiveStatement(substatements.size());
         effective.addAll(substatements);
@@ -363,40 +397,9 @@ public abstract class StatementContextBase<A, D extends DeclaredStatement<A>, E
      *
      * @return instance of ContextBuilder
      */
-    @SuppressWarnings({ "rawtypes", "unchecked" })
-    public ContextBuilder<?, ?, ?> substatementBuilder(final StatementDefinitionContext<?, ?, ?> def,
+    ContextBuilder<?, ?, ?> substatementBuilder(final int childId, final StatementDefinitionContext<?, ?, ?> def,
             final StatementSourceReference ref) {
-        return new ContextBuilder(def, ref) {
-
-            @Override
-            public StatementContextBase build() throws SourceException {
-                StatementContextBase<?, ?, ?> potential = null;
-
-                final StatementDefinition stmtDef = getDefinition().getPublicView();
-                if (stmtDef != Rfc6020Mapping.AUGMENT && stmtDef != Rfc6020Mapping.DEVIATION
-                        && stmtDef != Rfc6020Mapping.TYPE) {
-                    potential = substatements.get(createIdentifier());
-                }
-                if (potential == null) {
-                    potential = new SubstatementContext(StatementContextBase.this, this);
-                    if (substatements.isEmpty()) {
-                        substatements = new LinkedHashMap<>(1);
-                    }
-                    substatements.put(createIdentifier(), potential);
-                    getDefinition().onStatementAdded(potential);
-                }
-                potential.resetLists();
-                switch (this.getStamementSource().getStatementSource()) {
-                case DECLARATION:
-                    addDeclaredSubstatement(potential);
-                    break;
-                case CONTEXT:
-                    addEffectiveSubstatement(potential);
-                    break;
-                }
-                return potential;
-            }
-        };
+        return new SubContextBuilder(childId, def, ref);
     }
 
     /**
@@ -582,6 +585,7 @@ public abstract class StatementContextBase<A, D extends DeclaredStatement<A>, E
     /**
      * @see StatementSupport#getPublicView()
      */
+    @Nonnull
     @Override
     public StatementDefinition getPublicDefinition() {
         return definition().getPublicView();
@@ -661,6 +665,15 @@ public abstract class StatementContextBase<A, D extends DeclaredStatement<A>, E
     @Override
     public <K, KT extends K, N extends StatementNamespace<K, ?, ?>> void addContext(final Class<N> namespace, final KT key,
             final StmtContext<?, ?, ?> stmt) {
-        addContextToNamespace(namespace, (K) key, stmt);
+        addContextToNamespace(namespace, key, stmt);
+    }
+
+    @Override
+    public final String toString() {
+        return addToStringAttributes(MoreObjects.toStringHelper(this).omitNullValues()).toString();
+    }
+
+    protected ToStringHelper addToStringAttributes(final ToStringHelper toStringHelper) {
+        return toStringHelper.add("definition", definition).add("id", identifier);
     }
 }