Current iteration

core/src/main/java/io/parsingdata/metal/Shorthand.java

@@ -44,6 +44,7 @@
 import io.parsingdata.metal.expression.value.Cat;
 import io.parsingdata.metal.expression.value.Const;
 import io.parsingdata.metal.expression.value.ConstantFactory;
+import io.parsingdata.metal.expression.value.reference.CurrentIteration;
 import io.parsingdata.metal.expression.value.Elvis;
 import io.parsingdata.metal.expression.value.Expand;
 import io.parsingdata.metal.expression.value.FoldLeft;
@@ -89,6 +90,7 @@ public final class Shorthand {
     public static final Token EMPTY = def(EMPTY_NAME, 0L);
     public static final ValueExpression SELF = new Self();
     public static final ValueExpression CURRENT_OFFSET = new CurrentOffset();
+    public static final ValueExpression CURRENT_ITERATION = new CurrentIteration();
     public static final Expression TRUE = new True();
 
     private Shorthand() {}

core/src/main/java/io/parsingdata/metal/expression/value/reference/CurrentIteration.java

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2013-2016 Netherlands Forensic Institute
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.parsingdata.metal.expression.value.reference;
+
+import static java.math.BigInteger.ONE;
+import static java.math.BigInteger.ZERO;
+
+import static io.parsingdata.metal.Trampoline.complete;
+import static io.parsingdata.metal.Trampoline.intermediate;
+import static io.parsingdata.metal.expression.value.ConstantFactory.createFromNumeric;
+
+import java.math.BigInteger;
+import java.util.Optional;
+
+import io.parsingdata.metal.Trampoline;
+import io.parsingdata.metal.Util;
+import io.parsingdata.metal.data.ImmutableList;
+import io.parsingdata.metal.data.ParseGraph;
+import io.parsingdata.metal.data.ParseItem;
+import io.parsingdata.metal.data.ParseState;
+import io.parsingdata.metal.encoding.Encoding;
+import io.parsingdata.metal.expression.value.Value;
+import io.parsingdata.metal.expression.value.ValueExpression;
+
+/**
+ * A {@link ValueExpression} that represents the current iteration in an
+ * iterable {@link io.parsingdata.metal.token.Token} (e.g. when inside a
+ * {@link io.parsingdata.metal.token.Rep} or
+ * {@link io.parsingdata.metal.token.RepN}).
+ */
+public class CurrentIteration implements ValueExpression {
+
+    @Override
+    public ImmutableList<Optional<Value>> eval(final ParseState parseState, final Encoding encoding) {
+        final ParseGraph currentIterable = findCurrentIterable(parseState.order, ParseGraph.EMPTY).computeResult();
+        if (currentIterable.isEmpty()) { return ImmutableList.create(Optional.empty()); }
+
+        final BigInteger currentIteration = countIterable(currentIterable, ZERO).computeResult();
+        return ImmutableList.create(Optional.of(createFromNumeric(currentIteration, new Encoding())));
+    }
+
+    private Trampoline<ParseGraph> findCurrentIterable(final ParseItem item, final ParseGraph iterableCandidate) {
+        if (!item.isGraph()) { return complete(() -> iterableCandidate); }
+        if (item.getDefinition().isIterable()) {
+            return intermediate(() -> findCurrentIterable(item.asGraph().head, item.asGraph()));
+        }
+        return intermediate(() -> findCurrentIterable(item.asGraph().head, iterableCandidate));
+    }
+
+    private Trampoline<BigInteger> countIterable(final ParseGraph graph, final BigInteger count) {
+        if (!graph.isEmpty()) { return intermediate(() -> countIterable(graph.tail, count.add(ONE))); }
+        return complete(() -> count.subtract(ONE));
+    }
+
+    @Override
+    public String toString() {
+        return getClass().getSimpleName();
+    }
+
+    @Override
+    public boolean equals(final Object obj) {
+        return Util.notNullAndSameClass(this, obj);
+    }
+
+    @Override
+    public int hashCode() {
+        return getClass().hashCode();
+    }
+
+}

core/src/main/java/io/parsingdata/metal/token/Rep.java

@@ -59,6 +59,11 @@ private Trampoline<Optional<ParseState>> iterate(final Environment environment)
             .orElseGet(() -> complete(() -> success(environment.parseState.closeBranch())));
     }
 
+    @Override
+    public boolean isIterable() {
+        return true;
+    }
+
     @Override
     public String toString() {
         return getClass().getSimpleName() + "(" + makeNameFragment() + token + ")";

core/src/main/java/io/parsingdata/metal/token/RepN.java

@@ -76,6 +76,11 @@ private Trampoline<Optional<ParseState>> iterate(final Environment environment,
             .orElseGet(() -> complete(Util::failure));
     }
 
+    @Override
+    public boolean isIterable() {
+        return true;
+    }
+
     @Override
     public String toString() {
         return getClass().getSimpleName() + "(" + makeNameFragment() + token + "," + n + ")";

core/src/main/java/io/parsingdata/metal/token/Token.java

@@ -79,6 +79,10 @@ public boolean isLocal() {
         return true;
     }
 
+    public boolean isIterable() {
+        return false;
+    }
+
     public Token getCanonical(final ParseState parseState) {
         return this;
     }

core/src/main/java/io/parsingdata/metal/token/While.java

@@ -71,6 +71,11 @@ private Trampoline<Optional<ParseState>> iterate(final Environment environment)
         return complete(() -> success(environment.parseState.closeBranch()));
     }
 
+    @Override
+    public boolean isIterable() {
+        return true;
+    }
+
     @Override
     public String toString() {
         return getClass().getSimpleName() + "(" + makeNameFragment() + token + "," + predicate + ")";

core/src/test/java/io/parsingdata/metal/AutoEqualityTest.java

@@ -100,6 +100,7 @@
 import io.parsingdata.metal.expression.value.bitwise.ShiftLeft;
 import io.parsingdata.metal.expression.value.bitwise.ShiftRight;
 import io.parsingdata.metal.expression.value.reference.Count;
+import io.parsingdata.metal.expression.value.reference.CurrentIteration;
 import io.parsingdata.metal.expression.value.reference.CurrentOffset;
 import io.parsingdata.metal.expression.value.reference.First;
 import io.parsingdata.metal.expression.value.reference.Last;
@@ -191,7 +192,7 @@ public static Collection<Object[]> data() throws IllegalAccessException, Invocat
             And.class, Or.class, ShiftLeft.class, ShiftRight.class, Add.class, Div.class, Mod.class, Mul.class,
             io.parsingdata.metal.expression.value.arithmetic.Sub.class, Cat.class, Nth.class, Elvis.class,
             FoldLeft.class, FoldRight.class, Const.class, Expand.class, Bytes.class, CurrentOffset.class,
-            FoldCat.class,
+            FoldCat.class, CurrentIteration.class,
             // Expressions
             Eq.class, EqNum.class, EqStr.class, GtEqNum.class, GtNum.class, LtEqNum.class, LtNum.class,
             io.parsingdata.metal.expression.logical.And.class, io.parsingdata.metal.expression.logical.Or.class,

core/src/test/java/io/parsingdata/metal/ToStringTest.java

@@ -19,6 +19,7 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
+import static io.parsingdata.metal.Shorthand.CURRENT_ITERATION;
 import static io.parsingdata.metal.Shorthand.CURRENT_OFFSET;
 import static io.parsingdata.metal.Shorthand.SELF;
 import static io.parsingdata.metal.Shorthand.add;
@@ -121,7 +122,7 @@ private Token t() {
     }
 
     private ValueExpression v() {
-        return fold(foldLeft(foldRight(rev(bytes(neg(add(div(mod(mul(sub(cat(last(ref(n()))), first(nth(exp(ref(n()), con(1)), con(1)))), con(1)), cat(ref(n()), ref(t()))), add(SELF, add(offset(ref(n())), add(CURRENT_OFFSET, count(ref(n())))))), elvis(ref(n()), ref(n())))))), Shorthand::add, ref(n())), Shorthand::add), Shorthand::add, ref(n()));
+        return fold(foldLeft(foldRight(rev(bytes(neg(add(div(mod(mul(sub(cat(last(ref(n()))), first(nth(exp(ref(n()), con(1)), con(1)))), sub(CURRENT_ITERATION, con(1))), cat(ref(n()), ref(t()))), add(SELF, add(offset(ref(n())), add(CURRENT_OFFSET, count(ref(n())))))), elvis(ref(n()), ref(n())))))), Shorthand::add, ref(n())), Shorthand::add), Shorthand::add, ref(n()));
     }
 
     @Test
@@ -148,6 +149,8 @@ public void specialExpressions() {
         assertEquals("Self", SELF.toString());
         assertTrue(v().toString().contains("CurrentOffset"));
         assertEquals("CurrentOffset", CURRENT_OFFSET.toString());
+        assertTrue(v().toString().contains("CurrentIteration"));
+        assertEquals("CurrentIteration", CURRENT_ITERATION.toString());
     }
 
     @Test

core/src/test/java/io/parsingdata/metal/expression/value/reference/CurrentIterationTest.java

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2013-2016 Netherlands Forensic Institute
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.parsingdata.metal.expression.value.reference;
+
+import static io.parsingdata.metal.Shorthand.CURRENT_ITERATION;
+import static io.parsingdata.metal.Shorthand.con;
+import static io.parsingdata.metal.Shorthand.def;
+import static io.parsingdata.metal.Shorthand.eq;
+import static io.parsingdata.metal.Shorthand.not;
+import static io.parsingdata.metal.Shorthand.rep;
+import static io.parsingdata.metal.Shorthand.repn;
+import static io.parsingdata.metal.Shorthand.seq;
+import static io.parsingdata.metal.Shorthand.whl;
+import static io.parsingdata.metal.util.EncodingFactory.enc;
+import static io.parsingdata.metal.util.ParseStateFactory.stream;
+
+import java.util.Arrays;
+import java.util.Collection;
+
+import org.junit.runners.Parameterized;
+
+import io.parsingdata.metal.token.Token;
+import io.parsingdata.metal.util.ParameterizedParse;
+
+public class CurrentIterationTest extends ParameterizedParse {
+
+    public static final Token VALUE_EQ_ITERATION = def("value", con(1), eq(CURRENT_ITERATION));
+    public static final Token VALUE_NOT_EQ_ITERATION = def("value", con(1), not(eq(CURRENT_ITERATION)));
+    public static final Token VALUE_EQ_255 = def("value", con(1), eq(con(255)));
+
+    @Parameterized.Parameters(name="{0} ({4})")
+    public static Collection<Object[]> data() {
+        return Arrays.asList(new Object[][] {
+            { "[0, 1, 2, 3, 255] rep(CURRENT_ITERATION), def(255)", seq(rep(VALUE_EQ_ITERATION), VALUE_EQ_255), stream(0, 1, 2, 3, 255), enc(), true },
+            { "[0, 1, 2, 3] repn=4(CURRENT_ITERATION)", repn(VALUE_EQ_ITERATION, con(4)), stream(0, 1, 2, 3), enc(), true },
+            { "[255, 0, 1, 2, 3, 255] def(255), while<3(CURRENT_ITERATION), def (255)", seq(VALUE_EQ_255, whl(VALUE_EQ_ITERATION, not(eq(con(3)))), VALUE_EQ_255), stream(255, 0, 1, 2, 3, 255), enc(), true },
+            { "[0, 0, 1, 2, 1, 0, 1, 2] repn=2(CURRENT_ITERATION, repn=3(CURRENT_ITERATION))", repn(seq(VALUE_EQ_ITERATION, repn(VALUE_EQ_ITERATION, con(3))), con(2)), stream(0, 0, 1, 2, 1, 0, 1, 2), enc(), true },
+            { "[0, 1] seq(CURRENT_ITERATION, ...)", seq(VALUE_EQ_ITERATION, VALUE_EQ_ITERATION), stream(0, 1), enc(), false },
+            { "[0] CURRENT_ITERATION", VALUE_EQ_ITERATION, stream(0), enc(), false },
+            { "[0, 1] seq(!CURRENT_ITERATION, ...)", seq(VALUE_NOT_EQ_ITERATION, VALUE_NOT_EQ_ITERATION), stream(0, 1), enc(), true },
+            { "[0] !CURRENT_ITERATION", VALUE_NOT_EQ_ITERATION, stream(0), enc(), true }
+        });
+    }
+
+}