Again make parallellizations prettier.

Author: Maarten

src/main/java/org/leibnizcenter/cfg/earleyparser/ExpressionWrapper.java

@@ -8,22 +8,26 @@ public class ExpressionWrapper extends Resolvable {
     private Resolvable expression;
 
     public ExpressionWrapper(Resolvable expression) {
+        if (expression == null) throw new NullPointerException();
         this.expression = expression;
     }
 
     @SuppressWarnings("unused")
     public Resolvable getExpression() {
         if (lock) throw new IllegalStateException("Value already locked");
+        if (expression == null) throw new NullPointerException();
         return expression;
     }
 
     @SuppressWarnings("unused")
     public void setExpression(Resolvable expression) {
         if (lock) throw new IllegalStateException("Value already locked");
+        if (expression == null) throw new NullPointerException();
         this.expression = expression;
     }
 
     public double resolve() {
+        if (expression == null) throw new NullPointerException();
         if (lock) return cached;
         return expression.resolveFinal();
     }

src/main/java/org/leibnizcenter/cfg/earleyparser/chart/Chart.java

@@ -321,9 +321,8 @@ private void completeNoViterbi(final int position,
     ) {
         if (states == null || states.size() <= 0) return;
 
-
         final DeferredStateScoreComputations newStates = new DeferredStateScoreComputations(stateSets.grammar.semiring);
-        Stream<StateInformationTriple> stream = states.stream()
+        List<Complete.Delta> deltas = states.stream()
                 // For all states
                 //      i: Y<sub>j</sub> → value·    [a",y"]
                 //      j: X<sub>k</suv> → l·Zm  [a',y']
@@ -333,13 +332,10 @@ private void completeNoViterbi(final int position,
 
                 // WARNING: shared mutated mutability
                 .sequential()
-                .map(completedState -> new StateInformationTriple(null, completedState, addInnerScores.getOrCreate(completedState, stateSets.innerScores.getAtom(completedState))));
-
-        /* Safe to parallelize here */
-        if (parallelizeComplete) stream = stream.parallel();
-
-        List<Complete.Delta> deltas = stream
+                .map(completedState -> new StateInformationTriple(null, completedState, addInnerScores.getOrCreate(completedState, stateSets.innerScores.getAtom(completedState))))
+                // TODO can/want parallelize this?
                 .flatMap(stateSets.activeStates::streamAllStatesToAdvance)
+                .sequential()
                 .map(stateInformation -> completeNoViterbiForTriple(
                         position,
                         addInnerScores.getOrCreate(stateInformation.stateToAdvance, stateSets.innerScores.getAtom(stateInformation.stateToAdvance)),
@@ -396,9 +392,7 @@ private void computeViterbiScoresForCompletedState(
         int completedPos = completedState.position;
         final Set<State> statesToAdvance = stateSets.activeStates.getStatesActiveOnNonTerminal(Yl, completedState.ruleStartPosition, completedPos);
         if (statesToAdvance != null && statesToAdvance.size() > 0) {
-            Stream<State> stream = statesToAdvance.stream();
-                    /* Safe to parallelize here */
-            if (parallelizeComplete) stream = stream.parallel();
+            Stream<State> stream = (parallelizeComplete ? statesToAdvance.parallelStream() : statesToAdvance.stream());
             Collection<Complete.ViterbiDelta> newStates = stream
                     .map((stateToAdvance) -> computeViterbiForState(completedState, completedViterbi, stateToAdvance))
                     .filter(d -> d != null)